一般设计的微服务接口若被频繁大量调用，会导致CPU冲高，服务挂死等问题。此时可设计缓存方案，降低服务挂死风险。
beego 的 cache 模块是用来做数据缓存的，目前支持 file、memcache、memory 和 redis 四种引擎，本文主要介绍memory cache的使用，其他实现可参考beego官方文档。

使用入门

  1. // 首先引入包
  2. import "github.com/astaxie/beego/cache"
  4. // 然后初始化一个全局变量对象bm
  5. bm, err := cache.NewCache("memory", `{"interval":60}`)
  7. // 然后我们就可以使用bm增删改缓存
  8. bm.Put("astaxie", 1, 10*time.Second)
  9. bm.Get("astaxie")
  10. bm.IsExist("astaxie")
  11. bm.Delete("astaxie")

缓存机制的实现

  1. // cache.NewCache
  2. func init() {
  3.    Register("memory", NewMemoryCache)         // 模块初始化会把 创建Cache实例的方法注册到Map中
  4. }
  6. func NewCache(adapterName, config string) (adapter Cache, err error) {
  7.    instanceFunc, ok := adapters[adapterName]          // 获取到创建Cache实例的方法
  8.    if !ok {
  9.       err = fmt.Errorf("cache: unknown adapter name %q (forgot to import?)", adapterName)
  10.       return
  11.    }
  12.    adapter = instanceFunc()              // 调用方法创建Cache实例
  13.    err = adapter.StartAndGC(config)         // 调用GC
  14.    if err != nil {
  15.       adapter = nil
  16.    }
  17.    return
  18. }
  20. func (bc *MemoryCache) StartAndGC(config string) error {
  21.    var cf map[string]int
  22.    json.Unmarshal([]byte(config), &cf)
  23.    if _, ok := cf["interval"]; !ok {
  24.       cf = make(map[string]int)
  25.       cf["interval"] = DefaultEvery
  26.    }
  27.    dur := time.Duration(cf["interval"]) * time.Second
  28.    bc.Every = cf["interval"]
  29.    bc.dur = dur
  30.    go bc.vaccuum()      //上面主要是解析config，获取interval，此处起一个协程调用缓存的清理方法
  31.    return nil
  32. }
  34. func (bc *MemoryCache) vaccuum() {
  35.    if bc.Every < 1 {
  36.       return
  37.    }
  38.    for {
  39.       <-time.After(bc.dur)         // for循环，每bc.dur(如60)秒
  40.       if bc.items == nil {       // 若item为nil，退出循环，返回
  41.          return
  42.       }
  43.       if keys := bc.expiredKeys(); len(keys) != 0 {   //若不为空，清理掉过期的缓存键值对
  44.          bc.clearItems(keys)
  45.       }
  46.    }
  47. }
  50. // cache.Put
  51. func (bc *MemoryCache) Put(name string, value interface{}, lifespan time.Duration) error {                                                            
  52.     //除了键和值以外，还要给定超时时间参数
  53.    bc.Lock()
  54.    defer bc.Unlock()
  55.    bc.items[name] = &MemoryItem{
  56.       val:         value,
  57.       createdTime: time.Now(),       //存入缓存时间
  58.       lifespan:    lifespan,            //超时时间              
  59.    }
  60.    return nil
  61. }
  63. // cache.Get
  64. func (bc *MemoryCache) Get(name string) interface{} {
  65.    bc.RLock()
  66.    defer bc.RUnlock()
  67.    if itm, ok := bc.items[name]; ok {
  68.       if itm.isExpire() {          //如果超时，返回nil
  69.          return nil
  70.       }
  71.       return itm.val
  72.    }
  73.    return nil
  74. }
  76. func (mi *MemoryItem) isExpire() bool {
  77.    // 0 means forever
  78.    if mi.lifespan == 0 {
  79.       return false
  80.    }
  81.    return time.Now().Sub(mi.createdTime) > mi.lifespan //当前时间减去创建时间大于超时时间，则超时
  82. }

开发自己的引擎

cache 模块采用了接口的方式实现，因此用户可以很方便的实现接口，然后注册就可以实现自己的 Cache 引擎：

  1. type Cache interface {
  2.     Get(key string) interface{}
  3.     GetMulti(keys []string) []interface{}
  4.     Put(key string, val interface{}, timeout time.Duration) error    
  5.     Delete(key string) error    
  6.     Incr(key string) error    
  7.     Decr(key string) error    
  8.     IsExist(key string) bool
  9.     ClearAll() error    
  10.     StartAndGC(config string) error
  11. }
  13. // 用户开发完毕在最后写类似这样的：
  14. func init() {
  15.     Register("myowncache", NewOwnCache())
  16. }