Optimized cache-related code to fix database cache penetration issue

XIYUEKONGLING · XIYUEKONGLING · commit a547f4879900 · 2025-12-21T13:32:59.000+08:00
diff --git a/OpenBioCardServer/Configuration/CacheSettings.cs b/OpenBioCardServer/Configuration/CacheSettings.cs
@@ -5,11 +5,29 @@ public class CacheSettings
     public const string SectionName = "CacheSettings";
 
     public bool Enabled { get; set; } = true;
+    
+    // Redis
     public bool UseRedis { get; set; } = false;
     public string? RedisConnectionString { get; set; }
     public string InstanceName { get; set; } = "OpenBioCard:";
+    
+    // Memory
     public long? CacheSizeLimit { get; set; }
+    public double CompactionPercentage { get; set; } = 0.2;
+
     public int ExpirationMinutes { get; set; } = 30;
     public int SlidingExpirationMinutes { get; set; } = 5;
-    public double CompactionPercentage { get; set; } = 0.2;
+    
+    // 工厂软超时 (毫秒)
+    public int FactorySoftTimeoutMilliseconds { get; set; } = 500;
+
+    // 故障兜底 (Fail-Safe) 配置
+    public bool EnableFailSafe { get; set; } = true;
+    public int FailSafeMaxDurationMinutes { get; set; } = 120;
+    
+    // 故障节流时间 (秒)
+    public int FailSafeThrottleDurationSeconds { get; set; } = 30;
+
+    // 分布式缓存熔断时间 (秒)
+    public int DistributedCacheCircuitBreakerDurationSeconds { get; set; } = 2;
 }
diff --git a/OpenBioCardServer/Configuration/CacheSettingsValidator.cs b/OpenBioCardServer/Configuration/CacheSettingsValidator.cs
@@ -14,37 +14,43 @@ public ValidateOptionsResult Validate(string? name, CacheSettings options)
         var failures = new List<string>();
 
         if (options.CacheSizeLimit <= 0)
-        {
             failures.Add("CacheSizeLimit must be greater than 0.");
-        }
 
         if (options.ExpirationMinutes <= 0)
-        {
             failures.Add("ExpirationMinutes must be greater than 0.");
-        }
 
         if (options.SlidingExpirationMinutes <= 0)
-        {
             failures.Add("SlidingExpirationMinutes must be greater than 0.");
-        }
         
         if (options.CompactionPercentage < 0 || options.CompactionPercentage > 1)
-        {
             failures.Add("CompactionPercentage must be between 0 and 1.");
-        }
 
-        if (options.UseRedis && string.IsNullOrWhiteSpace(options.RedisConnectionString))
+        if (options.FactorySoftTimeoutMilliseconds <= 0)
+            failures.Add("FactorySoftTimeoutMilliseconds must be greater than 0.");
+
+        if (options.EnableFailSafe)
         {
-            failures.Add("RedisConnectionString cannot be empty when UseRedis is true.");
+            if (options.FailSafeMaxDurationMinutes <= 0)
+                failures.Add("FailSafeMaxDurationMinutes must be greater than 0 when FailSafe is enabled.");
+            
+            if (options.FailSafeThrottleDurationSeconds <= 0)
+                failures.Add("FailSafeThrottleDurationSeconds must be greater than 0 when FailSafe is enabled.");
         }
 
-        if (options.UseRedis && string.IsNullOrWhiteSpace(options.InstanceName))
+        if (options.DistributedCacheCircuitBreakerDurationSeconds <= 0)
+            failures.Add("DistributedCacheCircuitBreakerDurationSeconds must be greater than 0.");
+
+        if (options.UseRedis)
         {
-            failures.Add("InstanceName cannot be empty when UseRedis is true.");
+            if (string.IsNullOrWhiteSpace(options.RedisConnectionString))
+                failures.Add("RedisConnectionString cannot be empty when UseRedis is true.");
+
+            if (string.IsNullOrWhiteSpace(options.InstanceName))
+                failures.Add("InstanceName cannot be empty when UseRedis is true.");
         }
 
         return failures.Count > 0 
             ? ValidateOptionsResult.Fail(failures) 
             : ValidateOptionsResult.Success;
     }
-}
+}
diff --git a/OpenBioCardServer/Constants/CacheKeys.cs b/OpenBioCardServer/Constants/CacheKeys.cs
@@ -0,0 +1,6 @@
+namespace OpenBioCardServer.Constants;
+
+public class CacheKeys
+{
+    
+}
diff --git a/OpenBioCardServer/Controllers/Classic/ClassicSettingsController.cs b/OpenBioCardServer/Controllers/Classic/ClassicSettingsController.cs
@@ -10,6 +10,7 @@
 using OpenBioCardServer.Models.Enums;
 using OpenBioCardServer.Services;
 using OpenBioCardServer.Utilities.Mappers;
