feat(cache): 增加批量操作支持以提升性能

- 在 HoTimeCache 中新增 SessionsGet、SessionsSet 和 SessionsDelete 方法，支持批量获取、设置和删除 Session 缓存 - 优化缓存逻辑，减少数据库写入次数，提升性能 - 更新文档，详细说明批量操作的使用方法和性能对比 - 添加调试日志记录，便于追踪批量操作的执行情况
2026-01-30 17:51:43 +08:00
parent 27300025f3
commit 3d83c41905
12 changed files with 2065 additions and 46 deletions
@@ -1,10 +1,12 @@
 package main

 import (
-	. "code.hoteas.com/golang/hotime"
+	"encoding/json"
 	"fmt"
 	"time"

+	. "code.hoteas.com/golang/hotime"
+
 	. "code.hoteas.com/golang/hotime/common"
 	. "code.hoteas.com/golang/hotime/db"
 )
@@ -90,6 +92,16 @@ func main() {
 				"upsert":      func(that *Context) { that.Display(0, testUpsert(that)) },
 				"transaction": func(that *Context) { that.Display(0, testTransaction(that)) },
 				"rawsql":      func(that *Context) { that.Display(0, testRawSQL(that)) },
+
+				// ==================== 缓存测试 ====================
+				// 缓存全部测试
+				"cache":        func(that *Context) { that.Display(0, testCacheAll(that)) },
+				"cache-compat": func(that *Context) { that.Display(0, testCacheCompatible(that)) },
+				// 批量缓存操作测试
+				"cache-batch": func(that *Context) {
+					TestBatchCacheOperations(that.Application)
+					that.Display(0, Map{"message": "批量缓存测试完成，请查看控制台输出和日志文件"})
+				},
 			},
 		},
 	})
@@ -903,3 +915,394 @@ func testRawSQL(that *Context) Map {
 	result["success"] = true
 	return result
 }
