gedis：自己实现go语言的redis客户端第四节（redis命令的封装实现）

缺乏、安全感 2023-06-17 03:54 14阅读 0赞

我们在前面的文章中依次实现了通信模块、连接池及协议的处理，本节将对redis的命令进行封装，主要包含一下大类：

1、string类

2、hash类

3、list类

4、set类

5、sorted\_set类

6、其它类

string\_template.go

package client
    
    import (
    	"protocol"
    	"client/handler"
    	"fmt"
    )
    
    /**
     * 认证权限
     */
    func (client *Client) Auth(pwd string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.AUTH, protocol.SafeEncode(pwd))
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Set(key string, value string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.SET, protocol.SafeEncode(key), protocol.SafeEncode(value))
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Get(key string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.GET, protocol.SafeEncode(key))
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Mset(keyvalues ...string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	bytes := handler.HandleBulkRequest(keyvalues)
    	result := SendCommand(conn, protocol.MSET, bytes...)
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Mget(keys ...string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	bytes := handler.HandleBulkRequest(keys)
    	result := SendCommand(conn, protocol.MGET, bytes...)
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Setnx(key string, value string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.SETNX, protocol.SafeEncode(key), protocol.SafeEncode(value))
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Incr(key string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.INCR, protocol.SafeEncode(key))
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Decr(key string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.DECR, protocol.SafeEncode(key))
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Setex(key string, time int64, value string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.SETEX, protocol.SafeEncode(key), protocol.SafeEncodeInt(time), protocol.SafeEncode(value))
    	return handler.HandleReply(result)
    }

hash\_template.go

package client
    
    import (
    	"protocol"
    	"client/handler"
    	"fmt"
    )
    
    func (client *Client) Hset(hash string, key string, value string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.HSET, protocol.SafeEncode(hash), protocol.SafeEncode(key), protocol.SafeEncode(value))
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Hget(hash string, key string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.HGET, protocol.SafeEncode(hash), protocol.SafeEncode(key))
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Hmset(hash string, keyvalues ...string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	bytes := handler.HandleMultiBulkRequest(hash, keyvalues)
    	result := SendCommand(conn, protocol.HMSET, bytes...)
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Hmget(hash string, keys ...string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	bytes := handler.HandleMultiBulkRequest(hash, keys)
    	result := SendCommand(conn, protocol.HMGET, bytes...)
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Hgetall(hash string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.HGETALL, protocol.SafeEncode(hash))
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Hexists(hash string, key string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.HEXISTS, protocol.SafeEncode(hash), protocol.SafeEncode(key))
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Hdel(hash string, key string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.HDEL, protocol.SafeEncode(hash), protocol.SafeEncode(key))
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Hkeys(hash string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.HKEYS, protocol.SafeEncode(hash))
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Hvalues(hash string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.HVALS, protocol.SafeEncode(hash))
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Hlen(hash string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.HLEN, protocol.SafeEncode(hash))
    	return handler.HandleReply(result)
    }

key\_template.go

package client
    
    import (
    	"protocol"
    	"client/handler"
    	"fmt"
    )
    
    func (client *Client) Keys(regex string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.KEYS, protocol.SafeEncode(regex))
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Expire(key string, value int64) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.EXPIRE, protocol.SafeEncode(key), protocol.SafeEncodeInt(value))
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Del(key string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.DEL, protocol.SafeEncode(key))
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Ttl(key string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.TTL, protocol.SafeEncode(key))
    	return handler.HandleReply(result)
    }

list\_template.go

package client
    
    import (
    	"net"
    	"protocol"
    	"client/handler"
    	"fmt"
    )
    
    func (client *Client) Lpush(list string, elements ...string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	return push(conn, list, protocol.LPUSH, elements)
    }
    
    func (client *Client) Rpush(list string, elements ...string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	return push(conn, list, protocol.RPUSH, elements)
    }
    
    func push(conn *net.TCPConn, list string, cmd string, elements []string) (interface{}, error) {
    	bytes := handler.HandleMultiBulkRequest(list, elements)
    	result := SendCommand(conn, cmd, bytes...)
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Lrange(list string, start int64, end int64) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.LRANGE, protocol.SafeEncode(list), protocol.SafeEncodeInt(start), protocol.SafeEncodeInt(end))
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Lpop(list string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	return pop(conn, list, protocol.LPOP)
    }
    
    func (client *Client) Rpop(list string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	return pop(conn, list, protocol.RPOP)
    }
    
    func pop(conn *net.TCPConn, list string, cmd string) (interface{}, error) {
    	result := SendCommand(conn, cmd, protocol.SafeEncode(list))
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Llen(list string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.LLEN, protocol.SafeEncode(list))
    	return handler.HandleReply(result)
    }
    
    /**
     *  count > 0 : 从表头开始向表尾搜索，移除与 VALUE 相等的元素，数量为 COUNT 。
     *  count < 0 : 从表尾开始向表头搜索，移除与 VALUE 相等的元素，数量为 COUNT 的绝对值。
     *  count = 0 : 移除表中所有与 VALUE 相等的值。
     */
    func (client *Client) Lrem(list string, count int64, value string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.LREM, protocol.SafeEncode(list), protocol.SafeEncodeInt(count), protocol.SafeEncode(value))
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Lindex(list string, pos int64) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.LINDEX, protocol.SafeEncode(list), protocol.SafeEncodeInt(pos))
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Lset(list string, pos int64, value string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.LSET, protocol.SafeEncode(list), protocol.SafeEncodeInt(pos), protocol.SafeEncode(value))
    	return handler.HandleReply(result)
    }
    
    /**
     * target 目标元素
     */
    func (client *Client) LinsertBefore(list string, target string, value string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.LINSERT, protocol.SafeEncode(list), protocol.SafeEncode("BEFORE"), protocol.SafeEncode(target), protocol.SafeEncode(value))
    	return handler.HandleReply(result)
    }
    
    /**
     * target 目标元素
     */
    func (client *Client) LinsertAfter(list string, target string, value string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.LINSERT, protocol.SafeEncode(list), protocol.SafeEncode("AFTER"), protocol.SafeEncode(target), protocol.SafeEncode(value))
    	return handler.HandleReply(result)
    }

