[feat]完善字典，配置缓存预热相关代码。

AlphaYu · Jun 26, 2022 · 777252a · 777252a
1 parent d879a83
commit 777252a
Show file tree

Hide file tree

Showing 3 changed files with 123 additions and 6 deletions.
diff --git a/src/ServerApi/Services/Adnc.Maint/Adnc.Maint.Application/BloomFilters/CacheKeyBloomFilter.cs b/src/ServerApi/Services/Adnc.Maint/Adnc.Maint.Application/BloomFilters/CacheKeyBloomFilter.cs
@@ -27,9 +27,23 @@ public override async Task InitAsync()
         var exists = await ExistsBloomFilterAsync();
         if (!exists)
         {
-            var values = new List<string>()
-            {
-            };
+            var values = new List<string>();
+            using var scope = _serviceProvider.Value.CreateScope();
+            var dictRepository = scope.ServiceProvider.GetRequiredService<IEfRepository<SysDict>>();
+            var dictIds = await dictRepository
+                .Where(x => x.Pid == 0)
+                .Select(x => x.Id)
+                .ToListAsync();
+            if (dictIds.IsNotNullOrEmpty())
+                values.AddRange(dictIds.Select(x => string.Concat(CachingConsts.DictSingleKeyPrefix, CachingConsts.LinkChar, x)));
+
+            var cfgRepository = scope.ServiceProvider.GetRequiredService<IEfRepository<SysDict>>();
+            var cfgIds = await dictRepository
+                .GetAll()
+                .Select(x => x.Id)
+                .ToListAsync();
+            if (cfgIds.IsNotNullOrEmpty())
+                values.AddRange(cfgIds.Select(x => string.Concat(CachingConsts.CfgSingleKeyPrefix, CachingConsts.LinkChar, x)));
 
             await InitAsync(values);
         }