+
+// ==================== 缓存测试 ====================
+func testCacheAll(that *Context) Map {
+	result := Map{"name": "数据库缓存测试", "tests": Slice{}}
+	tests := Slice{}
+
+	// 获取当前缓存模式
+	cacheMode := "unknown"
+	if that.Application.HoTimeCache != nil && that.Application.HoTimeCache.Config != nil {
+		dbConfig := that.Application.HoTimeCache.Config.GetMap("db")
+		if dbConfig != nil {
+			cacheMode = dbConfig.GetString("mode")
+			if cacheMode == "" {
+				cacheMode = "new"
+			}
+		}
+	}
+	result["cache_mode"] = cacheMode
+
+	// 测试用的唯一前缀
+	testPrefix := fmt.Sprintf("cache_test_%d_", time.Now().UnixNano())
+
+	// ==================== 1. 基础读写测试 ====================
+	test1 := Map{"name": "1. 基础 set/get 测试"}
+	testKey1 := testPrefix + "basic"
+	testValue1 := Map{"name": "测试数据", "count": 123, "active": true}
+
+	// 设置缓存
+	that.Application.Cache(testKey1, testValue1)
+
+	// 读取缓存
+	cached1 := that.Application.Cache(testKey1)
+	if cached1.Data != nil {
+		cachedMap := cached1.ToMap()
+		test1["result"] = cachedMap.GetString("name") == "测试数据" && cachedMap.GetInt("count") == 123
+		test1["cached_value"] = cachedMap
+	} else {
+		test1["result"] = false
+		test1["error"] = "缓存读取返回 nil"
+	}
+	tests = append(tests, test1)
+
+	// ==================== 2. 删除缓存测试 ====================
+	test2 := Map{"name": "2. delete 删除缓存测试"}
+	testKey2 := testPrefix + "delete"
+	that.Application.Cache(testKey2, "删除测试值")
+
+	// 验证存在
+	before := that.Application.Cache(testKey2)
+	beforeExists := before.Data != nil
+
+	// 删除
+	that.Application.Cache(testKey2, nil)
+
+	// 验证已删除
+	after := that.Application.Cache(testKey2)
+	afterExists := after.Data != nil
+
+	test2["result"] = beforeExists && !afterExists
+	test2["before_exists"] = beforeExists
+	test2["after_exists"] = afterExists
+	tests = append(tests, test2)
+
+	// ==================== 3. 过期时间测试 ====================
+	test3 := Map{"name": "3. 过期时间测试（短超时）"}
+	testKey3 := testPrefix + "expire"
+
+	// 设置 2 秒过期
+	that.Application.Cache(testKey3, "短期数据", 2)
+
+	// 立即读取应该存在
+	immediate := that.Application.Cache(testKey3)
+	immediateExists := immediate.Data != nil
+
+	test3["result"] = immediateExists
+	test3["immediate_exists"] = immediateExists
+	test3["note"] = "设置了2秒过期，可等待后再次访问验证过期"
+	tests = append(tests, test3)
+
+	// ==================== 4. 不存在的 key 读取测试 ====================
+	test4 := Map{"name": "4. 不存在的 key 读取测试"}
+	nonExistKey := testPrefix + "non_exist_key_" + fmt.Sprintf("%d", time.Now().UnixNano())
+	nonExist := that.Application.Cache(nonExistKey)
+	test4["result"] = nonExist.Data == nil
+	test4["value"] = nonExist.Data
+	tests = append(tests, test4)
+
+	// ==================== 5. 重复 set 同一个 key 测试 ====================
+	test5 := Map{"name": "5. 重复 set 同一个 key 测试"}
+	testKey5 := testPrefix + "repeat"
+
+	that.Application.Cache(testKey5, "第一次值")
+	first := that.Application.Cache(testKey5).ToStr()
+
+	that.Application.Cache(testKey5, "第二次值")
+	second := that.Application.Cache(testKey5).ToStr()
+
+	that.Application.Cache(testKey5, Map{"version": 3})
+	third := that.Application.Cache(testKey5).ToMap()
+
+	test5["result"] = first == "第一次值" && second == "第二次值" && third.GetInt("version") == 3
+	test5["first"] = first
+	test5["second"] = second
+	test5["third"] = third
+	tests = append(tests, test5)
+
+	// ==================== 6. 通配删除测试 ====================
+	test6 := Map{"name": "6. 通配删除测试 (key*)"}
+	wildcardPrefix := testPrefix + "wildcard_"
+
+	// 创建多个带相同前缀的缓存
+	that.Application.Cache(wildcardPrefix+"a", "值A")
+	that.Application.Cache(wildcardPrefix+"b", "值B")
+	that.Application.Cache(wildcardPrefix+"c", "值C")
+
+	// 验证都存在
+	aExists := that.Application.Cache(wildcardPrefix+"a").Data != nil
+	bExists := that.Application.Cache(wildcardPrefix+"b").Data != nil
+	cExists := that.Application.Cache(wildcardPrefix+"c").Data != nil
+	allExistBefore := aExists && bExists && cExists
+
+	// 通配删除
+	that.Application.Cache(wildcardPrefix+"*", nil)
+
+	// 验证都已删除
+	aAfter := that.Application.Cache(wildcardPrefix+"a").Data != nil
+	bAfter := that.Application.Cache(wildcardPrefix+"b").Data != nil
+	cAfter := that.Application.Cache(wildcardPrefix+"c").Data != nil
+	allDeletedAfter := !aAfter && !bAfter && !cAfter
+
+	test6["result"] = allExistBefore && allDeletedAfter
+	test6["before"] = Map{"a": aExists, "b": bExists, "c": cExists}
+	test6["after"] = Map{"a": aAfter, "b": bAfter, "c": cAfter}
+	tests = append(tests, test6)
+
+	// ==================== 7. 不同数据类型测试 ====================
+	test7 := Map{"name": "7. 不同数据类型存储测试"}
+
+	// 字符串
+	that.Application.Cache(testPrefix+"type_string", "字符串值")
+	typeString := that.Application.Cache(testPrefix + "type_string").ToStr()
+
+	// 整数
+	that.Application.Cache(testPrefix+"type_int", 12345)
+	typeInt := that.Application.Cache(testPrefix + "type_int").ToInt()
+
+	// 浮点数
+	that.Application.Cache(testPrefix+"type_float", 3.14159)
+	typeFloat := that.Application.Cache(testPrefix + "type_float").ToFloat64()
+
+	// 布尔值
+	that.Application.Cache(testPrefix+"type_bool", true)
+	typeBoolData := that.Application.Cache(testPrefix + "type_bool").Data
+	typeBool := typeBoolData == true || typeBoolData == "true" || typeBoolData == 1.0
+
+	// Map
+	that.Application.Cache(testPrefix+"type_map", Map{"key": "value", "num": 100})
+	typeMap := that.Application.Cache(testPrefix + "type_map").ToMap()
+
+	// Slice
+	that.Application.Cache(testPrefix+"type_slice", Slice{1, 2, 3, "four", Map{"five": 5}})
+	typeSlice := that.Application.Cache(testPrefix + "type_slice").ToSlice()
+
+	test7["result"] = typeString == "字符串值" &&
+		typeInt == 12345 &&
+		typeFloat > 3.14 && typeFloat < 3.15 &&
+		typeBool == true &&
+		typeMap.GetString("key") == "value" &&
+		len(typeSlice) == 5
+
+	test7["string"] = typeString
+	test7["int"] = typeInt
+	test7["float"] = typeFloat
+	test7["bool"] = typeBool
+	test7["map"] = typeMap
+	test7["slice"] = typeSlice
+	tests = append(tests, test7)
+
+	// ==================== 8. 自定义超时时间测试 ====================
+	test8 := Map{"name": "8. 自定义超时时间参数测试"}
+	testKey8 := testPrefix + "custom_timeout"
+
+	// 设置 3600 秒（1小时）过期
+	that.Application.Cache(testKey8, "长期数据", 3600)
+	longTerm := that.Application.Cache(testKey8)
+	test8["result"] = longTerm.Data != nil
+	test8["value"] = longTerm.ToStr()
+	tests = append(tests, test8)
+
+	// ==================== 9. 查询缓存表状态 ====================
+	test9 := Map{"name": "9. 缓存表状态查询"}
+
+	// 查询新表记录数
+	prefix := that.Db.GetPrefix()
+	newTableName := prefix + "hotime_cache"
+	legacyTableName := prefix + "cached"
+
+	newCount := that.Db.Count(newTableName)
+	test9["new_table_count"] = newCount
+	test9["new_table_name"] = newTableName
+
+	// 尝试查询老表
+	legacyCount := int64(-1)
+	legacyExists := false
+	legacyData := that.Db.Query("SELECT COUNT(*) as cnt FROM `" + legacyTableName + "`")
+	if len(legacyData) > 0 {
+		legacyExists = true
+		legacyCount = legacyData[0].GetInt64("cnt")
+	}
+	test9["legacy_table_exists"] = legacyExists
+	test9["legacy_table_count"] = legacyCount
+	test9["legacy_table_name"] = legacyTableName
+
+	test9["result"] = newCount >= 0
+	tests = append(tests, test9)
+
+	// ==================== 清理测试数据 ====================
+	// 删除所有测试创建的缓存
+	that.Application.Cache(testPrefix+"*", nil)
+
+	result["tests"] = tests
+	result["success"] = true
+	result["cleanup"] = "已清理所有测试缓存数据"
+	return result
+}
+
+// testCacheCompatible 专门测试兼容模式 - 白盒测试
+func testCacheCompatible(that *Context) Map {
+	result := Map{
+		"test_name": "兼容模式白盒测试",
+		"timestamp": time.Now().Format("2006-01-02 15:04:05"),
+	}
+
+	prefix := that.Db.GetPrefix()
+	newTableName := prefix + "hotime_cache"
+	legacyTableName := prefix + "cached"
+
+	tests := Slice{}
+
+	// ==================== 1. 查询当前模式 ====================
+	test1 := Map{"name": "1. 查询当前缓存模式"}
+	// 读取配置确认模式
+	cacheConfig := that.Application.Config.GetMap("cache")
+	dbConfig := cacheConfig.GetMap("db")
+	mode := dbConfig.GetString("mode")
+	if mode == "" {
+		mode = "默认(compatible)"
+	}
+	test1["mode"] = mode
+	test1["result"] = true
+	tests = append(tests, test1)
+
+	// ==================== 2. 查询老表数据 ====================
+	test2 := Map{"name": "2. 查询老表cached现有数据"}
+
+	legacyData := that.Db.Query("SELECT * FROM `" + legacyTableName + "` LIMIT 5")
+	test2["legacy_table"] = legacyTableName
+	test2["count"] = len(legacyData)
+	test2["data"] = legacyData
+	test2["result"] = true
+	tests = append(tests, test2)
+
+	// ==================== 3. 查询新表数据 ====================
+	test3 := Map{"name": "3. 查询新表hotime_cache现有数据"}
+
+	newData := that.Db.Query("SELECT * FROM `" + newTableName + "` LIMIT 5")
+	test3["new_table"] = newTableName
+	test3["count"] = len(newData)
+	test3["data"] = newData
+	test3["result"] = true
+	tests = append(tests, test3)
+
+	// ==================== 4. 测试老表回退读取 ====================
+	test4 := Map{"name": "4. 测试兼容模式老表回退读取"}
+
+	// 插入一条未过期的老表数据进行测试
+	testKey4 := "test_compat_fallback_" + ObjToStr(time.Now().UnixNano())
+	testValue4 := Map{"admin_id": 999, "admin_name": "测试老数据"}
+	testValueJson4, _ := json.Marshal(Map{"data": testValue4})
+
+	// 在老表插入未过期数据
+	that.Db.Insert(legacyTableName, Map{
+		"key":     testKey4,
+		"value":   string(testValueJson4),
+		"endtime": time.Now().Unix() + 3600, // 1小时后过期
+		"time":    time.Now().UnixNano(),
+	})
+
+	test4["test_key"] = testKey4
+
+	// 确保新表没有这个 key
+	newExists := that.Db.Get(newTableName, "*", Map{"key": testKey4})
+	test4["key_in_new_table"] = newExists != nil
+
+	// 通过缓存 API 读取（应该回退到老表）
+	cacheValue := that.Application.Cache(testKey4)
+	test4["cache_api_result"] = cacheValue.Data
+
+	// 直接从老表读取确认
+	legacyValue := that.Db.Get(legacyTableName, "*", Map{"key": testKey4})
+	if legacyValue != nil {
+		test4["legacy_db_value"] = legacyValue.GetString("value")
+		test4["legacy_db_endtime"] = legacyValue.GetInt64("endtime")
+		test4["legacy_db_endtime_readable"] = time.Unix(legacyValue.GetInt64("endtime"), 0).Format("2006-01-02 15:04:05")
+	}
+
+	// 验证：新表没数据，但缓存API能读到老表数据
+	test4["result"] = newExists == nil && cacheValue.Data != nil
+	tests = append(tests, test4)
+
+	// ==================== 5. 测试写新删老 ====================
+	test5 := Map{"name": "5. 测试兼容模式写新删老"}
+
+	testKey5 := "test_compat_write_" + ObjToStr(time.Now().UnixNano())
+	testValue5 := "兼容模式测试数据"
+
+	// 先在老表插入一条数据
+	that.Db.Insert(legacyTableName, Map{
+		"key":     testKey5,
+		"value":   `{"data":"老表原始数据"}`,
+		"endtime": time.Now().Unix() + 3600, // 1小时后过期
+		"time":    time.Now().UnixNano(),
+	})
+
+	// 确认老表有数据
+	legacyBefore := that.Db.Get(legacyTableName, "*", Map{"key": testKey5})
+	test5["step1_legacy_before"] = legacyBefore != nil
+
+	// 通过缓存 API 写入（应该写新表并删老表）
+	that.Application.Cache(testKey5, testValue5)
+
+	// 检查新表
+	newAfter := that.Db.Get(newTableName, "*", Map{"key": testKey5})
+	test5["step2_new_after"] = newAfter != nil
+	if newAfter != nil {
+		test5["new_value"] = newAfter.GetString("value")
+	}
+
+	// 检查老表（应该被删除）
+	legacyAfter := that.Db.Get(legacyTableName, "*", Map{"key": testKey5})
+	test5["step3_legacy_after_deleted"] = legacyAfter == nil
+
+	test5["result"] = legacyBefore != nil && newAfter != nil && legacyAfter == nil
+	tests = append(tests, test5)
+
+	// ==================== 6. 测试删除同时删两表 ====================
+	test6 := Map{"name": "6. 测试兼容模式删除(删除两表)"}
+
+	testKey6 := "test_compat_delete_" + ObjToStr(time.Now().UnixNano())
+
+	// 在老表插入
+	that.Db.Insert(legacyTableName, Map{
+		"key":     testKey6,
+		"value":   `{"data":"待删除老数据"}`,
+		"endtime": time.Now().Unix() + 3600,
+		"time":    time.Now().UnixNano(),
+	})
+
+	// 在新表插入
+	that.Db.Insert(newTableName, Map{
+		"key":         testKey6,
+		"value":       `"待删除新数据"`,
+		"end_time":    time.Now().Add(time.Hour).Format("2006-01-02 15:04:05"),
+		"state":       0,
+		"create_time": time.Now().Format("2006-01-02 15:04:05"),
+		"modify_time": time.Now().Format("2006-01-02 15:04:05"),
+	})
+
+	// 确认两表都有数据
+	test6["before_legacy"] = that.Db.Get(legacyTableName, "*", Map{"key": testKey6}) != nil
+	test6["before_new"] = that.Db.Get(newTableName, "*", Map{"key": testKey6}) != nil
+
+	// 通过缓存 API 删除
+	that.Application.Cache(testKey6, nil)
+
+	// 确认两表都被删除
+	test6["after_legacy_deleted"] = that.Db.Get(legacyTableName, "*", Map{"key": testKey6}) == nil
+	test6["after_new_deleted"] = that.Db.Get(newTableName, "*", Map{"key": testKey6}) == nil
+
+	test6["result"] = test6.GetBool("before_legacy") && test6.GetBool("before_new") &&
+		test6.GetBool("after_legacy_deleted") && test6.GetBool("after_new_deleted")
+	tests = append(tests, test6)
+
+	// ==================== 7. 清理测试数据 ====================
+	that.Db.Delete(newTableName, Map{"key[~]": "test_compat_%"})
+	that.Db.Delete(legacyTableName, Map{"key[~]": "test_compat_%"})
+
+	result["tests"] = tests
+	result["success"] = true
+	return result
+}