通过合理的缓存管理，可以有效提升系统性能并降低数据库访问压力。

1. 缓存配置

缓存配置采用 JSON 格式定义，支持 Memory 和 Redis 两种缓存类型。

Redis 配置示例：

{
  "CacheConfig": {
    // 缓存类型：Memory = 0, Redis = 1
    "type": "Redis",
    // Redis 配置
    "redis": {
      // 连接字符串
      "connectionString": "127.0.0.1:6379,password=pwd,defaultDatabase=0"
    }
  }
}

参数	说明
type	缓存类型，支持Memory（内存缓存）和 Redis（分布式缓存）
redis.connectionString	Redis 连接字符串，包含主机地址、端口、密码和默认数据库等信息

2. 缓存键定义

缓存键用于唯一标识缓存数据。建议将缓存键定义为常量，并提供辅助方法以统一键的生成规则。

/// <summary>
/// 缓存键定义
/// </summary>
public static partial class CacheKeys
{
    /// <summary>
    /// 模块缓存键，格式：module:action:{id}
    /// </summary>
    [Description("模块缓存键")]
    public const string ModuleActionKey = "module:action:";

    /// <summary>
    /// 根据模块 ID 生成缓存键
    /// </summary>
    /// <param name="id">模块 ID</param>
    public static string GetModuleActionKey(long id) => $"{ModuleActionKey}{id}";
}

缓存键命名规范：

• 采用冒号分隔的层级结构，如 {entity}:{action}:{id}
• 统一使用常量定义，便于维护和避免硬编码

3. 缓存接口（ICacheTool）

ICacheTool 接口提供通用的缓存操作方法，包括：

方法	说明
GetAsync<T>	根据键获取缓存值
SetAsync	设置缓存，支持过期时间
DelAsync	删除指定键的缓存
ExistsAsync	判断键是否存在
KeysAsync	批量获取匹配的键

4. 缓存使用示例

/// <summary>
/// 模块服务
/// </summary>
[Order(1010)]
[DynamicApi(Area = ApiConsts.AreaName)]
public class ModuleService : IDynamicApi
{
    private readonly AppRepositoryBase<ModuleEntity> _moduleRep;
    private readonly ICacheTool _cache;

    public ModuleService(AppRepositoryBase<ModuleEntity> moduleRep, ICacheTool cache)
    {
        _moduleRep = moduleRep;
        _cache = cache;
    }

    /// <summary>
    /// 查询模块
    /// </summary>
    public async Task<ModuleGetOutput> GetAsync(long id)
    {
        var cacheKey = CacheKeys.GetModuleActionKey(id);

        // 优先从缓存获取
        var module = await _cache.GetAsync<ModuleGetOutput>(cacheKey);
        if (module == null)
        {
            // 缓存未命中，从数据库查询
            module = await _moduleRep.GetAsync<ModuleGetOutput>(id);
            // 并写入缓存，过期时间 5 分钟
            await _cache.SetAsync(cacheKey, module, TimeSpan.FromMinutes(5));
        }

        return module;
    }

    /// <summary>
    /// 修改模块
    /// </summary>
    public async Task UpdateAsync(ModuleUpdateInput input)
    {
        var entity = await _moduleRep.GetAsync(input.Id);
        if (entity?.Id is not > 0)
            throw ResultOutput.Exception("模块不存在");

        Mapper.Map(input, entity);
        await _moduleRep.UpdateAsync(entity);

        // 同步更新缓存
        var cacheKey = CacheKeys.GetModuleActionKey(input.Id);
        await _cache.SetAsync(cacheKey, Mapper.Map<ModuleGetOutput>(entity), TimeSpan.FromMinutes(5));
    }

    /// <summary>
    /// 彻底删除模块
    /// </summary>
    public async Task DeleteAsync(long id)
    {
        await _moduleRep.DeleteAsync(m => m.Id == id);

        // 删除缓存，避免脏数据
        var cacheKey = CacheKeys.GetModuleActionKey(id);
        await _cache.DelAsync(cacheKey);
    }
}

缓存策略说明

操作	缓存行为
查询（GetAsync）	缓存优先，miss 时回源数据库并回填缓存
修改（UpdateAsync）	先更新数据库，再同步更新缓存
删除（DeleteAsync）	先删除数据库记录，再删除缓存

优势

• 性能提升：减少数据库访问频率，加快查询响应
• 数据一致性：修改/删除时同步更新缓存，避免脏读
• 灵活过期：通过设置 TTL 避免缓存数据过期

适用场景

• 频繁读取但较少更新的数据（如模块配置、字典项）
• 对查询响应时间要求较高的业务场景
• 需承受一定数据延迟的业务场景

#缓存管理 #中台/配置文件 #中台/公共帮助类 #Redis #Memory