.NET9 中的多级缓存 HybridCache 用法示例

2024-12-28 .NET .NET9 HybridCache 64 0

在 .NET 9 中，HybridCache 是一种用于缓存的机制，它结合了多种缓存技术的优势，允许你为不同的缓存层级（如内存缓存和分布式缓存）提供优化的缓存策略。这种多级缓存解决方案通过在多个缓存源之间进行分级存储来提高应用程序的性能和扩展性。

HybridCache 的概念

HybridCache 允许应用程序在本地内存缓存和分布式缓存（如 Redis 或其他缓存存储）之间选择缓存策略。通常，本地内存缓存用于快速存取小数据，而分布式缓存用于存储更大的数据，并且在多个应用实例之间共享。

安装 HybridCache 依赖

在使用 HybridCache 之前，确保你的项目引用了 Microsoft.Extensions.Caching 和 Microsoft.Extensions.Caching.Memory 包。如果使用分布式缓存，可能还需要安装对应的缓存提供程序包，例如 Microsoft.Extensions.Caching.StackExchangeRedis。

dotnet add package Microsoft.Extensions.Caching.Memory
dotnet add package Microsoft.Extensions.Caching.StackExchangeRedis  // 如果使用 Redis

HybridCache 用法示例

下面是一个使用 HybridCache 的示例，包括如何配置内存缓存和分布式缓存（例如 Redis）。

1. 配置缓存服务

在 Program.cs 文件中配置 HybridCache。

using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.Caching.StackExchangeRedis;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;

var builder = WebApplication.CreateBuilder(args);

// 配置内存缓存和 Redis 缓存
builder.Services.AddMemoryCache();
builder.Services.AddStackExchangeRedisCache(options =>
{
    options.Configuration = "localhost"; // 设置 Redis 服务器地址
    options.InstanceName = "MyAppCache";  // 可选：指定 Redis 实例名称
});

// 配置 HybridCache
builder.Services.AddSingleton<IHybridCache, HybridCache>(serviceProvider =>
{
    var memoryCache = serviceProvider.GetRequiredService<IMemoryCache>();
    var redisCache = serviceProvider.GetRequiredService<IDistributedCache>();

    return new HybridCache(memoryCache, redisCache);
});

var app = builder.Build();

// 示例：使用 HybridCache
app.MapGet("/cache", async (IHybridCache cache) =>
{
    var cacheKey = "myDataKey";

    // 试图从缓存中获取数据
    var data = await cache.GetOrCreateAsync(cacheKey, async () =>
    {
        // 模拟获取数据
        return "This is a test value";
    });

    return Results.Ok(data);
});

app.Run();

2. 实现 HybridCache

HybridCache 是自定义实现的缓存层，它能够访问内存缓存和分布式缓存。

using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.Caching.Distributed;
using System.Threading.Tasks;

public interface IHybridCache
{
    Task<T> GetOrCreateAsync<T>(string key, Func<Task<T>> createItem);
}

public class HybridCache : IHybridCache
{
    private readonly IMemoryCache _memoryCache;
    private readonly IDistributedCache _distributedCache;

    public HybridCache(IMemoryCache memoryCache, IDistributedCache distributedCache)
    {
        _memoryCache = memoryCache;
        _distributedCache = distributedCache;
    }

    public async Task<T> GetOrCreateAsync<T>(string key, Func<Task<T>> createItem)
    {
        // 先尝试从内存缓存中获取
        if (_memoryCache.TryGetValue(key, out T memoryCacheItem))
        {
            return memoryCacheItem;
        }

        // 如果内存缓存中没有，尝试从分布式缓存中获取
        var distributedCacheItem = await _distributedCache.GetStringAsync(key);
        if (distributedCacheItem != null)
        {
            // 解析为 T 类型
            var result = Deserialize<T>(distributedCacheItem);
            _memoryCache.Set(key, result); // 同步缓存到内存
            return result;
        }

        // 如果都没有缓存，则创建新的值
        var newItem = await createItem();
        _memoryCache.Set(key, newItem); // 缓存到内存
        await _distributedCache.SetStringAsync(key, Serialize(newItem)); // 缓存到分布式存储
        return newItem;
    }

    private string Serialize<T>(T item)
    {
        // 序列化为字符串（可根据需要使用 JSON 或其他格式）
        return System.Text.Json.JsonSerializer.Serialize(item);
    }

    private T Deserialize<T>(string serializedItem)
    {
        // 反序列化字符串
        return System.Text.Json.JsonSerializer.Deserialize<T>(serializedItem);
    }
}

3. 使用缓存

在应用程序的任何地方，你可以通过注入 IHybridCache 来使用缓存。例如，在 Web API 路由中：

app.MapGet("/cache", async (IHybridCache cache) =>
{
    var cacheKey = "someUniqueKey";
    var result = await cache.GetOrCreateAsync(cacheKey, async () =>
    {
        // 如果缓存没有命中，这里可以从数据库或其他地方获取数据
        return "Hello, World!";
    });

    return Results.Ok(result);
});

解释

内存缓存（MemoryCache）：用于存储小而快速访问的数据。这种缓存是进程本地的，因此只在当前应用实例中有效。
分布式缓存（DistributedCache）：用于存储跨多个应用实例共享的数据，例如 Redis 缓存。它能够在多个服务器或容器之间共享缓存数据。

HybridCache 的实现会首先尝试从内存缓存中获取数据。如果找不到，它会继续尝试从分布式缓存中获取数据。若两者都没有缓存，则执行提供的 createItem 方法，生成新的数据，并缓存到内存和分布式缓存中。

总结

HybridCache 在 .NET 9 中提供了一个高效的方式来管理多级缓存。

可以根据需要在内存缓存和分布式缓存之间选择合适的缓存策略。

这种方法能够提高缓存的命中率，并且降低对外部缓存系统的依赖。