Einführung in die Methode zur Implementierung des sekundären Caches mit MySQL und Redis (Codebeispiel)

Dieser Artikel bietet Ihnen eine Einführung in die Methode zur Implementierung des sekundären Caches mit MySQL und Redis (Codebeispiele). Ich hoffe, dass er für Sie hilfreich ist .

Einführung in Redis

• Redis ist vollständig Open Source und kostenlos, hält sich an das BSD-Protokoll und ist eine leistungsstarke Schlüsselwertdatenbank

• Redis verfügt über die folgenden drei Funktionen mit anderen Schlüsselwert-Cache-Produkten:

• Redis unterstützt Datenpersistenz und kann Daten im Speicher auf der Festplatte speichern und neu starten Es kann zur Verwendung erneut geladen werden

• Redis unterstützt nicht nur einfache Daten vom Typ Schlüsselwert, sondern bietet auch die Speicherung von Listen-, Set-, Zset-, Hash- und anderen Datenstrukturen

• Redis unterstützt die Datensicherung, also die Datensicherung im Master-Slave-Modus

Vorteile

• Extrem hohe Leistung – Redis kann mit einer Geschwindigkeit von 110.000 Mal/s lesen und mit einer Geschwindigkeit von 81.000 Mal/s schreiben

• Rich Data Types – Redis unterstützt Strings und Listen in binären Fällen , Hashes, Sets und Ordered Sets Datentypoperationen

• Atomar – Alle Operationen in Redis sind atomar, was bedeutet, dass sie entweder erfolgreich ausgeführt werden oder gar nicht ausgeführt werden, wenn sie fehlschlagen. Einzelne Operationen sind atomar. Mehrere Operationen unterstützen auch Transaktionen, also Atomizität, verpackt durch MULTI- und EXEC-Anweisungen

Herunterladen und installieren

• Herunterladen und entpacken

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

• Ordner nach /usr/local/ verschieben

mv redis-5.0.3 /usr/local/

• Ordner eingeben und kompilieren und testen

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

• Kompilieren und installieren

sudo make install

• Redis starten

redis-server

Wenn der folgende Bildschirm erscheint, bedeutet dies, dass die Redis-Datenbank gestartet wurde:
jpg

MySQL und Redis führen sekundären Cache aus

• Bei Daten mit relativ großem Zugriffsvolumen müssen wir die aus der Datenbank erhaltenen Daten zwischenspeichern, um die Daten schneller abzurufen.

• Verwenden Sie den Redis-Caching-Prozess im Projekt

  Beim Daten-Caching sollten Synchronisierungsprobleme berücksichtigt werden: ob die Daten zwischengespeichert werden, bei der Abfrage der Daten, ob die Daten zwischengespeichert werden zwischengespeichert: Wenn Daten vorhanden sind, werden die zwischengespeicherten Daten direkt zurückgegeben, ohne die Datenbank abzufragen. Wenn sich die Datenbankdaten ändern, kann es zu Datenbankinkonsistenzen kommen. Sie können erwägen, die entsprechenden zwischengespeicherten Daten jedes Mal zu löschen, wenn Sie die Datenbank ändern, sodass die Datenbank bei einer erneuten Abfrage abgefragt und zwischengespeichert wird

1. bei der Abfrage Abfrage im Cache

2. Wenn sich keine Daten im Cache befinden, fragen Sie die Datenbank ab und speichern Sie die Daten im Cache

3. Wenn die Daten vorhanden sind wird im Cache abgefragt. Direkt zurückkehren, die Datenbank muss nicht mehr abgefragt werden

Schrittimplementierung

• Erstellen Sie die Datei redisPool.go zur Initialisierung des Verbindungspools

package redigo_pool

import (
    "flag"
    "github.com/garyburd/redigo/redis"
    "time"
)
var (
    Pool *redis.Pool
    RedisServer   = flag.String("redisServer", ":6379", "")
    
)
func init() {
    Pool = &redis.Pool{
        MaxIdle:     3, //最大空闲链接数，表示即使没有redis链接事依然可以保持N个空闲链接，而不被清除
        MaxActive:   3, //最大激活连接数，表示同时最多有多少个链接
        IdleTimeout: 240 * time.Second,//最大空闲链接等待时间，超过此时间，空闲将被关闭
        Dial: func() (redis.Conn, error) {
            c, err := redis.Dial("tcp", *RedisServer)
            if err != nil {
                return nil, err
            }
            return c, err
        },
        TestOnBorrow: func(c redis.Conn, t time.Time) error {
            if time.Since(t) < time.Minute {
                return nil
            }
            _, err := c.Do("PING")
            return err
        },
    }
}

• Main.go-Datei erstellen, um den Second-Level-Cache zu implementieren

package main

import (
    "database/sql"
    "encoding/json"
    "fmt"
    "github.com/garyburd/redigo/redis"
    _ "github.com/go-sql-driver/mysql"
    "strconv"
    "web/redis/redigo_pool"
    _ "web/redis/redigo_pool"
)

type Person struct {
    Id int `db:"id"`
    Name string `db:"name"`
    Age int `db:"age"`
    Rmb int `db:"rmb"`
}

func main() {
    var cmd string
    for{
        fmt.Println("输入命令")
        fmt.Scan(&cmd)
        switch cmd {
        case "getall":
            getAll()
        default:
            fmt.Println("不能识别其他命令")
        }
        fmt.Println()
    }
}

func getAll()  {
    //从连接池当中获取链接
    conn := redigo_pool.Pool.Get()
    //先查看redis中是否有数据
    //conn,_ :=redis.Dial("tcp","localhost:6379")
    defer conn.Close()
    values, _ := redis.Values(conn.Do("lrange", "mlist",0,-1))

    if len(values) > 0 {
        //如果有数据
        fmt.Println("从redis获取数据")
        //从redis中直接获取
        for _,key := range values{
            pid :=string(key.([]byte))
            id ,_:= strconv.Atoi(pid)
            results,_ := redis.Bytes(conn.Do("GET",id))
            var p Person
            err := json.Unmarshal(results,&p)
            if err != nil {
                fmt.Println("json 反序列化出错")
            }else {
                fmt.Printf("name = %s\n",p.Name)
            }
        }
    }else {
        fmt.Println("从mysql中获取")

        //查询数据库
        db,_ := sql.Open("mysql","root:Szt930708@tcp(localhost:3306)/mydb")
        defer db.Close()

        var persons []Person

        rows,_ := db.Query("select id,name,age,rmb from person")
        for rows.Next()  {
            var id int
            var name string
            var age int
            var rmb int
            rows.Scan(&id,&name,&age,&rmb)
            per := Person{id,name,age,rmb}
            persons = append(persons,per)

        }
        //写入到redis中:将person以hash的方式写入到redis中
        for _,p := range persons{

            p_byte,_ := json.Marshal(p)
            _,err1 := conn.Do("SETNX",p.Id,p_byte)
            _,err2 := conn.Do("lpush","mlist",p.Id)
            // 设置过期时间
            conn.Do("EXPIRE",p.Id,60*5)
            if err1 != nil || err2 != nil {
                fmt.Println("写入失败")
            }else {
                fmt.Println("写入成功")
            }
        }
        conn.Do("EXPIRE","mlist",60*5)
    }
}

Das obige ist der detaillierte Inhalt vonEinführung in die Methode zur Implementierung des sekundären Caches mit MySQL und Redis (Codebeispiel). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!