-
Notifications
You must be signed in to change notification settings - Fork 11
/
redigo.go
129 lines (103 loc) · 2.95 KB
/
redigo.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
package redigo
import (
"github.com/gomodule/redigo/redis"
)
// SubscribeFunc 订阅回调函数
type SubscribeFunc func(c redis.PubSubConn) (err error)
// ExecuteFunc 普通回调函数
type ExecuteFunc func(c redis.Conn) (res interface{}, err error)
type Client struct{ mode ModeInterface }
func New(mode ModeInterface) *Client {
return &Client{mode: mode}
}
// Mode 当前客户端使用模式
// alone 单机或者代理入口模式
// cluster Redis-Cluster集群模式
// sentinel Redis-Sentinel哨兵模式
func (c *Client) Mode() string {
return c.mode.String()
}
func (c *Client) Close() error {
return c.mode.Close()
}
func (c *Client) Execute(fn ExecuteFunc) (res interface{}, err error) {
conn := c.mode.GetConn()
defer conn.Close()
if res, err = fn(conn); err != nil {
if _, ok := err.(redis.Error); ok {
return
} else if newConn, newErr := c.mode.NewConn(); newErr != nil {
return
} else {
defer newConn.Close()
res, err = fn(newConn)
}
}
return
}
func (c *Client) MustExec(fun ExecuteFunc) interface{} {
res, err := c.Execute(fun)
if err != nil {
panic(err)
}
return res
}
func (c *Client) Subscribe(fn SubscribeFunc) error {
conn, err := c.mode.NewConn()
if err != nil {
return err
}
defer conn.Close()
return fn(redis.PubSubConn{Conn: conn})
}
func (c *Client) Int(fn ExecuteFunc) (int, error) {
return redis.Int(c.Execute(fn))
}
func (c *Client) Ints(fn ExecuteFunc) ([]int, error) {
return redis.Ints(c.Execute(fn))
}
func (c *Client) IntMap(fn ExecuteFunc) (map[string]int, error) {
return redis.IntMap(c.Execute(fn))
}
func (c *Client) Int64(fn ExecuteFunc) (int64, error) {
return redis.Int64(c.Execute(fn))
}
func (c *Client) Int64s(fn ExecuteFunc) ([]int64, error) {
return redis.Int64s(c.Execute(fn))
}
func (c *Client) Int64Map(fn ExecuteFunc) (map[string]int64, error) {
return redis.Int64Map(c.Execute(fn))
}
func (c *Client) Uint64(fn ExecuteFunc) (uint64, error) {
return redis.Uint64(c.Execute(fn))
}
func (c *Client) Bool(fn ExecuteFunc) (bool, error) {
return redis.Bool(c.Execute(fn))
}
func (c *Client) String(fn ExecuteFunc) (string, error) {
return redis.String(c.Execute(fn))
}
func (c *Client) StringMap(fn ExecuteFunc) (map[string]string, error) {
return redis.StringMap(c.Execute(fn))
}
func (c *Client) Strings(fn ExecuteFunc) ([]string, error) {
return redis.Strings(c.Execute(fn))
}
func (c *Client) Bytes(fn ExecuteFunc) ([]byte, error) {
return redis.Bytes(c.Execute(fn))
}
func (c *Client) ByteSlices(fn ExecuteFunc) ([][]byte, error) {
return redis.ByteSlices(c.Execute(fn))
}
func (c *Client) Positions(fn ExecuteFunc) ([]*[2]float64, error) {
return redis.Positions(c.Execute(fn))
}
func (c *Client) Float64(fn ExecuteFunc) (float64, error) {
return redis.Float64(c.Execute(fn))
}
func (c *Client) Float64s(fn ExecuteFunc) ([]float64, error) {
return redis.Float64s(c.Execute(fn))
}
func (c *Client) Values(fn ExecuteFunc) ([]interface{}, error) {
return redis.Values(c.Execute(fn))
}