From 7de69db70720cfe96d195442f8f21113e14b5e3f Mon Sep 17 00:00:00 2001 From: 564104865 <48121048+564104865@users.noreply.github.com> Date: Wed, 3 Nov 2021 10:16:41 +0800 Subject: [PATCH] 232234 --- os/gcache/gcache_z_example_adapter_redis.go | 118 +++++ os/gcache/gcache_z_example_cache_test.go | 475 ++++++++++++++++++++ 2 files changed, 593 insertions(+) create mode 100644 os/gcache/gcache_z_example_adapter_redis.go create mode 100644 os/gcache/gcache_z_example_cache_test.go diff --git a/os/gcache/gcache_z_example_adapter_redis.go b/os/gcache/gcache_z_example_adapter_redis.go new file mode 100644 index 000000000..6f6adfe65 --- /dev/null +++ b/os/gcache/gcache_z_example_adapter_redis.go @@ -0,0 +1,118 @@ +package gcache + +import ( + "context" + "github.com/gogf/gf/v2/container/gvar" + "github.com/gogf/gf/v2/database/gredis" + "time" +) + +// Redis is the gcache adapter implements using Redis server. +type Redis struct { + redis *gredis.Redis +} + +// newAdapterMemory creates and returns a new memory cache object. +func NewRedis(redis *gredis.Redis) Adapter { + return &Redis{ + redis: redis, + } +} + +func (r Redis) Set(ctx context.Context, key interface{}, value interface{}, duration time.Duration) error { + var err error + if value == nil || duration < 0 { + _, err = r.redis.Do(ctx,"DEL", key) + } else { + if duration == 0 { + _, err = r.redis.Do(ctx,"SET", key, value) + } else { + _, err = r.redis.Do(ctx,"SETEX", key, uint64(duration.Seconds()), value) + } + } + return err +} + +func (r Redis) SetMap(ctx context.Context, data map[interface{}]interface{}, duration time.Duration) error { + panic("implement me") +} + +func (r Redis) SetIfNotExist(ctx context.Context, key interface{}, value interface{}, duration time.Duration) (ok bool, err error) { + panic("implement me") +} + +func (r Redis) SetIfNotExistFunc(ctx context.Context, key interface{}, f func() (interface{}, error), duration time.Duration) (ok bool, err error) { + panic("implement me") +} + +func (r Redis) SetIfNotExistFuncLock(ctx context.Context, key interface{}, f func() (interface{}, error), duration time.Duration) (ok bool, err error) { + panic("implement me") +} + +func (r Redis) Get(ctx context.Context, key interface{}) (*gvar.Var, error) { + v, err := r.redis.Do(ctx,"GET", key) + if err != nil { + return nil, err + } + + return v, nil +} + +func (r Redis) GetOrSet(ctx context.Context, key interface{}, value interface{}, duration time.Duration) (result *gvar.Var, err error) { + panic("implement me") +} + +func (r Redis) GetOrSetFunc(ctx context.Context, key interface{}, f func() (interface{}, error), duration time.Duration) (result *gvar.Var, err error) { + panic("implement me") +} + +func (r Redis) GetOrSetFuncLock(ctx context.Context, key interface{}, f func() (interface{}, error), duration time.Duration) (result *gvar.Var, err error) { + panic("implement me") +} + +func (r Redis) Contains(ctx context.Context, key interface{}) (bool, error) { + panic("implement me") +} + +func (r Redis) Size(ctx context.Context) (size int, err error) { + panic("implement me") +} + +func (r Redis) Data(ctx context.Context) (data map[interface{}]interface{}, err error) { + panic("implement me") +} + +func (r Redis) Keys(ctx context.Context) (keys []interface{}, err error) { + panic("implement me") +} + +func (r Redis) Values(ctx context.Context) (values []interface{}, err error) { + panic("implement me") +} + +func (r Redis) Update(ctx context.Context, key interface{}, value interface{}) (oldValue *gvar.Var, exist bool, err error) { + panic("implement me") +} + +func (r Redis) UpdateExpire(ctx context.Context, key interface{}, duration time.Duration) (oldDuration time.Duration, err error) { + panic("implement me") +} + +func (r Redis) GetExpire(ctx context.Context, key interface{}) (time.Duration, error) { + panic("implement me") +} + +func (r Redis) Remove(ctx context.Context, keys ...interface{}) (lastValue *gvar.Var, err error) { + panic("implement me") +} + +func (r Redis) Clear(ctx context.Context) error { + panic("implement me") +} + +func (r Redis) Close(ctx context.Context) error { + panic("implement me") +} + + + diff --git a/os/gcache/gcache_z_example_cache_test.go b/os/gcache/gcache_z_example_cache_test.go new file mode 100644 index 000000000..f9b59db34 --- /dev/null +++ b/os/gcache/gcache_z_example_cache_test.go @@ -0,0 +1,475 @@ +package gcache_test + +import ( + "fmt" + "github.com/gogf/gf/v2/frame/g" + "github.com/gogf/gf/v2/os/gcache" + "time" +) + + +func ExampleNew() { + + //Create a cache object, + //Of course, you can also easily use the gcache package method directly + c := gcache.New() + + //Set cache without expiration + c.Set(ctx, "k1", "v1", 0) + + //Get cache + v, _ := c.Get(ctx, "k1") + fmt.Println(v) + + //Get cache size + n, _ := c.Size(ctx) + fmt.Println(n) + + //Does the specified key name exist in the cache + b, _ := c.Contains(ctx, "k1") + fmt.Println(b) + + //Delete and return the deleted key value + fmt.Println(c.Remove(ctx, "k1")) + + // Close the cache object and let the GC reclaim resources + // + c.Close(ctx) + + // Output: + // v1 + // 1 + // true + // v1 +} + +func ExampleCache_Set() { + + //Create a cache object, + //Of course, you can also easily use the gcache package method directly + c := gcache.New() + + //Set cache without expiration + c.Set(ctx, "k1", g.Slice{1, 2, 3, 4, 5, 6, 7, 8, 9}, 0) + + //Get cache + fmt.Println(c.Get(ctx, "k1")) + + // Output: + // [1,2,3,4,5,6,7,8,9] +} + +func ExampleCache_SetAdapters() { + + //Create a cache object, + //Of course, you can also easily use the gcache package method directly + c := gcache.New() + + //SetAdapter changes the adapter for this cache. Be very note that, this setting function is not concurrent-safe, + //which means you should not call this setting function concurrently in multiple goroutines. + adapter := gcache.NewRedis(g.Redis()) + c.SetAdapter(adapter) + + //Set cache + c.Set(ctx, "k1", g.Slice{1, 2, 3, 4, 5, 6, 7, 8, 9}, 0) + + // Reverse makes array with elements in reverse order. + fmt.Println(c.Get(ctx, "k1")) + + // May Output: + // [1,2,3,4,5,6,7,8,9] +} + +func ExampleCache_SetIfNotExist() { + + //Create a cache object, + //Of course, you can also easily use the gcache package method directly + c := gcache.New() + + //Write when the key name does not exist, and set the expiration time to 1000 milliseconds + k1, err := c.SetIfNotExist(ctx, "k1", "v1", 1000*time.Millisecond) + fmt.Println(k1, err) + + //Returns false when the key name already exists + k2, err := c.SetIfNotExist(ctx, "k1", "v2", 1000*time.Millisecond) + fmt.Println(k2, err) + + //Print the current list of key values + keys1, _ := c.Keys(ctx) + fmt.Println(keys1) + + //It does not expire if `duration` == 0. It deletes the `key` if `duration` < 0 or given `value` is nil. + c.SetIfNotExist(ctx, "k1", 0, -10000) + + // Wait 1 second for K1: V1 to expire automatically + time.Sleep(time.Second) + + // Print the current key value pair again and find that K1: V1 has expired + keys2, _ := c.Keys(ctx) + fmt.Println(keys2) + + // Output: + // true + // false + // [k1] + // [] +} + +func ExampleCache_Sets() { + + //Create a cache object, + //Of course, you can also easily use the gcache package method directly + c := gcache.New() + + //map[interface{}]interface{} + data := g.MapAnyAny{ + "k1": "v1", + "k2": "v2", + "k3": "v3", + } + + //Sets batch sets cache with key-value pairs by `data`, which is expired after `duration`. + //It does not expire if `duration` == 0. It deletes the keys of `data` if `duration` < 0 or given `value` is nil. + c.SetMap(ctx, data, 1000*time.Millisecond) + + //Print the current key value pair + data2, _ := c.Data(ctx) + + //Gets the specified key value + v1, _ := c.Get(ctx, "k1") + + fmt.Println(data2, v1) + + + // Output: + // map[k1:v1 k2:v2 k3:v3] v1 +} + +func ExampleCache_Size() { + + //Create a cache object, + //Of course, you can also easily use the gcache package method directly + c := gcache.New() + + // Add 10 elements without expiration + for i := 0; i < 10; i++ { + c.Set(ctx,i, i, 0) + } + + //Size returns the number of items in the cache. + n, _ := c.Size(ctx) + fmt.Println(n) + + // Output: + // 10 +} + +func ExampleCache_Update(){ + + //Create a cache object, + //Of course, you can also easily use the gcache package method directly + c := gcache.New() + + //Sets batch sets cache with key-value pairs by `data`, which is expired after `duration`. + //It does not expire if `duration` == 0. It deletes the keys of `data` if `duration` < 0 or given `value` is nil. + c.SetMap(ctx, g.MapAnyAny{"k1": "v1","k2":"v2","k3":"v3"}, 0) + + //Print the current key value pair + data, _ := c.Data(ctx) + fmt.Println(data) + + //Update updates the value of `key` without changing its expiration and returns the old value. + re,exist,_ := c.Update(ctx,"k1","v11") + fmt.Println(re,exist) + + //The returned value `exist` is false if the `key` does not exist in the cache. + //It does nothing if `key` does not exist in the cache. + re1,exist1,_ := c.Update(ctx,"k4","v44") + fmt.Println(re1,exist1) + + + data1, _ := c.Data(ctx) + fmt.Println(data1) + // Output: + // map[k1:v1 k2:v2 k3:v3] + // v1 true + // false + // map[k1:v11 k2:v2 k3:v3] +} + +func ExampleCache_UpdateExpire(){ + + //Create a cache object, + //Of course, you can also easily use the gcache package method directly + c := gcache.New() + + c.Set(ctx,"k1","v1",1000*time.Millisecond) + k1_expire,_ := c.GetExpire(ctx,"k1") + fmt.Println(k1_expire) + + //UpdateExpire updates the expiration of `key` and returns the old expiration duration value. + //It returns -1 and does nothing if the `key` does not exist in the cache. + c.UpdateExpire(ctx,"k1",500*time.Millisecond) + + k1_expires,_ := c.GetExpire(ctx,"k1") + fmt.Println(k1_expires) + // Output: + // 1s + // 500ms +} + +func ExampleCache_Values(){ + + //Create a cache object, + //Of course, you can also easily use the gcache package method directly + c := gcache.New() + + //Write value + c.Set(ctx,"k1",g.Map{"k1": "v1","k2":"v2"},0) + c.Set(ctx,"k2","Here is Value2",0) + c.Set(ctx,"k3",111,0) + + //Values returns all values in the cache as slice. + data,_ :=c.Values(ctx) + fmt.Println(data) + + // Output: + // [map[k1:v1 k2:v2] Here is Value2 111] +} + +func ExampleCache_Close(){ + + //Create a cache object, + //Of course, you can also easily use the gcache package method directly + c := gcache.New() + + //Set Cache + c.Set(ctx,"k1","v",0) + data,_ := c.Get(ctx,"k1") + fmt.Println(data) + + // Close closes the cache if necessary. + c.Close(ctx) + + data1,_ := c.Get(ctx,"k1") + + fmt.Println(data1) + + // Output: + // v + // v + +} + +func ExampleCache_Contains() { + + //Create a cache object, + //Of course, you can also easily use the gcache package method directly + c := gcache.New() + + //Set Cache + c.Set(ctx,"k","v",0) + + //Contains returns true if `key` exists in the cache, or else returns false. + // return true + data,_ := c.Contains(ctx,"k") + fmt.Println(data) + + // return false + data1,_ := c.Contains(ctx,"k1") + fmt.Println(data1) + + // Output: + // true + // false + +} + +func ExampleCache_Data() { + + //Create a cache object, + //Of course, you can also easily use the gcache package method directly + c := gcache.New() + + c.SetMap(ctx,g.MapAnyAny{"k1": "v1","k2":"v2"},0) + c.Set(ctx,"k5","v5",0) + + //Data returns a copy of all key-value pairs in the cache as map type. Note that this function may lead lots of memory usage, you can implement this function if necessary. + data,_ := c.Data(ctx) + fmt.Println(data) + + // Output: + // map[k1:v1 k2:v2 k5:v5] +} + +func ExampleCache_Get(){ + + //Create a cache object, + //Of course, you can also easily use the gcache package method directly + c := gcache.New() + + //Set Cache Object + c.Set(ctx,"k1","v1",0) + + //Get retrieves and returns the associated value of given `key`. It returns nil if it does not exist, its value is nil or it's expired. + data,_ := c.Get(ctx,"k1") + fmt.Println(data) + + // Output: + // v1 +} + +func ExampleCache_GetExpire(){ + + //Create a cache object, + //Of course, you can also easily use the gcache package method directly + c := gcache.New() + + // Set cache without expiration + c.Set(ctx,"k","v",10000*time.Millisecond) + + //GetExpire retrieves and returns the expiration of `key` in the cache. + //It returns 0 if the `key` does not expire. It returns -1 if the `key` does not exist in the cache. + data,_ := c.GetExpire(ctx,"k") + fmt.Println(data) + + // Output: + // 10s +} + +func ExampleCache_GetOrSet(){ + + //Create a cache object, + //Of course, you can also easily use the gcache package method directly + c := gcache.New() + + //GetOrSet retrieves and returns the value of `key`, or sets `key`-`value` pair and returns `value` if `key` does not exist in the cache. + data,_ := c.GetOrSet(ctx,"k","v",10000*time.Millisecond) + fmt.Println(data) + + data1,_ := c.Get(ctx,"k") + fmt.Println(data1) + + // Output: + // v + // v + +} + +func ExampleCache_GetOrSetFunc(){ + + //Create a cache object, + //Of course, you can also easily use the gcache package method directly + c := gcache.New() + + //GetOrSetFunc retrieves and returns the value of `key`, or sets `key` with result of function `f` and returns its result if `key` does not exist in the cache. + c.GetOrSetFunc(ctx,1,func() (interface{}, error) { + return 111, nil + }, 10000*time.Millisecond) + v, _ := c.Get(ctx, 1) + fmt.Println(v) + + //but it does nothing if `value` is a function and the function result is nil. + c.GetOrSetFunc(ctx,2,func() (interface{}, error) { + return nil, nil + }, 10000*time.Millisecond) + v1, _ := c.Get(ctx, 2) + fmt.Println(v1) + + // Output: + // 111 + // +} + +func ExampleCache_GetOrSetFuncLock(){ + //Create a cache object, + //Of course, you can also easily use the gcache package method directly + c := gcache.New() + + // Modify locking Note that the function `f` should be executed within writing mutex lock for concurrent safety purpose. + c.GetOrSetFuncLock(ctx, 1, func() (interface{}, error) { + return 11, nil + }, 0) + v, _ := c.Get(ctx, 1) + fmt.Println(v) + + // Modification failed + c.GetOrSetFuncLock(ctx, 1, func() (interface{}, error) { + return 111, nil + }, 0) + v, _ = c.Get(ctx, 1) + fmt.Println(v) + + c.Remove(ctx, g.Slice{1, 2, 3}...) + + // Modify locking + c.GetOrSetFuncLock(ctx, 1, func() (interface{}, error) { + return 111, nil + }, 0) + v, _ = c.Get(ctx, 1) + fmt.Println(v) + + // Modification failed + c.GetOrSetFuncLock(ctx, 1, func() (interface{}, error) { + return 11, nil + }, 0) + v, _ = c.Get(ctx, 1) + fmt.Println(v) + + // Output: + // 11 + // 11 + // 111 + // 111 +} + +func ExampleCache_Keys(){ + //Create a cache object, + //Of course, you can also easily use the gcache package method directly + c := gcache.New() + + c.SetMap(ctx,g.MapAnyAny{"k1": "v1", "k2": "v2"},0) + + //Print the current list of key values + keys1, _ := c.Keys(ctx) + fmt.Println(keys1) + + // Output: + // [k1 k2] + +} + +func ExampleCache_Remove() { + //Create a cache object, + //Of course, you can also easily use the gcache package method directly + c := gcache.New() + + c.SetMap(ctx,g.MapAnyAny{"k1": "v1", "k2": "v2","k3":"v3","k4":"v4"},0) + + //Remove deletes one or more keys from cache, and returns its value. If multiple keys are given, it returns the value of the last deleted item. + c.Remove(ctx,"k1") + + data, _ := c.Data(ctx) + fmt.Println(data) + + // Output: + // map[k2:v2 k3:v3 k4:v4] +} + +func ExampleCache_Removes(){ + //Create a cache object, + //Of course, you can also easily use the gcache package method directly + c := gcache.New() + + c.SetMap(ctx,g.MapAnyAny{"k1": "v1", "k2": "v2","k3":"v3","k4":"v4"},0) + + //Remove deletes one or more keys from cache, and returns its value. If multiple keys are given, it returns the value of the last deleted item. + c.Removes(ctx, g.Slice{"k1", "k3"}) + + data, _ := c.Data(ctx) + fmt.Println(data) + + // Output: + // map[k2:v2 k4:v4] +} +