分布式缓存与多级缓存架构

一、分布式缓存概述

分布式缓存是数据密集型应用的关键组件，通过将热点数据缓存到内存中，能够显著提升系统性能。多级缓存架构通过组合本地缓存和分布式缓存，能够进一步优化缓存命中率和减少网络开销。

二、多级缓存架构

2.1 多级缓存层次

2.2 缓存层级对比

三、分布式缓存实现

3.1 Redis集群缓存

public class RedisClusterCache : IDistributedCache
{
    private readonly IConnectionMultiplexer _connectionMultiplexer;
    
    public RedisClusterCache(IConnectionMultiplexer connectionMultiplexer)
    {
        _connectionMultiplexer = connectionMultiplexer;
    }
    
    public async Task GetAsync(string key)
    {
        var db = _connectionMultiplexer.GetDatabase();
        var value = await db.StringGetAsync(key);
        
        if (!value.HasValue)
        {
            return default;
        }
        
        return JsonSerializer.Deserialize(value);
    }
    
    public async Task SetAsync(string key, T value, TimeSpan? expiry = null)
    {
        var db = _connectionMultiplexer.GetDatabase();
        var json = JsonSerializer.Serialize(value);
        
        await db.StringSetAsync(key, json, expiry);
    }
    
    public async Task RemoveAsync(string key)
    {
        var db = _connectionMultiplexer.GetDatabase();
        await db.KeyDeleteAsync(key);
    }
    
    public async Task ExistsAsync(string key)
    {
        var db = _connectionMultiplexer.GetDatabase();
        return await db.KeyExistsAsync(key);
    }
    
    public async Task GetOrCreateAsync(string key, Func> factory, TimeSpan? expiry = null)
    {
        var value = await GetAsync(key);
        
        if (value != null)
        {
            return value;
        }
        
        value = await factory();
        
        if (value != null)
        {
            await SetAsync(key, value, expiry);
        }
        
        return value;
    }
    
    public async Task IncrementAsync(string key, long value = 1)
    {
        var db = _connectionMultiplexer.GetDatabase();
        return await db.StringIncrementAsync(key, value);
    }
    
    public async Task DecrementAsync(string key, long value = 1)
    {
        var db = _connectionMultiplexer.GetDatabase();
        return await db.StringDecrementAsync(key, value);
    }
}

3.2 本地缓存实现

public class LocalCache
{
    private readonly ConcurrentDictionary> _cache = new();
    private readonly TimeSpan _defaultExpiry;
    private readonly int _maxSize;
    
    public LocalCache(TimeSpan defaultExpiry, int maxSize = 1000)
    {
        _defaultExpiry = defaultExpiry;
        _maxSize = maxSize;
    }
    
    public T Get(string key)
    {
        if (_cache.TryGetValue(key, out var entry))
        {
            if (entry.ExpiryTime > DateTime.UtcNow)
            {
                entry.AccessTime = DateTime.UtcNow;
                return entry.Value;
            }
            
            _cache.TryRemove(key, out _);
        }
        
        return default;
    }
    
    public void Set(string key, T value, TimeSpan? expiry = null)
    {
        if (_cache.Count >= _maxSize)
        {
            EvictLeastRecentlyUsed();
        }
        
        _cache[key] = new CacheEntry
        {
            Value = value,
            ExpiryTime = DateTime.UtcNow + (expiry ?? _defaultExpiry),
            AccessTime = DateTime.UtcNow
        };
    }
    
    public bool Remove(string key)
    {
        return _cache.TryRemove(key, out _);
    }
    
    public bool TryGetValue(string key, out T value)
    {
        value = Get(key);
        return value != null;
    }
    
    public void Clear()
    {
        _cache.Clear();
    }
    
    public int Count => _cache.Count;
    
    private void EvictLeastRecentlyUsed()
    {
        var oldest = _cache.OrderBy(kv => kv.Value.AccessTime).FirstOrDefault();
        
        if (oldest.Key != null)
        {
            _cache.TryRemove(oldest.Key, out _);
        }
    }
    
    private class CacheEntry
    {
        public TValue Value { get; set; }
        public DateTime ExpiryTime { get; set; }
        public DateTime AccessTime { get; set; }
    }
}

四、多级缓存服务

4.1 多级缓存管理器

public class MultiLevelCacheManager : IMultiLevelCache
{
    private readonly LocalCache