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

我们在前面的文章中依次实现了通信模块、连接池及协议的处理，本节将对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