using Microsoft.Extensions.Caching.Memory;
|
using Microsoft.Extensions.Logging;
|
using Microsoft.Extensions.Options;
|
using WIDESEAWCS_Core.Caches;
|
using WIDESEAWCS_RedisService.Connection;
|
using WIDESEAWCS_RedisService.Options;
|
using WIDESEAWCS_RedisService.Serialization;
|
|
namespace WIDESEAWCS_RedisService.Cache
|
{
|
public class HybridCacheService : ICacheService
|
{
|
private readonly IMemoryCache _memoryCache;
|
private readonly IRedisConnectionManager _connectionManager;
|
private readonly IRedisSerializer _serializer;
|
private readonly RedisOptions _options;
|
private readonly ILogger<HybridCacheService> _logger;
|
private bool _disposed;
|
|
private bool RedisAvailable => _connectionManager.IsConnected;
|
|
public HybridCacheService(
|
IMemoryCache memoryCache,
|
IRedisConnectionManager connectionManager,
|
IRedisSerializer serializer,
|
IOptions<RedisOptions> options,
|
ILogger<HybridCacheService> logger)
|
{
|
_memoryCache = memoryCache;
|
_connectionManager = connectionManager;
|
_serializer = serializer;
|
_options = options.Value;
|
_logger = logger;
|
}
|
|
private string BuildKey(string key) => $"{_options.KeyPrefix}{key}";
|
|
public bool Exists(string key)
|
{
|
if (_memoryCache.TryGetValue(BuildKey(key), out _)) return true;
|
if (!RedisAvailable) return false;
|
try
|
{
|
return _connectionManager.GetDatabase().KeyExists(BuildKey(key));
|
}
|
catch (Exception ex)
|
{
|
_logger.LogWarning(ex, "Redis Exists失败, key={Key}", key);
|
return false;
|
}
|
}
|
|
public bool Add(string key, string value, int expireSeconds = -1, bool isSliding = false)
|
{
|
var fullKey = BuildKey(key);
|
|
// 只有启用L1缓存时才写入内存缓存
|
if (_options.EnableL1Cache)
|
{
|
SetMemoryCache(fullKey, value, expireSeconds, isSliding);
|
}
|
|
if (!RedisAvailable)
|
{
|
if (!_options.EnableL1Cache)
|
{
|
_logger.LogWarning("Redis不可用且L1缓存已禁用, key={Key}", key);
|
return false;
|
}
|
_logger.LogWarning("Redis不可用，仅使用内存缓存, key={Key}", key);
|
return true;
|
}
|
try
|
{
|
var expiry = expireSeconds > 0 ? TimeSpan.FromSeconds(expireSeconds) : (TimeSpan?)null;
|
var result = _connectionManager.GetDatabase().StringSet(fullKey, value, expiry);
|
_logger.LogInformation("Redis写入成功: key={Key}, result={Result}", fullKey, result);
|
return result;
|
}
|
catch (Exception ex)
|
{
|
_logger.LogWarning(ex, "Redis Add失败, key={Key}", key);
|
return _options.FallbackToMemory && _options.EnableL1Cache;
|
}
|
}
|
|
public bool AddObject(string key, object value, int expireSeconds = -1, bool isSliding = false)
|
{
|
return Add(key, _serializer.Serialize(value), expireSeconds, isSliding);
|
}
|
|
public void AddOrUpdate(string key, string value, int expireSeconds = -1, bool isSliding = false)
|
{
|
Add(key, value, expireSeconds, isSliding);
|
}
|
|
public void AddOrUpdate(string key, object value, int expireSeconds = -1, bool isSliding = false)
|
{
|
AddObject(key, value, expireSeconds, isSliding);
|
}
|
|
public bool Remove(string key)
|
{
|
var fullKey = BuildKey(key);
|
|
// 只有启用L1缓存时才从内存缓存中移除
|
if (_options.EnableL1Cache)
|
{
|
_memoryCache.Remove(fullKey);
|
}
|
|
if (!RedisAvailable) return _options.EnableL1Cache;
|
try
|
{
|
return _connectionManager.GetDatabase().KeyDelete(fullKey);
|
}
|
catch (Exception ex)
|
{
|
_logger.LogWarning(ex, "Redis Remove失败, key={Key}", key);
|
return true;
|
}
|
}
|
|
public void Remove(IEnumerable<string> keys)
|
{
|
foreach (var key in keys) Remove(key);
|
}
|
|
#region 删除扩展方法
|
|
public string? RemoveAndGet(string key)
|
{
|
var value = Get(key);
|
if (value != null) Remove(key);
|
return value;
|
}
|
|
public T? RemoveAndGet<T>(string key) where T : class
|
{
|
var value = Get<T>(key);
|
if (value != null) Remove(key);
|
return value;
|
}
|
|
public int RemoveByPrefix(string prefix)
|
{
|
if (string.IsNullOrEmpty(prefix)) return 0;
|
var fullPrefix = BuildKey(prefix);
|
int count = 0;
|
|
// 删除内存缓存中的匹配项
|
// MemoryCache无法枚举，跳过
|
|
if (RedisAvailable)
|
{
|
try
|
{
|
var server = _connectionManager.GetServer();
|
var keys = server.Keys(pattern: $"{fullPrefix}*").ToArray();
|
if (keys.Length > 0)
|
{
|
count = (int)_connectionManager.GetDatabase().KeyDelete(keys);
|
}
|
}
|
catch (Exception ex)
|
{
|
_logger.LogWarning(ex, "Redis RemoveByPrefix失败, prefix={Prefix}", prefix);
|
}
|
}
|
|
return count;
|
}
|
|
public int RemoveByPattern(string pattern)
|
{
|
if (string.IsNullOrEmpty(pattern)) return 0;
|
int count = 0;
|
|
if (RedisAvailable)
|
{
|
try
|
{
|
var server = _connectionManager.GetServer();
|
var keys = server.Keys(pattern: $"{_options.KeyPrefix}{pattern}").ToArray();
|
if (keys.Length > 0)
|
{
|
count = (int)_connectionManager.GetDatabase().KeyDelete(keys);
|
}
|
}
|
catch (Exception ex)
|
{
|
_logger.LogWarning(ex, "Redis RemoveByPattern失败, pattern={Pattern}", pattern);
|
}
|
}
|
|
return count;
|
}
|
|
public int RemoveAll(IEnumerable<string> keys)
|
{
|
if (keys == null) return 0;
|
int count = 0;
|
foreach (var key in keys)
|
{
|
if (Remove(key)) count++;
|
}
|
return count;
|
}
|
|
public int RemoveWhere(Func<string, bool> predicate)
|
{
|
if (predicate == null) return 0;
|
int count = 0;
|
|
if (RedisAvailable)
|
{
|
try
|
{
|
var server = _connectionManager.GetServer();
|
var keys = server.Keys(pattern: $"{_options.KeyPrefix}*").ToArray();
|
var keysToDelete = keys.Where(k =>
|
{
|
var originalKey = k.ToString().Replace(_options.KeyPrefix, "");
|
return predicate(originalKey);
|
}).ToArray();
|
|
if (keysToDelete.Length > 0)
|
{
|
count = (int)_connectionManager.GetDatabase().KeyDelete(keysToDelete);
|
}
|
}
|
catch (Exception ex)
|
{
|
_logger.LogWarning(ex, "Redis RemoveWhere失败");
|
}
|
}
|
|
return count;
|
}
|
|
#endregion
|
|
#region 添加和修改扩展方法
|
|
public void AddAll(IDictionary<string, string> items, int expireSeconds = -1)
|
{
|
if (items == null) return;
|
foreach (var item in items)
|
{
|
Add(item.Key, item.Value, expireSeconds);
|
}
|
}
|
|
public void AddAllObjects(IDictionary<string, object> items, int expireSeconds = -1)
|
{
|
if (items == null) return;
|
foreach (var item in items)
|
{
|
AddObject(item.Key, item.Value, expireSeconds);
|
}
|
}
|
|
public bool Replace(string key, string newValue, int expireSeconds = -1)
|
{
|
return TryUpdate(key, newValue, expireSeconds);
|
}
|
|
public bool Replace<T>(string key, T newValue, int expireSeconds = -1) where T : class
|
{
|
if (!Exists(key)) return false;
|
AddObject(key, newValue, expireSeconds);
|
return true;
|
}
|
|
public string? GetAndRefresh(string key, int expireSeconds)
|
{
|
var fullKey = BuildKey(key);
|
string? value = null;
|
|
// 从Redis获取值
|
if (RedisAvailable)
|
{
|
try
|
{
|
var redisValue = _connectionManager.GetDatabase().StringGet(fullKey);
|
if (!redisValue.IsNullOrEmpty)
|
{
|
value = redisValue.ToString();
|
// 刷新Redis过期时间
|
_connectionManager.GetDatabase().KeyExpire(fullKey, TimeSpan.FromSeconds(expireSeconds));
|
}
|
}
|
catch (Exception ex)
|
{
|
_logger.LogWarning(ex, "Redis GetAndRefresh失败, key={Key}", key);
|
}
|
}
|
|
// 如果Redis不可用，尝试从内存缓存获取
|
if (value == null && _options.EnableL1Cache)
|
{
|
if (_memoryCache.TryGetValue(fullKey, out string? cached))
|
value = cached;
|
}
|
|
// 更新内存缓存（如果有值）
|
if (value != null && _options.EnableL1Cache)
|
{
|
SetMemoryCache(fullKey, value, expireSeconds, false);
|
}
|
|
return value;
|
}
|
|
public T? GetAndRefresh<T>(string key, int expireSeconds) where T : class
|
{
|
var fullKey = BuildKey(key);
|
T? value = default;
|
|
// 从Redis获取值
|
if (RedisAvailable)
|
{
|
try
|
{
|
var redisValue = _connectionManager.GetDatabase().StringGet(fullKey);
|
if (!redisValue.IsNullOrEmpty)
|
{
|
var json = redisValue.ToString();
|
value = _serializer.Deserialize<T>(json);
|
// 刷新Redis过期时间
|
_connectionManager.GetDatabase().KeyExpire(fullKey, TimeSpan.FromSeconds(expireSeconds));
|
}
|
}
|
catch (Exception ex)
|
{
|
_logger.LogWarning(ex, "Redis GetAndRefresh<T>失败, key={Key}", key);
|
}
|
}
|
|
// 如果Redis不可用，尝试从内存缓存获取
|
if (value == null && _options.EnableL1Cache)
|
{
|
if (_memoryCache.TryGetValue(fullKey, out string? cached) && cached != null)
|
value = _serializer.Deserialize<T>(cached);
|
}
|
|
// 更新内存缓存（如果有值）
|
if (value != null && _options.EnableL1Cache)
|
{
|
SetMemoryCache(fullKey, _serializer.Serialize(value), expireSeconds, false);
|
}
|
|
return value;
|
}
|
|
public bool RefreshExpire(string key, int expireSeconds)
|
{
|
var fullKey = BuildKey(key);
|
bool result = false;
|
|
// 刷新Redis过期时间
|
if (RedisAvailable)
|
{
|
try
|
{
|
result = _connectionManager.GetDatabase().KeyExpire(fullKey, TimeSpan.FromSeconds(expireSeconds));
|
}
|
catch { }
|
}
|
|
// 更新内存缓存过期时间（需要重新设置值来刷新过期时间）
|
if (_options.EnableL1Cache && _memoryCache.TryGetValue(fullKey, out string? cached) && cached != null)
|
{
|
SetMemoryCache(fullKey, cached, expireSeconds, false);
|
return true;
|
}
|
|
return result;
|
}
|
|
public bool ExpireIn(string key, int seconds)
|
{
|
return RefreshExpire(key, seconds);
|
}
|
|
public bool ExpireAt(string key, DateTime expireTime)
|
{
|
var seconds = (long)(expireTime - DateTime.Now).TotalSeconds;
|
if (seconds <= 0) return Remove(key);
|
return RefreshExpire(key, (int)seconds);
|
}
|
|
public long? GetExpire(string key)
|
{
|
if (RedisAvailable)
|
{
|
try
|
{
|
var ttl = _connectionManager.GetDatabase().KeyTimeToLive(BuildKey(key));
|
return ttl.HasValue ? (long)ttl.Value.TotalSeconds : null;
|
}
|
catch { }
|
}
|
return null; // MemoryCache不支持TTL查询
|
}
|
|
public bool AddIfNotExists(string key, string value, int expireSeconds = -1)
|
{
|
return TryAdd(key, value, expireSeconds);
|
}
|
|
public bool AddIfNotExists<T>(string key, T value, int expireSeconds = -1) where T : class
|
{
|
return TryAdd(key, value, expireSeconds);
|
}
|
|
public string? GetAndSet(string key, string newValue, int expireSeconds = -1)
|
{
|
var fullKey = BuildKey(key);
|
string? oldValue = null;
|
|
// 从Redis获取旧值
|
if (RedisAvailable)
|
{
|
try
|
{
|
var value = _connectionManager.GetDatabase().StringGet(fullKey);
|
oldValue = value.IsNullOrEmpty ? null : value.ToString();
|
}
|
catch { }
|
}
|
|
// 如果Redis不可用，从内存缓存获取
|
if (oldValue == null && _options.EnableL1Cache)
|
{
|
_memoryCache.TryGetValue(fullKey, out oldValue);
|
}
|
|
// 写入Redis
|
if (RedisAvailable)
|
{
|
try
|
{
|
var expiry = expireSeconds > 0 ? TimeSpan.FromSeconds(expireSeconds) : (TimeSpan?)null;
|
_connectionManager.GetDatabase().StringSet(fullKey, newValue, expiry);
|
}
|
catch { }
|
}
|
|
// 更新内存缓存
|
if (_options.EnableL1Cache)
|
{
|
SetMemoryCache(fullKey, newValue, expireSeconds, false);
|
}
|
|
return oldValue;
|
}
|
|
public T? GetAndSet<T>(string key, T newValue, int expireSeconds = -1) where T : class
|
{
|
var fullKey = BuildKey(key);
|
T? oldValue = default;
|
string? oldJson = null;
|
|
// 从Redis获取旧值
|
if (RedisAvailable)
|
{
|
try
|
{
|
var value = _connectionManager.GetDatabase().StringGet(fullKey);
|
if (!value.IsNullOrEmpty)
|
{
|
oldJson = value.ToString();
|
oldValue = _serializer.Deserialize<T>(oldJson);
|
}
|
}
|
catch { }
|
}
|
|
var newJson = _serializer.Serialize(newValue);
|
|
// 写入Redis
|
if (RedisAvailable)
|
{
|
try
|
{
|
var expiry = expireSeconds > 0 ? TimeSpan.FromSeconds(expireSeconds) : (TimeSpan?)null;
|
_connectionManager.GetDatabase().StringSet(fullKey, newJson, expiry);
|
}
|
catch { }
|
}
|
|
// 更新内存缓存
|
if (_options.EnableL1Cache)
|
{
|
SetMemoryCache(fullKey, newJson, expireSeconds, false);
|
}
|
|
return oldValue;
|
}
|
|
public long Increment(string key, long value = 1)
|
{
|
if (RedisAvailable)
|
{
|
try
|
{
|
return _connectionManager.GetDatabase().StringIncrement(BuildKey(key), value);
|
}
|
catch { }
|
}
|
|
// Fallback to memory
|
var current = long.TryParse(Get(key), out var v) ? v : 0;
|
var newValue = current + value;
|
Add(key, newValue.ToString());
|
return newValue;
|
}
|
|
public long Decrement(string key, long value = 1)
|
{
|
return Increment(key, -value);
|
}
|
|
public long Append(string key, string value)
|
{
|
var current = Get(key) ?? "";
|
var newValue = current + value;
|
Add(key, newValue);
|
return newValue.Length;
|
}
|
|
#endregion
|
|
public T? Get<T>(string key) where T : class
|
{
|
var fullKey = BuildKey(key);
|
|
// 如果禁用了L1缓存，直接查Redis
|
if (!_options.EnableL1Cache)
|
{
|
if (!RedisAvailable) return default;
|
try
|
{
|
var value = _connectionManager.GetDatabase().StringGet(fullKey);
|
if (value.IsNullOrEmpty) return default;
|
return _serializer.Deserialize<T>(value!);
|
}
|
catch (Exception ex)
|
{
|
_logger.LogWarning(ex, "Redis Get<T>失败, key={Key}", key);
|
return default;
|
}
|
}
|
|
// 正常的L1+L2逻辑
|
if (_memoryCache.TryGetValue(fullKey, out string? cached) && cached != null)
|
return _serializer.Deserialize<T>(cached);
|
|
if (!RedisAvailable) return default;
|
try
|
{
|
var value = _connectionManager.GetDatabase().StringGet(fullKey);
|
if (value.IsNullOrEmpty) return default;
|
var str = value.ToString();
|
SetMemoryCache(fullKey, str, 300, false);
|
return _serializer.Deserialize<T>(str);
|
}
|
catch (Exception ex)
|
{
|
_logger.LogWarning(ex, "Redis Get<T>失败, key={Key}", key);
|
return default;
|
}
|
}
|
|
/// <summary>
|
/// 安全更新：仅当内存缓存中的值与expectedVersion匹配时才更新
|
/// 防止并发写入时旧值覆盖新值
|
/// </summary>
|
/// <typeparam name="T">值类型</typeparam>
|
/// <param name="key">缓存键</param>
|
/// <param name="newValue">新值</param>
|
/// <param name="expectedVersion">期望的版本（通常是旧对象的哈希值或时间戳）</param>
|
/// <param name="versionExtractor">从对象提取版本号的函数</param>
|
/// <param name="expireSeconds">过期时间</param>
|
/// <returns>是否更新成功</returns>
|
public bool TrySafeUpdate<T>(
|
string key,
|
T newValue,
|
object? expectedVersion,
|
Func<T, object?> versionExtractor,
|
int expireSeconds = -1) where T : class
|
{
|
var fullKey = BuildKey(key);
|
|
// 从Redis获取当前值
|
string? existingJson = null;
|
T? existingValue = default;
|
if (RedisAvailable)
|
{
|
try
|
{
|
var value = _connectionManager.GetDatabase().StringGet(fullKey);
|
if (!value.IsNullOrEmpty)
|
{
|
existingJson = value.ToString();
|
existingValue = _serializer.Deserialize<T>(existingJson);
|
}
|
}
|
catch { }
|
}
|
|
// 如果Redis不可用，从内存缓存获取
|
if (existingValue == null && _options.EnableL1Cache)
|
{
|
if (_memoryCache.TryGetValue(fullKey, out string? cached) && cached != null)
|
{
|
existingValue = _serializer.Deserialize<T>(cached);
|
existingJson = cached;
|
}
|
else
|
{
|
return false;
|
}
|
}
|
|
// 检查版本是否匹配
|
if (existingValue != null)
|
{
|
var currentVersion = versionExtractor(existingValue);
|
if (!Equals(currentVersion, expectedVersion))
|
{
|
_logger.LogWarning("TrySafeUpdate版本不匹配, key={Key}, expected={Expected}, current={Current}",
|
key, expectedVersion, currentVersion);
|
return false; // 版本不匹配，拒绝更新
|
}
|
}
|
|
// 版本匹配，执行更新
|
var newJson = _serializer.Serialize(newValue);
|
|
// 先写入Redis
|
if (RedisAvailable)
|
{
|
try
|
{
|
var expiry = expireSeconds > 0 ? TimeSpan.FromSeconds(expireSeconds) : (TimeSpan?)null;
|
if (!_connectionManager.GetDatabase().StringSet(fullKey, newJson, expiry))
|
{
|
_logger.LogWarning("Redis TrySafeUpdate写入失败, key={Key}", key);
|
return _options.FallbackToMemory && _options.EnableL1Cache;
|
}
|
else
|
{
|
_logger.LogInformation("Redis TrySafeUpdate写入成功, key={Key}", key);
|
}
|
}
|
catch (Exception ex)
|
{
|
_logger.LogWarning(ex, "Redis TrySafeUpdate写入失败, key={Key}", key);
|
return _options.FallbackToMemory && _options.EnableL1Cache;
|
}
|
}
|
|
// 更新内存缓存
|
if (_options.EnableL1Cache)
|
{
|
SetMemoryCache(fullKey, newJson, expireSeconds, false);
|
}
|
|
return true;
|
}
|
|
public object? Get(Type type, string key)
|
{
|
var fullKey = BuildKey(key);
|
|
// 如果禁用了L1缓存，直接查Redis
|
if (!_options.EnableL1Cache)
|
{
|
if (!RedisAvailable) return null;
|
try
|
{
|
var value = _connectionManager.GetDatabase().StringGet(fullKey);
|
if (value.IsNullOrEmpty) return null;
|
return _serializer.Deserialize(value!, type);
|
}
|
catch (Exception ex)
|
{
|
_logger.LogWarning(ex, "Redis Get(Type)失败, key={Key}", key);
|
return null;
|
}
|
}
|
|
// 正常的L1+L2逻辑
|
if (_memoryCache.TryGetValue(fullKey, out string? cached) && cached != null)
|
return _serializer.Deserialize(cached, type);
|
|
if (!RedisAvailable) return null;
|
try
|
{
|
var value = _connectionManager.GetDatabase().StringGet(fullKey);
|
if (value.IsNullOrEmpty) return null;
|
var str = value.ToString();
|
SetMemoryCache(fullKey, str, 300, false);
|
return _serializer.Deserialize(str, type);
|
}
|
catch (Exception ex)
|
{
|
_logger.LogWarning(ex, "Redis Get(Type)失败, key={Key}", key);
|
return null;
|
}
|
}
|
|
public string? Get(string key)
|
{
|
var fullKey = BuildKey(key);
|
|
// 如果禁用了L1缓存，直接查Redis
|
if (!_options.EnableL1Cache)
|
{
|
if (!RedisAvailable) return null;
|
try
|
{
|
var value = _connectionManager.GetDatabase().StringGet(fullKey);
|
return value.IsNullOrEmpty ? null : value.ToString();
|
}
|
catch (Exception ex)
|
{
|
_logger.LogWarning(ex, "Redis Get失败, key={Key}", key);
|
return null;
|
}
|
}
|
|
// 正常的L1+L2逻辑
|
if (_memoryCache.TryGetValue(fullKey, out string? cached))
|
return cached;
|
|
if (!RedisAvailable) return null;
|
try
|
{
|
var value = _connectionManager.GetDatabase().StringGet(fullKey);
|
if (value.IsNullOrEmpty) return null;
|
var str = value.ToString();
|
SetMemoryCache(fullKey, str, 300, false);
|
return str;
|
}
|
catch (Exception ex)
|
{
|
_logger.LogWarning(ex, "Redis Get失败, key={Key}", key);
|
return null;
|
}
|
}
|
|
private void SetMemoryCache(string fullKey, string value, int expireSeconds, bool isSliding)
|
{
|
var entryOptions = new MemoryCacheEntryOptions();
|
if (expireSeconds > 0)
|
{
|
if (isSliding)
|
entryOptions.SetSlidingExpiration(TimeSpan.FromSeconds(expireSeconds));
|
else
|
entryOptions.SetAbsoluteExpiration(TimeSpan.FromSeconds(expireSeconds));
|
}
|
_memoryCache.Set(fullKey, value, entryOptions);
|
}
|
|
#region ConcurrentDictionary风格方法
|
|
public bool TryAdd(string key, string value, int expireSeconds = -1)
|
{
|
if (Exists(key)) return false;
|
return Add(key, value, expireSeconds);
|
}
|
|
public bool TryAdd<T>(string key, T value, int expireSeconds = -1) where T : class
|
{
|
if (Exists(key)) return false;
|
return AddObject(key, value, expireSeconds);
|
}
|
|
public bool TryGetValue(string key, out string? value)
|
{
|
value = Get(key);
|
return value != null;
|
}
|
|
public bool TryGetValue<T>(string key, out T? value) where T : class
|
{
|
value = Get<T>(key);
|
return value != null;
|
}
|
|
public bool TryRemove(string key, out string? value)
|
{
|
value = Get(key);
|
if (value == null) return false;
|
Remove(key);
|
return true;
|
}
|
|
public bool TryUpdate(string key, string newValue, int expireSeconds = -1)
|
{
|
if (!Exists(key)) return false;
|
Add(key, newValue, expireSeconds);
|
return true;
|
}
|
|
public bool TryUpdateIfChanged(string key, string newValue, int expireSeconds = -1)
|
{
|
var existing = Get(key);
|
if (existing == null) return false;
|
if (existing == newValue) return false; // 值相同，不更新
|
Add(key, newValue, expireSeconds);
|
return true;
|
}
|
|
public bool TryUpdateIfChanged<T>(string key, T newValue, int expireSeconds = -1) where T : class
|
{
|
var fullKey = BuildKey(key);
|
|
// 总是从Redis获取当前实际值进行比较，确保数据一致性
|
string? existingJson = null;
|
if (RedisAvailable)
|
{
|
try
|
{
|
var value = _connectionManager.GetDatabase().StringGet(fullKey);
|
if (!value.IsNullOrEmpty)
|
existingJson = value.ToString();
|
}
|
catch { }
|
}
|
|
if (existingJson == null)
|
{
|
// Redis不可用，检查内存缓存
|
if (_options.EnableL1Cache && _memoryCache.TryGetValue(fullKey, out string? cached) && cached != null)
|
existingJson = cached;
|
else
|
return false;
|
}
|
|
var newJson = _serializer.Serialize(newValue);
|
if (existingJson == newJson) return false; // JSON字符串相同，不更新
|
|
// 先写入Redis，成功后再更新内存缓存
|
if (RedisAvailable)
|
{
|
try
|
{
|
var expiry = expireSeconds > 0 ? TimeSpan.FromSeconds(expireSeconds) : (TimeSpan?)null;
|
if (!_connectionManager.GetDatabase().StringSet(fullKey, newJson, expiry))
|
{
|
// Redis写入失败
|
_logger.LogWarning("Redis TryUpdateIfChanged写入失败, key={Key}", key);
|
return _options.FallbackToMemory && _options.EnableL1Cache;
|
}
|
}
|
catch (Exception ex)
|
{
|
_logger.LogWarning(ex, "Redis TryUpdateIfChanged写入失败, key={Key}", key);
|
return _options.FallbackToMemory && _options.EnableL1Cache;
|
}
|
}
|
|
// Redis写入成功（或Redis不可用时），更新内存缓存
|
if (_options.EnableL1Cache)
|
{
|
SetMemoryCache(fullKey, newJson, expireSeconds, false);
|
}
|
|
return true;
|
}
|
|
public string GetOrAdd(string key, string value, int expireSeconds = -1)
|
{
|
var existing = Get(key);
|
if (existing != null) return existing;
|
Add(key, value, expireSeconds);
|
return value;
|
}
|
|
public string GetOrAdd(string key, Func<string, string> valueFactory, int expireSeconds = -1)
|
{
|
var existing = Get(key);
|
if (existing != null) return existing;
|
var value = valueFactory(key);
|
Add(key, value, expireSeconds);
|
return value;
|
}
|
|
public T GetOrAdd<T>(string key, Func<string, T> valueFactory, int expireSeconds = -1) where T : class
|
{
|
var existing = Get<T>(key);
|
if (existing != null) return existing;
|
var value = valueFactory(key);
|
AddObject(key, value, expireSeconds);
|
return value;
|
}
|
|
#endregion
|
|
public void Dispose()
|
{
|
if (_disposed) return;
|
_disposed = true;
|
}
|
}
|
}
|
