So stellen Sie mithilfe der Go-Sprache eine Verbindung zu einer verteilten MySQL-Datenbank her

In verteilten Systemen spielen Datenbanken eine sehr wichtige Rolle. Bei großen verteilten Systemen müssen wir häufig mehrere Datenbanken für die amortisierte Verarbeitung verwenden, um die Anforderungen der Anwendung zu erfüllen. Als weit verbreitete relationale Datenbank kann MySQL über die Go-Sprache mehrere Instanzen verbinden und verwalten, um ein hochverfügbares, leistungsstarkes, verteiltes System aufzubauen.

In diesem Artikel wird erläutert, wie Sie mit der Go-Sprache eine Verbindung zur verteilten MySQL-Datenbank herstellen.

1. Installieren Sie den MySQL-Treiber.
3. Verwenden Sie den Verbindungspool um mehrere zu verwalten Beispiel
5. Verteilte Transaktionen verwenden

Installieren Sie die Go-Sprache

1. Zuerst müssen wir die Go-Sprachumgebung installieren. Wir können das Go-Sprachinstallationspaket von der offiziellen Go-Website herunterladen: https://golang.org/dl/. Wählen Sie die passende Version für Ihr Betriebssystem aus, laden Sie sie herunter und installieren Sie sie.

Installieren Sie den MySQL-Treiber

2. Um eine Verbindung zur MySQL-Datenbank herzustellen, müssen Sie den Go MySQL-Treiber verwenden. Wir können den offiziellen MySQL-Treiber oder einen Treiber eines Drittanbieters verwenden. Hier nehmen wir den offiziellen Treiber als Beispiel. Der offizielle MySQL-Treiber ist: github.com/go-sql-driver/mysql

Wir können den Befehl go get verwenden, um den MySQL-Treiber abzurufen und zu installieren. Führen Sie den folgenden Befehl im Terminal aus:

go get -u github.com/go-sql-driver/mysql

Mit MySQL-Datenbank verbinden

3. Um eine Verbindung zur MySQL-Datenbank herzustellen, müssen Sie die IP-Adresse, die Portnummer, den Benutzernamen und das Passwort der Datenbankinstanz angeben. In Go können wir über die vom Datenbank/SQL-Paket bereitgestellte API eine Verbindung zur MySQL-Datenbank herstellen. Das Folgende ist ein Beispielprogramm zum Herstellen einer Verbindung zur MySQL-Datenbank:

package main

import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
)

func main() {
    //连接MySQL数据库
    db, err := sql.Open("mysql", "root:123456@tcp(127.0.0.1:3306)/test")
    if err != nil {
        panic(err.Error())
    }
    defer db.Close()

    //查询MySQL数据库中的数据
    rows, err := db.Query("SELECT * from user")
    if err != nil {
        panic(err.Error())
    }
    defer rows.Close()

    //遍历查询结果
    for rows.Next() {
        var id int
        var name string
        if err := rows.Scan(&id, &name); err != nil {
            panic(err.Error())
        }
        fmt.Printf("id: %d, name: %s
", id, name)
    }
}

Im obigen Beispielprogramm verwenden wir zunächst die Funktion sql.Open(), um eine Verbindung zur MySQL-Datenbank herzustellen. Der Parameter „mysql“ bedeutet die Verwendung der MySQL-Datenbank; „root:123456“ ist der Benutzername und „127.0.0.1:3306“ ist die Datenbankadresse und „/test“ ist der Datenbankname.

Dann verwenden wir die Funktion db.Query(), um die Daten in der MySQL-Datenbank abzufragen. Das Abfrageergebnis ist ein Rows-Objekt. Schließlich verwenden wir die Funktion rows.Next(), um die Abfrageergebnisse zu durchlaufen, die Daten abzurufen und auszugeben.

Verwenden Sie den Verbindungspool, um mehrere Instanzen zu verwalten

4. Wenn Sie eine MySQL-Datenbank in einem verteilten System verwenden, müssen wir normalerweise mehrere Datenbankinstanzen verwenden und Verbindungspools verwenden, um diese Instanzen zu verwalten. In der Go-Sprache können wir das vom Datenbank-/SQL-Paket bereitgestellte sql.DB-Objekt verwenden, um Verbindungspooling zu implementieren. Das Folgende ist ein Beispielprogramm, das Verbindungspooling verwendet, um mehrere MySQL-Datenbankinstanzen zu verwalten:

package main

import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
    "sync"
)

var dbMap = sync.Map{}

func getDBInstance(addr string) (*sql.DB, error) {
    var (
        db  *sql.DB
        err error
    )
    //从连接池中获取数据库实例
    if val, ok := dbMap.Load(addr); ok {
        db = val.(*sql.DB)
        return db, nil
    }

    //创建新的数据库实例
    db, err = sql.Open("mysql", "root:123456@"+addr+"/test")
    if err != nil {
        return nil, err
    }

    //将新的数据库实例加入连接池中
    dbMap.Store(addr, db)
    return db, nil
}

