Verwendung von Apache Cassandra in Go: Eine vollständige Anleitung

Apache Cassandra ist eine nicht relationale Datenbank (NoSQL), die häufig in großen, durchsatzstarken und fehlertoleranten verteilten Datenspeicherszenarien verwendet wird. Es verwendet ein Datenmodell ähnlich dem Bigtable von Google und kombiniert es mit der verteilten Architektur von Amazon Dynamo. In diesem Artikel besprechen wir, wie man Apache Cassandra in der Go-Sprache verwendet und wie man damit eine einfache Webanwendung erstellt.

Cassandras Datenmodell

Cassandras Datenmodell kann logischerweise als vollständig verteilte Hash-Tabelle betrachtet werden. Die Tabelle besteht aus mehreren Spaltenfamilien. Jede Spaltenfamilie enthält einen Schlüsselraum (Keyspace), der mehrere Tabellen (Tabelle) enthält. In jeder Zeile können mehrere Daten mit dem Namen Spalten (Spalte) gespeichert werden. .

In Cassandra können Sie CQL (Cassandra Query Language) verwenden, um Daten abzufragen und zu bearbeiten. CQL ist leicht zu erlernen und zu verwenden, da es eine ähnliche Syntax wie die SQL-Sprache verwendet, einige Syntaxdetails jedoch dennoch unterschiedlich sind.

Schritte zur Verwendung von Apache Cassandra

Lassen Sie uns nun einen Blick darauf werfen, wie Sie Apache Cassandra in Ihrer Go-Anwendung verwenden. Nachfolgend finden Sie hauptsächlich 5 Schritte.

1. Cassandra installieren

Als Erstes müssen Sie Cassandra installieren. Sie können die entsprechende Binärdatei auf der offiziellen Website von Cassandra herunterladen und gemäß den Anweisungen installieren.

2. Erstellen Sie eine Spaltenfamilie

Nachdem Sie Cassandra installiert haben, besteht der nächste Schritt darin, eine Spaltenfamilie zu erstellen und einige Spalten zur Spaltenfamilie hinzuzufügen. Sie können cqlsh (Cassandra-Shell) verwenden, um Cassandra zu bedienen.

Hier haben wir eine Spaltenfamilie mit dem Namen „Schüler“ erstellt, die den Namen des Schülers, die Schülernummer, die Klasse und andere Informationen enthält:

CREATE KEYSPACE learning WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '3'} AND durable_writes = true;

CREATE TABLE learning.students (
   student_id text PRIMARY KEY,
   first_name text,
   last_name text,
   department text
);

3 Mit Cassandra verbinden

In der Go-Sprache können Sie Bibliotheken von Drittanbietern zum Herstellen einer Verbindung verwenden zu Kassandra. Hier verwenden wir gocql, um eine Verbindung herzustellen.

Hier ist ein Codebeispiel zum Herstellen einer Verbindung zu einem Cassandra-Cluster:

cluster := gocql.NewCluster("127.0.0.1")
cluster.Keyspace = "learning"
session, err := cluster.CreateSession()
if err != nil {
    log.Fatal(err)
}
defer session.Close()

Hier geben Sie einfach die IP-Adresse oder den Hostnamen des Cassandra-Clusters an und geben den Schlüsselraum an, mit dem Sie eine Verbindung herstellen möchten.

4. Abfrageanweisungen schreiben

In der Go-Sprache können Sie gocql.Query zum Schreiben von Abfrageanweisungen verwenden. Das Folgende ist ein Codebeispiel zum Abfragen aller Schülerinformationen in der Tabelle:

var students []model.Student

query := "SELECT * FROM students"
iter := session.Query(query).Iter()

for iter.Scan(&student.ID, &student.FirstName, &student.LastName, &student.Department) {
    students = append(students, student)
}

if err := iter.Close(); err != nil {
    log.Fatal(err)
}

for _, student := range students {
    fmt.Println(student.ID, student.FirstName, student.LastName, student.Department)
}

Hier deklarieren wir zunächst eine model.Student-Struktur zum Speichern der aus der Tabelle abgerufenen Schülerdaten. Anschließend haben wir eine SELECT-Abfrageanweisung geschrieben und mithilfe der session.Query-Methode ein Abfrageobjekt erstellt. Als Nächstes durchlaufen wir die Ergebnisse der Abfrage, speichern die Daten in einem Slice und geben schließlich die Informationen für alle Schüler aus.

