GO简单包一下缓存

ICacheQueryBase

type ICacheQueryBase  interface {
    GetCacheKey() string
}

CacheMiddleware

package entity_cache
 
import (
    "encoding/json"
    "errors"
    "github.com/coocood/freecache"
    "reflect"
)
 
type CacheCore   struct {
}
 
func (c *CacheCore) OnHit(key string) ([]byte, bool) {
    resp, err := LocalCache.Get([]byte(key))
    if err == freecache.ErrNotFound {
        return nil, false
    }
    if err != nil {
        //log
        return nil, false
    }
 
    return resp, true
}
 
func (c *CacheCore) Set(key string, data []byte, expireSeconds int) {
    err := LocalCache.Set([]byte(key), []byte(data), expireSeconds)
    if err != nil {
        //log
    }
}
 
type CacheMiddleware   struct {
}
 
func (c *CacheMiddleware) Query(query ICacheQueryBase, reload   func (query ICacheQueryBase) (  interface {}, error), refV   interface {}) error {
    cacheCore := CacheCore{}
 
    if cacheBytes, isHit := cacheCore.OnHit(query.GetCacheKey()); isHit {
        err := json.Unmarshal(cacheBytes, &refV)
        if err == nil {
            return nil
        }   else {
            //log
        }
    }
 
    resp, err := reload(query)
    if err != nil {
        return err
    }
 
    va := reflect.ValueOf(refV).Elem()
    if va.IsValid() {
        va.Set(reflect.ValueOf(resp))
    }   else {
        return errors.New(  "err type,refV must be pointer" )
    }
 
    respByte, err := json.Marshal(resp)
    if err != nil {
        //log
    }
    cacheCore.Set(query.GetCacheKey(), respByte, 60)
 
    return nil
}

Cache_test

type UserEntity struct {
    UserId   int64
    UserName string
}
 
type UserQuery struct {
    UserId int64
}
 
func (c UserQuery) GetCacheKey() string {
    idStr := strconv.FormatInt(c.UserId, 10)
    return "User" + idStr
}
func TestCache(t *testing.T) {
    Init()
 
    var userId int64 = 99
    query := UserQuery{
        UserId: userId,
    }
 
    var respV UserEntity
 
    medware := CacheMiddleware{}
    err := medware.Query(query, func(query ICacheQueryBase) (interface{}, error) {
        q := query.(UserQuery)
        return UserEntity{
            UserId:   q.UserId,
            UserName: "UUUUUUUUUUUUU",
        }, nil
    }, &respV)
    if err != nil {
        //
    }
 
    var respV2 UserEntity
    err = medware.Query(query, func(query ICacheQueryBase) (interface{}, error) {
        q := query.(UserQuery)
        return UserEntity{
            UserId:   q.UserId,
            UserName: "UUUUUUUUUUUUU",
        }, nil
    }, &respV2)
    if err != nil {
        //
    }
 
    fmt.Println(respV2)
}