zishuo/cache
1
0
Fork 0
mirror of https://github.com/gookit/cache.git synced 2025-10-21 23:30:10 +08:00
Code Issues Packages Projects Releases Wiki Activity

some update...

Browse Source
This commit is contained in:
inhere
2018-09-10 01:25:29 +08:00
parent 638c11bec0
commit ff8c04fd5d
8 changed files with 63 additions and 53 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
README.md
View File

@@ -52,16 +52,16 @@ func main() {
## Interface ## Interface
```go ```go
// CacheFace interface definition // Cache interface definition
type CacheFace interface { type Cache interface {
// basic op // basic op
Has(key string) bool Has(key string) bool
Get(key string) interface{} Get(key string) interface{}
Set(key string, val interface{}, ttl time.Duration) error Set(key string, val interface{}, ttl time.Duration) (err error)
Del(key string) error Del(key string) error
// multi op // multi op
GetMulti(keys []string) []interface{} GetMulti(keys []string) map[string]interface{}
SetMulti(mv map[string]interface{}, ttl time.Duration) error SetMulti(values map[string]interface{}, ttl time.Duration) (err error)
DelMulti(keys []string) error DelMulti(keys []string) error
// clear // clear
Clear() error Clear() error

48
cache.go
View File

@@ -8,8 +8,8 @@ import (
"time" "time"
) )
// CacheFace interface definition // Cache interface definition
type CacheFace interface { type Cache interface {
// basic op // basic op
Has(key string) bool Has(key string) bool
Get(key string) interface{} Get(key string) interface{}
@@ -74,33 +74,33 @@ var (
*************************************************************/ *************************************************************/
// default cache driver manager instance // default cache driver manager instance
var manager = NewManager() var defMgr = NewManager()
// Register driver to manager instance // Register driver to manager instance
func Register(name string, driver CacheFace) *CacheManager { func Register(name string, driver Cache) *Manager {
manager.SetDefName(name) defMgr.SetDefName(name)
manager.Register(name, driver) defMgr.Register(name, driver)
return manager return defMgr
} }
// SetDefName set default driver name // SetDefName set default driver name
func SetDefName(driverName string) { func SetDefName(driverName string) {
manager.SetDefName(driverName) defMgr.SetDefName(driverName)
} }
// Use returns a driver instance // Use returns a driver instance
func Use(driverName string) CacheFace { func Use(driverName string) Cache {
return manager.drivers[driverName] return defMgr.drivers[driverName]
} }
// Manager get default cache manager instance // DefMgr get default cache manager instance
func Manager() *CacheManager { func DefMgr() *Manager {
return manager return defMgr
} }
// Default get default cache driver instance // Default get default cache driver instance
func Default() CacheFace { func Default() Cache {
return manager.Default() return defMgr.Default()
} }
/************************************************************* /*************************************************************
@@ -109,40 +109,40 @@ func Default() CacheFace {
// Has cache key // Has cache key
func Has(key string) bool { func Has(key string) bool {
return manager.Default().Has(key) return defMgr.Default().Has(key)
} }
// Get value by key // Get value by key
func Get(key string) interface{} { func Get(key string) interface{} {
return manager.Default().Get(key) return defMgr.Default().Get(key)
} }
// Set value by key // Set value by key
func Set(key string, val interface{}, ttl time.Duration) error { func Set(key string, val interface{}, ttl time.Duration) error {
return manager.Default().Set(key, val, ttl) return defMgr.Default().Set(key, val, ttl)
} }
// Del value by key // Del value by key
func Del(key string) error { func Del(key string) error {
return manager.Default().Del(key) return defMgr.Default().Del(key)
} }
// GetMulti values by keys // GetMulti values by keys
func GetMulti(keys []string) []interface{} { func GetMulti(keys []string) map[string]interface{} {
return manager.Default().GetMulti(keys) return defMgr.Default().GetMulti(keys)
} }
// SetMulti values // SetMulti values
func SetMulti(mv map[string]interface{}, ttl time.Duration) error { func SetMulti(mv map[string]interface{}, ttl time.Duration) error {
return manager.Default().SetMulti(mv, ttl) return defMgr.Default().SetMulti(mv, ttl)
} }
// DelMulti values by keys // DelMulti values by keys
func DelMulti(keys []string) error { func DelMulti(keys []string) error {
return manager.Default().DelMulti(keys) return defMgr.Default().DelMulti(keys)
} }
// Clear all caches // Clear all caches
func Clear() error { func Clear() error {
return manager.Default().Clear() return defMgr.Default().Clear()
} }

4
file_cache.go
View File

@@ -31,7 +31,7 @@ func NewFileCache(dir string, pfxAndKey ...string) *FileCache {
c := &FileCache{ c := &FileCache{
cacheDir: dir, cacheDir: dir,
// init a memory cache. // init a memory cache.
MemoryCache: MemoryCache{caches: make(map[string]*CacheItem)}, MemoryCache: MemoryCache{caches: make(map[string]*Item)},
} }
if ln := len(pfxAndKey); ln > 0 { if ln := len(pfxAndKey); ln > 0 {
@@ -73,7 +73,7 @@ func (c *FileCache) Get(key string) interface{} {
return nil return nil
} }
item := &CacheItem{} item := &Item{}
if err = Unmarshal(bs, item); err != nil { if err = Unmarshal(bs, item); err != nil {
c.lastErr = err c.lastErr = err
return nil return nil

28
manager.go
View File

@@ -9,58 +9,58 @@ const (
) )
/************************************************************* /*************************************************************
* CacheManager * Manager
*************************************************************/ *************************************************************/
// CacheManager definition // Manager definition
type CacheManager struct { type Manager struct {
// Debug bool // Debug bool
// default driver name // default driver name
defName string defName string
// drivers map // drivers map
drivers map[string]CacheFace drivers map[string]Cache
} }
// NewManager create a cache manager instance // NewManager create a cache manager instance
func NewManager() *CacheManager { func NewManager() *Manager {
return &CacheManager{ return &Manager{
// defName: driverName, // defName: driverName,
drivers: make(map[string]CacheFace), drivers: make(map[string]Cache),
} }
} }
// SetDefName set default driver name // SetDefName set default driver name
func (m *CacheManager) SetDefName(driverName string) { func (m *Manager) SetDefName(driverName string) {
m.defName = driverName m.defName = driverName
} }
// Register new driver object // Register new driver object
func (m *CacheManager) Register(name string, driver CacheFace) *CacheManager { func (m *Manager) Register(name string, driver Cache) *Manager {
m.drivers[name] = driver m.drivers[name] = driver
return m return m
} }
// Default returns the default driver instance // Default returns the default driver instance
func (m *CacheManager) Default() CacheFace { func (m *Manager) Default() Cache {
return m.drivers[m.defName] return m.drivers[m.defName]
} }
// Use returns a driver instance // Use returns a driver instance
func (m *CacheManager) Use(driverName string) CacheFace { func (m *Manager) Use(driverName string) Cache {
return m.drivers[driverName] return m.drivers[driverName]
} }
// Get driver object by name // Get driver object by name
func (m *CacheManager) Get(name string) CacheFace { func (m *Manager) Get(name string) Cache {
return m.Use(name) return m.Use(name)
} }
// Driver object get // Driver object get
func (m *CacheManager) Driver(name string) CacheFace { func (m *Manager) Driver(name string) Cache {
return m.Use(name) return m.Use(name)
} }
// DefName get default driver name // DefName get default driver name
func (m *CacheManager) DefName() string { func (m *Manager) DefName() string {
return m.defName return m.defName
} }

12
memcached/memcached_test.go
View File

@@ -1,5 +1,17 @@
package memcached package memcached
import "fmt"
func Example() { func Example() {
c := New("10.0.0.1:11211", "10.0.0.2:11211") c := New("10.0.0.1:11211", "10.0.0.2:11211")
// set
c.Set("name", "cache value", 60)
// get
val := c.Get("name")
// del
c.Del("name")
// get: "cache value"
fmt.Print(val)
} }

10
memory_cache.go
View File

@@ -10,13 +10,13 @@ type MemoryCache struct {
// locker // locker
lock sync.RWMutex lock sync.RWMutex
// cache data in memory // cache data in memory
caches map[string]*CacheItem caches map[string]*Item
// last error // last error
lastErr error lastErr error
} }
// CacheItem for memory cache // Item for memory cache
type CacheItem struct { type Item struct {
// Exp expire time // Exp expire time
Exp int64 Exp int64
// Val cache value storage // Val cache value storage
@@ -26,7 +26,7 @@ type CacheItem struct {
// NewMemoryCache create a memory cache instance // NewMemoryCache create a memory cache instance
func NewMemoryCache() *MemoryCache { func NewMemoryCache() *MemoryCache {
return &MemoryCache{ return &MemoryCache{
caches: make(map[string]*CacheItem), caches: make(map[string]*Item),
} }
} }
@@ -62,7 +62,7 @@ func (c *MemoryCache) Set(key string, val interface{}, ttl time.Duration) (err e
c.lock.Lock() c.lock.Lock()
defer c.lock.Unlock() defer c.lock.Unlock()
item := &CacheItem{Val: val} item := &Item{Val: val}
if ttl > 0 { if ttl > 0 {
item.Exp = time.Now().Unix() + int64(ttl/time.Second) item.Exp = time.Now().Unix() + int64(ttl/time.Second)
} }

2
redis/redis.go
View File

@@ -171,7 +171,7 @@ func (c *RedisCache) String() string {
* helper methods * helper methods
*************************************************************/ *************************************************************/
// Driver object get // Pool get
func (c *RedisCache) Pool() *redis.Pool { func (c *RedisCache) Pool() *redis.Pool {
return c.pool return c.pool
} }

2
redis/redis_test.go
View File

@@ -6,8 +6,6 @@ func Example() {
// init driver // init driver
c := Connect("127.0.0.1:6379", "", 0) c := Connect("127.0.0.1:6379", "", 0)
// usage
//
// set // set
c.Set("name", "cache value", 60) c.Set("name", "cache value", 60)
// get // get