5. Schließen Sie die Verbindung

Zuletzt müssen wir die Verbindung zu Cassandra schließen. Das Folgende ist ein Codebeispiel zum Schließen der Cassandra-Verbindung:

defer session.Close()

Erstellen einer Webanwendung mit Cassandra

Lassen Sie uns nun sehen, wie Sie eine einfache Webanwendung mit Apache Cassandra in der Go-Sprache erstellen. In dieser Webanwendung erstellen wir eine Studentenlistenseite, zeigen die Informationen aller Studenten an und stellen ein Formular zum Hinzufügen von Studenteninformationen bereit.

Hier verwenden wir das Gin-Framework, um Webanwendungen zu erstellen. Das Folgende ist ein Codebeispiel zum Erstellen einer Webanwendung:

package main

import (
    "html/template"
    "log"
    "net/http"
    "strconv"

    "github.com/gin-gonic/gin"
    "github.com/gocql/gocql"
)

type Student struct {
    ID         string
    FirstName  string
    LastName   string
    Department string
}

var session *gocql.Session

func init() {
    cluster := gocql.NewCluster("127.0.0.1")
    cluster.Keyspace = "learning"
    var err error
    session, err = cluster.CreateSession()
    if err != nil {
        log.Fatal(err)
    }
}

func main() {
    router := gin.Default()

    router.LoadHTMLGlob("templates/*")

    router.GET("/", func(c *gin.Context) {
        var students []Student

        query := "SELECT * FROM students"
        iter := session.Query(query).Iter()

        for {
            var student Student
            if !iter.Scan(&student.ID, &student.FirstName, &student.LastName, &student.Department) {
                break
            }
            students = append(students, student)
        }

        if err := iter.Close(); err != nil {
            log.Fatal(err)
        }

        c.HTML(http.StatusOK, "index.tmpl", gin.H{
            "students": students,
        })
    })

    router.POST("/add", func(c *gin.Context) {
        student := Student{
            ID:         c.PostForm("id"),
            FirstName:  c.PostForm("first_name"),
            LastName:   c.PostForm("last_name"),
            Department: c.PostForm("department"),
        }

        query := "INSERT INTO students (student_id, first_name, last_name, department) VALUES (?, ?, ?, ?)"
        err := session.Query(query, student.ID, student.FirstName, student.LastName, student.Department).Exec()
        if err != nil {
            log.Fatal(err)
        }

        c.Redirect(http.StatusFound, "/")
    })

    router.Run(":8080")
}

Hier deklarieren wir zunächst eine Struktur namens Student, die zur Darstellung der Informationen eines Studenten verwendet wird. Anschließend stellen wir in der Init-Funktion eine Verbindung zum Cassandra-Cluster her.

In der Hauptfunktion verwenden wir Gin-Routing, um verschiedene HTTP-Anfragen zu verarbeiten. Auf dem Pfad „/“ fragen wir zunächst die Informationen aller Schüler ab und übergeben sie an die Vorlage index.tmpl zum Rendern der Schülerlistenseite. Im Pfad „/add“ fügen wir einen neuen Studentendatensatz basierend auf den vom Benutzer übermittelten Formulardaten ein und leiten den Benutzer dann zurück zur Studentenlistenseite.

Abschließend rufen wir router.Run() auf, um die Webanwendung zu starten.

Zusammenfassung

In diesem Artikel haben wir die Verwendung von Apache Cassandra in der Go-Sprache besprochen und eine einfache Webanwendung erstellt. Anhand dieses Beispiels können wir die einfache Verwendung von Cassandra und die Verwendung von Bibliotheken von Drittanbietern zum Betrieb von Cassandra in der Go-Sprache sehen. Wenn Sie nach einer verteilten Datenbank mit hohem Durchsatz und hoher Verfügbarkeit suchen, ist Apache Cassandra möglicherweise eine Option für Sie.

Das obige ist der detaillierte Inhalt vonVerwendung von Apache Cassandra in Go: Eine vollständige Anleitung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!