Golang和Redis配合真的好吗?

Myth丶恋晨 2022-12-02 10:53 278阅读 0赞

### Golang与Redis ###

*  Golang操作Redis
 *   *  安装第三方开源Redis库
 *  Golang操作Redis
 *   *  连接
     *  命令操作
     *   *  go中发送与响应对应类型
         *  Redis 命令响应会用以下Go类型表示：
         *  \*\*可以使用GO的类型断言或者reply辅助函数将返回的interface\{\}转换为对应类型。\*\*
         *  \*\*设置key过期时间\*\*
         *  批量获取mget、批量设置mset
         *  列表操作
         *  hash操作
 *  Pipelining(管道)
 *  发布/订阅
 *   *  发布者
     *  订阅者
 *  事务操作
 *  连接池使用
 *   *  代码实现

# Golang操作Redis #

## 安装第三方开源Redis库 ##

*  使用第三方开源的redis库 : github.com/garyburd/redigo/redis
 *  在使用Redis前,先安装第三方Redis库,在Gopath路径下执行安装指令:

> go get github.com/garyburd/redigo/redis

*  安装成功后,可以看到如下包  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ExMzA5NTI1ODAy_size_16_color_FFFFFF_t_70_pic_center]

# Golang操作Redis #

## 连接 ##

**Conn接口是与Redis协作的主要接口，可以使用Dial,DialWithTimeout或者NewConn函数来创建连接，当任务完成时，应用程序必须调用Close函数来完成操作。**

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

## 命令操作 ##

**通过使用Conn接口中的do方法执行redis命令**  
**redis命令大全参考**：http://doc.redisfans.com/

### go中发送与响应对应类型 ###

**Do函数会必要时将参数转化为二进制字符串**

<table> 
 <thead> 
  <tr> 
   <th>Go Type</th> 
   <th>Conversion</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>[]byte</td> 
   <td>Sent as is</td> 
  </tr> 
  <tr> 
   <td>string</td> 
   <td>Sent as is</td> 
  </tr> 
  <tr> 
   <td>int, int64</td> 
   <td>strconv.FormatInt(v)</td> 
  </tr> 
  <tr> 
   <td>float64</td> 
   <td>strconv.FormatFloat(v, ‘g’, -1, 64)</td> 
  </tr> 
  <tr> 
   <td>bool</td> 
   <td>true -&gt; “1”, false -&gt; “0”</td> 
  </tr> 
  <tr> 
   <td>nil</td> 
   <td>“”</td> 
  </tr> 
  <tr> 
   <td>all</td> 
   <td>other types fmt.Print(v)</td> 
  </tr> 
 </tbody> 
</table>

### Redis 命令响应会用以下Go类型表示： ###

<table> 
 <thead> 
  <tr> 
   <th>Redis type</th> 
   <th>Go type</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>error</td> 
   <td>redis.Error</td> 
  </tr> 
  <tr> 
   <td>integer</td> 
   <td>int64</td> 
  </tr> 
  <tr> 
   <td>simple string</td> 
   <td>string</td> 
  </tr> 
  <tr> 
   <td>bulk string</td> 
   <td>[]byte or nil if value not present.</td> 
  </tr> 
  <tr> 
   <td>array</td> 
   <td>[]interface{} or nil if value not present.</td> 
  </tr> 
 </tbody> 
</table>

### **可以使用GO的类型断言或者reply辅助函数将返回的interface\{\}转换为对应类型。** ###

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)
        }
    }

### **设置key过期时间** ###

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

### 批量获取mget、批量设置mset ###

_, 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

### 列表操作 ###

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

### hash操作 ###

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

# Pipelining(管道) #

**管道操作可以理解为并发操作，并通过Send()，Flush()，Receive()三个方法实现。客户端可以使用send()方法一次性向服务器发送一个或多个命令，命令发送完毕时，使用flush()方法将缓冲区的命令输入一次性发送到服务器，客户端再使用Receive()方法依次按照先进先出的顺序读取所有命令操作结果。**

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