//查询数据库中数据
func query(addr string) {
    db, err := getDBInstance(addr)
    if err != nil {
        panic(err)
    }
    rows, err := db.Query("SELECT * from user")
    if err != nil {
        panic(err)
    }
    defer rows.Close()

    for rows.Next() {
        var id int
        var name string
        if err := rows.Scan(&id, &name); err != nil {
            panic(err)
        }
        fmt.Printf("id:%d name:%s
", id, name)
    }
}

func main() {
    addrList := []string{"127.0.0.1:3306", "127.0.0.1:3307"}
    for _, addr := range addrList {
        go query(addr)
    }
    select {}
}

Im obigen Beispielprogramm verwenden wir ein sync.Map-Objekt dbMap, um alle Datenbankinstanzen im Verbindungspool zu speichern.

Beim Abfragen von Daten verwenden wir zunächst die Funktion getDBInstance(), um die Datenbankinstanz aus dem Verbindungspool abzurufen. Wenn nicht gefunden, verwenden Sie die Funktion sql.Open(), um eine neue Datenbankinstanz zu erstellen, und fügen Sie diese Instanz dann dem Verbindungspool hinzu.

Dann verwenden wir die Funktion db.Query(), um Daten aus der Datenbank abzufragen. Schließlich verwenden wir die Funktion rows.Scan(), um die Abfrageergebnisse zu durchlaufen, die Daten abzurufen und auszugeben.

Verteilte Transaktionen verwenden

5. Bei der Verwendung mehrerer MySQL-Datenbanken in einem großen verteilten System müssen wir möglicherweise Transaktionsvorgänge für verschiedene Datenquellen durchführen. In der Go-Sprache können wir das vom Datenbank-/SQL-Paket bereitgestellte Tx-Objekt verwenden, um verteilte Transaktionen zu verwalten. Hier ist ein Beispielprogramm, das verteilte Transaktionen verwendet:

package main

import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
    "sync"
)

var dbMap = sync.Map{}

func getDBInstance(addr string) (*sql.DB, error) {
    var (
        db  *sql.DB
        err error
    )
    if val, ok := dbMap.Load(addr); ok {
        db = val.(*sql.DB)
        return db, nil
    }

    db, err = sql.Open("mysql", "root:123456@"+addr+"/test")
    if err != nil {
        return nil, err
    }

    dbMap.Store(addr, db)
    return db, nil
}

func transfer(fromDB, toDB string, amount int) error {
    tx, err := getDBInstance(fromDB).Begin() //开始事务
    if err != nil {
        return err
    }
    defer tx.Rollback() //回滚事务

    //从fromDB转移amount到toDB
    _, err = tx.Exec("UPDATE account SET balance=balance-? WHERE id=1", amount)
    if err != nil {
        return err
    }
    _, err = getDBInstance(toDB).Exec("UPDATE account SET balance=balance+? WHERE id=2", amount)
    if err != nil {
        return err
    }

    err = tx.Commit() //提交事务
    if err != nil {
        tx.Rollback()
        return err
    }
    return nil
}

func main() {
    err := transfer("127.0.0.1:3306", "127.0.0.1:3307", 100)
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Println("transfer success")
    }
}

Im obigen Beispielprogramm verwenden wir die Funktion getDBInstance(), um die Datenbankinstanz aus dem Verbindungspool abzurufen. Dann verwenden wir in der Funktion transfer() die Funktion tx.Begin(), um eine neue Transaktion zu erstellen, und verwenden dann die Funktion tx.Exec(), um SQL-Anweisungen in fromDB und toDB auszuführen, um den Übertragungsvorgang abzuschließen.

Verwenden Sie abschließend die Funktion tx.Commit(), um die Transaktion festzuschreiben. Wenn in der Transaktion ein Fehler auftritt, verwenden Sie die Funktion tx.Rollback(), um die Transaktion zurückzusetzen.

Zusammenfassung

Durch die Verwendung der vom Paket go-sql-driver/mysql bereitgestellten API können wir problemlos eine Verbindung zur MySQL-Datenbank herstellen und mit ihr interagieren. In einem verteilten System kann die Verwendung von Verbindungspools zur Verwaltung mehrerer MySQL-Datenbankinstanzen die Systemleistung und -verfügbarkeit verbessern. Die Go-Sprache bietet auch Unterstützung für die Verwendung verteilter Transaktionen, und verteilte Transaktionen können einfach über das Tx-Objekt verwaltet werden.

Das obige ist der detaillierte Inhalt vonSo stellen Sie mithilfe der Go-Sprache eine Verbindung zu einer verteilten MySQL-Datenbank her. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!