Verwenden von MySQL zum Speichern zwischengespeicherter Daten in der Go-Sprache

In den letzten Jahren ist mit der zunehmenden Datenverarbeitung die Nachfrage nach Cache immer höher geworden. Der herkömmliche Cache basiert auf Speicherspeicherung. Der Vorteil dieser Methode besteht darin, dass sie schnell ist, aber hohe Kosten verursacht. Die MySQL-Datenbank ist eine relativ kostengünstige und äußerst zuverlässige Methode zur Datenspeicherung. Daher entscheiden sich viele Unternehmen für die Verwendung von MySQL zur Implementierung der Cache-Speicherung. In diesem Artikel wird erläutert, wie Sie MySQL zum Speichern von Cache-Daten in der Go-Sprache verwenden.

1. Verwenden Sie Go, um die MySQL-Datenbank zu betreiben.

1. Installieren Sie den MySQL-Treiber.

In der Go-Sprache müssen wir den entsprechenden MySQL-Treiber verwenden, um Datenbankoperationen durchzuführen. Zu den derzeit beliebten MySQL-Treibern gehören go-sql-driver/mysql, mysql/mysql-connector-go, gocraft/dbr usw. Hier wählen wir als Beispiel die Verwendung von go-sql-driver/mysql. Wenn Sie andere MySQL-Treiber verwenden, hat dies keinen Einfluss auf die Ausführung der folgenden Schritte. Zuerst müssen wir den folgenden Befehl im Terminal eingeben:

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

Dieser Befehl installiert den go-sql-driver/mysql-Treiber.

2. Verbindung zur MySQL-Datenbank herstellen

Als nächstes implementieren wir ein einfaches MySQL-Datenbankverbindungsprogramm. In MySQL müssen Sie sich mit einem Benutzernamen und einem Passwort anmelden. Daher müssen Sie den entsprechenden MySQL-Benutzernamen und das entsprechende Passwort im Voraus vorbereiten. In diesem Beispiel setzen wir den Benutzernamen auf root und das Passwort auf 123456. Der Code lautet wie folgt:

package main

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

const (
    username = "root"
    password = "123456"
    hostname = "127.0.0.1"
    port = 3306
    dbname = "test"
)

func main() {
    dataSourceName := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s", username, password, hostname, port, dbname)
    db, err := sql.Open("mysql", dataSourceName)
    if err != nil {
        panic(err)
    }
    defer db.Close()
    err = db.Ping()
    if err != nil {
        panic(err)
    }
    fmt.Println("Successfully connected to the database!")
}

Hinweis: Bevor Sie das Programm ausführen, stellen Sie bitte sicher, dass der MySQL-Dienst gestartet ist.

Nachdem das Programm ausgeführt wurde, können Sie die Ausgabe wie folgt sehen:

Successfully connected to the database!

Dies zeigt, dass wir erfolgreich eine Verbindung zur MySQL-Datenbank hergestellt haben.

2. Verwenden Sie MySQL zum Speichern von Cache-Daten.

Da MySQL eine relationale Datenbank ist und der Cache auf der Speicherung von Schlüssel-Wert-Paaren basiert, müssen wir in der MySQL-Datentabelle einen dedizierten Cache erstellen. In diesem Beispiel haben wir eine Tabelle namens „cache_data“ erstellt, die drei Felder enthält: Schlüssel, Wert und Ablaufdatum. Unter diesen stellen Schlüssel und Wert den Schlüssel bzw. den entsprechenden Wert dar, und Expire_time stellt die Ablaufzeit der Daten dar. Der Code lautet wie folgt:

CREATE TABLE `cache_data` (
  `key` varchar(255) NOT NULL DEFAULT '',
  `value` longblob NOT NULL,
  `expire_time` int(11) NOT NULL DEFAULT '0',
  PRIMARY KEY (`key`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

Nachdem die obige SQL-Anweisung abgeschlossen ist, können wir die MySQL-Datenbank in der Go-Sprache betreiben. Als Nächstes implementieren wir ein einfaches Cache-Beispiel. Der Code lautet wie folgt:

package main

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

const (
    username = "root"
    password = "123456"
    hostname = "127.0.0.1"
    port = 3306
    dbname = "test"
)

type Cache struct {
    db *sql.DB
}

func (c *Cache) Set(key string, value []byte, expireTime time.Duration) error {
    query := fmt.Sprintf("INSERT INTO cache_data (key, value, expire_time) VALUES ('%s', ?, %d) ON DUPLICATE KEY UPDATE value = ?", key, time.Now().Add(expireTime).Unix())
    stmt, err := c.db.Prepare(query)
    if err != nil {
        return err
    }
    _, err = stmt.Exec(value, value)
    if err != nil {
        return err
    }
    return nil
}

func (c *Cache) Get(key string) ([]byte, error) {
    var value []byte
    query := fmt.Sprintf("SELECT value, expire_time FROM cache_data WHERE key = '%s'", key)
    err := c.db.QueryRow(query).Scan(&value)
    if err != nil {
        return nil, err
    }
    return value, nil
}

func NewCache() (*Cache, error) {
    dataSourceName := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s", username, password, hostname, port, dbname)
    db, err := sql.Open("mysql", dataSourceName)
    if err != nil {
        return nil, err
    }
    err = db.Ping()
    if err != nil {
        return nil, err
    }
    cache := &Cache{
        db: db,
    }
    return cache, nil
}

func main() {
    cache, err := NewCache()
    if err != nil {
        panic(err)
    }
    err = cache.Set("key1", []byte("value1"), time.Second*10)
    if err != nil {
        panic(err)
    }
    value, err := cache.Get("key1")
    if err != nil {
        panic(err)
    }
    fmt.Println(string(value))
}

Im obigen Code implementieren wir eine Cache-Struktur, die drei Methoden enthält: Set, Get und NewCache. Unter anderem wird die Set-Methode zum Speichern von Schlüssel-Wert-Paaren in der MySQL-Datenbank verwendet; die Get-Methode wird zum Abrufen des Werts des angegebenen Schlüssels verwendet; die NewCache-Methode wird zum Initialisieren der Cache-Struktur verwendet. In diesem Beispiel setzen wir den Wert des Schlüssels „key1“ auf „value1“ und geben die Ablaufzeit auf 10 Sekunden an. Anschließend rufen wir die Get-Methode auf, um den Wert des Schlüssels „key1“ abzurufen und auszugeben.

Nachdem das Programm ausgeführt wurde, können Sie die Ausgabe wie folgt sehen:

value1

Dies zeigt, dass wir einen Cache-Speicher mithilfe von MySQL erfolgreich implementiert haben.

Zusammenfassung

In diesem Artikel wird erläutert, wie Sie MySQL zum Speichern von Cache-Daten in der Go-Sprache verwenden. Zu den spezifischen Schritten gehören die Verwendung von go-sql-driver/mysql-Treiber zum Herstellen einer Verbindung zur MySQL-Datenbank und das Erstellen eines Caches in MySQL speziell für die Speicherung von Daten Tabellen, Cache-Speicher usw. Durch die Einleitung dieses Artikels können wir sehen, dass die Verwendung von MySQL als Cache-Speichermethode die Vorteile geringer Kosten und hoher Zuverlässigkeit bietet und eine sehr empfehlenswerte Übungsmethode ist.

Das obige ist der detaillierte Inhalt vonVerwenden von MySQL zum Speichern zwischengespeicherter Daten in der Go-Sprache. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!