缓存与并发控制

// 未加缓存的查询：每次都打数据库
public async Task<ProductDto> GetProductAsync(int id)
{
    var product = await _db.Products.FindAsync(id);
    return product is null ? throw new KeyNotFoundException() : Mapper.ToDto(product);
}

// 加入内存缓存
public async Task<ProductDto> GetProductCachedAsync(int id)
{
    if (_cache.TryGetValue($"product:{id}", out ProductDto? cached))
        return cached!;

    var dto = await GetProductAsync(id);
    _cache.Set($"product:{id}", dto, TimeSpan.FromMinutes(10));
    return dto;
}

builder.Services.AddMemoryCache(options =>
{
    options.SizeLimit = 10_000;               // 缓存项数量上限
    options.CompactionPercentage = 0.5;       // 超限时压缩比例
});

public class ProductService(IMemoryCache cache, IProductRepository repo)
{
    public async Task<ProductDto> GetAsync(int id)
    {
        return await cache.GetOrCreateAsync($"product:{id}", async entry =>
        {
            entry.AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(30);
            entry.SlidingExpiration = TimeSpan.FromMinutes(5);
            entry.Size = 1;

            var product = await repo.FindByIdAsync(id)
                ?? throw new KeyNotFoundException();
            return Mapper.ToDto(product);
        }) ?? throw new KeyNotFoundException();
    }

    public void Invalidate(int id) => cache.Remove($"product:{id}");
}

builder.Services.AddStackExchangeRedisCache(options =>
{
    options.Configuration = builder.Configuration.GetConnectionString("Redis");
    options.InstanceName = "shop:";          // 统一前缀，避免键冲突
});

public class OrderSummaryService(IDistributedCache cache, IOrderRepository repo)
{
    public async Task<OrderSummary> GetSummaryAsync(int customerId)
    {
        var key = $"summary:{customerId}";
        var bytes = await cache.GetAsync(key);

        if (bytes is not null)
            return JsonSerializer.Deserialize<OrderSummary>(bytes)!;

        var summary = await repo.BuildSummaryAsync(customerId);
        var json = JsonSerializer.SerializeToUtf8Bytes(summary);
        await cache.SetAsync(key, json,
            new DistributedCacheEntryOptions
            {
                AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(15)
            });
        return summary;
    }
}

// 命中/未命中与 value 均为 UTF-8 字节
{
  "key": "shop:summary:42",
  "value": "{\"TotalOrders\":12,\"TotalAmount\":3456.78}",
  "ttl": 900
}

// 防穿透：空值也缓存 + 布隆过滤器前置
public async Task<ProductDto?> GetAsync(int id)
{
    if (!_bloomFilter.Contains($"product:{id}"))
        return null;                          // 布隆过滤器判定不存在，直接短路

    var key = $"product:{id}";
    var cached = await _cache.GetAsync(key);
    if (cached is not null)
    {
        // 空值标记也缓存，防止空数据穿透
        return JsonSerializer.Deserialize<ProductDto?>(cached);
    }

    var dto = await _repo.FindByIdAsync(id);
    var json = JsonSerializer.SerializeToUtf8Bytes(dto);   // null 也写入
    await _cache.SetAsync(key, json, new DistributedCacheEntryOptions
    {
        AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(5)
    });
    return dto;
}

// 防击穿：分布式锁保证只有一个请求重建热点 key
public async Task<ProductDto> GetHotAsync(int id)
{
    var key = $"hot:{id}";
    if (await _cache.GetAsync(key) is { } hit)
        return JsonSerializer.Deserialize<ProductDto>(hit)!;

    await using var gate = await _lock.AcquireAsync($"lock:{key}",
        TimeSpan.FromSeconds(5));            // 获取分布式锁

    // 双重检查：锁到手后可能已被其他线程重建
    if (await _cache.GetAsync(key) is { } fresh)
        return JsonSerializer.Deserialize<ProductDto>(fresh)!;

    var dto = await _repo.FindByIdAsync(id) ?? throw new KeyNotFoundException();
    var json = JsonSerializer.SerializeToUtf8Bytes(dto);
    // 加随机抖动，防雪崩
    var ttl = TimeSpan.FromMinutes(10 + Random.Shared.Next(0, 5));
    await _cache.SetAsync(key, json, new DistributedCacheEntryOptions
    {
        AbsoluteExpirationRelativeToNow = ttl
    });
    return dto;
}

// 基于 StackExchange.Redis 的锁封装
public sealed class RedisDistributedLock
{
    private readonly IDatabase _db;
    private const string Script =
        """
        if redis.call('get', KEYS[1]) == ARGV[1] then
            return redis.call('del', KEYS[1])
        else
            return 0
        end
        """;

    public RedisDistributedLock(IConnectionMultiplexer redis)
        => _db = redis.GetDatabase();

    public async Task<LockHandle?> AcquireAsync(string key, TimeSpan expiry)
    {
        var token = Guid.NewGuid().ToString("N");   // 唯一身份
        var ok = await _db.StringSetAsync(key, token, expiry, When.NotExists);
        return ok ? new LockHandle(this, key, token) : null;
    }

    private async Task ReleaseAsync(string key, string token)
        => await _db.ScriptEvaluateAsync(Script, [key], [token]);
}

public sealed class LockHandle : IAsyncDisposable
{
    private readonly RedisDistributedLock _lock;
    private readonly string _key;
    private readonly string _token;

    public LockHandle(RedisDistributedLock l, string k, string t)
        => (_lock, _key, _token) = (l, k, t);

    public async ValueTask DisposeAsync()
        => await _lock.ReleaseSafeAsync(_key, _token);
}

// EF Core 乐观并发：rowversion 令牌
public class Product
{
    public int Id { get; set; }
    public int Stock { get; set; }
    public byte[] RowVersion { get; set; } = [];   // 并发令牌
}

public async Task<bool> TryDeductStockAsync(int id, int qty)
{
    var product = await _db.Products.SingleAsync(p => p.Id == id);
    if (product.Stock < qty) return false;

    product.Stock -= qty;
    try
    {
        await _db.SaveChangesAsync();       // WHERE 带上 RowVersion
        return true;
    }
    catch (DbUpdateConcurrencyException)
    {
        return false;                        // 被并发修改，重试或失败
    }
}

// Redis Lua 原子扣减：读-改-写在服务端一次完成
var script = """
    local stock = tonumber(redis.call('GET', KEYS[1]) or '0')
    if stock >= tonumber(ARGV[1]) then
        redis.call('DECRBY', KEYS[1], ARGV[1])
        return 1
    end
    return 0
    """;
var ok = await _db.ScriptEvaluateAsync(script, ["stock:42"], [qty]);

// Cache-Aside 写入路径：先写库，再删缓存
public async Task UpdateProductAsync(int id, ProductDto dto)
{
    await _repo.UpdateAsync(id, dto);               // 1. 先写数据库
    await _cache.RemoveAsync($"product:{id}");      // 2. 再删缓存

    // 为什么不更新缓存而是删除？
    // 并发场景下「写缓存」可能写入旧值覆盖新值；
    // 删除后下次读取重新回源，保证拿到最新。
}

// 订阅数据库变更：CDC 驱动的主动失效
public class ProductChangedConsumer(IMessageBus bus, IDistributedCache cache)
{
    public async Task HandleAsync(ProductChangedEvent evt)
    {
        // 收到 binlog/outbox 事件后精准删除相关 key
        await cache.RemoveAsync($"product:{evt.ProductId}");
        await cache.RemoveAsync("product:hot-list");   // 列表缓存也失效
    }
}