同步跃恒redis

conn.go

@@ -8,10 +8,15 @@ import (
 
 func Conn(url ...string) (*RedisServiceClient, *rpc.Client, error) {
 
-	var rpc_url string = "127.0.0.1:" + conf.REDIS_RPC_PORT
+	var rpc_url string
 	if len(url) > 0 && url[0] != "" {
 		rpc_url = url[0]
+	} else if conf.REDIS_RPC_URL != "" {
+		rpc_url = conf.REDIS_RPC_URL
+	} else {
+		rpc_url = "127.0.0.1:" + conf.REDIS_RPC_PORT
 	}
 
 	return DialRedisService("tcp", rpc_url)
+
 }

expire.go

@@ -0,0 +1,30 @@
+package redisrpc
+
+import (
+	"github.com/golang/protobuf/proto"
+)
+
+/**
+ * 使用用户名查询
+ */
+func SetExpire(key string, ttl int64, url ...string) (int64, error) {
+
+	conn, _, err := Conn(url...)
+
+	if err != nil {
+		return 0, err
+	}
+	defer conn.Close()
+
+	req := &SetExpireRequest{proto.String(key), proto.Int64(ttl), nil}
+
+	res := &SetExpireResponse{}
+
+	err = conn.SetExpire(req, res)
+
+	if err != nil {
+		return 0, err
+	}
+
+	return res.GetRet(), nil
+}

expire_test.go

@@ -0,0 +1,17 @@
+package redisrpc
+
+import (
+	"testing"
+	// "time"
+)
+
+func Test_SetExpire(t *testing.T) {
+
+	c, err := Set("test", "33", 50)
+	t.Log(c)
+	t.Log(err)
+	c2, err := SetExpire("test", 100)
+	t.Log(c2)
+	t.Log(err)
+
+}

go.mod

@@ -1,9 +1,14 @@
 module git.tetele.net/tgo/redisrpc
 
-go 1.14
+go 1.17
 
 require (
-	git.tetele.net/tgo/conf v0.25.0 // indirect
-	github.com/chai2010/protorpc v1.0.0 // indirect
-	github.com/golang/protobuf v1.5.2 // indirect
+	git.tetele.net/tgo/conf v0.47.0
+	github.com/chai2010/protorpc v1.1.3
+	github.com/golang/protobuf v1.5.2
+)
+
+require (
+	github.com/golang/snappy v0.0.3 // indirect
+	google.golang.org/protobuf v1.26.0 // indirect
 )

go.sum

@@ -1,15 +1,16 @@
-git.tetele.net/tgo/conf v0.25.0 h1:fopDch45xw/di5fLvvzwltFiGiXrilMobZwQNO678Wo=
-git.tetele.net/tgo/conf v0.25.0/go.mod h1:DogEBvxG2fGdukpoobTVFE2b4Fd5OTE9FJ3Xetyn47E=
-github.com/chai2010/protorpc v1.0.0 h1:aJ45G9sl1utSKo35EqnBSTs5jqTpdJDJAuZMMYPAtFo=
-github.com/chai2010/protorpc v1.0.0/go.mod h1:woR3WwjaQDqFjlzdVsFEKiK5Ur12QL8mYxVPjfr5z54=
+git.tetele.net/tgo/conf v0.47.0 h1:2nGvXjyFV6gO7BPliG4lwERP/bgTOeSJpUv/I2ALGPg=
+git.tetele.net/tgo/conf v0.47.0/go.mod h1:AWVIBEDE5dtotthUgR0SWaR2Qa6/f+O5WQ3s7Tj8q7A=
+github.com/chai2010/protorpc v1.1.3 h1:VJK5hIoZn0XCGol0GmbxZkUG6FbTI5LP2Lam6RVd15w=
+github.com/chai2010/protorpc v1.1.3/go.mod h1:/wO0kiyVdu7ug8dCMrA2yDr2vLfyhsLEuzLa9J2HJ+I=
 github.com/golang/protobuf v1.0.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
 github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw=
 github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
-github.com/golang/snappy v0.0.0-20170215233205-553a64147049 h1:K9KHZbXKpGydfDN0aZrsoHpLJlZsBrGMFWbgLDGnPZk=
-github.com/golang/snappy v0.0.0-20170215233205-553a64147049/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/golang/snappy v0.0.3 h1:fHPg5GQYlCeLIPB9BZqMVR5nR9A+IM5zcgeTdjMYmLA=
+github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
 google.golang.org/protobuf v1.26.0 h1:bxAC2xTBsZGibn2RTntX0oH50xLsqy1OxA9tTL3p/lk=

hash.go

@@ -1,6 +1,10 @@
 package redisrpc
 
 import (
+	"encoding/json"
+	"log"
+	"strconv"
+
 	"github.com/golang/protobuf/proto"
 )
 
@@ -31,12 +35,12 @@ func HGetString(key, field string, url ...string) (string, error) {
 }
 
 //设置
-func HSet(key, field, value string, url ...string) (uint64, error) {
+func HSet(key, field, value string, url ...string) (int64, error) {
 
 	conn, _, err := Conn(url...)
 
 	if err != nil {
-		return "", err
+		return 0, err
 	}
 	defer conn.Close()
 
@@ -47,14 +51,14 @@ func HSet(key, field, value string, url ...string) (uint64, error) {
 	err = conn.HSet(req, res)
 
 	if err != nil {
-		return "", err
+		return 0, err
 	}
 
 	return res.GetRet(), nil
 }
 
 //删除
-func HDel(key string, field string, url ...string) (uint64, error) {
+func HDel(key string, field string, url ...string) (int64, error) {
 
 	conn, _, err := Conn(url...)
 
@@ -75,3 +79,119 @@ func HDel(key string, field string, url ...string) (uint64, error) {
 
 	return res.GetRet(), nil
 }
+
+/**
+ * 全部
+ */
+func HGetAll(key string, url ...string) ([]map[string]string, error) {
+
+	conn, _, err := Conn(url...)
+
+	if err != nil {
+		return []map[string]string{}, err
+	}
+	defer conn.Close()
+
+	req := &GetRequest{proto.String(key), nil}
+
+	res := &HGetListResponse{}
+
+	err = conn.HGetAll(req, res)
+
+	if err != nil {
+		return []map[string]string{}, err
+	}
+
+	value := res.GetList()
+
+	var list []map[string]string
+
+	err = json.Unmarshal(value, &list)
+
+	if err != nil {
+		log.Println("json unmarshal error:", err)
+		return []map[string]string{}, err
+	}
+	return list, nil
+}
+
+/**
+ * 全部
+ */
+func HGetList(key string, url ...string) ([]string, error) {
+
+	conn, _, err := Conn(url...)
+
+	if err != nil {
+		return []string{}, err
+	}
+	defer conn.Close()
+
+	req := &GetRequest{proto.String(key), nil}
+
+	res := &HGetListResponse{}
+
+	err = conn.HGetList(req, res)
+
+	if err != nil {
+		return []string{}, err
+	}
+
+	value := res.GetList()
+
+	var list []string
+
+	err = json.Unmarshal(value, &list)
+
+	if err != nil {
+		log.Println("json unmarshal error:", err)
+		return []string{}, err
+	}
+	return list, nil
+}
+
+/**
+ * hash键是否存在
+ */
+func HExists(key string, field string, url ...string) (int64, error) {
+	conn, _, err := Conn(url...)
+
+	if err != nil {
+		return 0, err
+	}
+	defer conn.Close()
+
+	req := &HGetRequest{proto.String(key), proto.String(field), nil}
+
+	res := &DelResponse{}
+
+	err = conn.HExists(req, res)
+
+	if err != nil {
+		return 0, err
+	}
+
+	return res.GetRet(), nil
+}
+
+func HIncrby(key, field string, value int, url ...string) (int64, error) {
+
+	conn, _, err := Conn(url...)
+
+	if err != nil {
+		return 0, err
+	}
+	defer conn.Close()
+
+	req := &HSetRequest{proto.String(key), proto.String(field), proto.String(strconv.Itoa(value)), nil}
+
+	res := &HSetResponse{}
+
+	err = conn.HIncrby(req, res)
+
+	if err != nil {
+		return 0, err
+	}
+
+	return res.GetRet(), nil
+}

hash_test.go

@@ -2,6 +2,7 @@ package redisrpc
 
 import (
 	// "strconv"
+	"log"
 	"testing"
 	// "tgo/helper"
 )
@@ -10,20 +11,28 @@ func Test_HSet(t *testing.T) {
 
 	// val := map[string]interface{}{"id": "123", "name": "这是一个测试", "dis": "xxx"}
 
-	reply, err := HSet("testing2", "test1", "val")
+	// reply, err := HSet("testing", "test", "test1")
 
-	t.Log(reply)
-	t.Log(err)
+	// t.Log(reply)
+	// t.Log(err)
 
-	ret, err := HGetString("testing", "test")
+	// ret, err := HGetString("testing", "test")
 
-	t.Log(ret)
-	if err == nil {
-		t.Log("nil", err)
-	} else {
-		t.Log("error:", err)
-	}
+	// t.Log(ret)
+	// if err == nil {
+	// 	t.Log("nil", err)
+	// } else {
+	// 	t.Log("error:", err)
+	// }
 
+	// del_ret, err := HDel("testing", "test")
+
+	// t.Log(del_ret)
+	// if err == nil {
+	// 	t.Log("nil", err)
+	// } else {
+	// 	t.Log("error:", err)
+	// }
 	// ret2, err := HSetExpire("testing2", 200)
 	// t.Log(ret2)
 	// t.Log(err)
@@ -41,4 +50,18 @@ func Test_HSet(t *testing.T) {
 	// 	t.Log(string(val))
 	// }
 	// t.Log(err)
+
+	ret, err := HGetList("test2")
+	t.Log(ret, err)
 }
+
+
+func Test_Incrby(t *testing.T){
+	res,err := HIncrby("test_incr","26_26",2)
+
+	if err != nil {
+		log.Println(err.Error())
+	}
+
+	log.Println(res)
+}

list.go

@@ -0,0 +1,112 @@
+package redisrpc
+
+import (
+	"encoding/json"
+	"log"
+
+	"github.com/golang/protobuf/proto"
+)
+
+//头部增加
+func LLpush(key, field string, url ...string) (int64, error) {
+
+	conn, _, err := Conn(url...)
+
+	if err != nil {
+		return 0, err
+	}
+	defer conn.Close()
+
+	req := &LSetRequest{proto.String(key), proto.String(field), nil}
+
+	res := &LSetResponse{}
+
+	err = conn.LLpush(req, res)
+
+	if err != nil {
+		return 0, err
+	}
+
+	return res.GetRet(), nil
+}
+
+//尾部增加
+func LRpush(key, field string, url ...string) (int64, error) {
+
+	conn, _, err := Conn(url...)
+
+	if err != nil {
+		return 0, err
+	}
+	defer conn.Close()
+
+	req := &LSetRequest{proto.String(key), proto.String(field), nil}
+
+	res := &LSetResponse{}
+
+	err = conn.LRpush(req, res)
+
+	if err != nil {
+		return 0, err
+	}
+
+	return res.GetRet(), nil
+}
+
+/**
+ * 全部
+ */
+func LRange(key string, start, stop int64, url ...string) ([]string, error) {
+
+	conn, _, err := Conn(url...)
+
+	if err != nil {
+		return []string{}, err
+	}
+	defer conn.Close()
+
+	req := &LRangeRequest{proto.String(key), proto.Int64(start), proto.Int64(stop), nil}
+
+	res := &HGetListResponse{}
+
+	err = conn.LRange(req, res)
+
+	if err != nil {
+		return []string{}, err
+	}
+
+	value := res.GetList()
+
+	var list []string
+
+	err = json.Unmarshal(value, &list)
+
+	if err != nil {
+		log.Println("json unmarshal error:", err)
+		return []string{}, err
+	}
+	return list, nil
+}
+
+//长度
+func LLen(key string, url ...string) (int64, error) {
+
+	conn, _, err := Conn(url...)
+
+	if err != nil {
+		return 0, err
+	}
+	defer conn.Close()
+
+	req := &LLenRequest{proto.String(key), nil}
+
+	res := &LSetResponse{}
+
+	err = conn.LLen(req, res)
+
+	if err != nil {
+		return 0, err
+	}
+
+	return res.GetRet(), nil
+}

list_test.go

@@ -0,0 +1,18 @@
+package redisrpc
+
+import (
+	// "strconv"
+	"testing"
+	// "tgo/helper"
+)
+
+func Test_LLpush(t *testing.T) {
+
+	// val := map[string]interface{}{"id": "123", "name": "这是一个测试", "dis": "xxx"}
+
+	reply, err := LLen("testing")
+
+	t.Log(reply)
+	t.Log(err)
+
+}

num.go

@@ -0,0 +1,51 @@
+package redisrpc
+
+import (
+	"github.com/golang/protobuf/proto"
+)
+
+//加
+func Incrby(key string, value int64, url ...string) (int64, error) {
+
+	conn, _, err := Conn(url...)
+
+	if err != nil {
+		return 0, err
+	}
+	defer conn.Close()
+
+	req := &AddRequest{proto.String(key), proto.Int64(value), nil}
+
+	res := &AddResponse{}
+
+	err = conn.Incrby(req, res)
+
+	if err != nil {
+		return 0, err
+	}
+
+	return res.GetRet(), nil
+}
+
+//减
+func Decrby(key string, value int64, url ...string) (int64, error) {
+
+	conn, _, err := Conn(url...)
+
+	if err != nil {
+		return 0, err
+	}
+	defer conn.Close()
+
+	req := &AddRequest{proto.String(key), proto.Int64(value), nil}
+
+	res := &AddResponse{}
+
+	err = conn.Decrby(req, res)
+
+	if err != nil {
+		return 0, err
+	}
+
+	return res.GetRet(), nil
+}

num_test.go

@@ -0,0 +1,15 @@
+package redisrpc
+
+import (
+	"testing"
+	// "time"
+)
+
+
+func Test_Decrby(t *testing.T) {
+
+	c, err := Decrby("test_incrby", 2)
+	t.Log(c)
+	t.Log(err)
+
+}

redis.pb.go

@@ -15,10 +15,26 @@ It has these top-level messages:
 	HGetRequest
 	HSetRequest
 	HDelRequest
+	SetExpireRequest
 	GetStringResponse
+	HGetListResponse
 	SetResponse
 	DelResponse
 	HSetResponse
+	SetExpireResponse
+	SSetRequest
+	SMembersRequest
+	SSetResponse
+	LSetRequest
+	LSetResponse
+	LRangeRequest
+	LLenRequest
+	AddRequest
+	AddResponse
+	ZSetRequest
+	ZSetResponse
+	ZRangeRequest
+	ZScanRequest
 */
 package redisrpc
 
@@ -57,7 +73,7 @@ func (m *GetRequest) GetKey() string {
 type SetRequest struct {
 	Key              *string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
 	Value            *string `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
-	Ttl              *string `protobuf:"bytes,3,opt,name=ttl" json:"ttl,omitempty"`
+	Ttl              *int64  `protobuf:"varint,3,opt,name=ttl" json:"ttl,omitempty"`
 	XXX_unrecognized []byte  `json:"-"`
 }
 
@@ -79,11 +95,11 @@ func (m *SetRequest) GetValue() string {
 	return ""
 }
 
-func (m *SetRequest) GetTtl() string {
+func (m *SetRequest) GetTtl() int64 {
 	if m != nil && m.Ttl != nil {
 		return *m.Ttl
 	}
-	return ""
+	return 0
 }
 
 type DelRequest struct {
@@ -185,6 +201,31 @@ func (m *HDelRequest) GetField() string {
 	return ""
 }
 
+// 有效期
+type SetExpireRequest struct {
+	Key              *string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
+	Expire           *int64  `protobuf:"varint,2,opt,name=expire" json:"expire,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *SetExpireRequest) Reset()         { *m = SetExpireRequest{} }
+func (m *SetExpireRequest) String() string { return proto.CompactTextString(m) }
+func (*SetExpireRequest) ProtoMessage()    {}
+
+func (m *SetExpireRequest) GetKey() string {
+	if m != nil && m.Key != nil {
+		return *m.Key
+	}
+	return ""
+}
+
+func (m *SetExpireRequest) GetExpire() int64 {
+	if m != nil && m.Expire != nil {
+		return *m.Expire
+	}
+	return 0
+}
+
 // 使用key查询响应结构
 type GetStringResponse struct {
 	Value            *string `protobuf:"bytes,1,opt,name=value" json:"value,omitempty"`
@@ -202,6 +243,23 @@ func (m *GetStringResponse) GetValue() string {
 	return ""
 }
 
+// 使用key查询响应结构
+type HGetListResponse struct {
+	List             []byte `protobuf:"bytes,1,opt,name=list" json:"list,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *HGetListResponse) Reset()         { *m = HGetListResponse{} }
+func (m *HGetListResponse) String() string { return proto.CompactTextString(m) }
+func (*HGetListResponse) ProtoMessage()    {}
+
+func (m *HGetListResponse) GetList() []byte {
+	if m != nil {
+		return m.List
+	}
+	return nil
+}
+
 // 设置key响应结构
 type SetResponse struct {
 	Ret              *string `protobuf:"bytes,1,opt,name=ret" json:"ret,omitempty"`
@@ -221,15 +279,15 @@ func (m *SetResponse) GetRet() string {
 
 // 删除key响应结构
 type DelResponse struct {
-	Ret              *uint64 `protobuf:"varint,1,opt,name=ret" json:"ret,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
+	Ret              *int64 `protobuf:"varint,1,opt,name=ret" json:"ret,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
 }
 
 func (m *DelResponse) Reset()         { *m = DelResponse{} }
 func (m *DelResponse) String() string { return proto.CompactTextString(m) }
 func (*DelResponse) ProtoMessage()    {}
 
-func (m *DelResponse) GetRet() uint64 {
+func (m *DelResponse) GetRet() int64 {
 	if m != nil && m.Ret != nil {
 		return *m.Ret
 	}
@@ -238,31 +296,377 @@ func (m *DelResponse) GetRet() uint64 {
 
 // 设置key响应结构
 type HSetResponse struct {
-	Ret              *uint64 `protobuf:"varint,1,opt,name=ret" json:"ret,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
+	Ret              *int64 `protobuf:"varint,1,opt,name=ret" json:"ret,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
 }
 
 func (m *HSetResponse) Reset()         { *m = HSetResponse{} }
 func (m *HSetResponse) String() string { return proto.CompactTextString(m) }
 func (*HSetResponse) ProtoMessage()    {}
 
-func (m *HSetResponse) GetRet() uint64 {
+func (m *HSetResponse) GetRet() int64 {
 	if m != nil && m.Ret != nil {
 		return *m.Ret
 	}
 	return 0
 }
 
+// 设置key有效期
+type SetExpireResponse struct {
+	Ret              *int64 `protobuf:"varint,1,opt,name=ret" json:"ret,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *SetExpireResponse) Reset()         { *m = SetExpireResponse{} }
+func (m *SetExpireResponse) String() string { return proto.CompactTextString(m) }
+func (*SetExpireResponse) ProtoMessage()    {}
+
+func (m *SetExpireResponse) GetRet() int64 {
+	if m != nil && m.Ret != nil {
+		return *m.Ret
+	}
+	return 0
+}
+
+// 集合添加值
+type SSetRequest struct {
+	Key              *string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
+	Field            *string `protobuf:"bytes,2,opt,name=field" json:"field,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *SSetRequest) Reset()         { *m = SSetRequest{} }
+func (m *SSetRequest) String() string { return proto.CompactTextString(m) }
+func (*SSetRequest) ProtoMessage()    {}
+
+func (m *SSetRequest) GetKey() string {
+	if m != nil && m.Key != nil {
+		return *m.Key
+	}
+	return ""
+}
+
+func (m *SSetRequest) GetField() string {
+	if m != nil && m.Field != nil {
+		return *m.Field
+	}
+	return ""
+}
+
+// 集合添加值
+type SMembersRequest struct {
+	Key              *string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *SMembersRequest) Reset()         { *m = SMembersRequest{} }
+func (m *SMembersRequest) String() string { return proto.CompactTextString(m) }
+func (*SMembersRequest) ProtoMessage()    {}
+
+func (m *SMembersRequest) GetKey() string {
+	if m != nil && m.Key != nil {
+		return *m.Key
+	}
+	return ""
+}
+
+// 设置响应结构
+type SSetResponse struct {
+	Ret              *int64 `protobuf:"varint,1,opt,name=ret" json:"ret,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *SSetResponse) Reset()         { *m = SSetResponse{} }
+func (m *SSetResponse) String() string { return proto.CompactTextString(m) }
+func (*SSetResponse) ProtoMessage()    {}
+
+func (m *SSetResponse) GetRet() int64 {
+	if m != nil && m.Ret != nil {
+		return *m.Ret
+	}
+	return 0
+}
+
+// 列表添加值
+type LSetRequest struct {
+	Key              *string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
+	Field            *string `protobuf:"bytes,2,opt,name=field" json:"field,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *LSetRequest) Reset()         { *m = LSetRequest{} }
+func (m *LSetRequest) String() string { return proto.CompactTextString(m) }
+func (*LSetRequest) ProtoMessage()    {}
+
+func (m *LSetRequest) GetKey() string {
+	if m != nil && m.Key != nil {
+		return *m.Key
+	}
+	return ""
+}
+
+func (m *LSetRequest) GetField() string {
+	if m != nil && m.Field != nil {
+		return *m.Field
+	}
+	return ""
+}
+
+// 设置key响应结构
+type LSetResponse struct {
+	Ret              *int64 `protobuf:"varint,1,opt,name=ret" json:"ret,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *LSetResponse) Reset()         { *m = LSetResponse{} }
+func (m *LSetResponse) String() string { return proto.CompactTextString(m) }
+func (*LSetResponse) ProtoMessage()    {}
+
+func (m *LSetResponse) GetRet() int64 {
+	if m != nil && m.Ret != nil {
+		return *m.Ret
+	}
+	return 0
+}
+
+// 列表取值
+type LRangeRequest struct {
+	Key              *string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
+	Start            *int64  `protobuf:"varint,2,opt,name=start" json:"start,omitempty"`
+	Stop             *int64  `protobuf:"varint,3,opt,name=stop" json:"stop,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *LRangeRequest) Reset()         { *m = LRangeRequest{} }
+func (m *LRangeRequest) String() string { return proto.CompactTextString(m) }
+func (*LRangeRequest) ProtoMessage()    {}
+
+func (m *LRangeRequest) GetKey() string {
+	if m != nil && m.Key != nil {
+		return *m.Key
+	}
+	return ""
+}
+
+func (m *LRangeRequest) GetStart() int64 {
+	if m != nil && m.Start != nil {
+		return *m.Start
+	}
+	return 0
+}
+
+func (m *LRangeRequest) GetStop() int64 {
+	if m != nil && m.Stop != nil {
+		return *m.Stop
+	}
+	return 0
+}
+
+// 列表长度
+type LLenRequest struct {
+	Key              *string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *LLenRequest) Reset()         { *m = LLenRequest{} }
+func (m *LLenRequest) String() string { return proto.CompactTextString(m) }
+func (*LLenRequest) ProtoMessage()    {}
+
+func (m *LLenRequest) GetKey() string {
+	if m != nil && m.Key != nil {
+		return *m.Key
+	}
+	return ""
+}
+
+// 数值增加
+type AddRequest struct {
+	Key              *string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
+	Value            *int64  `protobuf:"varint,2,opt,name=value" json:"value,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *AddRequest) Reset()         { *m = AddRequest{} }
+func (m *AddRequest) String() string { return proto.CompactTextString(m) }
+func (*AddRequest) ProtoMessage()    {}
+
+func (m *AddRequest) GetKey() string {
+	if m != nil && m.Key != nil {
+		return *m.Key
+	}
+	return ""
+}
+
+func (m *AddRequest) GetValue() int64 {
+	if m != nil && m.Value != nil {
+		return *m.Value
+	}
+	return 0
+}
+
+type AddResponse struct {
+	Ret              *int64 `protobuf:"varint,1,opt,name=ret" json:"ret,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *AddResponse) Reset()         { *m = AddResponse{} }
+func (m *AddResponse) String() string { return proto.CompactTextString(m) }
+func (*AddResponse) ProtoMessage()    {}
+
+func (m *AddResponse) GetRet() int64 {
+	if m != nil && m.Ret != nil {
+		return *m.Ret
+	}
+	return 0
+}
+
+// 有序集合添加值
+type ZSetRequest struct {
+	Key              *string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
+	Score            *string `protobuf:"bytes,2,opt,name=score" json:"score,omitempty"`
+	Member           *string `protobuf:"bytes,3,opt,name=member" json:"member,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *ZSetRequest) Reset()         { *m = ZSetRequest{} }
+func (m *ZSetRequest) String() string { return proto.CompactTextString(m) }
+func (*ZSetRequest) ProtoMessage()    {}
+
+func (m *ZSetRequest) GetKey() string {
+	if m != nil && m.Key != nil {
+		return *m.Key
+	}
+	return ""
+}
+
+func (m *ZSetRequest) GetScore() string {
+	if m != nil && m.Score != nil {
+		return *m.Score
+	}
+	return ""
+}
+
+func (m *ZSetRequest) GetMember() string {
+	if m != nil && m.Member != nil {
+		return *m.Member
+	}
+	return ""
+}
+
+// 设置响应结构
+type ZSetResponse struct {
+	Ret              *int64 `protobuf:"varint,1,opt,name=ret" json:"ret,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *ZSetResponse) Reset()         { *m = ZSetResponse{} }
+func (m *ZSetResponse) String() string { return proto.CompactTextString(m) }
+func (*ZSetResponse) ProtoMessage()    {}
+
+func (m *ZSetResponse) GetRet() int64 {
+	if m != nil && m.Ret != nil {
+		return *m.Ret
+	}
+	return 0
+}
+
+// 有序集合取值
+type ZRangeRequest struct {
+	Key              *string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
+	Start            *int64  `protobuf:"varint,2,opt,name=start" json:"start,omitempty"`
+	Stop             *int64  `protobuf:"varint,3,opt,name=stop" json:"stop,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *ZRangeRequest) Reset()         { *m = ZRangeRequest{} }
+func (m *ZRangeRequest) String() string { return proto.CompactTextString(m) }
+func (*ZRangeRequest) ProtoMessage()    {}
+
+func (m *ZRangeRequest) GetKey() string {
+	if m != nil && m.Key != nil {
+		return *m.Key
+	}
+	return ""
+}
+
+func (m *ZRangeRequest) GetStart() int64 {
+	if m != nil && m.Start != nil {
+		return *m.Start
+	}
+	return 0
+}
+
+func (m *ZRangeRequest) GetStop() int64 {
+	if m != nil && m.Stop != nil {
+		return *m.Stop
+	}
+	return 0
+}
+
+type ZScanRequest struct {
+	Key              *string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
+	Field            *string `protobuf:"bytes,2,opt,name=field" json:"field,omitempty"`
+	Len              *int64  `protobuf:"varint,3,opt,name=len" json:"len,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *ZScanRequest) Reset()         { *m = ZScanRequest{} }
+func (m *ZScanRequest) String() string { return proto.CompactTextString(m) }
+func (*ZScanRequest) ProtoMessage()    {}
+
+func (m *ZScanRequest) GetKey() string {
+	if m != nil && m.Key != nil {
+		return *m.Key
+	}
+	return ""
+}
+
+func (m *ZScanRequest) GetField() string {
+	if m != nil && m.Field != nil {
+		return *m.Field
+	}
+	return ""
+}
+
+func (m *ZScanRequest) GetLen() int64 {
+	if m != nil && m.Len != nil {
+		return *m.Len
+	}
+	return 0
+}
+
 func init() {
 }
 
 type RedisService interface {
 	Get(in *GetRequest, out *GetStringResponse) error
 	Set(in *SetRequest, out *SetResponse) error
+	SetNx(in *SetRequest, out *DelResponse) error
 	Del(in *DelRequest, out *DelResponse) error
 	HGet(in *HGetRequest, out *GetStringResponse) error
-	HSet(in *HSetRequest, out *SetResponse) error
+	HSet(in *HSetRequest, out *HSetResponse) error
 	HDel(in *HDelRequest, out *DelResponse) error
+	SetExpire(in *SetExpireRequest, out *SetExpireResponse) error
+	HGetAll(in *GetRequest, out *HGetListResponse) error
+	HGetList(in *GetRequest, out *HGetListResponse) error
+	HExists(in *HGetRequest, out *DelResponse) error
+	Exists(in *GetRequest, out *DelResponse) error
+	HIncrby(in *HSetRequest, out *HSetResponse) error
+	SAdd(in *SSetRequest, out *SSetResponse) error
+	SIsmember(in *SSetRequest, out *SSetResponse) error
+	SRem(in *SSetRequest, out *SSetResponse) error
+	SCard(in *SMembersRequest, out *SSetResponse) error
+	LLpush(in *LSetRequest, out *LSetResponse) error
+	LRpush(in *LSetRequest, out *LSetResponse) error
+	LRange(in *LRangeRequest, out *HGetListResponse) error
+	LLen(in *LLenRequest, out *LSetResponse) error
+	ReduceStock(in *SetRequest, out *SetResponse) error
+	Incrby(in *AddRequest, out *AddResponse) error
+	Decrby(in *AddRequest, out *AddResponse) error
+	ZAdd(in *ZSetRequest, out *ZSetResponse) error
+	ZIncrBy(in *ZSetRequest, out *ZSetResponse) error
+	ZRange(in *ZRangeRequest, out *HGetListResponse) error
+	ZScan(in *ZScanRequest, out *HGetListResponse) error
 }
 
 // AcceptRedisServiceClient accepts connections on the listener and serves requests
@@ -340,18 +744,84 @@ func (c *RedisServiceClient) Get(in *GetRequest, out *GetStringResponse) error {
 func (c *RedisServiceClient) Set(in *SetRequest, out *SetResponse) error {
 	return c.Call("RedisService.Set", in, out)
 }
+func (c *RedisServiceClient) SetNx(in *SetRequest, out *DelResponse) error {
+	return c.Call("RedisService.SetNx", in, out)
+}
 func (c *RedisServiceClient) Del(in *DelRequest, out *DelResponse) error {
 	return c.Call("RedisService.Del", in, out)
 }
 func (c *RedisServiceClient) HGet(in *HGetRequest, out *GetStringResponse) error {
 	return c.Call("RedisService.HGet", in, out)
 }
-func (c *RedisServiceClient) HSet(in *HSetRequest, out *SetResponse) error {
+func (c *RedisServiceClient) HSet(in *HSetRequest, out *HSetResponse) error {
 	return c.Call("RedisService.HSet", in, out)
 }
 func (c *RedisServiceClient) HDel(in *HDelRequest, out *DelResponse) error {
 	return c.Call("RedisService.HDel", in, out)
 }
+func (c *RedisServiceClient) SetExpire(in *SetExpireRequest, out *SetExpireResponse) error {
+	return c.Call("RedisService.SetExpire", in, out)
+}
+func (c *RedisServiceClient) HGetAll(in *GetRequest, out *HGetListResponse) error {
+	return c.Call("RedisService.HGetAll", in, out)
+}
+func (c *RedisServiceClient) HGetList(in *GetRequest, out *HGetListResponse) error {
+	return c.Call("RedisService.HGetList", in, out)
+}
+func (c *RedisServiceClient) HExists(in *HGetRequest, out *DelResponse) error {
+	return c.Call("RedisService.HExists", in, out)
+}
+func (c *RedisServiceClient) Exists(in *GetRequest, out *DelResponse) error {
+	return c.Call("RedisService.Exists", in, out)
+}
+func (c *RedisServiceClient) HIncrby(in *HSetRequest, out *HSetResponse) error {
+	return c.Call("RedisService.HIncrby", in, out)
+}
+func (c *RedisServiceClient) SAdd(in *SSetRequest, out *SSetResponse) error {
+	return c.Call("RedisService.SAdd", in, out)
+}
+func (c *RedisServiceClient) SIsmember(in *SSetRequest, out *SSetResponse) error {
+	return c.Call("RedisService.SIsmember", in, out)
+}
+func (c *RedisServiceClient) SRem(in *SSetRequest, out *SSetResponse) error {
+	return c.Call("RedisService.SRem", in, out)
+}
+func (c *RedisServiceClient) SCard(in *SMembersRequest, out *SSetResponse) error {
+	return c.Call("RedisService.SCard", in, out)
+}
+func (c *RedisServiceClient) LLpush(in *LSetRequest, out *LSetResponse) error {
+	return c.Call("RedisService.LLpush", in, out)
+}
+func (c *RedisServiceClient) LRpush(in *LSetRequest, out *LSetResponse) error {
+	return c.Call("RedisService.LRpush", in, out)
+}
+func (c *RedisServiceClient) LRange(in *LRangeRequest, out *HGetListResponse) error {
+	return c.Call("RedisService.LRange", in, out)
+}
+func (c *RedisServiceClient) LLen(in *LLenRequest, out *LSetResponse) error {
+	return c.Call("RedisService.LLen", in, out)
+}
+func (c *RedisServiceClient) ReduceStock(in *SetRequest, out *SetResponse) error {
+	return c.Call("RedisService.ReduceStock", in, out)
+}
+func (c *RedisServiceClient) Incrby(in *AddRequest, out *AddResponse) error {
+	return c.Call("RedisService.Incrby", in, out)
+}
+func (c *RedisServiceClient) Decrby(in *AddRequest, out *AddResponse) error {
+	return c.Call("RedisService.Decrby", in, out)
+}
+func (c *RedisServiceClient) ZAdd(in *ZSetRequest, out *ZSetResponse) error {
+	return c.Call("RedisService.ZAdd", in, out)
+}
+func (c *RedisServiceClient) ZIncrBy(in *ZSetRequest, out *ZSetResponse) error {
+	return c.Call("RedisService.ZIncrBy", in, out)
+}
+func (c *RedisServiceClient) ZRange(in *ZRangeRequest, out *HGetListResponse) error {
+	return c.Call("RedisService.ZRange", in, out)
+}
+func (c *RedisServiceClient) ZScan(in *ZScanRequest, out *HGetListResponse) error {
+	return c.Call("RedisService.ZScan", in, out)
+}
 
 // DialRedisService connects to an RedisService at the specified network address.
 func DialRedisService(network, addr string) (*RedisServiceClient, *rpc.Client, error) {

redis.proto

@@ -9,7 +9,7 @@ message GetRequest {
 message SetRequest {
 	string key = 1;
 	string value = 2;
-	string ttl = 3;
+	int64 ttl = 3;
 }
 message DelRequest {
 	string key = 1;
@@ -33,11 +33,21 @@ message HDelRequest {
     string field = 2;
 }
 
+//有效期
+message SetExpireRequest {
+	string key = 1;
+    int64 expire = 2;
+}
+
 // 使用key查询响应结构
 message GetStringResponse {
     string value = 1;
 }
 
+// 使用key查询响应结构
+message HGetListResponse {
+    bytes list = 1;
+}
 // 设置key响应结构
 message SetResponse {
     string ret = 1;
@@ -45,20 +55,114 @@ message SetResponse {
 
 // 删除key响应结构
 message DelResponse {
-    uint64 ret = 1;
+    int64 ret = 1;
 }
 
 // 设置key响应结构
 message HSetResponse {
-    uint64 ret = 1;
+    int64 ret = 1;
+}
+// 设置key有效期
+message SetExpireResponse {
+    int64 ret = 1;
+}
+
+//集合添加值
+message SSetRequest{
+	string key = 1;
+    string field = 2;
+}
+//集合添加值
+message SMembersRequest{
+	string key = 1;
+}
+// 设置响应结构
+message SSetResponse {
+    int64 ret = 1;
+}
+
+//列表添加值
+message LSetRequest{
+	string key = 1;
+    string field = 2;
+}
+
+// 设置key响应结构
+message LSetResponse {
+    int64 ret = 1;
+}
+
+//列表取值
+message LRangeRequest{
+	string key = 1;
+    int64 start = 2;
+    int64 stop = 3;
+}
+//列表长度
+message LLenRequest{
+	string key = 1;
+}
+
+//数值增加
+message AddRequest {
+	string key = 1;
+	int64 value = 2;
+}
+message AddResponse {
+    int64 ret = 1;
+}
+
+//有序集合添加值
+message ZSetRequest{
+	string key = 1;
+    string score = 2;
+    string member = 3;
+}
+// 设置响应结构
+message ZSetResponse {
+    int64 ret = 1;
+}
+//有序集合取值
+message ZRangeRequest{
+	string key = 1;
+    int64 start = 2;
+    int64 stop = 3;
+}
+
+message ZScanRequest {
+    string key = 1;
+    string field = 2;
+    int64 len = 3;
 }
 
 // rpc方法
 service RedisService {
     rpc Get (GetRequest) returns (GetStringResponse);    // 使用key查询
     rpc Set (SetRequest) returns (SetResponse);
+    rpc SetNx (SetRequest) returns (DelResponse);        // 如果不存在则设置
     rpc Del (DelRequest) returns (DelResponse);
     rpc HGet (HGetRequest) returns (GetStringResponse);    // 使用hash key查询
-    rpc HSet (HSetRequest) returns (SetResponse);
+    rpc HSet (HSetRequest) returns (HSetResponse);
     rpc HDel (HDelRequest) returns (DelResponse);
+    rpc SetExpire (SetExpireRequest) returns (SetExpireResponse); //设置有效期
+    rpc HGetAll(GetRequest) returns (HGetListResponse); //get hash all
+    rpc HGetList(GetRequest) returns (HGetListResponse); //get hash all
+    rpc HExists(HGetRequest) returns (DelResponse); //hash键是否存在
+    rpc Exists(GetRequest) returns (DelResponse); //键是否存在
+    rpc HIncrby(HSetRequest) returns (HSetResponse); //hash数值+-1
+    rpc SAdd(SSetRequest) returns (SSetResponse); //添加进入集合
+    rpc SIsmember(SSetRequest) returns (SSetResponse); //集合中是否存在值
+    rpc SRem(SSetRequest) returns (SSetResponse); //集合中删除值
+    rpc SCard(SMembersRequest) returns (SSetResponse); //获取集合的成员数
+    rpc LLpush(LSetRequest) returns (LSetResponse); //列表头部增加值
+    rpc LRpush(LSetRequest) returns (LSetResponse); //列表尾部增加值
+    rpc LRange(LRangeRequest) returns (HGetListResponse); //列表尾部增加值
+    rpc LLen(LLenRequest) returns (LSetResponse); //列表长度
+    rpc ReduceStock(SetRequest) returns(SetResponse);//扣减库存
+    rpc Incrby(AddRequest) returns(AddResponse);//增加
+    rpc Decrby(AddRequest) returns(AddResponse);//减
+    rpc ZAdd(ZSetRequest) returns (ZSetResponse); //添加进入有序集合
+    rpc ZIncrBy(ZSetRequest) returns (ZSetResponse); //有序集合权重递增
+    rpc ZRange(ZRangeRequest) returns (HGetListResponse);
+    rpc ZScan(ZScanRequest) returns(HGetListResponse);//zset match
 }

set.go

@@ -0,0 +1,213 @@
+package redisrpc
+
+import (
+	"encoding/json"
+	"log"
+
+	"github.com/golang/protobuf/proto"
+)
+
+//设置
+func SAdd(key, field string, url ...string) (int64, error) {
+
+	conn, _, err := Conn(url...)
+
+	if err != nil {
+		return 0, err
+	}
+	defer conn.Close()
+
+	req := &SSetRequest{proto.String(key), proto.String(field), nil}
+
+	res := &SSetResponse{}
+
+	err = conn.SAdd(req, res)
+
+	if err != nil {
+		return 0, err
+	}
+
+	return res.GetRet(), nil
+}
+
+//删除
+func SRem(key string, field string, url ...string) (int64, error) {
+
+	conn, _, err := Conn(url...)
+
+	if err != nil {
+		return 0, err
+	}
+	defer conn.Close()
+
+	req := &SSetRequest{proto.String(key), proto.String(field), nil}
+
+	res := &SSetResponse{}
+
+	err = conn.SRem(req, res)
+
+	if err != nil {
+		return 0, err
+	}
+
+	return res.GetRet(), nil
+}
+
+/**
+ * 全部
+ */
+func SIsmember(key string, field string, url ...string) (int64, error) {
+
+	conn, _, err := Conn(url...)
+
+	if err != nil {
+		return 0, err
+	}
+	defer conn.Close()
+
+	req := &SSetRequest{proto.String(key), proto.String(field), nil}
+
+	res := &SSetResponse{}
+
+	err = conn.SIsmember(req, res)
+
+	if err != nil {
+		return 0, err
+	}
+
+	return res.GetRet(), nil
+}
+
+/**
+ * 集合成员数
+ */
+func SCard(key string, url ...string) (int64, error) {
+
+	conn, _, err := Conn(url...)
+
+	if err != nil {
+		return 0, err
+	}
+	defer conn.Close()
+
+	req := &SMembersRequest{proto.String(key), nil}
+
+	res := &SSetResponse{}
+
+	err = conn.SCard(req, res)
+
+	if err != nil {
+		return 0, err
+	}
+
+	return res.GetRet(), nil
+}
+
+//设置
+func ZAdd(key, score, member string, url ...string) (int64, error) {
+
+	conn, _, err := Conn(url...)
+
+	if err != nil {
+		return 0, err
+	}
+	defer conn.Close()
+
+	req := &ZSetRequest{proto.String(key), proto.String(score), proto.String(member), nil}
+
+	res := &ZSetResponse{}
+
+	err = conn.ZAdd(req, res)
+
+	if err != nil {
+		return 0, err
+	}
+
+	return res.GetRet(), nil
+}
+
+//递增
+func ZIncrBy(key, inc, member string, url ...string) (int64, error) {
+
+	conn, _, err := Conn(url...)
+
+	if err != nil {
+		return 0, err
+	}
+	defer conn.Close()
+
+	req := &ZSetRequest{proto.String(key), proto.String(inc), proto.String(member), nil}
+
+	res := &ZSetResponse{}
+
+	err = conn.ZIncrBy(req, res)
+
+	if err != nil {
+		return 0, err
+	}
+
+	return res.GetRet(), nil
+}
+
+/**
+ * 集合成员
+ */
+func ZRange(key string, start, stop int64, url ...string) ([]map[string]string, error) {
+
+	conn, _, err := Conn(url...)
+	if err != nil {
+		return nil, err
+	}
+	defer conn.Close()
+
+	req := &ZRangeRequest{proto.String(key), proto.Int64(start), proto.Int64(stop), nil}
+	res := &HGetListResponse{}
+
+	err = conn.ZRange(req, res)
+
+	if err != nil {
+		return nil, err
+	}
+
+	value := res.GetList()
+	var list []map[string]string
+
+	err = json.Unmarshal(value, &list)
+	if err != nil {
+		log.Println("json unmarshal error:", err)
+		return nil, err
+	}
+	return list, nil
+}
+
+/**
+ * 集合成员
+ */
+func ZScan(key, field string, len int64, url ...string) ([]string, error) {
+
+	conn, _, err := Conn(url...)
+
+	if err != nil {
+		return nil, err
+	}
+	defer conn.Close()
+
+	req := &ZScanRequest{proto.String(key), proto.String(field), proto.Int64(len), nil}
+	res := &HGetListResponse{}
+
+	err = conn.ZScan(req, res)
+	if err != nil {
+		return nil, err
+	}
+
+	value := res.GetList()
+	var list []string
+
+	err = json.Unmarshal(value, &list)
+
+	if err != nil {
+		log.Println("json unmarshal error:", err)
+		return nil, err
+	}
+	return list, nil
+}

set_test.go

@@ -0,0 +1,45 @@
+package redisrpc
+
+import (
+	// "strconv"
+
+	"testing"
+	// "unicode/utf8"
+)
+
+func Test_SAdd(t *testing.T) {
+
+	// reply, err := SAdd("test", "44")
+	reply, err := SIsmember("test", "44")
+	t.Log(reply)
+	t.Log(err)
+
+	reply, err = SRem("test", "44")
+
+	t.Log(reply)
+	t.Log(err)
+
+}
+
+func Test_SCard(t *testing.T) {
+	res, err := SCard("test_article")
+
+	t.Log(res)
+	t.Log(err)
+}
+
+func Test_ZSet(t *testing.T) {
+
+	Del("zset-test")
+	res, err := ZAdd("zset-test", "2", "{\"keyword\":\"test\",\"id\":\"12\"}")
+	t.Log("ZAdd: ", res, err)
+
+	ress, err := ZScan("zset-test", "*test*", 10)
+	t.Log("ZScan: ", ress, err)
+
+	list, err := ZRange("zset-test", 0, 100)
+	t.Log("ZRangexx: ", list, err)
+
+	// res, err = ZIncrBy("zset-test", "2", "test")
+	// t.Log("ZIncrBy: ", res, err)
+}

string.go

@@ -30,7 +30,7 @@ func GetString(key string, url ...string) (string, error) {
 }
 
 //设置
-func Set(key, value string, ttl string, url ...string) (string, error) {
+func Set(key, value string, ttl int64, url ...string) (string, error) {
 
 	conn, _, err := Conn(url...)
 
@@ -39,7 +39,7 @@ func Set(key, value string, ttl string, url ...string) (string, error) {
 	}
 	defer conn.Close()
 
-	req := &SetRequest{proto.String(key), proto.String(value), proto.String(ttl), nil}
+	req := &SetRequest{proto.String(key), proto.String(value), proto.Int64(ttl), nil}
 
 	res := &SetResponse{}
 
@@ -53,7 +53,7 @@ func Set(key, value string, ttl string, url ...string) (string, error) {
 }
 
 //删除
-func Del(key string, url ...string) (uint64, error) {
+func Del(key string, url ...string) (int64, error) {
 
 	conn, _, err := Conn(url...)
 
@@ -74,3 +74,48 @@ func Del(key string, url ...string) (uint64, error) {
 
 	return res.GetRet(), nil
 }
+
+func Exists(key string, url ...string)(int64, error){
+	conn, _, err := Conn(url...)
+
+	if err != nil {
+		return 0, err
+	}
+	defer conn.Close()
+
+	req := &GetRequest{proto.String(key), nil}
+
+	res := &DelResponse{}
+
+	err = conn.Exists(req, res)
+
+	if err != nil {
+		return 0, err
+	}
+
+	return res.GetRet(), nil
+}
+
+
+//设置如果不存在
+func SetNx(key, value string, ttl int64, url ...string) (int64, error) {
+
+	conn, _, err := Conn(url...)
+
+	if err != nil {
+		return 0, err
+	}
+	defer conn.Close()
+
+	req := &SetRequest{proto.String(key), proto.String(value), proto.Int64(ttl), nil}
+
+	res := &DelResponse{}
+
+	err = conn.SetNx(req, res)
+
+	if err != nil {
+		return 0, err
+	}
+
+	return res.GetRet(), nil
+}

string_test.go

@@ -15,7 +15,7 @@ func Test_Get(t *testing.T) {
 
 func Test_Set(t *testing.T) {
 
-	c, err := Set("test", "1111", "7200")
+	c, err := Set("test", "222", 10)
 	t.Log(c)
 	t.Log(err)
 
@@ -23,8 +23,8 @@ func Test_Set(t *testing.T) {
 
 func Test_Del(t *testing.T) {
 
-	c, err := Del("test")
+	c, err := Del("test2")
 	t.Log(c)
 	t.Log(err)
 
-}
+}

watch_test.go

@@ -0,0 +1,24 @@
+package redisrpc
+
+import (
+	"log"
+	"testing"
+	// "time"
+)
+
+func Test_ReduceStock(t *testing.T) {
+
+	ch := make(chan int)
+	for i := 0; i < 100; i++ {
+		go func() {
+			log.Println("start")
+
+			reply, err := ReduceStock("test_watch", "2")
+
+			log.Println(reply)
+			log.Println(err)
+			log.Println("end")
+		}()
+	}
+	<-ch
+}

wath.go

@@ -0,0 +1,30 @@
+package redisrpc
+
+import (
+	"github.com/golang/protobuf/proto"
+)
+
+/**
+ * 使用用户名查询
+ */
+func ReduceStock(key string, value string, url ...string) (string, error) {
+
+	conn, _, err := Conn(url...)
+
+	if err != nil {
+		return "", err
+	}
+	defer conn.Close()
+
+	req := &SetRequest{proto.String(key), proto.String(value), proto.Int64(0), nil}
+
+	res := &SetResponse{}
+
+	err = conn.ReduceStock(req, res)
+
+	if err != nil {
+		return "", err
+	}
+
+	return res.GetRet(), nil
+}