cache

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 implemetn 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

• Variables
• func FileGetContents(filename string) (data []byte, e error)
• func FilePutContents(filename string, content []byte) error
• func GetBool(v interface{}) bool
• func GetFloat64(v interface{}) float64
• func GetInt(v interface{}) int
• func GetInt64(v interface{}) int64
• func GetString(v interface{}) string
• func GobDecode(data []byte, to *FileCacheItem) error
• func GobEncode(data interface{}) ([]byte, error)
• func Register(name string, adapter Instance)
• type Cache
  • func NewCache(adapterName, config string) (adapter Cache, err error)
  • func NewFileCache() Cache
  • func NewMemoryCache() Cache
• type FileCache
  • func (fc *FileCache) ClearAll() error
  • func (fc *FileCache) Decr(key string) error
  • func (fc *FileCache) Delete(key string) error
  • func (fc *FileCache) Get(key string) interface{}
  • func (fc *FileCache) GetMulti(keys []string) []interface{}
  • func (fc *FileCache) Incr(key string) error
  • func (fc *FileCache) Init()
  • func (fc *FileCache) IsExist(key string) bool
  • func (fc *FileCache) Put(key string, val interface{}, timeout time.Duration) error
  • func (fc *FileCache) StartAndGC(config string) error
• type FileCacheItem
• type Instance
• type MemoryCache
  • func (bc *MemoryCache) ClearAll() error
  • func (bc *MemoryCache) Decr(key string) error
  • func (bc *MemoryCache) Delete(name string) error
  • func (bc *MemoryCache) Get(name string) interface{}
  • func (bc *MemoryCache) GetMulti(names []string) []interface{}
  • func (bc *MemoryCache) Incr(key string) error
  • func (bc *MemoryCache) IsExist(name string) bool
  • func (bc *MemoryCache) Put(name string, value interface{}, lifespan time.Duration) error
  • func (bc *MemoryCache) StartAndGC(config string) error
• type MemoryItem

Variables

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

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 FileCacheEmbedExpiry(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.