README

cache

cache is a Go cache manager. It can use many cache adapters. The repo is inspired by database/sql .

How to install?

go get github.com/astaxie/beego/cache

What adapters are supported?

As of now this cache support memory, Memcache and Redis.

How to use it?

First you must import it

import (
    "github.com/astaxie/beego/cache"
)

Then init a Cache (example with memory adapter)

bm, err := cache.NewCache("memory", `{"interval":60}`)	

Use it like this:

bm.Put("astaxie", 1, 10 * time.Second)
bm.Get("astaxie")
bm.IsExist("astaxie")
bm.Delete("astaxie")

Memory adapter

Configure memory adapter like this:

{"interval":60}

interval means the gc time. The cache will check at each time interval, whether item has expired.

Memcache adapter

Memcache adapter use the gomemcache client.

Configure like this:

{"conn":"127.0.0.1:11211"}

Redis adapter

Redis adapter use the redigo client.

Configure like this:

{"conn":":6039"}

Documentation

Overview

    Package cache provide a Cache interface and some implement engine Usage:

    import(

    "github.com/astaxie/beego/cache"
    

    )

    bm, err := cache.NewCache("memory", `{"interval":60}`)

    Use it like this:

    	bm.Put("astaxie", 1, 10 * time.Second)
    	bm.Get("astaxie")
    	bm.IsExist("astaxie")
    	bm.Delete("astaxie")
    
     more docs http://beego.me/docs/module/cache.md
    

    Index

    Constants

    This section is empty.

    Variables

    View Source
    var (
    	FileCachePath           = "cache"     // cache directory
    	FileCacheFileSuffix     = ".bin"      // cache file suffix
    	FileCacheDirectoryLevel = 2           // cache file deep level if auto generated cache files.
    	FileCacheEmbedExpiry    time.Duration // cache expire time, default is no expire forever.
    )

      FileCache Config

      View Source
      var (
      	// DefaultEvery means the clock time of recycling the expired cache items in memory.
      	DefaultEvery = 60 // 1 minute
      )

      Functions

      func FileGetContents

      func FileGetContents(filename string) (data []byte, e error)

        FileGetContents Get bytes to file. if non-exist, create this file.

        func FilePutContents

        func FilePutContents(filename string, content []byte) error

          FilePutContents Put bytes to file. if non-exist, create this file.

          func GetBool

          func GetBool(v interface{}) bool

            GetBool convert interface to bool.

            func GetFloat64

            func GetFloat64(v interface{}) float64

              GetFloat64 convert interface to float64.

              func GetInt

              func GetInt(v interface{}) int

                GetInt convert interface to int.

                func GetInt64

                func GetInt64(v interface{}) int64

                  GetInt64 convert interface to int64.

                  func GetString

                  func GetString(v interface{}) string

                    GetString convert interface to string.

                    func GobDecode

                    func GobDecode(data []byte, to *FileCacheItem) error

                      GobDecode Gob decodes file cache item.

                      func GobEncode

                      func GobEncode(data interface{}) ([]byte, error)

                        GobEncode Gob encodes file cache item.

                        func Register

                        func Register(name string, adapter Instance)

                          Register makes a cache adapter available by the adapter name. If Register is called twice with the same name or if driver is nil, it panics.

                          Types

                          type Cache

                          type Cache interface {
                          	// get cached value by key.
                          	Get(key string) interface{}
                          	// GetMulti is a batch version of Get.
                          	GetMulti(keys []string) []interface{}
                          	// set cached value with key and expire time.
                          	Put(key string, val interface{}, timeout time.Duration) error
                          	// delete cached value by key.
                          	Delete(key string) error
                          	// increase cached int value by key, as a counter.
                          	Incr(key string) error
                          	// decrease cached int value by key, as a counter.
                          	Decr(key string) error
                          	// check if cached value exists or not.
                          	IsExist(key string) bool
                          	// clear all cache.
                          	ClearAll() error
                          	// start gc routine based on config string settings.
                          	StartAndGC(config string) error
                          }

                            Cache interface contains all behaviors for cache adapter. usage:

                            cache.Register("file",cache.NewFileCache) // this operation is run in init method of file.go.
                            c,err := cache.NewCache("file","{....}")
                            c.Put("key",value, 3600 * time.Second)
                            v := c.Get("key")
                            
                            c.Incr("counter")  // now is 1
                            c.Incr("counter")  // now is 2
                            count := c.Get("counter").(int)
                            

                            func NewCache

                            func NewCache(adapterName, config string) (adapter Cache, err error)

                              NewCache Create a new cache driver by adapter name and config string. config need to be correct JSON as string: {"interval":360}. it will start gc automatically.

                              func NewFileCache

                              func NewFileCache() Cache

                                NewFileCache Create new file cache with no config. the level and expiry need set in method StartAndGC as config string.

                                func NewMemoryCache

                                func NewMemoryCache() Cache

                                  NewMemoryCache returns a new MemoryCache.

                                  type FileCache

                                  type FileCache struct {
                                  	CachePath      string
                                  	FileSuffix     string
                                  	DirectoryLevel int
                                  	EmbedExpiry    int
                                  }

                                    FileCache is cache adapter for file storage.

                                    func (*FileCache) ClearAll

                                    func (fc *FileCache) ClearAll() error

                                      ClearAll will clean cached files. not implemented.

                                      func (*FileCache) Decr

                                      func (fc *FileCache) Decr(key string) error

                                        Decr will decrease cached int value.

                                        func (*FileCache) Delete

                                        func (fc *FileCache) Delete(key string) error

                                          Delete file cache value.

                                          func (*FileCache) Get

                                          func (fc *FileCache) Get(key string) interface{}

                                            Get value from file cache. if non-exist or expired, return empty string.

                                            func (*FileCache) GetMulti

                                            func (fc *FileCache) GetMulti(keys []string) []interface{}

                                              GetMulti gets values from file cache. if non-exist or expired, return empty string.

                                              func (*FileCache) Incr

                                              func (fc *FileCache) Incr(key string) error

                                                Incr will increase cached int value. fc value is saving forever unless Delete.

                                                func (*FileCache) Init

                                                func (fc *FileCache) Init()

                                                  Init will make new dir for file cache if not exist.

                                                  func (*FileCache) IsExist

                                                  func (fc *FileCache) IsExist(key string) bool

                                                    IsExist check value is exist.

                                                    func (*FileCache) Put

                                                    func (fc *FileCache) Put(key string, val interface{}, timeout time.Duration) error

                                                      Put value into file cache. timeout means how long to keep this file, unit of ms. if timeout equals fc.EmbedExpiry(default is 0), cache this item forever.

                                                      func (*FileCache) StartAndGC

                                                      func (fc *FileCache) StartAndGC(config string) error

                                                        StartAndGC will start and begin gc for file cache. the config need to be like {CachePath:"/cache","FileSuffix":".bin","DirectoryLevel":"2","EmbedExpiry":"0"}

                                                        type FileCacheItem

                                                        type FileCacheItem struct {
                                                        	Data       interface{}
                                                        	Lastaccess time.Time
                                                        	Expired    time.Time
                                                        }

                                                          FileCacheItem is basic unit of file cache adapter. it contains data and expire time.

                                                          type Instance

                                                          type Instance func() Cache

                                                            Instance is a function create a new Cache Instance

                                                            type MemoryCache

                                                            type MemoryCache struct {
                                                            	sync.RWMutex
                                                            
                                                            	Every int // run an expiration check Every clock time
                                                            	// contains filtered or unexported fields
                                                            }

                                                              MemoryCache is Memory cache adapter. it contains a RW locker for safe map storage.

                                                              func (*MemoryCache) ClearAll

                                                              func (bc *MemoryCache) ClearAll() error

                                                                ClearAll will delete all cache in memory.

                                                                func (*MemoryCache) Decr

                                                                func (bc *MemoryCache) Decr(key string) error

                                                                  Decr decrease counter in memory.

                                                                  func (*MemoryCache) Delete

                                                                  func (bc *MemoryCache) Delete(name string) error

                                                                    Delete cache in memory.

                                                                    func (*MemoryCache) Get

                                                                    func (bc *MemoryCache) Get(name string) interface{}

                                                                      Get cache from memory. if non-existed or expired, return nil.

                                                                      func (*MemoryCache) GetMulti

                                                                      func (bc *MemoryCache) GetMulti(names []string) []interface{}

                                                                        GetMulti gets caches from memory. if non-existed or expired, return nil.

                                                                        func (*MemoryCache) Incr

                                                                        func (bc *MemoryCache) Incr(key string) error

                                                                          Incr increase cache counter in memory. it supports int,int32,int64,uint,uint32,uint64.

                                                                          func (*MemoryCache) IsExist

                                                                          func (bc *MemoryCache) IsExist(name string) bool

                                                                            IsExist check cache exist in memory.

                                                                            func (*MemoryCache) Put

                                                                            func (bc *MemoryCache) Put(name string, value interface{}, lifespan time.Duration) error

                                                                              Put cache to memory. if lifespan is 0, it will be forever till restart.

                                                                              func (*MemoryCache) StartAndGC

                                                                              func (bc *MemoryCache) StartAndGC(config string) error

                                                                                StartAndGC start memory cache. it will check expiration in every clock time.

                                                                                type MemoryItem

                                                                                type MemoryItem struct {
                                                                                	// contains filtered or unexported fields
                                                                                }

                                                                                  MemoryItem store memory cache item.

                                                                                  Directories

                                                                                  Path Synopsis
                                                                                  Package memcache for cache provider depend on github.com/bradfitz/gomemcache/memcache go install github.com/bradfitz/gomemcache/memcache Usage: import( _ "github.com/astaxie/beego/cache/memcache" "github.com/astaxie/beego/cache" ) bm, err := cache.NewCache("memcache", `{"conn":"127.0.0.1:11211"}`) more docs http://beego.me/docs/module/cache.md
                                                                                  Package memcache for cache provider depend on github.com/bradfitz/gomemcache/memcache go install github.com/bradfitz/gomemcache/memcache Usage: import( _ "github.com/astaxie/beego/cache/memcache" "github.com/astaxie/beego/cache" ) bm, err := cache.NewCache("memcache", `{"conn":"127.0.0.1:11211"}`) more docs http://beego.me/docs/module/cache.md
                                                                                  Package redis for cache provider depend on github.com/gomodule/redigo/redis go install github.com/gomodule/redigo/redis Usage: import( _ "github.com/astaxie/beego/cache/redis" "github.com/astaxie/beego/cache" ) bm, err := cache.NewCache("redis", `{"conn":"127.0.0.1:11211"}`) more docs http://beego.me/docs/module/cache.md
                                                                                  Package redis for cache provider depend on github.com/gomodule/redigo/redis go install github.com/gomodule/redigo/redis Usage: import( _ "github.com/astaxie/beego/cache/redis" "github.com/astaxie/beego/cache" ) bm, err := cache.NewCache("redis", `{"conn":"127.0.0.1:11211"}`) more docs http://beego.me/docs/module/cache.md