缓存驱动更换成功，支持3级缓存，memory，以及db

cache/cache.go

@@ -2,31 +2,276 @@ package cache
 
 import (
 	. "../common"
+	"errors"
 )
 
+// HoTimeCache 可配置memory，db，redis，默认启用memory，默认优先级为memory>redis>db,memory与数据库缓存设置项一致，
+//缓存数据填充会自动反方向反哺，加入memory缓存过期将自动从redis更新，但memory永远不会更新redis，如果是集群建议不要开启memory，配置即启用
 type HoTimeCache struct {
-
-	//set(key string, value interface{}, time int64)
-	//get(key string) interface{}
-	//delete(key string)
-	Error
-	dbCache     CacheIns
-	redisCache  CacheIns
-	memoryCache CacheIns
+	*Error
+	dbCache     *CacheDb
+	redisCache  *CacheRedis
+	memoryCache *CacheMemory
+	Config      Map
 }
 
-func (this *HoTimeCache) Session(key string, data ...interface{}) *Obj {
-	return nil
+func (that *HoTimeCache) Session(key string, data ...interface{}) *Obj {
+	var reData *Obj
+	if len(data) == 0 {
+		//内存缓存有
+		if that.memoryCache != nil && that.memoryCache.SessionSet {
+			reData = that.memoryCache.Cache(key, data)
+			if reData != nil {
+				return reData
+			}
+		}
+
+		//redis缓存有
+		if that.redisCache != nil && that.redisCache.SessionSet {
+			reData = that.redisCache.Cache(key, data)
+			if reData != nil {
+				if that.memoryCache != nil && that.memoryCache.SessionSet {
+					that.memoryCache.Cache(key, reData)
+				}
+				return reData
+			}
+		}
+
+		//db缓存有
+		if that.dbCache != nil && that.dbCache.SessionSet {
+			reData = that.dbCache.Cache(key, data)
+			if reData != nil {
+				if that.memoryCache != nil && that.memoryCache.SessionSet {
+					that.memoryCache.Cache(key, reData)
+				}
+				if that.redisCache != nil && that.redisCache.SessionSet {
+					that.redisCache.Cache(key, reData)
+				}
+
+				return reData
+			}
+		}
+		return reData
+	}
+
+	//设置缓存
+	//设置内存缓存
+	if that.memoryCache != nil && that.memoryCache.SessionSet {
+		reData = that.memoryCache.Cache(key, data)
+	}
+	//redis缓存有
+	if that.redisCache != nil && that.redisCache.SessionSet {
+		reData = that.redisCache.Cache(key, data)
+	}
+	//redis缓存有
+	if that.dbCache != nil && that.dbCache.SessionSet {
+		reData = that.dbCache.Cache(key, data)
+	}
+	return reData
+
 }
-func (this *HoTimeCache) Db(key string, data ...interface{}) *Obj {
-	return nil
+func (that *HoTimeCache) Db(key string, data ...interface{}) *Obj {
+	var reData *Obj
+	if len(data) == 0 {
+		//内存缓存有
+		if that.memoryCache != nil && that.memoryCache.DbSet {
+			reData = that.memoryCache.Cache(key, data)
+			if reData != nil {
+				return reData
+			}
+		}
+
+		//redis缓存有
+		if that.redisCache != nil && that.redisCache.DbSet {
+			reData = that.redisCache.Cache(key, data)
+			if reData != nil {
+				if that.memoryCache != nil && that.memoryCache.DbSet {
+					that.memoryCache.Cache(key, reData)
+				}
+				return reData
+			}
+		}
+
+		//redis缓存有
+		if that.dbCache != nil && that.dbCache.DbSet {
+			reData = that.dbCache.Cache(key, data)
+			if reData != nil {
+				if that.memoryCache != nil && that.memoryCache.DbSet {
+					that.memoryCache.Cache(key, reData)
+				}
+
+				if that.redisCache != nil && that.redisCache.DbSet {
+					that.redisCache.Cache(key, reData)
+				}
+
+				return reData
+			}
+		}
+		return reData
+	}
+
+	//设置缓存
+	//设置内存缓存
+	if that.memoryCache != nil && that.memoryCache.DbSet {
+		reData = that.memoryCache.Cache(key, data)
+	}
+	//redis缓存有
+	if that.redisCache != nil && that.redisCache.DbSet {
+		reData = that.redisCache.Cache(key, data)
+	}
+	//redis缓存有
+	if that.dbCache != nil && that.dbCache.DbSet {
+		reData = that.dbCache.Cache(key, data)
+	}
+	return reData
 }
 
-func (this *HoTimeCache) Cache(key string, data ...interface{}) *Obj {
-	return nil
+func (that *HoTimeCache) Cache(key string, data ...interface{}) *Obj {
+	var reData *Obj
+	if len(data) == 0 {
+		//内存缓存有
+		if that.memoryCache != nil {
+			reData = that.memoryCache.Cache(key, data)
+			if reData != nil {
+				return reData
+			}
+		}
+
+		//redis缓存有
+		if that.redisCache != nil {
+			reData = that.redisCache.Cache(key, data)
+			if reData != nil {
+
+				if that.memoryCache != nil {
+					that.memoryCache.Cache(key, reData)
+				}
+				return reData
+			}
+		}
+
+		//redis缓存有
+		if that.dbCache != nil {
+			reData = that.dbCache.Cache(key, data)
+			if reData != nil {
+				if that.memoryCache != nil {
+					that.memoryCache.Cache(key, reData)
+				}
+				if that.redisCache != nil {
+					that.redisCache.Cache(key, reData)
+				}
+				return reData
+			}
+		}
+		return reData
+	}
+
+	//设置缓存
+	//设置内存缓存
+	if that.memoryCache != nil {
+		reData = that.memoryCache.Cache(key, data)
+	}
+	//redis缓存有
+	if that.redisCache != nil {
+		reData = that.redisCache.Cache(key, data)
+	}
+	//redis缓存有
+	if that.dbCache != nil {
+		reData = that.dbCache.Cache(key, data)
+	}
+	return reData
 }
 
-func (this *HoTimeCache) getIndex() []CacheIns {
+func (that *HoTimeCache) Init(config Map, hotimeDb HoTimeDBInterface, err ...*Error) {
+	//防止空数据问题
+	if config == nil {
+		config = Map{}
+	}
+	if err[0] != nil {
+		that.Error = err[0]
+	}
+	that.Config = config
+	//memory配置初始化
+	memory := that.Config.GetMap("memory")
+	if memory == nil {
+		memory = Map{
+			"db":      true,
+			"session": true,
+			"sort":    0,
+			"timeout": 60 * 60 * 2,
+		}
+
+	}
+	if memory.Get("db") == nil {
+		memory["db"] = true
+	}
+
+	if memory.Get("session") == nil {
+		memory["session"] = true
+	}
+
+	if memory.Get("timeout") == nil {
+		memory["timeout"] = 60 * 60 * 2
+	}
+	that.Config["memory"] = memory
+	that.memoryCache = &CacheMemory{TimeOut: memory.GetCeilInt64("timeout"),
+		DbSet: memory.GetBool("db"), SessionSet: memory.GetBool("session")}
+	if err[0] != nil {
+		that.memoryCache.SetError(err[0])
+	}
+
+	//db配置初始化
+	redis := that.Config.GetMap("redis")
+	if redis != nil {
+		if redis.GetString("host") == "" || redis.GetString("port") == "" {
+			if err[0] != nil {
+				err[0].SetError(errors.New("请检查redis配置host和port配置"))
+			}
+			return
+		}
+		if redis.Get("db") == nil {
+			redis["db"] = true
+		}
+
+		if redis.Get("session") == nil {
+			redis["session"] = true
+		}
+
+		if redis.Get("timeout") == nil {
+			redis["timeout"] = 60 * 60 * 24 * 30
+		}
+		that.Config["redis"] = redis
+		that.redisCache = &CacheRedis{TimeOut: redis.GetCeilInt64("timeout"),
+			DbSet: redis.GetBool("db"), SessionSet: redis.GetBool("session"), Host: redis.GetString("host"),
+			Pwd: redis.GetString("password"), Port: redis.GetCeilInt64("port")}
+
+		if err[0] != nil {
+			that.redisCache.SetError(err[0])
+		}
+	}
+
+	//db配置初始化
+	db := that.Config.GetMap("db")
+	if db != nil {
+
+		if db.Get("db") == nil {
+			db["db"] = false
+		}
+
+		if db.Get("session") == nil {
+			db["session"] = true
+		}
+		if db.Get("timeout") == nil {
+			db["timeout"] = 60 * 60 * 24 * 30
+		}
+		that.Config["db"] = db
+
+		that.dbCache = &CacheDb{TimeOut: db.GetCeilInt64("timeout"),
+			DbSet: db.GetBool("db"), SessionSet: db.GetBool("session"),
+			Db: hotimeDb}
+
+		if err[0] != nil {
+			that.dbCache.SetError(err[0])
+		}
+	}
 
-	return nil
 }

cache/cache_db.go

@@ -20,13 +20,26 @@ type HoTimeDBInterface interface {
 }
 
 type CacheDb struct {
-	Time int64
-	Db   HoTimeDBInterface
-	Error
+	TimeOut    int64
+	DbSet      bool
+	SessionSet bool
+	Time       int64
+	Db         HoTimeDBInterface
+	*Error
 	ContextBase
 	isInit bool
 }
 
+func (this *CacheDb) GetError() *Error {
+
+	return this.Error
+
+}
+
+func (this *CacheDb) SetError(err *Error) {
+	this.Error = err
+}
+
 func (that *CacheDb) initDbTable() {
 	if that.isInit {
 		return
@@ -146,7 +159,7 @@ func (that *CacheDb) Cache(key string, data ...interface{}) *Obj {
 	}
 	if len(data) == 2 {
 		that.SetError(nil)
-		tempt := ObjToInt64(data[1], &that.Error)
+		tempt := ObjToInt64(data[1], that.Error)
 
 		if tempt > tim {
 			tim = tempt

cache/cache_memory.go

@@ -8,13 +8,25 @@ import (
 )
 
 type CacheMemory struct {
-	Time int64
+	TimeOut    int64
+	DbSet      bool
+	SessionSet bool
 	Map
-	Error
+	*Error
 	ContextBase
 	mutex *sync.RWMutex
 }
 
+func (this *CacheMemory) GetError() *Error {
+
+	return this.Error
+
+}
+
+func (this *CacheMemory) SetError(err *Error) {
+	this.Error = err
+}
+
 //获取Cache键只能为string类型
 func (this *CacheMemory) get(key string) interface{} {
 	this.Error.SetError(nil)
@@ -25,8 +37,8 @@ func (this *CacheMemory) get(key string) interface{} {
 	if this.Map[key] == nil {
 		return nil
 	}
-	data := this.Map.Get(key, &this.Error).(cacheData)
-	if this.GetError() != nil {
+	data := this.Map.Get(key, this.Error).(cacheData)
+	if this.Error.GetError() != nil {
 		return nil
 	}
 
@@ -121,21 +133,18 @@ func (this *CacheMemory) Cache(key string, data ...interface{}) *Obj {
 	}
 
 	if len(data) == 1 {
-		if this.Time == 0 {
-			//this.Time = Config.GetInt64("cacheShortTime")
-		}
 
-		tim = tim + this.Time
+		tim = tim + this.TimeOut
 
 	}
 	if len(data) == 2 {
 		this.Error.SetError(nil)
-		tempt := ObjToInt64(data[1], &this.Error)
+		tempt := ObjToInt64(data[1], this.Error)
 
 		if tempt > tim {
 
 			tim = tempt
-		} else if this.GetError() == nil {
+		} else if this.Error.GetError() == nil {
 
 			tim = tim + tempt
 		}

cache/cache_redis.go

@@ -8,13 +8,26 @@ import (
 )
 
 type CacheRedis struct {
-	Host string
-	Pwd  string
-	Time int64
-	conn redis.Conn
-	tag  int64
+	TimeOut    int64
+	DbSet      bool
+	SessionSet bool
+	Host       string
+	Pwd        string
+	Port       int64
+	conn       redis.Conn
+	tag        int64
 	ContextBase
-	Error
+	*Error
+}
+
+func (this *CacheRedis) GetError() *Error {
+
+	return this.Error
+
+}
+
+func (this *CacheRedis) SetError(err *Error) {
+	this.Error = err
 }
 
 //唯一标志
@@ -28,7 +41,7 @@ func (this *CacheRedis) GetTag() int64 {
 
 func (this *CacheRedis) reCon() bool {
 	var err error
-	this.conn, err = redis.Dial("tcp", this.Host)
+	this.conn, err = redis.Dial("tcp", this.Host+":"+ObjToStr(this.Port))
 	if err != nil {
 		this.conn = nil
 		this.Error.SetError(err)
@@ -129,15 +142,15 @@ func (this *CacheRedis) Cache(key string, data ...interface{}) *Obj {
 	//添加缓存
 	if len(data) == 1 {
 
-		if this.Time == 0 {
+		if this.TimeOut == 0 {
 			//this.Time = Config.GetInt64("cacheShortTime")
 		}
 
-		tim += this.Time
+		tim += this.TimeOut
 	}
 	if len(data) == 2 {
 		this.Error.SetError(nil)
-		tempt := ObjToInt64(data[1], &this.Error)
+		tempt := ObjToInt64(data[1], this.Error)
 		if tempt > tim {
 
 			tim = tempt

cache/type.go

@@ -8,8 +8,8 @@ type CacheIns interface {
 	//set(key string, value interface{}, time int64)
 	//get(key string) interface{}
 	//delete(key string)
-	GetError() error
-	SetError(err error)
+	GetError() *Error
+	SetError(err *Error)
 	Cache(key string, data ...interface{}) *Obj
 }