- update redis
continuous-integration/drone/push Build is passing Details
continuous-integration/drone/tag Build is passing Details

master v1.0.11
李光春 2 years ago
parent d51b35450b
commit 2c2b2bc62a

@ -1,3 +1,3 @@
package gocache
const Version = "1.0.10"
const Version = "1.0.11"

@ -4,9 +4,7 @@ go 1.19
require (
github.com/allegro/bigcache/v3 v3.0.2
github.com/bradfitz/gomemcache v0.0.0-20220106215444-fb4bf637b56d
github.com/dgraph-io/ristretto v0.1.0
github.com/go-redis/redis/v9 v9.0.0-beta.1
github.com/patrickmn/go-cache v2.1.0+incompatible
go.dtapp.net/dorm v1.0.14
go.etcd.io/etcd/client/v3 v3.5.4
@ -19,6 +17,7 @@ require (
github.com/coreos/go-systemd/v22 v22.3.2 // indirect
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
github.com/dustin/go-humanize v1.0.0 // indirect
github.com/go-redis/redis/v9 v9.0.0-beta.1 // indirect
github.com/go-sql-driver/mysql v1.6.0 // indirect
github.com/go-stack/stack v1.8.1 // indirect
github.com/goccy/go-json v0.8.1 // indirect

@ -36,8 +36,6 @@ github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+Ce
github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
github.com/bitly/go-simplejson v0.5.0 h1:6IH+V8/tVMab511d5bn4M7EwGXZf9Hj6i2xSwkNEM+Y=
github.com/bradfitz/gomemcache v0.0.0-20220106215444-fb4bf637b56d h1:pVrfxiGfwelyab6n21ZBkbkmbevaf+WvMIiR7sr97hw=
github.com/bradfitz/gomemcache v0.0.0-20220106215444-fb4bf637b56d/go.mod h1:H0wQNHz2YrLsuXOZozoeDmnHXkNCRmMW0gwFWDfEZDA=
github.com/casbin/casbin/v2 v2.1.2/go.mod h1:YcPU1XXisHhLzuxH9coDNf2FbKpjGlbCg3n9yuLkIJQ=
github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM=
github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=

@ -1,51 +0,0 @@
package gocache
import (
"github.com/bradfitz/gomemcache/memcache"
)
// MemcachedConfig 配置
type MemcachedConfig struct {
Dns string // 连接地址,可选
Db *memcache.Client // 驱动,可选
}
// Memcached https://github.com/bradfitz/gomemcache
type Memcached struct {
db *memcache.Client // 驱动
}
// NewMemcached 实例化
func NewMemcached(config *MemcachedConfig) *Memcached {
if config.Dns == "" {
return &Memcached{db: config.Db}
} else {
mc := memcache.New(config.Dns)
if mc == nil {
panic("连接失败")
}
return &Memcached{db: mc}
}
}
// Set 插入数据
func (m *Memcached) Set(key string, value []byte) error {
return m.db.Set(&memcache.Item{Key: key, Value: value})
}
// Get 获取单个数据
func (m *Memcached) Get(key string) (string, error) {
it, err := m.db.Get(key)
if err == memcache.ErrCacheMiss {
return "", memcache.ErrCacheMiss
}
if it.Key == key {
return string(it.Value), nil
}
return "", memcache.ErrCacheMiss
}
// Del 删除单个数据
func (m *Memcached) Del(key string) error {
return m.db.Delete(key)
}

@ -1,57 +0,0 @@
package gocache
import (
"encoding/json"
"github.com/bradfitz/gomemcache/memcache"
)
// MemcachedCache https://github.com/bradfitz/gomemcache
type MemcachedCache struct {
db *Memcached // 驱动
GetterString GttStringFunc // 不存在的操作
GetterInterface GttInterfaceFunc // 不存在的操作
}
// NewCache 实例化
func (m *Memcached) NewCache() *MemcachedCache {
return &MemcachedCache{db: m}
}
// GetString 缓存操作
func (mc *MemcachedCache) GetString(key string) (ret string) {
f := func() string {
return mc.GetterString()
}
// 如果不存在则调用GetterString
ret, err := mc.db.Get(key)
if err == memcache.ErrCacheMiss {
mc.db.Set(key, []byte(f()))
ret, _ = mc.db.Get(key)
}
return
}
// GetInterface 缓存操作
func (mc *MemcachedCache) GetInterface(key string, result interface{}) {
f := func() string {
marshal, _ := json.Marshal(mc.GetterInterface())
return string(marshal)
}
// 如果不存在则调用GetterInterface
ret, err := mc.db.Get(key)
if err == memcache.ErrCacheMiss {
mc.db.Set(key, []byte(f()))
ret, _ = mc.db.Get(key)
}
err = json.Unmarshal([]byte(ret), result)
return
}

@ -3,94 +3,66 @@ package gocache
import (
"context"
"encoding/json"
"errors"
"fmt"
"github.com/go-redis/redis/v9"
"go.dtapp.net/dorm"
"time"
)
// RedisConfig 配置
type RedisConfig struct {
Addr string // 地址,可选
Password string // 密码,可选
DbName int // 数据库,可选
DefaultExpiration time.Duration // 默认过期时间
RedisClient *dorm.RedisClient // 驱动,可选
Client *dorm.RedisClient // 驱动,可选
Debug bool // 调试,可选
}
// Redis https://github.com/go-redis/redis
type Redis struct {
RedisConfig
db *redis.Client // 驱动
ctx context.Context // 上下文内容
config *RedisConfig // 配置
Client *dorm.RedisClient // 驱动
}
// NewRedis 实例化
func NewRedis(config *RedisConfig) *Redis {
app := &Redis{}
app.DefaultExpiration = config.DefaultExpiration
app.ctx = context.Background()
if config.Addr == "" {
app.db = config.RedisClient.Db
return app
} else {
app.db = redis.NewClient(&redis.Options{
Addr: config.Addr, // 地址
Password: config.Password, // 密码
DB: config.DbName, // 数据库
PoolSize: 100, // 连接池大小
})
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
_, err := app.db.Ping(ctx).Result()
if err != nil {
panic(errors.New(fmt.Sprintf("连接失败,%s", err.Error())))
}
return app
}
c := &Redis{config: config}
c.Client = config.Client
return c
}
// Set 设置一个key的值
func (r *Redis) Set(key string, value interface{}, expiration time.Duration) (string, error) {
r.setLog(key)
return r.db.Set(r.ctx, key, value, expiration).Result()
return r.Client.Db.Set(context.Background(), key, value, expiration).Result()
}
// SetInterface 设置一个key的值
func (r *Redis) SetInterface(key string, value interface{}, expiration time.Duration) (string, error) {
r.setLog(key)
marshal, _ := json.Marshal(value)
return r.db.Set(r.ctx, key, marshal, expiration).Result()
return r.Client.Db.Set(context.Background(), key, marshal, expiration).Result()
}
// SetDefaultExpiration 设置一个key的值使用全局默认过期时间
func (r *Redis) SetDefaultExpiration(key string, value interface{}) (string, error) {
r.setLog(key)
return r.db.Set(r.ctx, key, value, r.DefaultExpiration).Result()
return r.Client.Db.Set(context.Background(), key, value, r.config.DefaultExpiration).Result()
}
// SetInterfaceDefaultExpiration 设置一个key的值使用全局默认过期时间
func (r *Redis) SetInterfaceDefaultExpiration(key string, value interface{}) (string, error) {
r.setLog(key)
marshal, _ := json.Marshal(value)
return r.db.Set(r.ctx, key, marshal, r.DefaultExpiration).Result()
return r.Client.Db.Set(context.Background(), key, marshal, r.config.DefaultExpiration).Result()
}
// Get 查询key的值
func (r *Redis) Get(key string) (string, error) {
r.getLog(key)
return r.db.Get(r.ctx, key).Result()
return r.Client.Db.Get(context.Background(), key).Result()
}
// GetInterface 查询key的值
func (r *Redis) GetInterface(key string, result interface{}) error {
r.getLog(key)
ret, err := r.db.Get(r.ctx, key).Result()
ret, err := r.Client.Db.Get(context.Background(), key).Result()
if err != nil {
return err
}
@ -100,52 +72,52 @@ func (r *Redis) GetInterface(key string, result interface{}) error {
// GetSet 设置一个key的值并返回这个key的旧值
func (r *Redis) GetSet(key string, value interface{}) (string, error) {
return r.db.GetSet(r.ctx, key, value).Result()
return r.Client.Db.GetSet(context.Background(), key, value).Result()
}
// SetNX 如果key不存在则设置这个key的值
func (r *Redis) SetNX(key string, value interface{}, expiration time.Duration) error {
return r.db.SetNX(r.ctx, key, value, expiration).Err()
return r.Client.Db.SetNX(context.Background(), key, value, expiration).Err()
}
// SetNXDefaultExpiration 如果key不存在则设置这个key的值使用全局默认过期时间
func (r *Redis) SetNXDefaultExpiration(key string, value interface{}) error {
return r.db.SetNX(r.ctx, key, value, r.DefaultExpiration).Err()
return r.Client.Db.SetNX(context.Background(), key, value, r.config.DefaultExpiration).Err()
}
// MGet 批量查询key的值
func (r *Redis) MGet(keys ...string) ([]interface{}, error) {
return r.db.MGet(r.ctx, keys...).Result()
return r.Client.Db.MGet(context.Background(), keys...).Result()
}
// MSet 批量设置key的值
// MSet(map[string]interface{}{"key1": "value1", "key2": "value2"})
func (r *Redis) MSet(values map[string]interface{}) error {
return r.db.MSet(r.ctx, values).Err()
return r.Client.Db.MSet(context.Background(), values).Err()
}
// Incr 针对一个key的数值进行递增操作
func (r *Redis) Incr(key string) (int64, error) {
return r.db.Incr(r.ctx, key).Result()
return r.Client.Db.Incr(context.Background(), key).Result()
}
// IncrBy 针对一个key的数值进行递增操作指定每次递增多少
func (r *Redis) IncrBy(key string, value int64) (int64, error) {
return r.db.IncrBy(r.ctx, key, value).Result()
return r.Client.Db.IncrBy(context.Background(), key, value).Result()
}
// Decr 针对一个key的数值进行递减操作
func (r *Redis) Decr(key string) (int64, error) {
return r.db.Decr(r.ctx, key).Result()
return r.Client.Db.Decr(context.Background(), key).Result()
}
// DecrBy 针对一个key的数值进行递减操作指定每次递减多少
func (r *Redis) DecrBy(key string, value int64) (int64, error) {
return r.db.DecrBy(r.ctx, key, value).Result()
return r.Client.Db.DecrBy(context.Background(), key, value).Result()
}
// Del 删除key操作支持批量删除
func (r *Redis) Del(keys ...string) error {
r.delLog(keys...)
return r.db.Del(r.ctx, keys...).Err()
return r.Client.Db.Del(context.Background(), keys...).Err()
}

@ -12,26 +12,25 @@ type RedisCacheConfig struct {
// RedisCache https://github.com/go-redis/redis
type RedisCache struct {
RedisCacheConfig
db *Redis // 驱动
config *RedisCacheConfig
operation *Redis // 操作
GetterString GttStringFunc // 不存在的操作
GetterInterface GttInterfaceFunc // 不存在的操作
}
// NewCache 实例化
func (r *Redis) NewCache(config *RedisCacheConfig) *RedisCache {
app := &RedisCache{}
app.expiration = config.expiration
app.db = r
return app
c := &RedisCache{config: config}
c.operation = r
return c
}
// NewCacheDefaultExpiration 实例化
func (r *Redis) NewCacheDefaultExpiration() *RedisCache {
app := &RedisCache{}
app.expiration = r.DefaultExpiration
app.db = r
return app
c := &RedisCache{}
c.config.expiration = r.config.DefaultExpiration
c.operation = r
return c
}
// GetString 缓存操作
@ -42,10 +41,10 @@ func (rc *RedisCache) GetString(key string) (ret string) {
}
// 如果不存在则调用GetterString
ret, err := rc.db.Get(key)
ret, err := rc.operation.Get(key)
if err != nil {
rc.db.Set(key, f(), rc.expiration)
ret, _ = rc.db.Get(key)
rc.operation.Set(key, f(), rc.config.expiration)
ret, _ = rc.operation.Get(key)
}
return
@ -60,11 +59,11 @@ func (rc *RedisCache) GetInterface(key string, result interface{}) {
}
// 如果不存在则调用GetterInterface
ret, err := rc.db.Get(key)
ret, err := rc.operation.Get(key)
if err != nil {
rc.db.Set(key, f(), rc.expiration)
ret, _ = rc.db.Get(key)
rc.operation.Set(key, f(), rc.config.expiration)
ret, _ = rc.operation.Get(key)
}
err = json.Unmarshal([]byte(ret), result)

@ -3,17 +3,17 @@ package gocache
import "log"
func (r *Redis) setLog(key string) {
if r.Debug == true {
if r.config.Debug == true {
log.Printf("gocache [%s] set\n", key)
}
}
func (r *Redis) getLog(key string) {
if r.Debug == true {
if r.config.Debug == true {
log.Printf("gocache [%s] get\n", key)
}
}
func (r *Redis) delLog(key ...string) {
if r.Debug == true {
if r.config.Debug == true {
log.Printf("gocache [%s] del\n", key)
}
}

Loading…
Cancel
Save