So bedienen Sie Redis und Redigo in Go

Go-operate redis

Installation

golang verfügt über mehrere Client-Pakete für den Betrieb von Redis, wie Redigo und Go-Redis. Das mit den meisten Sternen auf Github ist Redigo.

go get github.com/garyburd/redigo/redis
import "github.com/garyburd/redigo/redis"

Connection

Die Conn-Schnittstelle ist die Hauptschnittstelle für die Zusammenarbeit mit Redis. Sie können die Funktion Dial, DialWithTimeout oder NewConn verwenden, um eine Verbindung herzustellen. Wenn die Aufgabe abgeschlossen ist, muss die Anwendung die Funktion Close aufrufen, um den Vorgang abzuschließen .

package main
import (
"github.com/garyburd/redigo/redis"
"fmt"
)
func main()  {
    conn,err := redis.Dial("tcp","10.1.210.69:6379")
    if err != nil {
        fmt.Println("connect redis error :",err)
        return
    }
    defer conn.Close()
}

Verwenden Sie

package main
import (
"github.com/garyburd/redigo/redis"
"fmt"
)
func main()  {
    conn,err := redis.Dial("tcp","10.1.210.69:6379")
    if err != nil {
        fmt.Println("connect redis error :",err)
        return
    }
    defer conn.Close()
    _, err = conn.Do("SET", "name", "wd")
    if err != nil {
        fmt.Println("redis set error:", err)
    }
    name, err := redis.String(conn.Do("GET", "name"))
    if err != nil {
        fmt.Println("redis get error:", err)
    } else {
        fmt.Printf("Got name: %s \n", name)
    }
}

, um die Schlüsselablaufzeit festzulegen

Durch die Verwendung von Send(), Flush( ) und Receive() können drei Methoden Pipeline-Operationen gleichzeitig ausführen. Der Client kann die send()-Methode verwenden, um einen oder mehrere Befehle gleichzeitig an den Server zu senden. Wenn der Befehl gesendet wird, wird die Flush()-Methode verwendet, um die Befehlseingabe im Puffer gleichzeitig an den Server zu senden Verwendet dann nacheinander die Methode „Receive()“. Liest alle Ergebnisse der Befehlsoperation in der Reihenfolge „First In, First Out“.

  _, err = conn.Do("expire", "name", 10) //10秒过期
    if err != nil {
        fmt.Println("set expire error: ", err)
        return
    }

Send: Den Befehl an den Puffer senden

Flush: Den Puffer löschen und den Befehl sofort an den Server senden

• Recevie: Die Ergebnisse der Serverantwort nacheinander lesen, wenn der Lesebefehl dies tut Wenn Sie nicht antworten, wird der Vorgang blockiert.

_, err = conn.Do("MSET", "name", "wd","age",22)
    if err != nil {
        fmt.Println("redis mset error:", err)
    }
    res, err := redis.Strings(conn.Do("MGET", "name","age"))
    if err != nil {
        fmt.Println("redis get error:", err)
    } else {
        res_type := reflect.TypeOf(res)
        fmt.Printf("res type : %s \n", res_type)
        fmt.Printf("MGET name: %s \n", res)
        fmt.Println(len(res))
    }
//结果：
//res type : []string 
//MGET name: [wd 22] 
//2

• redis-Release-Abonnementmodus

  package main
  import (
  "github.com/garyburd/redigo/redis"
  "fmt"
      "reflect"
  )
  func main()  {
      conn,err := redis.Dial("tcp","10.1.210.69:6379")
      if err != nil {
          fmt.Println("connect redis error :",err)
          return
      }
      defer conn.Close()
      _, err = conn.Do("LPUSH", "list1", "ele1","ele2","ele3")
      if err != nil {
          fmt.Println("redis mset error:", err)
      }
      res, err := redis.String(conn.Do("LPOP", "list1"))
      if err != nil {
          fmt.Println("redis POP error:", err)
      } else {
          res_type := reflect.TypeOf(res)
          fmt.Printf("res type : %s \n", res_type)
          fmt.Printf("res  : %s \n", res)
      }
  }
  //res type : string 
  //res  : ele3

  Transaktionsvorgang
