Utilisez MySQL en langage Go pour gérer les données du système distribué

Avec le développement d'Internet, les systèmes distribués attirent de plus en plus l'attention. Les avantages d'un système distribué sont une extension facile et une bonne tolérance aux pannes, mais cela pose également des problèmes de gestion des données. Dans un système distribué, plusieurs nœuds lisent et écrivent les mêmes données en même temps, et l'incohérence des données est un problème courant. En conséquence, la gestion des données devient plus complexe. Cet article explique comment utiliser MySQL en langage Go pour gérer les données du système distribué.

Le langage Go offre un bon support pour les systèmes distribués. Il fournit également un package de base de données/SQL qui peut être utilisé pour faire fonctionner facilement la base de données. MySQL est une base de données relationnelle très couramment utilisée qui offre de nombreuses fonctionnalités avancées, telles que les transactions, la réplication, la topologie, le clustering, etc. Ci-dessous, nous expliquerons comment utiliser MySQL pour gérer les données du système distribué.

Première étape : Installer MySQL

Vous devez d'abord installer MySQL, qui peut être téléchargé et installé sur le site officiel. De plus, vous pouvez également utiliser certaines distributions MySQL open source, telles que MariaDB. Pendant le processus d'installation, vous devez faire attention à la configuration des paramètres associés tels que le mot de passe et le port. Généralement, l'utilisateur par défaut est root et le mot de passe est vide.

Étape 2 : Go langage pour vous connecter à MySQL

Dans le langage Go, utilisez le package base de données/sql et le pilote mysql pour vous connecter à la base de données MySQL. Dans l'instruction d'importation, utilisez les packages de pilotes database/sql et mysql :

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

Dans la fonction principale, nous pouvons utiliser le code suivant pour nous connecter à MySQL :

db, err := sql.Open("mysql", "username:password@tcp(127.0.0.1:3306)/testdb")
if err != nil {
    log.Fatal(err)
}
defer db.Close()

err = db.Ping()
if err != nil {
    log.Fatal(err)
}

Où, Le nom d'utilisateur et le mot de passe sont le nom d'utilisateur et le mot de passe MySQL définis par vous-même, tcp (127.0.0.1:3306) indique le service MySQL connecté à l'hôte local et testbd est le nom de la base de données à connecter.

Étape 3 : Créer une table de données

Dans MySQL, vous pouvez utiliser l'instruction SQL suivante pour créer une table :

CREATE TABLE `books` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `title` varchar(255) COLLATE utf8mb4_unicode_ci NOT NULL,
  `author` varchar(255) COLLATE utf8mb4_unicode_ci NOT NULL,
  `description` varchar(1024) COLLATE utf8mb4_unicode_ci NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

Dans cet exemple , nous créons Créez une table nommée livres avec quatre champs. id est la clé primaire, le titre, l'auteur et la description sont le titre, l'auteur et la description du livre.

Étape 4 : Ajouter, supprimer, modifier et interroger des données

En langage Go, vous pouvez utiliser des instructions SQL pour faire fonctionner la base de données MySQL. Voici un exemple d'utilisation du langage Go pour ajouter, supprimer, modifier et interroger des données :

// insert
stmt, err := db.Prepare("INSERT INTO books(title, author, description) VALUES (?, ?, ?)")
if err != nil {
    log.Fatal(err)
}
res, err := stmt.Exec("Go语言编程", "张三", "Go语言的基础知识")
if err != nil {
    log.Fatal(err)
}

// retrieve
rows, err := db.Query("SELECT id, title, author, description FROM books")
if err != nil {
    log.Fatal(err)
}
defer rows.Close()
for rows.Next() {
    var id int
    var title string
    var author string
    var description string
    err = rows.Scan(&id, &title, &author, &description)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(id, title, author, description)
}
err = rows.Err()
if err != nil {
    log.Fatal(err)
}

// update
stmt, err = db.Prepare("UPDATE books SET title=? WHERE id=?")
if err != nil {
    log.Fatal(err)
}
res, err = stmt.Exec("Go语言从入门到精通", 1)
if err != nil {
    log.Fatal(err)
}

// delete
stmt, err = db.Prepare("DELETE FROM books WHERE id=?")
if err != nil {
    log.Fatal(err)
}
res, err = stmt.Exec(1)
if err != nil {
    log.Fatal(err)
}

Ici, nous utilisons les fonctions Prepare et Exec pour effectuer des opérations d'insertion, de requête, de mise à jour et de suppression. En fait, ces opérations peuvent être combinées à l’aide de transactions pour assurer la cohérence des données. Dans le langage Go, les transactions peuvent être utilisées des manières suivantes :

tx, err := db.Begin()
if err != nil {
    log.Fatal(err)
}

stmt, err := tx.Prepare("INSERT INTO books(title, author, description) VALUES (?, ?, ?)")
if err != nil {
    tx.Rollback()
    log.Fatal(err)
}
defer stmt.Close()

res, err := stmt.Exec("Go语言编程", "张三", "Go语言的基础知识")
if err != nil {
    tx.Rollback()
    log.Fatal(err)
}

stmt, err = tx.Prepare("UPDATE books SET title=? WHERE id=?")
if err != nil {
    tx.Rollback()
    log.Fatal(err)
}
res, err = stmt.Exec("Go语言从入门到精通", 1)
if err != nil {
    tx.Rollback()
    log.Fatal(err)
}

err = tx.Commit()
if err != nil {
    tx.Rollback()
    log.Fatal(err)
}

Dans l'exemple ci-dessus, nous ouvrons d'abord une transaction, puis effectuons des opérations d'insertion et de mise à jour dans la transaction, et enfin validons la transaction. Si une erreur se produit, la transaction peut être annulée.

Résumé

Dans cet article, nous expliquons comment utiliser MySQL dans le langage Go pour gérer les données du système distribué. Grâce au fonctionnement du langage Go et de MySQL, nous pouvons facilement ajouter, interroger, mettre à jour et supprimer des données, et en même temps, nous pouvons également utiliser des transactions pour assurer la cohérence des données. Lorsque vous utilisez MySQL, vous devez faire attention aux paramètres de configuration, tels que le nom d'utilisateur, le mot de passe, le port, etc. En outre, vous devez également prêter attention aux problèmes causés par des opérations simultanées, telles que les verrous.

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!