Die Praxis, Cache zu verwenden, um die Effizienz des Datenbankzugriffs in Golang zu beschleunigen.

Die Praxis der Verwendung von Cache zur Beschleunigung des Datenbankzugriffs in Golang

Da Webanwendungen immer komplexer werden, wird der Zugriff auf die Datenbank immer häufiger. Der Zugriff auf die Datenbank ist in der Regel ein sehr zeitaufwändiger Vorgang, insbesondere wenn die Datenmenge groß ist. Um die Effizienz des Datenbankzugriffs zu verbessern, können Strategien wie Caching zur Optimierung des Datenbankzugriffs eingesetzt werden.

In diesem Artikel wird die Praxis der Verwendung von Cache zur Beschleunigung des Datenbankzugriffs in Golang vorgestellt. Für Experimente werden wir Golang als Entwicklungssprache, Redis als Cache-Server und MySQL als Datenbankserver verwenden.

1. Richten Sie die Umgebung ein

Bevor wir beginnen, müssen wir die Umgebung einrichten. Installieren Sie zunächst Golang- und MySQL- und Redis-Server, die hier nicht beschrieben werden.

Dann installieren Sie den Go-Treiber für lokales Redis und MySQL in Golang:

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

2. Schreiben Sie den Code

Als nächstes schreiben wir den Code, um Caching zu implementieren und den Datenbankzugriff zu beschleunigen.

Der erste ist der Code für den Datenbankzugriff. Wir haben eine globale Variable namens DB für die Verbindung zu MySQL definiert. Dann haben wir eine Funktion getUserByID definiert, um die Informationen eines Benutzers von MySQL abzufragen:

package main
 
import (
   "database/sql"
   "fmt"
   "log"
 
   _ "github.com/go-sql-driver/mysql"
)
 
var DB *sql.DB
 
type User struct {
   ID       int
   Username string
   Password string
   Age      int
}
 
func init() {
   db, err := sql.Open("mysql", "root:password@tcp(127.0.0.1:3306)/test?charset=utf8")
   if err != nil {
      log.Fatal("Open mysql failed,err:", err)
      return
   }
   DB = db
   fmt.Println("Connect to mysql success")
}
 
func getUserByID(id int) (*User, error) {
   var user User
   query := "SELECT id, username, password, age FROM users WHERE id=?"
   err := DB.QueryRow(query, id).Scan(&user.ID, &user.Username, &user.Password, &user.Age)
   if err != nil {
      log.Println(err)
      return nil, err
   }
   return &user, nil
}

Dann haben wir dieser getUserByID-Funktion Caching-Logik hinzugefügt. Konkret versuchen wir zunächst, die angeforderten Benutzerinformationen über die Funktion getUserByID aus dem Redis-Cache zu lesen. Wenn in Redis kein Informationsdatensatz für den Benutzer vorhanden ist, werden die Benutzerinformationen aus MySQL gelesen und für den nächsten Zugriff in Redis gespeichert. Wenn die Benutzerinformationen in Redis aufgezeichnet werden, werden die Benutzerinformationen direkt von Redis zurückgegeben:

package main
 
import (
   "database/sql"
   "encoding/json"
   "fmt"
   "log"
   "strconv"
 
   "github.com/go-redis/redis/v8"
   _ "github.com/go-sql-driver/mysql"
)
 
var DB *sql.DB
var RedisClient *redis.Client
 
type User struct {
   ID       int
   Username string
   Password string
   Age      int
}
 
func init() {
   db, err := sql.Open("mysql", "root:password@tcp(127.0.0.1:3306)/test?charset=utf8")
   if err != nil {
      log.Fatal("Open mysql failed,err:", err)
      return
   }
   DB = db
   fmt.Println("Connect to mysql success")
 
   RedisClient = redis.NewClient(&redis.Options{
      Addr: "127.0.0.1:6379",
   })
   pong, err := RedisClient.Ping(RedisClient.Context()).Result()
   if err != nil {
      panic(err)
      return
   }
   fmt.Println("Connect to redis success: ", pong)
}
 