set\_template.go

package client
    
    import (
    	"protocol"
    	"client/handler"
    	"fmt"
    )
    
    func (client *Client) Sadd(set string, elements ...string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	bytes := handler.HandleMultiBulkRequest(set, elements)
    	result := SendCommand(conn, protocol.SADD, bytes...)
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Smembers(set string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.SMEMBERS, protocol.SafeEncode(set))
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Srem(set string, elements ...string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	bytes := handler.HandleMultiBulkRequest(set, elements)
    	result := SendCommand(conn, protocol.SREM, bytes...)
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Sismember(set string, value string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.SISMEMBER, protocol.SafeEncode(set), protocol.SafeEncode(value))
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Scard(set string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.SCARD, protocol.SafeEncode(set))
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Srandmembers(set string, count int64) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.SRANDMEMBER, protocol.SafeEncode(set), protocol.SafeEncodeInt(count))
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Spop(set string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.SPOP, protocol.SafeEncode(set))
    	return handler.HandleReply(result)
    }
    
    /**
     * 返回给定所有集合的差集
     */
    func (client *Client) Sdiff(sets ... string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	bytes := handler.HandleBulkRequest(sets)
    	result := SendCommand(conn, protocol.SDIFF, bytes...)
    	return handler.HandleReply(result)
    }

sorted\_set\_template.go

package client
    
    import (
    	"protocol"
    	"client/handler"
    	"fmt"
    )
    
    func (client *Client) Zadd(zset string, scoresvalues ...string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	bytes := handler.HandleMultiBulkRequest(zset, scoresvalues)
    	result := SendCommand(conn, protocol.ZADD, bytes...)
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Zscore(zset string, value string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.ZSCORE, protocol.SafeEncode(zset), protocol.SafeEncode(value))
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Zrange(zset string, start int64, end int64) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.ZRANGE, protocol.SafeEncode(zset), protocol.SafeEncodeInt(start), protocol.SafeEncodeInt(end))
    	return handler.HandleReply(result)
    }
    
    func (client *Client) ZrangeWithScores(zset string, start int64, end int64) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.ZRANGE, protocol.SafeEncode(zset), protocol.SafeEncodeInt(start), protocol.SafeEncodeInt(end), protocol.SafeEncode("WITHSCORES"))
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Zrevrange(zset string, start int64, end int64) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.ZREVRANGE, protocol.SafeEncode(zset), protocol.SafeEncodeInt(start), protocol.SafeEncodeInt(end))
    	return handler.HandleReply(result)
    }
    
    func (client *Client) ZrevrangeWithScores(zset string, start int64, end int64) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.ZREVRANGE, protocol.SafeEncode(zset), protocol.SafeEncodeInt(start), protocol.SafeEncodeInt(end), protocol.SafeEncode("WITHSCORES"))
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Zcard(zset string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.ZCARD, protocol.SafeEncode(zset))
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Zrem(zset string, elements ...string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	bytes := handler.HandleMultiBulkRequest(zset, elements)
    	result := SendCommand(conn, protocol.ZREM, bytes...)
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Zrank(zset string, value string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.ZRANK, protocol.SafeEncode(zset))
    	return handler.HandleReply(result)
    }
    
    func (client *Client) Zrevrank(zset string, value string) (interface{}, error) {
    	pool := client.getConnectPool()
    	conn, err := GetConn(pool)
    	if err != nil {
    		return nil, fmt.Errorf("get conn fail")
    	}
    	defer pool.PutConn(conn)
    	result := SendCommand(conn, protocol.ZREVRANK, protocol.SafeEncode(zset))
    	return handler.HandleReply(result)
    }

项目地址：

[https://github.com/zhangxiaomin1993/gedis][https_github.com_zhangxiaomin1993_gedis]

[https_github.com_zhangxiaomin1993_gedis]: https://github.com/zhangxiaomin1993/gedis