go-封装使用redis功能

昨天上文中提过了通过连接池连接redis，日常redis常用的功能包括set,get , del,expire key等基础功能，以及sadd,hset,hget 功能，下面函数都封装好了，直接用即可

var (
	RedisClient *redis.Pool
)

func RedisConn(host, port, auth string) {
	address := fmt.Sprintf("%s:%s", host, port)
	// 建立连接池
	RedisClient = &redis.Pool{
		// 从配置文件获取maxidle以及maxactive，取不到则用后面的默认值
		MaxIdle: 16, //最初的连接数量
		//MaxActive:10000,    //最大连接数量
		MaxActive:   0,               //连接池最大连接数量,不确定可以用0（0表示自动定义），按需分配
		IdleTimeout: 5 * time.Second, //连接关闭时间 300秒 （300秒不使用自动关闭）
		Dial: func() (redis.Conn, error) { //要连接的redis数据库
			c, err := redis.Dial("tcp", address)
			if err != nil {
				return nil, err
			}
			if auth != "" && auth != "none" {
				if _, err := c.Do("AUTH", auth); err != nil {
					c.Close()
					logger.Error("redis auth error : ", err.Error())
					return nil, err
				}
			}
			return c, nil
		},
		TestOnBorrow: func(c redis.Conn, t time.Time) error {
			_, err := c.Do("PING")
			return err
		},
	}
}
func SetNxLock(ex int, k string) bool {
	//when return true pass ...
	rs := RedisClient.Get()
	if rs == nil {
		logger.Error("redis session get error, by pass .")
		return true
	}
	defer rs.Close()
	//redis lock when multi conductors are running
	rrsp, err := redis.String(rs.Do("SET", k, time.Now().String(), "EX", strconv.Itoa(ex), "NX"))
	if err != nil && err != redis.ErrNil {
		logger.Errorf("redis set %s nx error : %s", k, err.Error())
		return true
	}
	if err != nil && err == redis.ErrNil {
		logger.Debugf("redis of key %s get err : %s, do nothing on this time.", k, err.Error())
		return false
	}
	logger.Debugf("redis of key %s in lock succeed, resp : %s", k, rrsp)
	return true
}
func SetKey(k, v string, ex interface{}) (bool, error) {
	rs := RedisClient.Get()
	if rs == nil {
		logger.Error("redis session get error, by pass .")
		return false, nil
	}
	defer rs.Close()
	var rrsp string
	var err error
	if ex != nil {
		rrsp, err = redis.String(rs.Do("SET", k, v, "EX", ex.(int)))
	} else {
		rrsp, err = redis.String(rs.Do("SET", k, v))
	}

	if err != nil {
		logger.Errorf("redis set %s nx error : %s", k, err.Error())
		return false, err
	}
	if rrsp != "OK" {
		logger.Warningf("redis of key %s set resp %s.", k, rrsp)
		return false, err
	}
	logger.Debugf("redis of key %s set succeed, resp : %s", k, rrsp)
	return true, nil
}
func HsetKey(h, k, v string, ex interface{}) error {
	rs := RedisClient.Get()
	if rs == nil {
		logger.Error("redis session get error, by pass .")
		return nil
	}
	defer rs.Close()
	var err error
	rrsp, err := redis.Int64(rs.Do("HSET", h, k, v))
	if err != nil {
		logger.Errorf("redis set %s nx error : %s", h, err.Error())
		return err
	}
	if ex != nil {
		rrsp, err = redis.Int64(rs.Do("EXPIRE", h, ex.(int)))
	}
	if err != nil {
		logger.Errorf("redis hset %s nx error : %s", h, err.Error())
		return err
	}
	logger.Debugf("redis of key %s hset succeed, resp : %v", h, rrsp)
	return nil
}
func HgetKey(h, k string) (string, error) {
	rs := RedisClient.Get()
	if rs == nil {
		logger.Error("redis session get error, by pass .")
		return "unknown", errors.New("redis session get error")
	}
	defer rs.Close()
	var rrsp string
	var err error
	rrsp, err = redis.String(rs.Do("HGET", h, k))
	if err != nil {
		if err == redis.ErrNil {
			logger.Debugf("redis hget %s is nil", h)
			return "Nil", errors.New("nil error")
		} else {
			logger.Errorf("redis hget %s nx error : %s", h, err.Error())
			return "unknown", err
		}
	}
	logger.Debugf("redis of key %s hget succeed, resp : %s", h, rrsp)
	return rrsp, nil
}