+using ZiggyCreatures.Caching.Fusion;
 
 namespace OpenBioCardServer.Controllers.Classic;
 
@@ -19,7 +20,7 @@ public class ClassicSettingsController : ControllerBase
 {
     private readonly AppDbContext _context;
     private readonly ClassicAuthService _authService;
-    private readonly ICacheService _cacheService;
+    private readonly IFusionCache _cache;
     private readonly ILogger<ClassicSettingsController> _logger;
     
     // 缓存 Key 常量
@@ -28,12 +29,12 @@ public class ClassicSettingsController : ControllerBase
     public ClassicSettingsController(
         AppDbContext context,
         ClassicAuthService authService,
-        ICacheService cacheService,
+        IFusionCache cache,
         ILogger<ClassicSettingsController> logger)
     {
         _context = context;
         _authService = authService;
-        _cacheService = cacheService;
+        _cache = cache;
         _logger = logger;
     }
 
@@ -46,17 +47,19 @@ public async Task<IActionResult> GetPublicSettings()
     {
         try
         {
-            var response = await _cacheService.GetOrCreateAsync(PublicSettingsCacheKey, async () =>
-            {
-                var settings = await _context.SystemSettings.FindAsync(1);
-                return new ClassicSystemSettingsResponse
+            var response = await _cache.GetOrSetAsync<ClassicSystemSettingsResponse>(
+                PublicSettingsCacheKey, 
+                async (ctx, token) =>
                 {
-                    Title = settings?.Title ?? "OpenBioCard",
-                    Logo = settings?.LogoType.HasValue == true
-                        ? ClassicMapper.AssetToString(settings.LogoType.Value, settings.LogoText, settings.LogoData)
-                        : string.Empty
-                };
-            });
+                    var settings = await _context.SystemSettings.FindAsync(new object[] { 1 }, token);
+                    return new ClassicSystemSettingsResponse
+                    {
+                        Title = settings?.Title ?? "OpenBioCard",
+                        Logo = settings?.LogoType.HasValue == true
+                            ? ClassicMapper.AssetToString(settings.LogoType.Value, settings.LogoText, settings.LogoData)
+                            : string.Empty
+                    };
+                });
             
             return Ok(response);
         }
@@ -178,7 +181,7 @@ public async Task<IActionResult> UpdateSettings([FromBody] ClassicUpdateSettings
             await _context.SaveChangesAsync();
 
             // 更新成功后清除公共设置的缓存以确保前端获取到最新数据
-            await _cacheService.RemoveAsync(PublicSettingsCacheKey);
+            await _cache.RemoveAsync(PublicSettingsCacheKey);
 
             _logger.LogInformation("Admin {Username} updated system settings", request.Username);
 
diff --git a/OpenBioCardServer/Controllers/ProfileController.cs b/OpenBioCardServer/Controllers/ProfileController.cs
@@ -6,6 +6,7 @@
 using OpenBioCardServer.Models.Entities;
 using OpenBioCardServer.Services;
 using OpenBioCardServer.Utilities.Mappers;
+using ZiggyCreatures.Caching.Fusion;
 
 namespace OpenBioCardServer.Controllers;
 
@@ -15,13 +16,13 @@ public class ProfileController : ControllerBase
 {
     private readonly AppDbContext _context;
     private readonly AuthService _authService;
-    private readonly ICacheService _cacheService;
+    private readonly IFusionCache _cacheService;
     private readonly ILogger<ProfileController> _logger;
 
     public ProfileController(
         AppDbContext context,
         AuthService authService,
-        ICacheService cacheService,
+        IFusionCache cacheService,
         ILogger<ProfileController> logger)
     {
         _context = context;
@@ -44,21 +45,22 @@ public async Task<ActionResult<ProfileDto>> GetProfile(string username)
 
         try
         {
-            var profileDto = await _cacheService.GetOrCreateAsync(cacheKey, async () =>
-            {
-                var profile = await _context.Profiles
-                    .AsNoTracking()
-                    .AsSplitQuery()
-                    .Include(p => p.Contacts)
-                    .Include(p => p.SocialLinks)
-                    .Include(p => p.Projects)
-                    .Include(p => p.WorkExperiences)
-                    .Include(p => p.SchoolExperiences)
-                    .Include(p => p.Gallery)
-                    .FirstOrDefaultAsync(p => p.Username == username);
-
-                return profile == null ? null : DataMapper.ToProfileDto(profile);
-            });
+            var profileDto = await _cacheService.GetOrSetAsync<ProfileDto?>(
+                cacheKey, 
+                async (ctx, token) =>
+                {
+                    var profile = await _context.Profiles
+                        .AsNoTracking()
+                        .AsSplitQuery()
+                        .Include(p => p.Contacts)
+                        .Include(p => p.SocialLinks)
+                        .Include(p => p.Projects)
+                        .Include(p => p.WorkExperiences)
+                        .Include(p => p.SchoolExperiences)
+                        .Include(p => p.Gallery)
+                        .FirstOrDefaultAsync(p => p.Username == username, token); // 传入 token
+                    return profile == null ? null : DataMapper.ToProfileDto(profile);
+                });
 
             if (profileDto == null)
             {
diff --git a/OpenBioCardServer/OpenBioCardServer.csproj b/OpenBioCardServer/OpenBioCardServer.csproj
@@ -25,6 +25,10 @@
         <PackageReference Include="Pomelo.EntityFrameworkCore.MySql" Version="9.0.0" />
         <PackageReference Include="StackExchange.Redis" Version="2.10.1" />
         <PackageReference Include="System.Text.Json" Version="10.0.1" />
+        <PackageReference Include="ZiggyCreatures.FusionCache" Version="2.4.0" />
+        <PackageReference Include="ZiggyCreatures.FusionCache.Backplane.StackExchangeRedis" Version="2.4.0" />
+        <PackageReference Include="ZiggyCreatures.FusionCache.Serialization.NewtonsoftJson" Version="2.4.0" />
+        <PackageReference Include="ZiggyCreatures.FusionCache.Serialization.SystemTextJson" Version="2.4.0" />
     </ItemGroup>
 
     <ItemGroup>
diff --git a/OpenBioCardServer/Program.cs b/OpenBioCardServer/Program.cs
@@ -15,6 +15,8 @@
 using OpenBioCardServer.Constants;
 using OpenBioCardServer.Interfaces;
 using OpenBioCardServer.Structs.ENums;
+using ZiggyCreatures.Caching.Fusion;
+using ZiggyCreatures.Caching.Fusion.Serialization.SystemTextJson;
 
 namespace OpenBioCardServer;
 
@@ -246,21 +248,70 @@ private static void ConfigureCacheService(WebApplicationBuilder builder)
     {
         var cacheSettings = builder.Configuration.GetSection(CacheSettings.SectionName).Get<CacheSettings>() ?? new CacheSettings();
 
+        if (!cacheSettings.Enabled)
+        {
+            Console.WriteLine("==> Cache is DISABLED via configuration.");
+            
+            builder.Services.AddFusionCache()
+                .WithDefaultEntryOptions(new FusionCacheEntryOptions
+                {
+                    Duration = TimeSpan.Zero,
+                    IsFailSafeEnabled = false,
+                    FactorySoftTimeout = Timeout.InfiniteTimeSpan,
+                    AllowBackgroundDistributedCacheOperations = false
+                });
+                
+            return;
+        }
+        
         builder.Services.AddMemoryCache(options =>
         {
             options.SizeLimit = cacheSettings.CacheSizeLimit ?? 100;
             options.CompactionPercentage = cacheSettings.CompactionPercentage;
         });
 
-        if (cacheSettings.UseRedis && !string.IsNullOrEmpty(cacheSettings.RedisConnectionString))
+        var fusionBuilder = builder.Services.AddFusionCache()
+            .WithOptions(options =>
+            {
+                options.DistributedCacheCircuitBreakerDuration = TimeSpan.FromSeconds(cacheSettings.DistributedCacheCircuitBreakerDurationSeconds);
+            })
+            .WithDefaultEntryOptions(new FusionCacheEntryOptions
+            {
+                Duration = TimeSpan.FromMinutes(cacheSettings.ExpirationMinutes),
+                
+                FactorySoftTimeout = TimeSpan.FromMilliseconds(cacheSettings.FactorySoftTimeoutMilliseconds),
+                
+                IsFailSafeEnabled = cacheSettings.EnableFailSafe,
+                FailSafeMaxDuration = TimeSpan.FromMinutes(cacheSettings.FailSafeMaxDurationMinutes),
+                FailSafeThrottleDuration = TimeSpan.FromSeconds(30),
+            })
+            .WithSerializer(new FusionCacheSystemTextJsonSerializer());
+        
+        // 根据配置决定是否启用 Redis 和 Backplane
+        if (cacheSettings.Enabled && cacheSettings.UseRedis && !string.IsNullOrEmpty(cacheSettings.RedisConnectionString))
         {
             builder.Services.AddStackExchangeRedisCache(options =>
             {
                 options.Configuration = cacheSettings.RedisConnectionString;
                 options.InstanceName = cacheSettings.InstanceName;
             });
+            
+            // 将 Redis 注册为 FusionCache 的二级缓存
+            fusionBuilder.WithRegisteredDistributedCache();
+            
+            // 注册 Redis Backplane (用于集群缓存同步)
+            fusionBuilder.WithStackExchangeRedisBackplane(options =>
+            {
+                options.Configuration = cacheSettings.RedisConnectionString;
+            });
+            
+            Console.WriteLine("==> FusionCache configured with Redis L2 & Backplane.");
+        }
+        else
+        {
+            Console.WriteLine("==> FusionCache configured in Memory-Only mode.");
         }
-        builder.Services.AddSingleton<ICacheService, CacheService>();
+        // builder.Services.AddSingleton<ICacheService, CacheService>();
     }
 
     private static void ConfigureCompressionService(WebApplicationBuilder builder)
diff --git a/OpenBioCardServer/Services/ClassicProfileService.cs b/OpenBioCardServer/Services/ClassicProfileService.cs
@@ -3,22 +3,23 @@
 using OpenBioCardServer.Interfaces;
 using OpenBioCardServer.Models.DTOs.Classic;
 using OpenBioCardServer.Utilities.Mappers;
+using ZiggyCreatures.Caching.Fusion;
 
 namespace OpenBioCardServer.Services;
 
 public class ClassicProfileService
 {
     private readonly AppDbContext _context;
-    private readonly ICacheService _cacheService;
+    private readonly IFusionCache _cache; 
     private readonly ILogger<ClassicProfileService> _logger;
 
     public ClassicProfileService(
         AppDbContext context,
-        ICacheService cacheService,
+        IFusionCache cache,
         ILogger<ClassicProfileService> logger)
     {
         _context = context;
-        _cacheService = cacheService;
+        _cache = cache;
         _logger = logger;
     }
 
@@ -32,21 +33,22 @@ private static string GetProfileCacheKey(string username) =>
     {
         var cacheKey = GetProfileCacheKey(username);
 
-        return await _cacheService.GetOrCreateAsync(cacheKey, async () =>
-        {
-            var profile = await _context.Profiles
-                .AsNoTracking()
-                .AsSplitQuery()
-                .Include(p => p.Contacts)
-                .Include(p => p.SocialLinks)
-                .Include(p => p.Projects)
-                .Include(p => p.WorkExperiences)
-                .Include(p => p.SchoolExperiences)
-                .Include(p => p.Gallery)
-                .FirstOrDefaultAsync(p => p.Username == username);
-
-            return profile == null ? null : ClassicMapper.ToClassicProfile(profile);
-        });
+        return await _cache.GetOrSetAsync<ClassicProfile?>(
+            cacheKey, 
+            async (ctx, token) =>
+            {
+                var profile = await _context.Profiles
+                    .AsNoTracking()
+                    .AsSplitQuery()
+                    .Include(p => p.Contacts)
+                    .Include(p => p.SocialLinks)
+                    .Include(p => p.Projects)
+                    .Include(p => p.WorkExperiences)
+                    .Include(p => p.SchoolExperiences)
+                    .Include(p => p.Gallery)
+                    .FirstOrDefaultAsync(p => p.Username == username, token); // 传入 token
+                return profile == null ? null : ClassicMapper.ToClassicProfile(profile);
+            });
     }
 
     /// <summary>
@@ -121,7 +123,7 @@ public async Task<bool> UpdateProfileAsync(string username, ClassicProfile reque
             await transaction.CommitAsync();
 
             // 4. Invalidate Cache
-            await _cacheService.RemoveAsync(GetProfileCacheKey(username));
+            await _cache.RemoveAsync(GetProfileCacheKey(username));
             
             _logger.LogInformation("Profile updated successfully for user: {Username}", username);
             return true;
diff --git a/OpenBioCardServer/appsettings.Development.json b/OpenBioCardServer/appsettings.Development.json
diff --git a/OpenBioCardServer/appsettings.json b/OpenBioCardServer/appsettings.json

-Original file line number
+Diff line change
@@ @@ -0,0 +1,6 @@ @@
 +namespace OpenBioCardServer.Constants;
++
 +public class CacheKeys
 +{
++
 +}