Added support for memory cache and Redis cache

XIYUEKONGLING · XIYUEKONGLING · commit f92638e23421 · 2025-12-20T16:58:35.000+08:00
diff --git a/OpenBioCardServer/Controllers/Classic/ClassicUserController.cs b/OpenBioCardServer/Controllers/Classic/ClassicUserController.cs
@@ -1,5 +1,8 @@
+using System.Text.Json;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Caching.Distributed;
+using Microsoft.Extensions.Caching.Memory;
 using OpenBioCardServer.Data;
 using OpenBioCardServer.Models.DTOs.Classic;
 using OpenBioCardServer.Services;
@@ -14,23 +17,82 @@ public class ClassicUserController : ControllerBase
     private readonly AppDbContext _context;
     private readonly ClassicAuthService _authService;
     private readonly ILogger<ClassicUserController> _logger;
+    
+    // 缓存相关依赖
+    private readonly IMemoryCache _memoryCache;
+    private readonly IDistributedCache? _distributedCache;
+    private readonly IConfiguration _configuration;
+    
+    // 缓存配置字段
+    private readonly bool _useRedis;
+    private readonly int _expirationMinutes;
 
     public ClassicUserController(
         AppDbContext context,
         ClassicAuthService authService,
-        ILogger<ClassicUserController> logger)
+        ILogger<ClassicUserController> logger,
+        IMemoryCache memoryCache,
+        IConfiguration configuration,
+        IServiceProvider serviceProvider)
     {
         _context = context;
         _authService = authService;
         _logger = logger;
+        _memoryCache = memoryCache;
+        _configuration = configuration;
+        
+        // 读取缓存配置
+        _useRedis = configuration.GetValue<bool>("CacheSettings:UseRedis");
+        _expirationMinutes = configuration.GetValue<int>("CacheSettings:ExpirationMinutes", 5);
+        
+        // 如果启用了 Redis，尝试获取 IDistributedCache 服务
+        if (_useRedis)
+        {
+            _distributedCache = serviceProvider.GetService<IDistributedCache>();
+        }
     }