func GetKey(k string) (string, error) {
	rs := RedisClient.Get()
	defer rs.Close()
	rrsp, err := redis.String(rs.Do("GET", k))
	if err != nil {
		logger.Errorf("redis get %s nx error : %s", k, err.Error())
		return "", err
	}
	return rrsp, nil
}
func ExistKey(k string) (bool, error) {
	rs := RedisClient.Get()
	defer rs.Close()
	rrsp, _ := redis.Bool(rs.Do("EXISTS", k))
	return rrsp, nil
}
func ScanKeys(maxCount int) ([]interface{}, error) {
	rs := RedisClient.Get()
	defer rs.Close()
	rrsp, err := redis.Values(rs.Do("SCAN", 0, "MATCH", "*", "COUNT", maxCount))
	if err != nil {
		logger.Errorf("redis scan keys error : %s", err.Error())
		return nil, err
	}
	return rrsp, nil
}
func DelKey(k string) (string, error) {
	rs := RedisClient.Get()
	defer rs.Close()
	rrsp, _ := redis.String(rs.Do("DEL", k))
	return rrsp, nil
}
func ExpireKey(k string, ex int) (bool, error) {
	rs := RedisClient.Get()
	if rs == nil {
		logger.Error("redis session get error, by pass .")
		return false, nil
	}
	defer rs.Close()
	var rrsp string
	var err error
	rrsp, err = redis.String(rs.Do("EXPIRE", k, strconv.Itoa(ex)))
	if err != nil {
		logger.Errorf("redis expire %s nx error : %s", k, err.Error())
		return false, err
	}
	if rrsp != "OK" {
		logger.Warningf("redis of key %s set resp %s.", k, rrsp)
		return false, err
	}
	logger.Debugf("redis of key %s set succeed, resp : %s", k, rrsp)
	return true, nil
}
func SaddKey(s, k string,ex int) (bool, error) {
	rs := RedisClient.Get()
	if rs == nil {
		logger.Error("redis session get error, by pass .")
		return false, nil
	}
	defer rs.Close()
	var rrsp int64
	var err error
	rrsp, err = redis.Int64(rs.Do("SADD", s, k))
	if err != nil {
		logger.Errorf("redis sadd %s nx error : %s", k, err.Error())
		return false, err
	}
	if rrsp == 0 {
		logger.Warningf("redis of key %s sadd resp %d.", k, rrsp)
		return false, err
	}
	exrsp, err := redis.Int64(rs.Do("EXPIRE", s, strconv.Itoa(ex)))
	if err != nil {
		logger.Errorf("redis expire %s nx error : %s", s, err.Error())
		return false, err
	}
	if exrsp == 0 {
		logger.Warningf("redis of key %s set resp %d.", s, exrsp)
		return false, err
	}

	logger.Debugf("redis of key %s sadd succeed, resp : %d", k, rrsp)
	logger.Debugf("redis of key %s set succeed, resp : %d",s, exrsp)
	return true, nil
}
func SMEMBERSKey(s string) (interface{}, error) {
	rs := RedisClient.Get()
	if rs == nil {
		logger.Error("redis session get error, by pass .")
		return false, nil
	}
	defer rs.Close()
	var rrsp interface{}
	var err error
	rrsp, err = redis.ByteSlices(rs.Do("SMEMBERS", s))
	if err != nil {
		logger.Errorf("redis smembers %s nx error : %s", s, err.Error())
		return nil, err
	}
	//if rrsp {
	//	logger.Warningf("redis of key %s smembers resp %v.", s, rrsp)
	//	return nil, err
	//}
	logger.Debugf("redis of key %s smembers succeed, resp : %v",s, rrsp)
	return rrsp, nil
}