Multi-layer caching implemented by golang

example

local caeche

package cache
import (
"context""time"
)
typeLocalCache[Tany] struct {
namestringcachemap[string]TzeroT
}
var_Cache[any] = (*LocalCache[any])(nil)
// NewLocalCache// @name cache name // @defaultExpiration default cache key expiration time// @cleanupInterval default time between cache cleanupsfuncNewLocalCache[Tany](namestring, defaultExpiration, cleanupInterval time.Duration) Cache[T] {
return&LocalCache[T]{
name: name,
cache: make(map[string]T),
}
}
func (lc*LocalCache[T]) Get(_ context.Context, keystring) (T, bool, error) {
v, exist:=lc.cache[key]
if!exist {
returnlc.zero, false, nil
}
vv, _:=v.(T)
returnvv, exist, nil
}
func (lc*LocalCache[T]) Set(_ context.Context, keystring, tT, _ time.Duration) error {
lc.cache[key] =treturnnil
}
func (lc*LocalCache[T]) Delete(_ context.Context, keys...string) error {
for_, key:=rangekeys {
delete(lc.cache, key)
}
returnnil
}
func (lc*LocalCache[T]) Name() string {
returnlc.name
}

remote cache

package cache
import (
"context""fmt""github.com/redis/go-redis/v9""reflect""time"
)
typeRedisClientstruct {
*redis.Client
}
funcNewRedisClient(ctx context.Context, options*redis.Options) (*RedisClient, error) {
rc:=&RedisClient{redis.NewClient(options)}
returnrc, rc.Ping(ctx).Err()
}
func (rc*RedisClient) Close() error {
returnrc.Client.Close()
}
// RedisCache// Redis Cache the implementation only supports the normal key/value formattypeRedisCache[Tany] struct {
namestringcache*RedisClientzeroT
}
funcNewRedisCache[Tany](namestring, rc*RedisClient) Cache[T] {
return&RedisCache[T]{
name: name,
cache: rc,
}
}
func (rc*RedisCache[T]) Name() string {
returnrc.name
}
func (rc*RedisCache[T]) Get(ctx context.Context, keystring) (T, bool, error) {
strCmd:=rc.cache.Get(ctx, key)
value, err:=strCmd.Result()
iferr!=nil {
iferr==redis.Nil {
returnrc.zero, false, nil
}
returnrc.zero, false, err
}
varvTswitchreflect.TypeOf(rc.zero).Kind() {
casereflect.String:
varptranyptr=valuev=ptr.(T)
default:
err=json.Unmarshal([]byte(value), &v)
iferr!=nil {
returnrc.zero, false, err
}
}
returnv, true, err
}
func (rc*RedisCache[T]) Set(ctx context.Context, keystring, tT, expiration time.Duration) error {
varvstringswitchreflect.TypeOf(t).Kind() {
casereflect.String:
v=fmt.Sprintf("%v", t)
default:
body, err:=json.Marshal(t)
iferr!=nil {
returnerr
}
v=string(body)
}
statusCmd:=rc.cache.Set(ctx, key, v, expiration)
returnstatusCmd.Err()
}
func (rc*RedisCache[T]) Delete(ctx context.Context, keys...string) error {
intCmd:=rc.cache.Del(ctx, keys...)
returnintCmd.Err()
}
func (rc*RedisCache[T]) Close() error {
returnrc.cache.Close()
}

use

ctx:=context.Background()
local:=NewLocalCache[string]("local", 1*time.Minute, 1*time.Minute)
rc, err:=NewRedisClient(ctx, &redis.Options{
Addr: "",
Password: "",
})
iferr!=nil{
panic(err)
}
remote:=NewRedisCache[string]("remote", rc)
mCache:=NewMultilayerCache[string](1*time.Minute, local, remote)
defermCache.Close()
err=mCache.Set(ctx,"key","value")
iferr!=nil{
panic(err)
}
fmt.Println(mCache.Get(ctx,"key"))