*  Send：发送命令至缓冲区
 *  Flush：清空缓冲区，将命令一次性发送至服务器
 *  Recevie：依次读取服务器响应结果，当读取的命令未响应时，该操作会阻塞。

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

# 发布/订阅 #

**redis本身具有发布订阅的功能，其发布订阅功能通过命令SUBSCRIBE(订阅)／PUBLISH(发布)实现，并且发布订阅模式可以是多对多模式还可支持正则表达式，发布者可以向一个或多个频道发送消息，订阅者可订阅一个或者多个频道接受消息。**

## 发布者 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ExMzA5NTI1ODAy_size_16_color_FFFFFF_t_70_pic_center 1]

## 订阅者 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ExMzA5NTI1ODAy_size_16_color_FFFFFF_t_70_pic_center 2]

##	操作
    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

# 事务操作 #

**MULTI, EXEC,DISCARD和WATCH是构成Redis事务的基础，当然我们使用go语言对redis进行事务操作的时候本质也是使用这些命令。**

*  MULTI：开启事务
 *  EXEC：执行事务
 *  DISCARD：取消事务
 *  WATCH：监视事务中的键变化，一旦有改变则取消事务。

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]

# 连接池使用 #

**redis连接池是通过pool结构体实现，以下是源码定义，相关参数说明已经备注：**

type Pool struct { 
        // Dial is an application supplied function for creating and configuring a
        // connection.
        //
        // The connection returned from Dial must not be in a special state
        // (subscribed to pubsub channel, transaction started, ...).
        Dial func() (Conn, error) //连接方法
    
        // TestOnBorrow is an optional application supplied function for checking
        // the health of an idle connection before the connection is used again by
        // the application. Argument t is the time that the connection was returned
        // to the pool. If the function returns an error, then the connection is
        // closed.
        TestOnBorrow func(c Conn, t time.Time) error
    
        // Maximum number of idle connections in the pool.
        MaxIdle int  //最大的空闲连接数，即使没有redis连接时依然可以保持N个空闲的连接，而不被清除，随时处于待命状态
    
        // Maximum number of connections allocated by the pool at a given time.
        // When zero, there is no limit on the number of connections in the pool.
        MaxActive int //最大的激活连接数，同时最多有N个连接
    
        // Close connections after remaining idle for this duration. If the value
        // is zero, then idle connections are not closed. Applications should set
        // the timeout to a value less than the server's timeout.
        IdleTimeout time.Duration  //空闲连接等待时间，超过此时间后，空闲连接将被关闭
    
        // If Wait is true and the pool is at the MaxActive limit, then Get() waits
        // for a connection to be returned to the pool before returning.
        Wait bool  //当配置项为true并且MaxActive参数有限制时候，使用Get方法等待一个连接返回给连接池
    
        // Close connections older than this duration. If the value is zero, then
        // the pool does not close connections based on age.
        MaxConnLifetime time.Duration
        // contains filtered or unexported fields
        }

## 代码实现 ##

package main
    
    import (
        "github.com/garyburd/redigo/redis"
        "fmt"
    )
    
    var Pool redis.Pool
    func init()  {       //init 用于初始化一些参数，先于main执行
        Pool = redis.Pool{ 
            MaxIdle:     16,
            MaxActive:   32,
            IdleTimeout: 120,
            Dial: func() (redis.Conn, error) { 
                return redis.Dial("tcp", "10.1.210.69:6379")
            },
        }
    }
    
    func main()  { 
    
        conn :=Pool.Get()
        res,err := conn.Do("HSET","student","name","jack")
        fmt.Println(res,err)
        res1,err := redis.String(conn.Do("HGET","student","name"))
        fmt.Printf("res:%s,error:%v",res1,err)
    
    }
    //0 <nil>
    //res:jack,error:<nil>

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ExMzA5NTI1ODAy_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/74b64e127b2f46a4b62a007bd2a77b15.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ExMzA5NTI1ODAy_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/1aa89b85e9fe48ef8ea4eb7602942515.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ExMzA5NTI1ODAy_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/c186f1d3f0994a0bbb6871ed44ddf767.png