Detaillierte Erklärung zur Implementierung des sekundären Caches mit MySQL und Redis

wget http://download.redis.io/releases/redis-5.0.3.tar.gz
tar xzf redis-5.0.3.tar.gz

mv redis-5.0.3 /usr/local/

cd /usr/local/redis-5.0.3
sudo machen test

sudo make installieren

Redis-Server

Paket redigo_pool

importieren (
 "Flagge"
 „github.com/garyburd/redigo/redis“
 "Zeit"
)
var (
 Pool *redis.Pool
 RedisServer = flag.String("redisServer", ":6379", "")
 
)
Funktion init() {
 Pool = &redis.Pool{
  MaxIdle: 3, // Maximale Anzahl inaktiver Links, was bedeutet, dass auch wenn keine Redis-Verbindung besteht, N inaktive Links aufrechterhalten werden können, ohne gelöscht zu werden. MaxActive: 3, // Maximale Anzahl aktiver Verbindungen, was die maximale Anzahl gleichzeitig aktiver Links angibt. IdleTimeout: 240 * time.Second, // Maximale Wartezeit für inaktive Links. Wenn diese Zeit überschritten wird, werden inaktive Links geschlossen. Dial: func() (redis.Conn, error) {
   c, err := redis.Dial("tcp", *RedisServer)
   wenn err != nil {
    returniere nil, err
   }
   returniere c, err
  },
  TestOnBorrow: func(c redis.Conn, t Zeit.Zeit) Fehler {
   if Zeit.Seit(t) < Zeit.Minute {
    Rückgabe Null
   }
   _, err := c.Do("PING")
   Rückgabefehler
  },
 }
}

Paket Haupt

importieren (
 "Datenbank/SQL"
 "Kodierung/JSON"
 "fmt"
 „github.com/garyburd/redigo/redis“
 _ "github.com/go-sql-driver/mysql"
 "strconv"
 "web/redis/redigo_pool"
 _ "web/redis/redigo_pool"
)

Typ Person Struktur {
 ID int `db:"id"`
 Name der Zeichenfolge `db:"name"`
 Alter int `db:"Alter"`
 Rmb int `db:"rmb"`
}

Funktion main() {
 var cmd Zeichenfolge
 für{
  fmt.Println("Befehl eingeben")
  fmt.Scan(&cmd)
  Schalter cmd {
  Fall "getall":
   getAll()
  Standard:
   fmt.Println("Kann andere Befehle nicht erkennen")
  }
  fmt.Println()
 }
}

Funktion getAll() {
 //Holen Sie sich die Verbindung aus dem Verbindungspool conn := redigo_pool.Pool.Get()
 //Überprüfen Sie zunächst, ob Daten in Redis vorhanden sind//conn,_ :=redis.Dial("tcp","localhost:6379")
 conn.Close() verschieben
 Werte, _ := redis.Werte(conn.Do("lrange", "mlist",0,-1))

 wenn Länge(Werte) > 0 {
  //Wenn Daten vorhanden sind, fmt.Println("Daten von Redis abrufen")
  //Direkt von Redis abrufen für _, Schlüssel := Bereichswerte{
   pid := Zeichenfolge(Schlüssel.([]Byte))
   Ich würde ,_:= strconv.Atoi(pid)
   Ergebnisse,_ := redis.Bytes(conn.Do("GET",id))
   var p Person
   err := json.Unmarshal(Ergebnisse,&p)
   wenn err != nil {
    fmt.Println("JSON-Deserialisierungsfehler")
   }anders {
    fmt.Printf("name = %s\n",p.Name)
   }
  }
 }anders {
  fmt.Println("Von MySQL abrufen")

  //Datenbank abfragen db,_ := sql.Open("mysql","root:Szt930708@tcp(localhost:3306)/mydb")
  db.Close() verschieben

  var Personen []Person

  Zeilen, _ := db.Query("Wählen Sie ID, Name, Alter, RMB aus Person aus")
  für Zeilen.Weiter() {
   var id int
   Variablenname Zeichenfolge
   var Alter int
   var rmb int
   Zeilen.Scan(&id,&name,&alter,&rmb)
   pro := Person{id,name,alter,rmb}
   Personen = anhängen(Personen,pro)

  }
  //Nach Redis schreiben: Person im Hash-Modus nach Redis schreiben für _,p := range persons{

   p_byte,_ := json.Marshal(p)
   _,err1 := conn.Do("SETNX",p.Id,p_byte)
   _,err2 := conn.Do("lpush","mlist",p.Id)
   // Ablaufzeit festlegen conn.Do("EXPIRE",p.Id,60*5)
   wenn err1 != nil || err2 != nil {
    fmt.Println("Schreiben fehlgeschlagen")
   }anders {
    fmt.Println("Erfolgreich geschrieben")
   }
  }
  conn.Do("ABLAUF","mlist",60*5)
 }
}