diff --git a/src/ServerApi/Services/Adnc.Maint/Adnc.Maint.Application/Caching/CacheService.cs b/src/ServerApi/Services/Adnc.Maint/Adnc.Maint.Application/Caching/CacheService.cs
@@ -1,14 +1,114 @@
-namespace Adnc.Maint.Application.Services.Caching;
+using Adnc.Infra.Core.Interfaces;
+
+namespace Adnc.Maint.Application.Services.Caching;
 
 public sealed class CacheService : AbstractCacheService, ICachePreheatable
 {
-    public CacheService(Lazy<ICacheProvider> cacheProvider, Lazy<IServiceProvider> serviceProvider)
+    private Lazy<IDistributedLocker> _dictributeLocker;
+    private ILogger<CacheService> _logger;
+
+    public CacheService(
+        Lazy<ICacheProvider> cacheProvider,
+        Lazy<IDistributedLocker> dictributeLocker,
+        Lazy<IServiceProvider> serviceProvider,
+         ILogger<CacheService> logger)
         : base(cacheProvider, serviceProvider)
     {
+        _dictributeLocker = dictributeLocker;
+        _logger = logger;
     }
 
     public override async Task PreheatAsync()
     {
-        await Task.CompletedTask;
+        await PreheatAllDictsAsync();
+        await PreheatAllCfgsAsync();
+    }
+
+    private async Task PreheatAllDictsAsync()
+    {
+        var exists = await CacheProvider.Value.ExistsAsync(CachingConsts.DictPreheatedKey);
+        if (exists)
+            return;
+
+        var flag = await _dictributeLocker.Value.LockAsync(CachingConsts.DictPreheatedKey);
+        if (!flag.Success)
+        {
+            await Task.Delay(500);
+            await PreheatAllDictsAsync();
+        }
+
+        using var scope = ServiceProvider.Value.CreateScope();
+        var dictRepository = scope.ServiceProvider.GetRequiredService<IEfRepository<SysDict>>();
+        var dictEntities = await dictRepository.GetAll().ToListAsync();
+        if (dictEntities.IsNullOrEmpty())
+            return;
+
+        var parentEntities = dictEntities.Where(x => x.Pid == 0).ToList();
+        var childrenEntities = dictEntities.Where(x => x.Pid > 0).ToList();
+        var parentDtos = Mapper.Value.Map<List<DictDto>>(parentEntities);
+        var childrenDtos = Mapper.Value.Map<List<DictDto>>(childrenEntities);
+
+        _logger.LogInformation($"start preheat {CachingConsts.DictSingleKeyPrefix}");
+        var cahceDictionary = new Dictionary<string, DictDto>();
+        for (var index = 1; index <= parentDtos.Count; index++)
+        {
+            var dto = parentDtos[index - 1];
+            var subDtos = childrenDtos?.Where(x => x.Pid == dto.Id).ToList();
+            if (subDtos.IsNotNullOrEmpty())
+            {
+                dto.Children = subDtos;
+            }
+
+            var cacheKey = ConcatCacheKey(CachingConsts.DictSingleKeyPrefix, dto.Id);
+            cahceDictionary.Add(cacheKey, dto);
+            if (index % 50 == 0 || index == parentDtos.Count)
+            {
+                await CacheProvider.Value.SetAllAsync(cahceDictionary, TimeSpan.FromSeconds(CachingConsts.OneMonth));
+                cahceDictionary.Clear();
+            }
+        }
+
+        var serverInfo = ServiceProvider.Value.GetService<IServiceInfo>();
+        await CacheProvider.Value.SetAsync(CachingConsts.DictPreheatedKey, serverInfo.Version, TimeSpan.FromSeconds(CachingConsts.OneYear));
+        _logger.LogInformation($"finished({parentDtos.Count}) preheat {CachingConsts.DictSingleKeyPrefix}");
+    }
+
+    private async Task PreheatAllCfgsAsync()
+    {
+        var exists = await CacheProvider.Value.ExistsAsync(CachingConsts.CfgPreheatedKey);
+        if (exists)
+            return;
+
+        var flag = await _dictributeLocker.Value.LockAsync(CachingConsts.CfgPreheatedKey);
+        if (!flag.Success)
+        {
+            await Task.Delay(500);
+            await PreheatAllCfgsAsync();
+        }
+
+        using var scope = ServiceProvider.Value.CreateScope();
+        var cfgRepository = scope.ServiceProvider.GetRequiredService<IEfRepository<SysCfg>>();
+        var cfgEntities = await cfgRepository.GetAll().ToListAsync();
+        if (cfgEntities.IsNullOrEmpty())
+            return;
+
+        var cfgDtos = Mapper.Value.Map<List<CfgDto>>(cfgEntities);
+        _logger.LogInformation($"start preheat {CachingConsts.CfgSingleKeyPrefix}");
+        var cahceDictionary = new Dictionary<string, CfgDto>();
+        for (var index = 1; index <= cfgDtos.Count; index++)
+        {
+            var dto = cfgDtos[index - 1];
+            var cacheKey = ConcatCacheKey(CachingConsts.CfgSingleKeyPrefix, dto.Id);
+            cahceDictionary.Add(cacheKey, dto);
+            if (index % 50 == 0 || index == cfgDtos.Count)
+            {
+                await CacheProvider.Value.SetAllAsync(cahceDictionary, TimeSpan.FromSeconds(CachingConsts.OneMonth));
+                cahceDictionary.Clear();
+            }
+        }
+
+        var serverInfo = ServiceProvider.Value.GetService<IServiceInfo>();
+        await CacheProvider.Value.SetAsync(CachingConsts.CfgPreheatedKey, serverInfo.Version, TimeSpan.FromSeconds(CachingConsts.OneYear));
+        _logger.LogInformation($"finished({cfgDtos.Count}) preheat {CachingConsts.CfgSingleKeyPrefix}");
     }
 }
diff --git a/src/ServerApi/Services/Shared/Adnc.Shared/Consts/Caching/CachingConsts.Maint.cs b/src/ServerApi/Services/Shared/Adnc.Shared/Consts/Caching/CachingConsts.Maint.cs
@@ -2,6 +2,9 @@
 
 public class CachingConsts : Common.CachingConsts
 {
+    public const string DictPreheatedKey = "adnc:maint:dicts:preheated";
+    public const string CfgPreheatedKey = "adnc:maint:cfgs:preheated";
+
     public const string DictSingleKeyPrefix = "adnc:maint:dicts:single";
     public const string CfgSingleKeyPrefix = "adnc:maint:cfgs:single";