Detailed explanation of how to implement secondary cache with MySQL and 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 make test

sudo make install

redis-server

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, //Maximum number of idle links, indicating that even if there is no redis connection, N idle links can still be maintained without being cleared MaxActive: 3, //Maximum number of active connections, indicating the maximum number of links at the same time IdleTimeout: 240 * time.Second, //Maximum idle link waiting time, exceeding this time, the idle will be closed 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
  },
 }
}

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("Enter command")
  fmt.Scan(&cmd)
  switch cmd {
  case "getall":
   getAll()
  default:
   fmt.Println("Cannot recognize other commands")
  }
  fmt.Println()
 }
}

func getAll() {
 //Get the connection from the connection pool conn := redigo_pool.Pool.Get()
 //First check whether there is data in redis//conn,_ :=redis.Dial("tcp","localhost:6379")
 defer conn.Close()
 values, _ := redis.Values(conn.Do("lrange", "mlist",0,-1))

 if len(values) > 0 {
  //If there is data fmt.Println("Get data from redis")
  //Get directly from 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 deserialization error")
   }else {
    fmt.Printf("name = %s\n",p.Name)
   }
  }
 }else {
  fmt.Println("Get from mysql")

  //Query database 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)

  }
  //Write to redis: Write person to redis in hash mode for _,p := range persons{

   p_byte,_ := json.Marshal(p)
   _,err1 := conn.Do("SETNX",p.Id,p_byte)
   _,err2 := conn.Do("lpush","mlist",p.Id)
   // Set the expiration time conn.Do("EXPIRE",p.Id,60*5)
   if err1 != nil || err2 != nil {
    fmt.Println("Write failed")
   }else {
    fmt.Println("Written successfully")
   }
  }
  conn.Do("EXPIRE","mlist",60*5)
 }
}