From 1101937028319e34da2ae2b58228dce040fb30d4 Mon Sep 17 00:00:00 2001 From: hoteas Date: Fri, 28 May 2021 22:52:22 +0800 Subject: [PATCH] =?UTF-8?q?=E7=BC=93=E5=AD=98=E9=A9=B1=E5=8A=A8=E6=9B=B4?= =?UTF-8?q?=E6=8D=A2=E6=88=90=E5=8A=9F=EF=BC=8C=E6=94=AF=E6=8C=813?= =?UTF-8?q?=E7=BA=A7=E7=BC=93=E5=AD=98=EF=BC=8Cmemory=EF=BC=8C=E4=BB=A5?= =?UTF-8?q?=E5=8F=8Adb?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- application.go | 35 ++---- cache/cache.go | 277 +++++++++++++++++++++++++++++++++++++++--- cache/cache_db.go | 21 +++- cache/cache_memory.go | 29 +++-- cache/cache_redis.go | 33 +++-- cache/type.go | 4 +- common/error.go | 2 +- db/db.go | 25 ++-- example/main.go | 20 +-- session.go | 38 ++---- var.go | 11 +- 11 files changed, 369 insertions(+), 126 deletions(-) diff --git a/application.go b/application.go index fa9f391..18706e6 100644 --- a/application.go +++ b/application.go @@ -32,10 +32,8 @@ type Application struct { configPath string Config Map Db HoTimeDB + *HoTimeCache *http.Server - CacheIns - sessionLong CacheIns - sessionShort CacheIns http.Handler } @@ -51,8 +49,8 @@ func (that *Application) Run(router Router) { } //防止手动设置缓存误伤 - if that.CacheIns == nil { - that.SetCache(CacheIns(&CacheMemory{})) + if that.HoTimeCache == nil { + that.SetCache() } //防止手动设置session误伤 @@ -103,10 +101,6 @@ func (that *Application) Run(router Router) { that.Db.SetConnect(that.connectDbFunc) } - if that.CacheIns == nil { - that.CacheIns = CacheIns(&CacheMemory{Map: Map{}, Time: that.Config.GetInt64("cacheShortTime")}) - } - //异常处理 defer func() { if err := recover(); err != nil { @@ -170,13 +164,6 @@ func (that *Application) SetConnectDB(connect func(err ...*Error) (master, slave } -// SetSession 设置配置文件路径全路径或者相对路径 -func (that *Application) SetSession(short CacheIns, Long CacheIns) { - that.sessionLong = Long - that.sessionShort = short - -} - // SetDefault 默认配置缓存和session实现 func (that *Application) SetDefault(connect func(err ...*Error) (*sql.DB, *sql.DB)) { that.SetConfig() @@ -189,10 +176,10 @@ func (that *Application) SetDefault(connect func(err ...*Error) (*sql.DB, *sql.D } // SetCache 设置配置文件路径全路径或者相对路径 -func (that *Application) SetCache(cache CacheIns) { - - that.CacheIns = cache - +func (that *Application) SetCache() { + cacheIns := HoTimeCache{} + cacheIns.Init(that.Config.GetMap("cache"), HoTimeDBInterface(&that.Db), &that.Error) + that.HoTimeCache = &cacheIns } // SetConfig 设置配置文件路径全路径或者相对路径 @@ -320,11 +307,9 @@ func (that *Application) handler(w http.ResponseWriter, req *http.Request) { } //访问实例 context := Context{SessionIns: SessionIns{SessionId: sessionId, - LongCache: that.sessionLong, - ShortCache: that.sessionShort, + HoTimeCache: that.HoTimeCache, }, - CacheIns: that.CacheIns, - Resp: w, Req: req, Application: that, RouterString: s, Config: that.Config, Db: &that.Db, HandlerStr: unescapeUrl} + Resp: w, Req: req, Application: that, RouterString: s, Config: that.Config, Db: &that.Db, HandlerStr: unescapeUrl} //header默认设置 header := w.Header() header.Set("Content-Type", "text/html; charset=utf-8") @@ -470,7 +455,7 @@ func Init(config string) Application { appIns.SetConfig(config) SetDB(&appIns) - //appIns.SetCache() + appIns.SetCache() return appIns } diff --git a/cache/cache.go b/cache/cache.go index c0cecb1..59500e8 100644 --- a/cache/cache.go +++ b/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 } diff --git a/cache/cache_db.go b/cache/cache_db.go index 94e3d85..9d6d05c 100644 --- a/cache/cache_db.go +++ b/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 diff --git a/cache/cache_memory.go b/cache/cache_memory.go index c586de3..9247b3e 100644 --- a/cache/cache_memory.go +++ b/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 } diff --git a/cache/cache_redis.go b/cache/cache_redis.go index ac026d0..fc4ca1b 100644 --- a/cache/cache_redis.go +++ b/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 diff --git a/cache/type.go b/cache/type.go index decd53f..a95e8b1 100644 --- a/cache/type.go +++ b/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 } diff --git a/common/error.go b/common/error.go index 45878f8..a5d82ad 100644 --- a/common/error.go +++ b/common/error.go @@ -6,7 +6,7 @@ import ( // Error 框架层处理错误 type Error struct { - *logrus.Logger + Logger *logrus.Logger error } diff --git a/db/db.go b/db/db.go index 9324d93..7d07e53 100644 --- a/db/db.go +++ b/db/db.go @@ -16,9 +16,8 @@ import ( type HoTimeDB struct { *sql.DB ContextBase - cache.CacheIns + *cache.HoTimeCache Type string - DBCached bool LastQuery string LastData []interface{} ConnectFunc func(err ...*Error) (*sql.DB, *sql.DB) @@ -42,7 +41,7 @@ func (that *HoTimeDB) GetType() string { // Action 事务，如果action返回true则执行成功；false则回滚 func (that *HoTimeDB) Action(action func(db HoTimeDB) bool) bool { - db := HoTimeDB{DB: that.DB, CacheIns: that.CacheIns, DBCached: that.DBCached} + db := HoTimeDB{DB: that.DB, HoTimeCache: that.HoTimeCache} tx, err := db.Begin() if err != nil { that.LastErr.SetError(err) @@ -468,9 +467,9 @@ func (that *HoTimeDB) Select(table string, qu ...interface{}) []Map { qs = append(qs, resWhere...) md5 := that.md5(query, qs...) - if that.DBCached && that.CacheIns != nil { + if that.HoTimeCache != nil { //如果缓存有则从缓存取 - cacheData := that.Cache(table + ":" + md5) + cacheData := that.HoTimeCache.Db(table + ":" + md5) if cacheData.Data != nil { return cacheData.ToMapArray() @@ -485,9 +484,9 @@ func (that *HoTimeDB) Select(table string, qu ...interface{}) []Map { } //缓存 - if that.DBCached && that.CacheIns != nil { + if that.HoTimeCache != nil { - _ = that.Cache(table+":"+md5, res) + _ = that.HoTimeCache.Db(table+":"+md5, res) } return res @@ -889,8 +888,8 @@ func (that *HoTimeDB) Update(table string, data Map, where Map) int64 { //如果更新成功，则删除缓存 if rows != 0 { - if that.DBCached && that.CacheIns != nil { - _ = that.Cache(table+"*", nil) + if that.HoTimeCache != nil { + _ = that.HoTimeCache.Db(table+"*", nil) } } @@ -912,8 +911,8 @@ func (that *HoTimeDB) Delete(table string, data map[string]interface{}) int64 { //如果删除成功,删除对应缓存 if rows != 0 { - if that.DBCached && that.CacheIns != nil { - _ = that.Cache(table+"*", nil) + if that.HoTimeCache != nil { + _ = that.HoTimeCache.Db(table+"*", nil) } } //return 0 @@ -954,8 +953,8 @@ func (that *HoTimeDB) Insert(table string, data map[string]interface{}) int64 { //如果插入成功，删除缓存 if id != 0 { - if that.DBCached && that.CacheIns != nil { - _ = that.Cache(table+"*", nil) + if that.HoTimeCache != nil { + _ = that.HoTimeCache.Db(table+"*", nil) } } diff --git a/example/main.go b/example/main.go index dad347a..1d73fef 100644 --- a/example/main.go +++ b/example/main.go @@ -2,7 +2,6 @@ package main import ( "../../hotime" - "../../hotime/cache" "fmt" "golang.org/x/net/websocket" "time" @@ -22,18 +21,18 @@ func main() { //手动模式， //appIns.SetConfig("example/config/config.json") //redis缓存接入 - ca := cache.CacheIns(&cache.CacheRedis{Host: appIns.Config.GetString("redisHost"), Pwd: appIns.Config.GetString("redisPwd"), Time: appIns.Config.GetCeilInt64("cacheLongTime")}) - ca.Cache("xyzm", "dasdas") - ca.Cache("xyzn", "dasdas") - ca.Cache("xyzo", "dasdas") - ca.Cache("xyz*", nil) + //ca := cache.CacheIns(&cache.CacheRedis{Host: appIns.Config.GetString("redisHost"), Pwd: appIns.Config.GetString("redisPwd"), Time: appIns.Config.GetCeilInt64("cacheLongTime")}) + //ca.Cache("xyzm", "dasdas") + //ca.Cache("xyzn", "dasdas") + //ca.Cache("xyzo", "dasdas") + //ca.Cache("xyz*", nil) //fmt.Println(ca.Cache("xyzm").Data) //mysql //mysql.SetDB(&appIns) //自动选择数据库 - dbInterface := cache.HoTimeDBInterface(&appIns.Db) - appIns.SetSession(cache.CacheIns(&cache.CacheMemory{}), cache.CacheIns(&cache.CacheDb{Db: dbInterface, Time: appIns.Config.GetInt64("cacheTime")})) - appIns.SetCache(cache.CacheIns(&cache.CacheMemory{})) + //dbInterface := cache.HoTimeDBInterface(&appIns.Db) + //appIns.SetSession(cache.CacheIns(&cache.CacheMemory{}), cache.CacheIns(&cache.CacheDb{Db: dbInterface, Time: appIns.Config.GetInt64("cacheTime")})) + //appIns.SetCache(cache.CacheIns(&cache.CacheMemory{})) //快捷模式 //appIns.SetDefault(func(err ...*common.Error) (*sql.DB, *sql.DB) { @@ -50,6 +49,9 @@ func main() { "app": hotime.Proj{ "index": hotime.Ctr{ "test": func(this *hotime.Context) { + fmt.Println(this.Session("test").Data) + this.Session("test", 145484978484) + fmt.Println(this.Session("test").Data) //fmt.Println(this.Db.GetTag()) //this.Application.Log.Error("dasdasdas") //this.Log.Error("dadasdasd") diff --git a/session.go b/session.go index 9a569e3..33079b4 100644 --- a/session.go +++ b/session.go @@ -7,22 +7,14 @@ import ( //session对象 type SessionIns struct { - ShortCache CacheIns - LongCache CacheIns - SessionId string + *HoTimeCache + SessionId string Map ContextBase } func (that *SessionIns) set() { - - if that.ShortCache != nil { - that.ShortCache.Cache(HEAD_SESSION_ADD+that.SessionId, that.Map) - } - if that.LongCache != nil { - that.LongCache.Cache(HEAD_SESSION_ADD+that.SessionId, that.Map) - } - + that.HoTimeCache.Session(HEAD_SESSION_ADD+that.SessionId, that.Map) } func (that *SessionIns) Session(key string, data ...interface{}) *Obj { @@ -48,29 +40,17 @@ func (that *SessionIns) Session(key string, data ...interface{}) *Obj { func (that *SessionIns) get() { - if that.ShortCache != nil { - that.Map = that.ShortCache.Cache(HEAD_SESSION_ADD + that.SessionId).ToMap() - if that.Map != nil { - return - } + that.Map = that.HoTimeCache.Session(HEAD_SESSION_ADD + that.SessionId).ToMap() + if that.Map != nil { + return } - if that.LongCache != nil { - that.Map = that.LongCache.Cache(HEAD_SESSION_ADD + that.SessionId).ToMap() - if that.Map != nil { - if that.ShortCache != nil { - that.ShortCache.Cache(HEAD_SESSION_ADD+that.SessionId, that.Map) - } - return - } - } that.Map = Map{} - that.ShortCache.Cache(HEAD_SESSION_ADD+that.SessionId, that.Map) + that.HoTimeCache.Session(HEAD_SESSION_ADD+that.SessionId, that.Map) return } -func (that *SessionIns) Init(short CacheIns, long CacheIns) { - that.ShortCache = short - that.LongCache = long +func (that *SessionIns) Init(cache *HoTimeCache) { + that.HoTimeCache = cache } diff --git a/var.go b/var.go index bbb4ab0..e367d78 100644 --- a/var.go +++ b/var.go @@ -68,25 +68,22 @@ var ConfigNote = Map{ "cache": Map{ "注释": "可配置memory，db，redis，默认启用memory，默认优先级为memory>redis>db,memory与数据库缓存设置项一致，缓存数据填充会自动反方向反哺，加入memory缓存过期将自动从redis更新，但memory永远不会更新redis，如果是集群建议不要开启memory，配置即启用", "memory": Map{ - "timeout": "默认60 * 60 * 2，必须，过期时间，超时自动删除", + "timeout": "默认60 * 60 * 2，非必须，过期时间，超时自动删除", "db": "默认true，非必须，缓存数据库，启用后能减少数据库的读写压力", "session": "默认true，非必须，缓存web session，同时缓存session保持的用户缓存", - "sort": "默认0，非必须，优先级，数值越大优先级越高，默认优先级为memory>redis>db,", }, "db": Map{ - "timeout": "默认60 * 60 * 24 * 30，必须，过期时间，超时自动删除", - "db": "默认true，非必须，缓存数据库，启用后能减少数据库的读写压力", + "timeout": "默认60 * 60 * 24 * 30，非必须，过期时间，超时自动删除", + "db": "默认false，非必须，缓存数据库，启用后能减少数据库的读写压力", "session": "默认true，非必须，缓存web session，同时缓存session保持的用户缓存", - "sort": "默认0，非必须，优先级，数值越大优先级越高，默认优先级为memory>redis>db,", }, "redis": Map{ "host": "默认服务ip：127.0.0.1，必须，如果需要使用redis服务时配置，", "port": "默认服务端口：6379，必须，如果需要使用redis服务时配置，", "password": "默认密码空，必须，如果需要使用redis服务时配置，默认密码空", - "timeout": "memory默认60 * 60 * 30，db默认60 * 60 * 24 * 30，必须，过期时间，超时自动删除", + "timeout": "默认60 * 60 * 24 * 15，非必须，过期时间，超时自动删除", "db": "默认true，非必须，缓存数据库，启用后能减少数据库的读写压力", "session": "默认true，非必须，缓存web session，同时缓存session保持的用户缓存", - "sort": "默认0，非必须，优先级，数值越大优先级越高，默认优先级为memory>redis>db,", }, }, "error": Map{