beego redigo redis连接池封装了一下常用的方法 持续学习 持续更新

Posted post&get

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了beego redigo redis连接池封装了一下常用的方法 持续学习 持续更新相关的知识,希望对你有一定的参考价值。

package models

import (
"encoding/json"
"errors"
"fmt"
"github.com/astaxie/beego"
"github.com/astaxie/beego/logs"
"github.com/garyburd/redigo/redis"
"time"
)

var Rdb redis.Conn

/**
redis 初始化连接
*/
func GetRedisPool() *redis.Pool {
//连接地址
RedisConn := beego.AppConfig.String("RedisConn")
//db分区
RedisDbNum := beego.AppConfig.DefaultInt("RedisDbNum", 0)
//密码
RedisPassword := beego.AppConfig.String("RedisPassword")

//建立连接池
return &redis.Pool{
//最大的空闲连接数,表示即使没有redis连接时依然可以保持N个空闲的连接,而不被清除,随时处于待命状态。
MaxIdle: beego.AppConfig.DefaultInt("RedisMaxIdle", 1),
//最大的激活连接数,表示同时最多有N个连接
MaxActive: beego.AppConfig.DefaultInt("RedisMaxActive", 10),
//最大的空闲连接等待时间,超过此时间后,空闲连接将被关闭
IdleTimeout: 300 * time.Second,
//建立连接
Dial: func() (redis.Conn, error) {
logs.Info(RedisConn)
c, err := redis.Dial("tcp", RedisConn)
if err != nil {
return nil, fmt.Errorf("redis connection error: %s", err)
}
if RedisPassword != "" {
if _, authErr := c.Do("AUTH", RedisPassword); authErr != nil {
return nil, fmt.Errorf("redis auth password error: %s", authErr)
}
}
//选择分区
c.Do("SELECT", RedisDbNum)
return c, nil
},
//ping
TestOnBorrow: func(c redis.Conn, t time.Time) error {
_, err := c.Do("PING")
if err != nil {
return fmt.Errorf("ping redis error: %s", err)
}
return nil
},
}

}

func init() {
Rdb = GetRedisPool().Get()
}

/**
redis SET
*/
func RdbSet(key, v string) (bool, error) {
b, err := redis.Bool(Rdb.Do("SET", key, v))
if err != nil {
logs.Error("set error", err.Error())
return false, err
}
return b, nil
}

/**
redis GET
*/
func RdbGet(key string) (string, error) {
val, err := redis.String(Rdb.Do("GET", key))
if err != nil {
logs.Error("get error", err.Error())
return "", err
}

return val, nil
}

/**
redis EXPIRE
*/
func RdbSetKeyExp(key string, ex int) error {
_, err := Rdb.Do("EXPIRE", key, ex)
if err != nil {
logs.Error("set error", err.Error())
return err
}
return nil
}

func RdbSetExp(key, v string, ex int) error {
_, err := Rdb.Do("SET", key, v, "EX", ex)
if err != nil {
logs.Error("set error", err.Error())
return err
}
return nil
}

/**
redis EXISTS
*/
func RdbCheck(key string) bool {
b, err := redis.Bool(Rdb.Do("EXISTS", key))
if err != nil {
fmt.Println(err)
return false
}
return b
}

/**
redis DEL
*/
func RdbDel(key string) error {
_, err := Rdb.Do("DEL", key)
if err != nil {
fmt.Println(err)
return err
}
return nil
}

/**
redis SETNX
*/
func RdbSetJson(key string, data interface{}) error {
value, _ := json.Marshal(data)
n, _ := Rdb.Do("SETNX", key, value)
if n != int64(1) {
return errors.New("set failed")
}
return nil
}

/**
redis GET
return map
*/
func RdbGetJson(key string) (map[string]string, error) {
var jsonData map[string]string
bv, err := redis.Bytes(Rdb.Do("GET", key))
if err != nil {
logs.Error("get json error", err.Error())
return nil, err
}
errJson := json.Unmarshal(bv, &jsonData)
if errJson != nil {
logs.Error("json nil", err.Error())
return nil, err
}
return jsonData, nil
}

/**
redis hSet 注意 设置什么类型 取的时候需要获取对应类型
*/
func RdbHSet(key string, field string, data interface{}) error {
_, err := Rdb.Do("HSET", key, field, data)
if err != nil {
logs.Error("hSet error", err.Error())
return err
}
return nil
}

/**
redis hGet 注意 设置什么类型 取的时候需要获取对应类型
*/
func RdbHGet(key, field string) (interface{}, error) {
data, err := Rdb.Do("HGET", key, field)
if err != nil {
logs.Error("hGet error", err.Error())
return nil, err
}
return data, nil
}

/**
redis hGetAll
return map
*/
func RdbHGetAll(key string) (map[string]string, error) {
data, err2 := redis.StringMap(Rdb.Do("HGETALL", key))
_, err := data, err2
if err != nil {
logs.Error("hGetAll error", err.Error())
return nil, err
}
return data, nil
}

/**
redis INCR 将 key 中储存的数字值增一
*/
func RdbIncr(key string) error {
_, err := Rdb.Do("INCR", key)
if err != nil {
logs.Error("INCR error", err.Error())
return err
}
return nil

}

/**
redis INCRBY 将 key 所储存的值加上增量 n
*/
func RdbIncrBy(key string, n int) error {
_, err := Rdb.Do("INCRBY", key, n)
if err != nil {
logs.Error("INCRBY error", err.Error())
return err
}
return nil
}

/**
redis DECR 将 key 中储存的数字值减一。
*/
func RdbDecr(key string) error {
_, err := Rdb.Do("DECR", key)
if err != nil {
logs.Error("DECR error", err.Error())
return err
}
return nil
}

/**
redis DECRBY 将 key 所储存的值减去减量 n
*/
func RdbDecrBy(key string, n int) error {
_, err := Rdb.Do("DECRBY", key, n)
if err != nil {
logs.Error("DECRBY error", err.Error())
return err
}
return nil
}

/**
redis SADD 将一个或多个 member 元素加入到集合 key 当中,已经存在于集合的 member 元素将被忽略。
*/
func RdbSAdd(key, v string) error {
_, err := Rdb.Do("SADD", key, v)
if err != nil {
logs.Error("SADD error", err.Error())
return err
}
return nil
}

/**
redis SMEMBERS 返回集合 key 中的所有成员。
return map
*/
func RdbSMembers(key string) (interface{}, error) {
data, err := redis.Strings(Rdb.Do("SMEMBERS", key))
if err != nil {
logs.Error("json nil", err)
return nil, err
}
return data, nil
}

/**
redis SISMEMBER 判断 member 元素是否集合 key 的成员。
return bool
*/
func RdbSISMembers(key, v string) bool {
b, err := redis.Bool(Rdb.Do("SISMEMBER", key, v))
if err != nil {
logs.Error("SISMEMBER error", err.Error())
return false
}
return b
}

以上是关于beego redigo redis连接池封装了一下常用的方法 持续学习 持续更新的主要内容,如果未能解决你的问题,请参考以下文章

redigo 连接池 - 为啥在删除陈旧连接时释放锁

go-redis 基于beego正确使用序列化存储数据和反序列化获取数据

Redigo:尝试连接池时无效的内存地址或 nil 指针取消引用

go redigo的简单操作

redis(包括连接池)

golang redis连接池使用方法