+    
+    // 生成统一的 Cache Key
+    private static string GetProfileCacheKey(string username) => 
+        $"Profile:{username.Trim().ToLowerInvariant()}";
 
     /// <summary>
     /// Get user profile (public endpoint)
     /// </summary>
     [HttpGet("{username}")]
     public async Task<IActionResult> GetProfile(string username)
     {
+        string cacheKey = GetProfileCacheKey(username);
+        ClassicProfile? cachedProfile = null;
+        
+        // 读取缓存
+        try
+        {
+            if (_useRedis && _distributedCache != null)
+            {
+                // Redis: 读取字符串并反序列化
+                var jsonStr = await _distributedCache.GetStringAsync(cacheKey);
+                if (!string.IsNullOrEmpty(jsonStr))
+                {
+                    cachedProfile = JsonSerializer.Deserialize<ClassicProfile>(jsonStr);
+                }
+            }
+            else
+            {
+                // Memory: 直接读取对象引用
+                _memoryCache.TryGetValue(cacheKey, out cachedProfile);
+            }
+            if (cachedProfile != null)
+            {
+                return Ok(cachedProfile);
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Cache read failed for {Key}", cacheKey);
+        }
+
+        
         try
         {
             var profile = await _context.Profiles
@@ -50,6 +112,32 @@ public async Task<IActionResult> GetProfile(string username)
             }
 
             var classicProfile = ClassicMapper.ToClassicProfile(profile);
+            
+            // 写入缓存
+            try 
+            {
+                if (_useRedis && _distributedCache != null)
+                {
+                    // Redis: 序列化为 JSON 存储
+                    var jsonStr = JsonSerializer.Serialize(classicProfile);
+                    await _distributedCache.SetStringAsync(cacheKey, jsonStr, new DistributedCacheEntryOptions
+                    {
+                        AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(_expirationMinutes)
+                    });
+                }
+                else
+                {
+                    // Memory: 存储对象引用 (带 Size 限制)
+                    _memoryCache.Set(cacheKey, classicProfile, new MemoryCacheEntryOptions()
+                        .SetAbsoluteExpiration(TimeSpan.FromMinutes(_expirationMinutes))
+                        .SetSlidingExpiration(TimeSpan.FromMinutes(2))
+                        .SetSize(1));
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Cache write failed for {Key}", cacheKey);
+            }
 
             return Ok(classicProfile);
         }
@@ -166,6 +254,24 @@ await _context.GalleryItems
 
             await _context.SaveChangesAsync();
             await transaction.CommitAsync();
+            
+            // 清除缓存
+            string cacheKey = GetProfileCacheKey(username);
+            try 
+            {
+                if (_useRedis && _distributedCache != null)
+                {
+                    await _distributedCache.RemoveAsync(cacheKey);
+                }
+                else
+                {
+                    _memoryCache.Remove(cacheKey);
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Cache removal failed for {Key}", cacheKey);
+            }
 
             _logger.LogInformation("Profile updated for user: {Username}", username);
 
diff --git a/OpenBioCardServer/OpenBioCardServer.csproj b/OpenBioCardServer/OpenBioCardServer.csproj
@@ -16,11 +16,14 @@
           <PrivateAssets>all</PrivateAssets>
           <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
         </PackageReference>
+        <PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="10.0.1" />
+        <PackageReference Include="Microsoft.Extensions.Caching.StackExchangeRedis" Version="10.0.1" />
         <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.1" />
         <PackageReference Include="Newtonsoft.Json" Version="13.0.4" />
         <PackageReference Include="Newtonsoft.Json.Bson" Version="1.0.3" />
         <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="10.0.0" />
         <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" />
     </ItemGroup>
 
diff --git a/OpenBioCardServer/Program.cs b/OpenBioCardServer/Program.cs
@@ -10,6 +10,8 @@
 using OpenBioCardServer.Models.Enums;
 using OpenBioCardServer.Services;
 using OpenBioCardServer.Utilities;
+using Microsoft.AspNetCore.ResponseCompression;
+using System.IO.Compression;
 
 namespace OpenBioCardServer;
 
@@ -77,7 +79,65 @@ await context.HttpContext.Response.WriteAsJsonAsync(new
 
         // Database configuration with validation
         builder.Services.AddDatabaseContext(builder.Configuration);
-        
+
+        // Cache Configuration (Memory & Redis)
+        var cacheSection = builder.Configuration.GetSection("CacheSettings");
+        var useRedis = cacheSection.GetValue<bool>("UseRedis");
+        var cacheSizeLimit = cacheSection.GetValue<long?>("ProfileCacheSizeLimit") ?? 100;
+        var redisInstanceName = cacheSection.GetValue<string>("InstanceName") ?? "OpenBioCard:";
+
+        // Configure Local Memory Cache (Always available, with OOM protection)
+        builder.Services.AddMemoryCache(options =>
+        {
+            options.SizeLimit = cacheSizeLimit;
+            options.CompactionPercentage = 0.2; // Free up 20% when limit is reached
+        });
+
+        // Configure Distributed Cache (Redis) if enabled
+        if (useRedis)
+        {
+            var redisConn = cacheSection.GetValue<string>("RedisConnectionString");
+            if (!string.IsNullOrEmpty(redisConn))
+            {
+                builder.Services.AddStackExchangeRedisCache(options =>
+                {
+                    options.Configuration = redisConn;
+                    options.InstanceName = redisInstanceName;
+                });
+            }
+        }
+
+        // Response Compression Configuration
+        var compressionSection = builder.Configuration.GetSection("CompressionSettings");
+        var enableCompression = compressionSection.GetValue<bool>("Enabled", true); // Default to true
+
+        if (enableCompression)
+        {
+            var enableForHttps = compressionSection.GetValue<bool>("EnableForHttps", true);
+            var compressionLevelStr = compressionSection.GetValue<string>("Level") ?? "Fastest";
+
+            // Parse Compression Level Enum
+            if (!Enum.TryParse(compressionLevelStr, true, out CompressionLevel compressionLevel))
+            {
+                compressionLevel = CompressionLevel.Fastest;
+            }
+
+            builder.Services.AddResponseCompression(options =>
+            {
+                options.EnableForHttps = enableForHttps;
+                options.Providers.Add<BrotliCompressionProvider>();
+                options.Providers.Add<GzipCompressionProvider>();
+                // Optional: Add MIME types if needed, defaults are usually fine for JSON/Text
+            });
+
+            // Configure Providers
+            builder.Services.Configure<BrotliCompressionProviderOptions>(options => 
+                options.Level = compressionLevel);
+            
+            builder.Services.Configure<GzipCompressionProviderOptions>(options => 
+                options.Level = compressionLevel);
+        }
+
         builder.Services.AddControllers()
             .AddNewtonsoftJson(options =>
             {
@@ -243,6 +303,13 @@ await context.HttpContext.Response.WriteAsJsonAsync(new
         }
 
         app.UseHttpsRedirection();
+
+        // Enable Response Compression Middleware
+        if (enableCompression)
+        {
+            app.UseResponseCompression();
+        }
+
         app.UseRateLimiter();
         app.UseCors("AllowFrontend");
         app.UseAuthorization();
diff --git a/OpenBioCardServer/appsettings.Development.json b/OpenBioCardServer/appsettings.Development.json
@@ -15,6 +15,18 @@
       "http://localhost:8787"
     ]
   },
+  "CacheSettings": {
+    "UseRedis": false,
+    "RedisConnectionString": "localhost:6379",
+    "InstanceName": "OpenBioCard:",
+    "ProfileCacheSizeLimit": 200,
+    "ExpirationMinutes": 5
+  },
+  "CompressionSettings": {
+    "Enabled": true,
+    "EnableForHttps": true,
+    "Level": "Fastest"
+  },
   "AuthSettings": {
     "RootUsername": "root",
     "RootPassword": "password"
diff --git a/OpenBioCardServer/appsettings.json b/OpenBioCardServer/appsettings.json
@@ -15,6 +15,18 @@
       "https://example.com/"
     ]
   },
+  "CacheSettings": {
+    "UseRedis": false,
+    "RedisConnectionString": "localhost:6379",
+    "InstanceName": "OpenBioCard:",
+    "ProfileCacheSizeLimit": 300,
+    "ExpirationMinutes": 30
+  },
+  "CompressionSettings": {
+    "Enabled": true,
+    "EnableForHttps": true,
+    "Level": "Fastest"
+  },
   "AuthSettings": {
     "RootUsername": "root",
     "RootPassword": "change_me_in_production_env_vars"
