(base) ➜  go_study git:(master) ✗ go get github.com/gomodule/redigo/redis
go: downloading github.com/gomodule/redigo v1.8.6
go: downloading github.com/gomodule/redigo/redis v0.0.0-do-not-use

import (
    "fmt"
    "github.com/gomodule/redigo/redis"
)

func connect() {
    // 连接 redis-server
    // 创建连接
    con, err := redis.Dial("tcp", "localhost:6379")
    if err != nil {
        fmt.Printf("redis.Dial() error:%v", err)
        return
    }
    // 操作 con.Do()

    // 操作完成后关闭连接
    defer con.Close()
}

import (
    "fmt"
    "github.com/gomodule/redigo/redis"
)

// redis.Pool指针
var pool *redis.Pool

// 包初始化时执行
func init() {
    // 实例化连接池
    pool = &redis.Pool{
        MaxIdle:     10,  // 最初的连接数量
        MaxActive:   0,   // 连接池最大连接数量,不确定可以用0（0表示自动定义），按需分配
        IdleTimeout: 300, // 连接关闭时间 300秒 （300秒不使用自动关闭）
        Dial: func() (redis.Conn, error) { //要连接的redis数据库
            return redis.Dial("tcp", "localhost:6379")
        },
    }
}

func main() {
    con := pool.Get() //从连接池，取一个链接
    defer con.Close() //函数运行结束 ，把连接放回连接池

    // 操作 con.Do()
    v, err := redis.String(con.Do("get", "redigo"))
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(v)

}

    // Do sends a command to the server and returns the received reply.
    // This function will use the timeout which was set when the connection is created
    Do(commandName string, args ...interface{}) (reply interface{}, err error)

    reply, err := con.Do("set", "redigo", "succ")
    if err != nil {
        fmt.Println("SET error: ", err)
    }
    fmt.Println(reply) // OK

    v, err := redis.String(con.Do("get", "redigo"))
    if err != nil {
        fmt.Println(err)
        return
    }

go mod init project_name

go get github.com/go-redis/redis/v8

import (
    "context"
    "github.com/go-redis/redis/v8"
)

var ctx = context.Background()

func ExampleClient() {
    rdb := redis.NewClient(&redis.Options{
        Addr:     "localhost:6379",
        Password: "", // no password set
        DB:       0,  // use default DB
    })

    err := rdb.Set(ctx, "key", "value", 0).Err()
    if err != nil {
        panic(err)
    }

    val, err := rdb.Get(ctx, "key").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("key", val)
}

rdb := redis.NewClient(&redis.Options{
    Addr:     "localhost:6379",
    Password: "", // no password set
    DB:       0,  // use default DB
})

// Options keeps the settings to setup redis connection.
type Options struct {
    // The network type, either tcp or unix.
    // Default is tcp.
    Network string
    // host:port address.
    Addr string

    // Dialer creates new network connection and has priority over
    // Network and Addr options.
    Dialer func(ctx context.Context, network, addr string) (net.Conn, error)

    // Hook that is called when new connection is established.
    OnConnect func(ctx context.Context, cn *Conn) error

    // Use the specified Username to authenticate the current connection
    // with one of the connections defined in the ACL list when connecting
    // to a Redis 6.0 instance, or greater, that is using the Redis ACL system.
    Username string
    // Optional password. Must match the password specified in the
    // requirepass server configuration option (if connecting to a Redis 5.0 instance, or lower),
    // or the User Password when connecting to a Redis 6.0 instance, or greater,
    // that is using the Redis ACL system.
    Password string

    // Database to be selected after connecting to the server.
    DB int

    // Maximum number of retries before giving up.
    // Default is 3 retries; -1 (not 0) disables retries.
    MaxRetries int
    // Minimum backoff between each retry.
    // Default is 8 milliseconds; -1 disables backoff.
    MinRetryBackoff time.Duration
    // Maximum backoff between each retry.
    // Default is 512 milliseconds; -1 disables backoff.
    MaxRetryBackoff time.Duration

    // Dial timeout for establishing new connections.
    // Default is 5 seconds.
    DialTimeout time.Duration
    // Timeout for socket reads. If reached, commands will fail
    // with a timeout instead of blocking. Use value -1 for no timeout and 0 for default.
    // Default is 3 seconds.
    ReadTimeout time.Duration
    // Timeout for socket writes. If reached, commands will fail
    // with a timeout instead of blocking.
    // Default is ReadTimeout.
    WriteTimeout time.Duration

    // Type of connection pool.
    // true for FIFO pool, false for LIFO pool.
    // Note that fifo has higher overhead compared to lifo.
    PoolFIFO bool
    // Maximum number of socket connections.
    // Default is 10 connections per every available CPU as reported by runtime.GOMAXPROCS.
    PoolSize int
    // Minimum number of idle connections which is useful when establishing
    // new connection is slow.
    MinIdleConns int
    // Connection age at which client retires (closes) the connection.
    // Default is to not close aged connections.
    MaxConnAge time.Duration
    // Amount of time client waits for connection if all connections
    // are busy before returning an error.
    // Default is ReadTimeout + 1 second.
    PoolTimeout time.Duration
    // Amount of time after which client closes idle connections.
    // Should be less than server's timeout.
    // Default is 5 minutes. -1 disables idle timeout check.
    IdleTimeout time.Duration
    // Frequency of idle checks made by idle connections reaper.
    // Default is 1 minute. -1 disables idle connections reaper,
    // but idle connections are still discarded by the client
    // if IdleTimeout is set.
    IdleCheckFrequency time.Duration

    // Enables read only queries on slave nodes.
    readOnly bool

    // TLS Config to use. When set TLS will be negotiated.
    TLSConfig *tls.Config

    // Limiter interface used to implemented circuit breaker or rate limiter.
    Limiter Limiter
}

opt, err := redis.ParseURL("redis://localhost:6379/<db>")
if err != nil {
    panic(err)
}

rdb := redis.NewClient(opt)

package main

import (
    "context"
    "fmt"
    "github.com/go-redis/redis/v8"
)

func main() {
    ctx := context.Background()

    rdb := redis.NewClient(&redis.Options{
        Addr:     "localhost:6379",
        Password: "", // no password set
        DB:       0,  // use default DB
    })

    // set值
    err := rdb.Set(ctx, "key", "value", 0).Err()
    if err != nil {
        panic(err)
    }

    // get值
    val, err := rdb.Get(ctx, "key").Result()
    if err == redis.Nil {
        fmt.Println("key does not exist")
    } else if err != nil {
        panic(err)
    } else {
        fmt.Println("key", val)
    }
}

rdb := redis.NewClusterClient(&redis.ClusterOptions{
    Addrs: []string{":7000", ":7001", ":7002", ":7003", ":7004", ":7005"},
})