refactor(cache): 重构 CacheMemory 实现

- 使用 sync.Map替代自定义 Map 结构- 优化缓存过期处理逻辑
- 改进通配符删除功能
- 随机触发缓存清理机制

cache/cache_memory.go

@@ -7,14 +7,13 @@ import (
 	"time"
 )
 
+// CacheMemory 基于 sync.Map 的缓存实现
 type CacheMemory struct {
 	TimeOut    int64
 	DbSet      bool
 	SessionSet bool
-	Map
 	*Error
-	ContextBase
-	mutex *sync.RWMutex
+	cache sync.Map // 替代传统的 Map
 }
 
 func (that *CacheMemory) GetError() *Error {
@@ -26,133 +25,91 @@ func (that *CacheMemory) GetError() *Error {
 func (that *CacheMemory) SetError(err *Error) {
 	that.Error = err
 }
+func (c *CacheMemory) get(key string) (res *Obj) {
 
-//获取Cache键只能为string类型
-func (that *CacheMemory) get(key string) interface{} {
-	that.Error.SetError(nil)
-	if that.Map == nil {
-		that.Map = Map{}
+	res = &Obj{
+		Error: *c.Error,
+	}
+	value, ok := c.cache.Load(key)
+	if !ok {
+		return res // 缓存不存在
 	}
 
-	if that.Map[key] == nil {
-		return nil
-	}
-	data := that.Map.Get(key, that.Error).(cacheData)
-	if that.Error.GetError() != nil {
-		return nil
-	}
+	data := value.(cacheData)
 
+	// 检查是否过期
 	if data.time < time.Now().Unix() {
-		delete(that.Map, key)
-		return nil
+		c.cache.Delete(key) // 删除过期缓存
+		return res
 	}
-	return data.data
+	res.Data = data.data
+	return res
 }
-
-func (that *CacheMemory) refreshMap() {
-
+func (c *CacheMemory) set(key string, value interface{}, expireAt int64) {
+	data := cacheData{
+		data: value,
+		time: expireAt,
+	}
+	c.cache.Store(key, data)
+}
+func (c *CacheMemory) delete(key string) {
+	if strings.Contains(key, "*") {
+		// 通配符删除
+		prefix := strings.TrimSuffix(key, "*")
+		c.cache.Range(func(k, v interface{}) bool {
+			if strings.HasPrefix(k.(string), prefix) {
+				c.cache.Delete(k)
+			}
+			return true
+		})
+	} else {
+		// 精确删除
+		c.cache.Delete(key)
+	}
+}
+func (c *CacheMemory) refreshMap() {
 	go func() {
-		that.mutex.Lock()
-		defer that.mutex.Unlock()
-		for key, v := range that.Map {
-			data := v.(cacheData)
-			if data.time <= time.Now().Unix() {
-				delete(that.Map, key)
+		now := time.Now().Unix()
+		c.cache.Range(func(key, value interface{}) bool {
+			data := value.(cacheData)
+			if data.time <= now {
+				c.cache.Delete(key) // 删除过期缓存
 			}
-		}
-
+			return true
+		})
 	}()
-
 }
+func (c *CacheMemory) Cache(key string, data ...interface{}) *Obj {
+	now := time.Now().Unix()
 
-//key value ,时间为时间戳
-func (that *CacheMemory) set(key string, value interface{}, time int64) {
-	that.Error.SetError(nil)
-	var data cacheData
-
-	if that.Map == nil {
-		that.Map = Map{}
+	// 随机触发刷新
+	if x := RandX(1, 100000); x > 99950 {
+		c.refreshMap()
 	}
 
-	dd := that.Map[key]
-
-	if dd == nil {
-		data = cacheData{}
-	} else {
-		data = dd.(cacheData)
-	}
-
-	data.time = time
-	data.data = value
-
-	that.Map.Put(key, data)
-}
-
-func (that *CacheMemory) delete(key string) {
-	del := strings.Index(key, "*")
-	//如果通配删除
-	if del != -1 {
-		key = Substr(key, 0, del)
-		for k, _ := range that.Map {
-			if strings.Index(k, key) != -1 {
-				delete(that.Map, k)
-
-			}
-		}
-
-	} else {
-		delete(that.Map, key)
-	}
-
-}
-
-func (that *CacheMemory) Cache(key string, data ...interface{}) *Obj {
-
-	x := RandX(1, 100000)
-	if x > 99950 {
-		that.refreshMap()
-	}
-	if that.mutex == nil {
-		that.mutex = &sync.RWMutex{}
-	}
-
-	reData := &Obj{Data: nil}
-
 	if len(data) == 0 {
-		that.mutex.RLock()
-		reData.Data = that.get(key)
-		that.mutex.RUnlock()
-		return reData
+		// 读操作
+		return c.get(key)
 	}
-	tim := time.Now().Unix()
 
 	if len(data) == 1 && data[0] == nil {
-		that.mutex.Lock()
-		that.delete(key)
-		that.mutex.Unlock()
-		return reData
+		// 删除操作
+		c.delete(key)
+		return nil
 	}
 
-	if len(data) == 1 {
-
-		tim = tim + that.TimeOut
-
-	}
+	// 写操作
+	expireAt := now + c.TimeOut
 	if len(data) == 2 {
-		that.Error.SetError(nil)
-		tempt := ObjToInt64(data[1], that.Error)
-
-		if tempt > tim {
-
-			tim = tempt
-		} else if that.Error.GetError() == nil {
-
-			tim = tim + tempt
+		if customExpire, ok := data[1].(int64); ok {
+			if customExpire > now {
+				expireAt = customExpire
+			} else {
+				expireAt = now + customExpire
+			}
 		}
 	}
-	that.mutex.Lock()
-	that.set(key, data[0], tim)
-	that.mutex.Unlock()
-	return reData
 
+	c.set(key, data[0], expireAt)
+	return nil
 }