using Microsoft.Extensions.Caching.Memory;
|
using Microsoft.Extensions.Hosting;
|
using Microsoft.Extensions.Logging;
|
using Microsoft.Extensions.Options;
|
using StackExchange.Redis;
|
using System.Collections.Concurrent;
|
using WIDESEAWCS_RedisService.Connection;
|
using WIDESEAWCS_RedisService.Options;
|
using WIDESEAWCS_RedisService.Serialization;
|
|
namespace WIDESEAWCS_RedisService.Cache
|
{
|
/// <summary>
|
/// Redis到内存缓存的自动同步后台服务
|
/// 定期从Redis提取数据并覆盖内存缓存，确保数据一致性
|
/// </summary>
|
public class CacheSyncBackgroundService : BackgroundService
|
{
|
private readonly IRedisConnectionManager _connectionManager;
|
private readonly IMemoryCache _memoryCache;
|
private readonly IRedisSerializer _serializer;
|
private readonly RedisOptions _options;
|
private readonly ILogger<CacheSyncBackgroundService> _logger;
|
private readonly ConcurrentDictionary<string, bool> _trackedKeys;
|
|
public CacheSyncBackgroundService(
|
IRedisConnectionManager connectionManager,
|
IMemoryCache memoryCache,
|
IRedisSerializer serializer,
|
IOptions<RedisOptions> options,
|
ILogger<CacheSyncBackgroundService> logger)
|
{
|
_connectionManager = connectionManager;
|
_memoryCache = memoryCache;
|
_serializer = serializer;
|
_options = options.Value;
|
_logger = logger;
|
_trackedKeys = new ConcurrentDictionary<string, bool>();
|
}
|
|
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
|
{
|
// 如果未启用L1缓存，则无需同步
|
if (!_options.EnableL1Cache)
|
{
|
_logger.LogInformation("L1缓存未启用，后台同步服务不会运行");
|
return;
|
}
|
|
// 如果未启用自动同步，则不运行
|
if (!_options.EnableAutoSync)
|
{
|
_logger.LogInformation("Redis自动同步未启用，后台同步服务不会运行");
|
return;
|
}
|
|
_logger.LogInformation("Redis缓存同步服务已启动，同步间隔: {Interval}秒", _options.SyncIntervalSeconds);
|
|
// 等待Redis连接就绪
|
while (!_connectionManager.IsConnected && !stoppingToken.IsCancellationRequested)
|
{
|
_logger.LogWarning("等待Redis连接就绪...");
|
await Task.Delay(5000, stoppingToken);
|
}
|
|
if (stoppingToken.IsCancellationRequested)
|
return;
|
|
// 启动时先进行一次全量同步
|
await SyncCacheAsync(stoppingToken);
|
|
// 定期同步
|
while (!stoppingToken.IsCancellationRequested)
|
{
|
try
|
{
|
await Task.Delay(TimeSpan.FromSeconds(_options.SyncIntervalSeconds), stoppingToken);
|
|
if (_connectionManager.IsConnected)
|
{
|
await SyncCacheAsync(stoppingToken);
|
}
|
else
|
{
|
_logger.LogWarning("Redis未连接，跳过本次同步");
|
}
|
}
|
catch (OperationCanceledException)
|
{
|
// 正常退出
|
break;
|
}
|
catch (Exception ex)
|
{
|
_logger.LogError(ex, "缓存同步过程中发生错误");
|
}
|
}
|
|
_logger.LogInformation("Redis缓存同步服务已停止");
|
}
|
|
/// <summary>
|
/// 执行缓存同步
|
/// </summary>
|
private async Task SyncCacheAsync(CancellationToken stoppingToken)
|
{
|
try
|
{
|
var db = _connectionManager.GetDatabase();
|
var server = _connectionManager.GetServer();
|
var keyPrefix = _options.KeyPrefix;
|
|
// 获取所有匹配前缀的Redis key
|
var redisKeys = server.Keys(pattern: $"{keyPrefix}*", pageSize: _options.SyncBatchSize).ToList();
|
|
if (redisKeys.Count == 0)
|
{
|
_logger.LogDebug("Redis中没有找到匹配前缀 {Prefix} 的key", keyPrefix);
|
return;
|
}
|
|
int syncedCount = 0;
|
int skippedCount = 0;
|
int removedCount = 0;
|
|
// 1. 同步Redis中的数据到内存缓存
|
foreach (var redisKey in redisKeys)
|
{
|
if (stoppingToken.IsCancellationRequested)
|
break;
|
|
try
|
{
|
var keyStr = redisKey.ToString();
|
_trackedKeys.AddOrUpdate(keyStr, true, (_, _) => true);
|
|
// 获取Redis中的值
|
var value = db.StringGet(redisKey);
|
if (!value.IsNullOrEmpty)
|
{
|
var valueStr = value.ToString();
|
var ttl = db.KeyTimeToLive(redisKey);
|
|
// 获取过期时间，如果没有设置TTL则使用默认5分钟
|
var expireSeconds = ttl.HasValue && ttl.Value.TotalSeconds > 0
|
? (int)ttl.Value.TotalSeconds
|
: 300;
|
|
// 更新内存缓存
|
var entryOptions = new MemoryCacheEntryOptions
|
{
|
AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(expireSeconds)
|
};
|
|
_memoryCache.Set(keyStr, valueStr, entryOptions);
|
syncedCount++;
|
}
|
}
|
catch (Exception ex)
|
{
|
_logger.LogWarning(ex, "同步key {Key} 时发生错误", redisKey);
|
}
|
}
|
|
// 2. 清理内存缓存中不存在于Redis的key
|
// 注意：IMemoryCache不支持枚举，这里只能清理已跟踪的key
|
var keysToRemove = _trackedKeys.Where(k => !redisKeys.Contains(k.Key)).Select(k => k.Key).ToList();
|
|
foreach (var keyToRemove in keysToRemove)
|
{
|
_memoryCache.Remove(keyToRemove);
|
_trackedKeys.TryRemove(keyToRemove, out _);
|
removedCount++;
|
}
|
|
_logger.LogInformation(
|
"缓存同步完成: 同步 {SyncedCount} 个, 跳过 {SkippedCount} 个, 清理 {RemovedCount} 个, 总计 {TotalCount} 个key",
|
syncedCount, skippedCount, removedCount, redisKeys.Count);
|
}
|
catch (Exception ex)
|
{
|
_logger.LogError(ex, "缓存同步时发生错误");
|
}
|
}
|
|
/// <summary>
|
/// 获取同步统计信息
|
/// </summary>
|
public CacheSyncStatistics GetStatistics()
|
{
|
return new CacheSyncStatistics
|
{
|
IsEnabled = _options.EnableAutoSync && _options.EnableL1Cache,
|
SyncIntervalSeconds = _options.SyncIntervalSeconds,
|
TrackedKeysCount = _trackedKeys.Count,
|
IsRedisConnected = _connectionManager.IsConnected
|
};
|
}
|
}
|
|
/// <summary>
|
/// 缓存同步统计信息
|
/// </summary>
|
public class CacheSyncStatistics
|
{
|
public bool IsEnabled { get; set; }
|
public int SyncIntervalSeconds { get; set; }
|
public int TrackedKeysCount { get; set; }
|
public bool IsRedisConnected { get; set; }
|
}
|
}
|
