Comment se connecter à une base de données MySQL distribuée en utilisant le langage Go

Dans les systèmes distribués, les bases de données jouent un rôle très critique. Pour les grands systèmes distribués, nous devons souvent utiliser plusieurs bases de données pour le traitement amorti afin de répondre aux besoins de l'application. En tant que base de données relationnelle largement utilisée, MySQL peut connecter et gérer plusieurs instances via le langage Go pour créer un système distribué hautement disponible et hautes performances.

Cet article explique comment utiliser le langage Go pour se connecter à la base de données MySQL distribuée, divisé en les parties suivantes :

1 Installer le langage Go
2. Installer le pilote MySQL
3. pour gérer plusieurs Exemple
5. Utiliser des transactions distribuées

Installer le langage Go

Tout d'abord, nous devons installer l'environnement du langage Go. Nous pouvons télécharger le package d'installation du langage Go depuis le site officiel de Go : https://golang.org/dl/. Sélectionnez la version appropriée pour votre système d'exploitation, téléchargez-la et installez-la.

Installez le pilote MySQL

Pour vous connecter à la base de données MySQL, vous devez utiliser le pilote Go MySQL. Nous pouvons utiliser le pilote MySQL officiel ou un pilote tiers. Ici, nous prenons le pilote officiel comme exemple. Le pilote MySQL officiel est : github.com/go-sql-driver/mysql

Nous pouvons utiliser la commande go get pour obtenir et installer le pilote MySQL. Exécutez la commande suivante dans le terminal :

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

Connectez-vous à la base de données MySQL

Pour vous connecter à la base de données MySQL, vous devez spécifier l'adresse IP, le numéro de port, le nom d'utilisateur et le mot de passe de l'instance de base de données. Dans Go, nous pouvons nous connecter à la base de données MySQL via l'API fournie par le package database/sql. Voici un exemple de programme pour se connecter à la base de données MySQL :

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)
    }
}

Dans l'exemple de programme ci-dessus, nous utilisons d'abord la fonction sql.Open() pour nous connecter à la base de données MySQL. Le paramètre "mysql" signifie utiliser la base de données MySQL ; "root:123456" est le nom d'utilisateur et le mot de passe ; "127.0.0.1:3306" est l'adresse de la base de données et "/test" est le nom de la base de données.

Ensuite, nous utilisons la fonction db.Query() pour interroger les données dans la base de données MySQL. Le résultat de la requête est un objet Rows. Enfin, nous utilisons la fonction rows.Next() pour parcourir les résultats de la requête, obtenir les données et les afficher.

Utilisez un pool de connexions pour gérer plusieurs instances

Lors de l'utilisation d'une base de données MySQL dans un système distribué, nous devons généralement utiliser plusieurs instances de base de données et utiliser des pools de connexions pour gérer ces instances. En langage Go, nous pouvons utiliser l'objet sql.DB fourni par le package database/sql pour implémenter le pooling de connexions. Voici un exemple de programme qui utilise le pool de connexions pour gérer plusieurs instances de base de données MySQL :

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 {}
}

Dans l'exemple de programme ci-dessus, nous utilisons un objet sync.Map dbMap pour stocker toutes les instances de base de données dans le pool de connexions.

Lors de l'interrogation des données, nous utilisons d'abord la fonction getDBInstance() pour obtenir l'instance de base de données à partir du pool de connexions. S'il n'est pas trouvé, utilisez la fonction sql.Open() pour créer une nouvelle instance de base de données, puis ajoutez cette instance au pool de connexions.

Ensuite, nous utilisons la fonction db.Query() pour interroger les données de la base de données. Enfin, nous utilisons la fonction rows.Scan() pour parcourir les résultats de la requête, obtenir les données et les afficher.

Utilisation de transactions distribuées

Lors de l'utilisation de plusieurs bases de données MySQL dans un grand système distribué, nous devrons peut-être effectuer des opérations de transaction sur différentes sources de données. Dans le langage Go, nous pouvons utiliser l'objet Tx fourni par le package database/sql pour gérer les transactions distribuées. Voici un exemple de programme utilisant des transactions distribuées :

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")
    }
}

Dans l'exemple de programme ci-dessus, nous utilisons la fonction getDBInstance() pour obtenir l'instance de base de données à partir du pool de connexions. Ensuite, dans la fonction transfer(), nous utilisons la fonction tx.Begin() pour créer une nouvelle transaction, puis utilisons la fonction tx.Exec() pour exécuter des instructions SQL dans fromDB et toDB afin de terminer l'opération de transfert.

Enfin, utilisez la fonction tx.Commit() pour valider la transaction. Si une erreur se produit dans la transaction, utilisez la fonction tx.Rollback() pour annuler la transaction.

Résumé

En utilisant l'API fournie par le package go-sql-driver/mysql, nous pouvons facilement nous connecter et interagir avec la base de données MySQL. Dans un système distribué, l'utilisation de pools de connexions pour gérer plusieurs instances de base de données MySQL peut améliorer les performances et la disponibilité du système. Le langage Go prend également en charge l'utilisation de transactions distribuées, et les transactions distribuées peuvent être facilement gérées via l'objet Tx.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!