From e8692e9cd053fff608357af8b7814b7c5afc83fb Mon Sep 17 00:00:00 2001 From: huangjuajun <102564160@qq.com> Date: Mon, 30 May 2022 13:34:09 +0800 Subject: [PATCH] add Reverse:for v1.1.0 --- go.mod | 4 +- utils/cache/redis.go | 107 ++++++++++++++++++++++--------------------- 2 files changed, 56 insertions(+), 55 deletions(-) diff --git a/go.mod b/go.mod index 4575af7..5de508c 100644 --- a/go.mod +++ b/go.mod @@ -1,6 +1,6 @@ module code.fnuoos.com/go_rely_warehouse/zyos_go_tools.git -go 1.15 +go 1.16 require ( github.com/boombuler/barcode v1.0.1 @@ -8,7 +8,7 @@ require ( github.com/gin-gonic/gin v1.7.7 github.com/go-creed/sat v1.0.3 github.com/go-redis/redis v6.15.9+incompatible - github.com/gomodule/redigo v2.0.0+incompatible + github.com/gomodule/redigo/redis v0.0.1 github.com/json-iterator/go v1.1.12 // indirect github.com/makiuchi-d/gozxing v0.1.1 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect diff --git a/utils/cache/redis.go b/utils/cache/redis.go index 73d7cad..d39ac6e 100644 --- a/utils/cache/redis.go +++ b/utils/cache/redis.go @@ -3,10 +3,11 @@ package zhios_tool_cache import ( "encoding/json" "errors" - redigo "github.com/gomodule/redigo/redis" "log" "strings" "time" + + redigoRedis "github.com/gomodule/redigo/redis" ) // configuration @@ -32,24 +33,24 @@ type Config struct { KeyPlaceholder string // placeholder to be parsed using given arguments to obtain a final key; example is "?" } -var pool *redigo.Pool +var pool *redigoRedis.Pool var conf *Config func NewRedis(addr string) { if addr == "" { panic("\nredis connect string cannot be empty\n") } - pool = &redigo.Pool{ + pool = &redigoRedis.Pool{ MaxIdle: redisMaxIdleConn, IdleTimeout: redisIdleTTL, MaxActive: redisMaxActive, // MaxConnLifetime: redisDialTTL, Wait: true, - Dial: func() (redigo.Conn, error) { - c, err := redigo.Dial("tcp", addr, - redigo.DialConnectTimeout(redisDialTTL), - redigo.DialReadTimeout(redisReadTTL), - redigo.DialWriteTimeout(redisWriteTTL), + Dial: func() (redigoRedis.Conn, error) { + c, err := redigoRedis.Dial("tcp", addr, + redigoRedis.DialConnectTimeout(redisDialTTL), + redigoRedis.DialReadTimeout(redisReadTTL), + redigoRedis.DialWriteTimeout(redisWriteTTL), ) if err != nil { log.Println("Redis Dial failed: ", err) @@ -57,7 +58,7 @@ func NewRedis(addr string) { } return c, err }, - TestOnBorrow: func(c redigo.Conn, t time.Time) error { + TestOnBorrow: func(c redigoRedis.Conn, t time.Time) error { _, err := c.Do("PING") if err != nil { log.Println("Unable to ping to redis server:", err) @@ -80,7 +81,7 @@ func Do(cmd string, args ...interface{}) (reply interface{}, err error) { return conn.Do(cmd, args...) } -func GetPool() *redigo.Pool { +func GetPool() *redigoRedis.Pool { return pool } @@ -163,26 +164,26 @@ func Get(key string) (interface{}, error) { return Do("GET", key) } func GetTTL(key string) (time.Duration, error) { - ttl, err := redigo.Int64(Do("TTL", key)) + ttl, err := redigoRedis.Int64(Do("TTL", key)) return time.Duration(ttl) * time.Second, err } func GetBytes(key string) ([]byte, error) { - return redigo.Bytes(Do("GET", key)) + return redigoRedis.Bytes(Do("GET", key)) } func GetString(key string) (string, error) { - return redigo.String(Do("GET", key)) + return redigoRedis.String(Do("GET", key)) } func GetStringMap(key string) (map[string]string, error) { - return redigo.StringMap(Do("GET", key)) + return redigoRedis.StringMap(Do("GET", key)) } func GetInt(key string) (int, error) { - return redigo.Int(Do("GET", key)) + return redigoRedis.Int(Do("GET", key)) } func GetInt64(key string) (int64, error) { - return redigo.Int64(Do("GET", key)) + return redigoRedis.Int64(Do("GET", key)) } func GetStringLength(key string) (int, error) { - return redigo.Int(Do("STRLEN", key)) + return redigoRedis.Int(Do("STRLEN", key)) } func ZAdd(key string, score float64, data interface{}) (interface{}, error) { return Do("ZADD", key, score, data) @@ -195,30 +196,30 @@ func ZRem(key string, data interface{}) (interface{}, error) { } func ZRange(key string, start int, end int, withScores bool) ([]interface{}, error) { if withScores { - return redigo.Values(Do("ZRANGE", key, start, end, "WITHSCORES")) + return redigoRedis.Values(Do("ZRANGE", key, start, end, "WITHSCORES")) } - return redigo.Values(Do("ZRANGE", key, start, end)) + return redigoRedis.Values(Do("ZRANGE", key, start, end)) } func ZRemRangeByScore(key string, start int64, end int64) ([]interface{}, error) { - return redigo.Values(Do("ZREMRANGEBYSCORE", key, start, end)) + return redigoRedis.Values(Do("ZREMRANGEBYSCORE", key, start, end)) } func ZCard(setName string) (int64, error) { - return redigo.Int64(Do("ZCARD", setName)) + return redigoRedis.Int64(Do("ZCARD", setName)) } func ZScan(setName string) (int64, error) { - return redigo.Int64(Do("ZCARD", setName)) + return redigoRedis.Int64(Do("ZCARD", setName)) } func SAdd(setName string, data interface{}) (interface{}, error) { return Do("SADD", setName, data) } func SCard(setName string) (int64, error) { - return redigo.Int64(Do("SCARD", setName)) + return redigoRedis.Int64(Do("SCARD", setName)) } func SIsMember(setName string, data interface{}) (bool, error) { - return redigo.Bool(Do("SISMEMBER", setName, data)) + return redigoRedis.Bool(Do("SISMEMBER", setName, data)) } func SMembers(setName string) ([]string, error) { - return redigo.Strings(Do("SMEMBERS", setName)) + return redigoRedis.Strings(Do("SMEMBERS", setName)) } func SRem(setName string, data interface{}) (interface{}, error) { return Do("SREM", setName, data) @@ -256,41 +257,41 @@ func HMSet(key string, hashKeys []string, vals []interface{}) (interface{}, erro } func HGetString(key string, HKey string) (string, error) { - return redigo.String(Do("HGET", key, HKey)) + return redigoRedis.String(Do("HGET", key, HKey)) } func HGetFloat(key string, HKey string) (float64, error) { - f, err := redigo.Float64(Do("HGET", key, HKey)) + f, err := redigoRedis.Float64(Do("HGET", key, HKey)) return f, err } func HGetInt(key string, HKey string) (int, error) { - return redigo.Int(Do("HGET", key, HKey)) + return redigoRedis.Int(Do("HGET", key, HKey)) } func HGetInt64(key string, HKey string) (int64, error) { - return redigo.Int64(Do("HGET", key, HKey)) + return redigoRedis.Int64(Do("HGET", key, HKey)) } func HGetBool(key string, HKey string) (bool, error) { - return redigo.Bool(Do("HGET", key, HKey)) + return redigoRedis.Bool(Do("HGET", key, HKey)) } func HDel(key string, HKey string) (interface{}, error) { return Do("HDEL", key, HKey) } func HGetAll(key string) (map[string]interface{}, error) { - vals, err := redigo.Values(Do("HGETALL", key)) + vals, err := redigoRedis.Values(Do("HGETALL", key)) if err != nil { return nil, err } num := len(vals) / 2 result := make(map[string]interface{}, num) for i := 0; i < num; i++ { - key, _ := redigo.String(vals[2*i], nil) + key, _ := redigoRedis.String(vals[2*i], nil) result[key] = vals[2*i+1] } return result, nil } func FlushAll() bool { - res, _ := redigo.String(Do("FLUSHALL")) + res, _ := redigoRedis.String(Do("FLUSHALL")) if res == "" { return false } @@ -298,17 +299,17 @@ func FlushAll() bool { } // NOTE: Use this in production environment with extreme care. -// Read more here:https://redigo.io/commands/keys +// Read more here:https://redigoRedis.io/commands/keys func Keys(pattern string) ([]string, error) { - return redigo.Strings(Do("KEYS", pattern)) + return redigoRedis.Strings(Do("KEYS", pattern)) } func HKeys(key string) ([]string, error) { - return redigo.Strings(Do("HKEYS", key)) + return redigoRedis.Strings(Do("HKEYS", key)) } func Exists(key string) bool { - count, err := redigo.Int(Do("EXISTS", key)) + count, err := redigoRedis.Int(Do("EXISTS", key)) if count == 0 || err != nil { return false } @@ -316,27 +317,27 @@ func Exists(key string) bool { } func Incr(key string) (int64, error) { - return redigo.Int64(Do("INCR", key)) + return redigoRedis.Int64(Do("INCR", key)) } func Decr(key string) (int64, error) { - return redigo.Int64(Do("DECR", key)) + return redigoRedis.Int64(Do("DECR", key)) } func IncrBy(key string, incBy int64) (int64, error) { - return redigo.Int64(Do("INCRBY", key, incBy)) + return redigoRedis.Int64(Do("INCRBY", key, incBy)) } func DecrBy(key string, decrBy int64) (int64, error) { - return redigo.Int64(Do("DECRBY", key)) + return redigoRedis.Int64(Do("DECRBY", key)) } func IncrByFloat(key string, incBy float64) (float64, error) { - return redigo.Float64(Do("INCRBYFLOAT", key, incBy)) + return redigoRedis.Float64(Do("INCRBYFLOAT", key, incBy)) } func DecrByFloat(key string, decrBy float64) (float64, error) { - return redigo.Float64(Do("DECRBYFLOAT", key, decrBy)) + return redigoRedis.Float64(Do("DECRBYFLOAT", key, decrBy)) } // use for message queue @@ -350,17 +351,17 @@ func LPop(key string) (interface{}, error) { } func LPopString(key string) (string, error) { - return redigo.String(Do("LPOP", key)) + return redigoRedis.String(Do("LPOP", key)) } func LPopFloat(key string) (float64, error) { - f, err := redigo.Float64(Do("LPOP", key)) + f, err := redigoRedis.Float64(Do("LPOP", key)) return f, err } func LPopInt(key string) (int, error) { - return redigo.Int(Do("LPOP", key)) + return redigoRedis.Int(Do("LPOP", key)) } func LPopInt64(key string) (int64, error) { - return redigo.Int64(Do("LPOP", key)) + return redigoRedis.Int64(Do("LPOP", key)) } func RPush(key string, data interface{}) (interface{}, error) { @@ -373,28 +374,28 @@ func RPop(key string) (interface{}, error) { } func RPopString(key string) (string, error) { - return redigo.String(Do("RPOP", key)) + return redigoRedis.String(Do("RPOP", key)) } func RPopFloat(key string) (float64, error) { - f, err := redigo.Float64(Do("RPOP", key)) + f, err := redigoRedis.Float64(Do("RPOP", key)) return f, err } func RPopInt(key string) (int, error) { - return redigo.Int(Do("RPOP", key)) + return redigoRedis.Int(Do("RPOP", key)) } func RPopInt64(key string) (int64, error) { - return redigo.Int64(Do("RPOP", key)) + return redigoRedis.Int64(Do("RPOP", key)) } func Scan(cursor int64, pattern string, count int64) (int64, []string, error) { var items []string var newCursor int64 - values, err := redigo.Values(Do("SCAN", cursor, "MATCH", pattern, "COUNT", count)) + values, err := redigoRedis.Values(Do("SCAN", cursor, "MATCH", pattern, "COUNT", count)) if err != nil { return 0, nil, err } - values, err = redigo.Scan(values, &newCursor, &items) + values, err = redigoRedis.Scan(values, &newCursor, &items) if err != nil { return 0, nil, err }