• MULTI, EXEC, DISCARD und WATCH sind die Grundlage für Redis-Transaktionen. Wenn wir die Go-Sprache verwenden, um Transaktionsvorgänge auf Redis durchzuführen, verwenden wir natürlich im Wesentlichen diese Befehle .
  MULTI: Eine Transaktion starten

EXEC: Eine Transaktion ausführen

DISCARD: Eine Transaktion abbrechen

WATCH: Die Schlüsseländerungen in der Transaktion überwachen und die Transaktion abbrechen, sobald eine Änderung vorliegt.

Beispiel:

package main
import (
"github.com/garyburd/redigo/redis"
"fmt"
    "reflect"
)
func main()  {
    conn,err := redis.Dial("tcp","10.1.210.69:6379")
    if err != nil {
        fmt.Println("connect redis error :",err)
        return
    }
    defer conn.Close()
    _, err = conn.Do("HSET", "student","name", "wd","age",22)
    if err != nil {
        fmt.Println("redis mset error:", err)
    }
    res, err := redis.Int64(conn.Do("HGET", "student","age"))
    if err != nil {
        fmt.Println("redis HGET error:", err)
    } else {
        res_type := reflect.TypeOf(res)
        fmt.Printf("res type : %s \n", res_type)
        fmt.Printf("res  : %d \n", res)
    }
}
//res type : int64 
//res  : 22

Universeller Betrieb

Redis verbinden

Send(commandName string, args ...interface{}) error
Flush() error
Receive() (reply interface{}, err error)

Schreiben

package main
import (
"github.com/garyburd/redigo/redis"
"fmt"
)
func main()  {
    conn,err := redis.Dial("tcp","10.1.210.69:6379")
    if err != nil {
        fmt.Println("connect redis error :",err)
        return
    }
    defer conn.Close()
    conn.Send("HSET", "student","name", "wd","age","22")
    conn.Send("HSET", "student","Score","100")
    conn.Send("HGET", "student","age")
    conn.Flush()
    res1, err := conn.Receive()
    fmt.Printf("Receive res1:%v \n", res1)
    res2, err := conn.Receive()
    fmt.Printf("Receive res2:%v\n",res2)
    res3, err := conn.Receive()
    fmt.Printf("Receive res3:%s\n",res3)
}
//Receive res1:0 
//Receive res2:0
//Receive res3:22

Lesen

package main
import (
    "github.com/garyburd/redigo/redis"
    "fmt"
    "time"
)
func Subs() {  //订阅者
    conn, err := redis.Dial("tcp", "10.1.210.69:6379")
    if err != nil {
        fmt.Println("connect redis error :", err)
        return
    }
    defer conn.Close()
    psc := redis.PubSubConn{conn}
    psc.Subscribe("channel1") //订阅channel1频道
    for {
        switch v := psc.Receive().(type) {
        case redis.Message:
            fmt.Printf("%s: message: %s\n", v.Channel, v.Data)
        case redis.Subscription:
            fmt.Printf("%s: %s %d\n", v.Channel, v.Kind, v.Count)
        case error:
            fmt.Println(v)
            return
        }
    }
}
func Push(message string)  { //发布者
    conn, _ := redis.Dial("tcp", "10.1.210.69:6379")
    _,err1 := conn.Do("PUBLISH", "channel1", message)
       if err1 != nil {
             fmt.Println("pub err: ", err1)
                 return
            }

}
func main()  {
    go Subs()
    go Push("this is wd")
    time.Sleep(time.Second*3)
}
//channel1: subscribe 1
//channel1: message: this is wd

Vollständiger Code

package main
import (
"github.com/garyburd/redigo/redis"
"fmt"
)
func main()  {
    conn,err := redis.Dial("tcp","10.1.210.69:6379")
    if err != nil {
        fmt.Println("connect redis error :",err)
        return
    }
    defer conn.Close()
    conn.Send("MULTI")
    conn.Send("INCR", "foo")
    conn.Send("INCR", "bar")
    r, err := conn.Do("EXEC")
    fmt.Println(r)
}
//[1, 1]

Das obige ist der detaillierte Inhalt vonSo bedienen Sie Redis und Redigo in Go. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!