增加vendor

vendor/github.com/silenceper/wechat/v2/cache/cache.go

@@ -0,0 +1,11 @@
+package cache
+
+import "time"
+
+// Cache interface
+type Cache interface {
+	Get(key string) interface{}
+	Set(key string, val interface{}, timeout time.Duration) error
+	IsExist(key string) bool
+	Delete(key string) error
+}

vendor/github.com/silenceper/wechat/v2/cache/memcache.go

@@ -0,0 +1,57 @@
+package cache
+
+import (
+	"encoding/json"
+	"time"
+
+	"github.com/bradfitz/gomemcache/memcache"
+)
+
+// Memcache struct contains *memcache.Client
+type Memcache struct {
+	conn *memcache.Client
+}
+
+// NewMemcache create new memcache
+func NewMemcache(server ...string) *Memcache {
+	mc := memcache.New(server...)
+	return &Memcache{mc}
+}
+
+// Get return cached value
+func (mem *Memcache) Get(key string) interface{} {
+	var err error
+	var item *memcache.Item
+	if item, err = mem.conn.Get(key); err != nil {
+		return nil
+	}
+	var result interface{}
+	if err = json.Unmarshal(item.Value, &result); err != nil {
+		return nil
+	}
+	return result
+}
+
+// IsExist check value exists in memcache.
+func (mem *Memcache) IsExist(key string) bool {
+	if _, err := mem.conn.Get(key); err != nil {
+		return false
+	}
+	return true
+}
+
+// Set cached value with key and expire time.
+func (mem *Memcache) Set(key string, val interface{}, timeout time.Duration) (err error) {
+	var data []byte
+	if data, err = json.Marshal(val); err != nil {
+		return err
+	}
+
+	item := &memcache.Item{Key: key, Value: data, Expiration: int32(timeout / time.Second)}
+	return mem.conn.Set(item)
+}
+
+// Delete delete value in memcache.
+func (mem *Memcache) Delete(key string) error {
+	return mem.conn.Delete(key)
+}

vendor/github.com/silenceper/wechat/v2/cache/memory.go

@@ -0,0 +1,74 @@
+package cache
+
+import (
+	"sync"
+	"time"
+)
+
+// Memory struct contains *memcache.Client
+type Memory struct {
+	sync.Mutex
+
+	data map[string]*data
+}
+
+type data struct {
+	Data    interface{}
+	Expired time.Time
+}
+
+// NewMemory create new memcache
+func NewMemory() *Memory {
+	return &Memory{
+		data: map[string]*data{},
+	}
+}
+
+// Get return cached value
+func (mem *Memory) Get(key string) interface{} {
+	if ret, ok := mem.data[key]; ok {
+		if ret.Expired.Before(time.Now()) {
+			mem.deleteKey(key)
+			return nil
+		}
+		return ret.Data
+	}
+	return nil
+}
+
+// IsExist check value exists in memcache.
+func (mem *Memory) IsExist(key string) bool {
+	if ret, ok := mem.data[key]; ok {
+		if ret.Expired.Before(time.Now()) {
+			mem.deleteKey(key)
+			return false
+		}
+		return true
+	}
+	return false
+}
+
+// Set cached value with key and expire time.
+func (mem *Memory) Set(key string, val interface{}, timeout time.Duration) (err error) {
+	mem.Lock()
+	defer mem.Unlock()
+
+	mem.data[key] = &data{
+		Data:    val,
+		Expired: time.Now().Add(timeout),
+	}
+	return nil
+}
+
+// Delete delete value in memcache.
+func (mem *Memory) Delete(key string) error {
+	mem.deleteKey(key)
+	return nil
+}
+
+// deleteKey
+func (mem *Memory) deleteKey(key string) {
+	mem.Lock()
+	defer mem.Unlock()
+	delete(mem.data, key)
+}

vendor/github.com/silenceper/wechat/v2/cache/redis.go

@@ -0,0 +1,112 @@
+package cache
+
+import (
+	"encoding/json"
+	"time"
+
+	"github.com/gomodule/redigo/redis"
+)
+
+// Redis .redis cache
+type Redis struct {
+	conn *redis.Pool
+}
+
+// RedisOpts redis 连接属性
+type RedisOpts struct {
+	Host        string `yml:"host" json:"host"`
+	Password    string `yml:"password" json:"password"`
+	Database    int    `yml:"database" json:"database"`
+	MaxIdle     int    `yml:"max_idle" json:"max_idle"`
+	MaxActive   int    `yml:"max_active" json:"max_active"`
+	IdleTimeout int    `yml:"idle_timeout" json:"idle_timeout"` // second
+}
+
+// NewRedis 实例化
+func NewRedis(opts *RedisOpts, dialOpts ...redis.DialOption) *Redis {
+	pool := &redis.Pool{
+		MaxActive:   opts.MaxActive,
+		MaxIdle:     opts.MaxIdle,
+		IdleTimeout: time.Second * time.Duration(opts.IdleTimeout),
+		Dial: func() (redis.Conn, error) {
+			dialOpts = append(dialOpts, []redis.DialOption{
+				redis.DialDatabase(opts.Database),
+				redis.DialPassword(opts.Password),
+			}...)
+			return redis.Dial("tcp", opts.Host, dialOpts...)
+		},
+		TestOnBorrow: func(conn redis.Conn, t time.Time) error {
+			if time.Since(t) < time.Minute {
+				return nil
+			}
+			_, err := conn.Do("PING")
+			return err
+		},
+	}
+	return &Redis{pool}
+}
+
+// SetRedisPool 设置redis连接池
+func (r *Redis) SetRedisPool(pool *redis.Pool) {
+	r.conn = pool
+}
+
+// SetConn 设置conn
+func (r *Redis) SetConn(conn *redis.Pool) {
+	r.conn = conn
+}
+
+// Get 获取一个值
+func (r *Redis) Get(key string) interface{} {
+	conn := r.conn.Get()
+	defer conn.Close()
+
+	var data []byte
+	var err error
+	if data, err = redis.Bytes(conn.Do("GET", key)); err != nil {
+		return nil
+	}
+	var reply interface{}
+	if err = json.Unmarshal(data, &reply); err != nil {
+		return nil
+	}
+
+	return reply
+}
+
+// Set 设置一个值
+func (r *Redis) Set(key string, val interface{}, timeout time.Duration) (err error) {
+	conn := r.conn.Get()
+	defer conn.Close()
+
+	var data []byte
+	if data, err = json.Marshal(val); err != nil {
+		return
+	}
+
+	_, err = conn.Do("SETEX", key, int64(timeout/time.Second), data)
+
+	return
+}
+
+// IsExist 判断key是否存在
+func (r *Redis) IsExist(key string) bool {
+	conn := r.conn.Get()
+	defer conn.Close()
+
+	a, _ := conn.Do("EXISTS", key)
+	i := a.(int64)
+	return i > 0
+}
+
+// Delete 删除
+func (r *Redis) Delete(key string) error {
+	conn := r.conn.Get()
+	defer conn.Close()
+
+	if _, err := conn.Do("DEL", key); err != nil {
+		return err
+	}
+
+	return nil
+}