func getUserByID(id int) (*User, error) {
   var user User
   key := "user-" + strconv.Itoa(id)
 
   // 1.尝试从Redis中读取用户信息
   val, err := RedisClient.Get(RedisClient.Context(), key).Result()
   if err == redis.Nil {
      fmt.Println("Cache miss")
   } else if err != nil {
      log.Println("Get from Redis fail:", err)
   } else {
      fmt.Println("Get from Redis:", val)
      if err := json.Unmarshal([]byte(val), &user); err != nil { // 将json字符串转换为结构体
         log.Panicln("Unmarshal to user fail:", err)
      }
      return &user, nil
   }
 
   // 2.如果Redis中没有，从MySQL中查询
   query := "SELECT id, username, password, age FROM users WHERE id=?"
   err = DB.QueryRow(query, id).Scan(&user.ID, &user.Username, &user.Password, &user.Age)
   if err != nil {
      log.Println(err)
      return nil, err
   }
 
   // 3.然后更新Redis缓存
   val, err = json.Marshal(user) // 将结构体转换为json字符串
   if err != nil {
      log.Panicln("Marshal user fail:", err)
   }
   err = RedisClient.Set(RedisClient.Context(), key, val, 0).Err()
   if err != nil {
      log.Panicln("Cache to Redis fail:", err)
   }
   return &user, nil
}

3. Wir haben das Schreiben der Cache-Logik abgeschlossen. Jetzt testen wir diesen Code und sehen, wie er funktioniert.

Zuallererst muss unser Testprogramm zum ersten Mal Benutzerinformationen aus MySQL lesen:

func main() {
   id := 1
   user, err := getUserByID(id)
   if err != nil {
      log.Fatal(err)
      return
   }
   fmt.Printf("User info: id=%d, username=%s, password=%s, age=%d
",
      user.ID, user.Username, user.Password, user.Age)
}

Führen Sie das Programm aus. Die Ausgabe lautet wie folgt:

Cache miss
User info: id=1, username=kirito, password=123456, age=18

Sie können sehen, dass das Programm die Benutzerinformationen aus MySQL entnimmt und speichert es im Redis-Cache.

Nachdem derselbe Benutzer zum zweiten Mal abgefragt wurde, liest das Programm die Benutzerinformationen von Redis, anstatt auf die MySQL-Datenbank zuzugreifen:

func main() {
   id := 1
   user, err := getUserByID(id)
   if err != nil {
      log.Fatal(err)
      return
   }
   fmt.Printf("User info: id=%d, username=%s, password=%s, age=%d
",
      user.ID, user.Username, user.Password, user.Age)
}

Führen Sie das Programm aus und die Ausgabe lautet wie folgt:

Get from Redis: {"ID":1,"Username":"kirito","Password":"123456","Age":18}
User info: id=1, username=kirito, password=123456, age=18

Sie können sehen, dass das Programm liest den Benutzer direkt aus Redis-Informationen, ohne auf die MySQL-Datenbank zuzugreifen, was die Nützlichkeit von Caching beweist.

Zusammenfassung

In diesem Artikel haben wir die Praxis der Verwendung des Redis-Caching-Mechanismus in Golang vorgestellt, um die Effizienz des Datenbankzugriffs zu optimieren. Durch das Schreiben der Funktion getUserByID versuchen wir beim Abfragen von Benutzerinformationen zunächst, die Informationen aus Redis zu lesen, um die Abfrage zu beschleunigen. Wenn die Benutzerinformationen nicht in Redis vorhanden sind, lesen wir sie aus MySQL und speichern sie in Redis. Wenn das Programm nach dem Zwischenspeichern der Daten mehrmals auf dieselben Daten zugreift, kann es direkt aus dem Cache lesen, ohne jedes Mal auf die Datenbank zugreifen zu müssen.

Es ist zu beachten, dass durch die Verwendung des Caches die Generierung schmutziger Daten vermieden werden muss. Bei CRUD-Operationen für Daten muss der Cache auch den Datenoperationen folgen, um die Konsistenz der Daten im Cache und in der Datenbank sicherzustellen.

Im Allgemeinen kann die Verwendung des Caching-Mechanismus die Leistung des Programms erheblich verbessern und ist besonders effektiv bei der Verarbeitung großer Datenmengen. Diese Strategie ist auch in Systemen mit hoher Parallelität sehr praktisch und Entwicklern wird empfohlen, sie auszuprobieren.

Das obige ist der detaillierte Inhalt vonDie Praxis, Cache zu verwenden, um die Effizienz des Datenbankzugriffs in Golang zu beschleunigen.. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!