midway-fatcms 0.0.1-beta.64 → 0.0.1-beta.66

package/src/service/base/cache/CacheServiceFactory.ts

@@ -0,0 +1,66 @@
+import { Inject, Provide, Config } from '@midwayjs/core';
+import { Context } from '@midwayjs/koa';
+import { ICacheServiceBase, IfatcmsCacheConfig } from '@/models/bizmodels';
+import { CacheLevelEnum, CacheNameEnum } from '@/models/SystemEntities';
+import { RedisService } from '@midwayjs/redis';
+import { FatcmsBaseCtxCache } from './FatcmsBaseCtxCache';
+import { FatcmsBaseRedisCache } from './FatcmsBaseRedisCache';
+import { FatcmsBaseDiskCache } from './FatcmsBaseDiskCache';
+import { FatcmsBaseMemoryCache } from './FatcmsBaseMemoryCache';
+import { FatcmsBaseNoneCache } from './FatcmsBaseNoneCache';
+
+interface IGetJsonObjectCacheParam {
+    cacheLevel: CacheLevelEnum;
+    cacheName: CacheNameEnum;
+    cacheKey: string;
+    cacheSecond: number;
+    refreshCache?: boolean;
+    getter: () => Promise<any>;
+}
+
+@Provide()
+export class CacheServiceFactory {
+    @Inject()
+    protected ctx: Context;
+
+    @Config('fatcmsCache')
+    private fatcmsCache: IfatcmsCacheConfig;
+
+    @Inject()
+    protected redisService: RedisService;
+
+    public getCacheService(cacheLevelEnum: CacheLevelEnum, cacheName: CacheNameEnum): ICacheServiceBase {
+        switch (cacheLevelEnum) {
+            case CacheLevelEnum.CONTEXT:
+                return new FatcmsBaseCtxCache(this.ctx, cacheName);
+            case CacheLevelEnum.REDIS:
+                return new FatcmsBaseRedisCache(this.ctx, cacheName, this.redisService);
+            case CacheLevelEnum.DISK:
+                return new FatcmsBaseDiskCache(this.ctx, cacheName, this.fatcmsCache);
+            case CacheLevelEnum.MEMORY:
+                return new FatcmsBaseMemoryCache(this.ctx, cacheName);
+            default:
+                return new FatcmsBaseNoneCache(this.ctx, cacheName);
+        }
+    }
+
+    public async getJsonObjectCache(param: IGetJsonObjectCacheParam): Promise<any> {
+        let { cacheLevel, cacheName, cacheKey, cacheSecond, refreshCache, getter } = param;
+
+        if (!cacheSecond || typeof cacheSecond !== 'number') {
+            console.error('[CacheServiceFactory#getJsonObjectCache] cacheSecond is not number, use default value 60, ' + JSON.stringify(param));
+            cacheSecond = 60;
+        }
+
+        const realCacheKey = this.fatcmsCache.keyPrefix + cacheKey;
+
+        const cacheService = this.getCacheService(cacheLevel, cacheName);
+        let obj = cacheService.getJsonObject(realCacheKey);
+        if (!obj || refreshCache === true) {
+            obj = await getter();
+            cacheService.setJsonObject(realCacheKey, obj, cacheSecond);
+        }
+        return obj;
+    }
+
+}

package/src/service/base/cache/FatcmsBaseCtxCache.ts

@@ -0,0 +1,47 @@
+import { ICacheServiceBase } from '@/models/bizmodels';
+import { CacheNameEnum } from '@/models/SystemEntities';
+import { Context } from '@midwayjs/koa';
+
+
+
+export class FatcmsBaseCtxCache implements ICacheServiceBase {
+    private ctx: Context;
+    private cacheName: CacheNameEnum;
+
+    constructor(ctx: Context, cacheName: CacheNameEnum) {
+        this.ctx = ctx;
+        this.cacheName = cacheName;
+    }
+
+    private getCacheMap(): Map<string, any> {
+        if (!this.ctx.baseCtxCacheMap) {
+            this.ctx.baseCtxCacheMap = new Map();
+        }
+        if (!this.ctx.baseCtxCacheMap.has(this.cacheName)) {
+            this.ctx.baseCtxCacheMap.set(this.cacheName, new Map());
+        }
+        return this.ctx.baseCtxCacheMap.get(this.cacheName);
+    }
+
+    async getJsonObject(key: string): Promise<any> {
+        const cacheMap = this.getCacheMap();
+        return cacheMap.get(key);
+    }
+
+    /**
+     * 设置缓存对象
+     * @param key
+     * @param obj
+     * @param expireSecond 过期时间，单位秒
+     * @returns
+     */
+    async setJsonObject(key: string, obj: any, expireSecond?: number): Promise<any> {
+        const cacheMap = this.getCacheMap();
+        cacheMap.set(key, obj);
+    }
+
+    async removeItem(key: string): Promise<any> {
+        const cacheMap = this.getCacheMap();
+        cacheMap.delete(key);
+    }
+}

package/src/service/base/cache/FatcmsBaseDiskCache.ts

@@ -0,0 +1,87 @@
+import { Context } from '@midwayjs/koa';
+import * as md5 from 'md5';
+import * as fs from 'fs/promises';
+import * as fs2 from 'fs';
+import * as path from 'path';
+import { parseJsonObject } from '../../../libs/utils/functions';
+import { ICacheServiceBase, IfatcmsCacheConfig } from '@/models/bizmodels';
+
+
+export class FatcmsBaseDiskCache implements ICacheServiceBase {
+    protected ctx: Context;
+    protected cacheName: string;
+    private fatcmsCache: IfatcmsCacheConfig;
+
+    constructor(ctx: Context, cacheName: string, fatcmsCache: IfatcmsCacheConfig) {
+        this.ctx = ctx;
+        this.cacheName = cacheName;
+        this.fatcmsCache = fatcmsCache;
+    }
+
+
+    /**
+     * 获取缓存文件路径
+     * @param key
+     * @returns
+     */
+    private async getCacheFilePath(key: string, checkDirExist: boolean = true): Promise<string> {
+        const cacheDir0 = this.fatcmsCache.diskCacheDir;
+        const cacheDir = path.join(cacheDir0, this.cacheName);
+        if (checkDirExist) {
+            const isDirExist = await fs2.promises.access(cacheDir).then(() => true, () => false);
+            if (!isDirExist) {
+                await fs2.promises.mkdir(cacheDir, { recursive: true });    
+            }
+        }
+        return path.join(cacheDir, `${md5(key)}.json`);
+    }
+
+    async getJsonObject(key: string): Promise<any> {
+        const cacheFilePath = await this.getCacheFilePath(key, false);
+        try {
+            const str = await fs.readFile(cacheFilePath, 'utf8');
+            const data = parseJsonObject(str);
+            if (data && data.key === key && data.expireAt > Date.now()) {
+                return data.data;
+            }
+            return null;
+        } catch (error) {
+            return null;
+        }
+    }
+
+    /**
+     * 设置缓存对象
+     * @param key
+     * @param obj
+     * @param expireSecond 过期时间，单位秒
+     * @returns
+     */
+    async setJsonObject(key: string, obj: any, expireSecond?: number): Promise<any> {
+        if (!expireSecond) {
+            expireSecond = 60;
+        }
+        const str = JSON.stringify({
+            data: obj,
+            key,
+            expireAt: Date.now() + expireSecond * 1000,
+        });
+        const cacheFilePath = await this.getCacheFilePath(key);
+        try {
+            await fs.writeFile(cacheFilePath, str, 'utf8');
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    async removeItem(key: string): Promise<any> {
+        const cacheFilePath = await this.getCacheFilePath(key);
+        try {
+            await fs.unlink(cacheFilePath);
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+}

package/src/service/base/cache/FatcmsBaseMemoryCache.ts

@@ -0,0 +1,74 @@
+import { Context } from '@midwayjs/koa';
+import { LRUCache } from 'lru-cache';
+import { ICacheServiceBase } from '@/models/bizmodels';
+
+
+
+const LRU_CACHE_MAP = new Map<string, LRUCache<string, any>>();
+
+
+export class FatcmsBaseMemoryCache implements ICacheServiceBase {
+    protected ctx: Context;
+    protected cacheName: string;
+
+    constructor(ctx: Context, cacheName: string) {
+        this.ctx = ctx;
+        this.cacheName = cacheName;
+    }
+
+    private getLruCache(): LRUCache<string, any> {
+        if (!LRU_CACHE_MAP.has(this.cacheName)) {
+            const lruCache = new LRUCache<string, any>({
+                max: 500,
+                ttl: 1000 * 60 * 60 * 24,
+                ttlAutopurge: true,
+            });
+            LRU_CACHE_MAP.set(this.cacheName, lruCache);
+        }
+        return LRU_CACHE_MAP.get(this.cacheName);
+    }
+
+    async getJsonObject(key: string): Promise<any> {
+        try {
+            const lruCache = this.getLruCache();
+            const saveObj = lruCache.get(key);
+            if (saveObj && saveObj.key === key && saveObj.expireAt > Date.now()) {
+                return saveObj.data;
+            }
+            return null;
+        } catch (error) {
+            return null;
+        }
+    }
+
+    /**
+     * 设置缓存对象
+     * @param key
+     * @param obj
+     * @param expireSecond 过期时间，单位秒
+     * @returns
+     */
+    async setJsonObject(key: string, obj: any, expireSecond?: number): Promise<any> {
+        const lruCache = this.getLruCache();
+        if (!expireSecond) {
+            expireSecond = 60;
+        }
+        const saveObj = {
+            data: obj,
+            key,
+            expireAt: Date.now() + expireSecond * 1000,
+        };
+        lruCache.set(key, saveObj);
+        return true;
+    }
+
+    async removeItem(key: string): Promise<any> {
+        try {
+            const lruCache = this.getLruCache();
+            lruCache.delete(key);
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+}

package/src/service/base/cache/FatcmsBaseNoneCache.ts

@@ -0,0 +1,24 @@
+import { ICacheServiceBase } from '@/models/bizmodels';
+import { Context } from '@midwayjs/koa';
+
+export class FatcmsBaseNoneCache implements ICacheServiceBase {
+    protected ctx: Context;
+    protected cacheName: string;
+   
+    constructor(ctx: Context, cacheName: string) {
+        this.ctx = ctx;
+        this.cacheName = cacheName;
+    }
+
+    async getJsonObject(key: string): Promise<any> {
+       return null;
+    }
+
+    async setJsonObject(key: string, obj: any, expireSecond?: number): Promise<any> {
+        return true;
+    }
+
+    async removeItem(key: string): Promise<any> {
+       return true;
+    }
+}

package/src/service/base/cache/FatcmsBaseRedisCache.ts

@@ -0,0 +1,48 @@
+import { Context } from '@midwayjs/koa';
+import { RedisService } from '@midwayjs/redis';
+import { parseJsonObject } from '../../../libs/utils/functions';
+import { ICacheServiceBase } from '@/models/bizmodels';
+
+
+export class FatcmsBaseRedisCache implements ICacheServiceBase {
+  protected ctx: Context;
+  protected cacheName: string;
+  protected redisService: RedisService;
+
+  constructor(ctx: Context, cacheName: string, redisService: RedisService) {
+    this.ctx = ctx;
+    this.cacheName = cacheName;
+    this.redisService = redisService;
+  }
+
+  private getCacheKey(key: string): string {
+    return `${this.cacheName}${key}`;
+  }
+
+  async getJsonObject(key: string): Promise<any> {
+    const cacheKey = this.getCacheKey(key);
+    const str = await this.redisService.get(cacheKey);
+    return parseJsonObject(str);
+  }
+
+  /**
+   * 设置缓存对象
+   * @param key
+   * @param obj
+   * @param expireSecond 过期时间，单位秒
+   * @returns
+   */
+  async setJsonObject(key: string, obj: any, expireSecond?: number): Promise<any> {
+    const cacheKey = this.getCacheKey(key);
+    if (!expireSecond) {
+      expireSecond = 60;
+    }
+    const str = JSON.stringify(obj);
+    return this.redisService.set(cacheKey, str, 'EX', expireSecond);
+  }
+
+  async removeItem(key: string): Promise<any> {
+    const cacheKey = this.getCacheKey(key);
+    return await this.redisService.del(cacheKey);
+  }
+}

package/src/service/crudstd/CrudStdService.ts

@@ -17,6 +17,8 @@ import { ApiBaseService } from '../base/ApiBaseService';
 import { parseDatabaseName } from '@/libs/crud-pro/utils/DatabaseName';
 import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
 import { MixinUtils } from '@/libs/crud-pro/utils/MixinUtils';
+import { CacheServiceFactory } from '../base/cache/CacheServiceFactory';
+import { CacheLevelEnum, CacheNameEnum } from '@/models/SystemEntities';
 
 
 export const SPECIAL_SETTING_KEY = {
@@ -31,12 +33,16 @@ export interface ICrudStdActionParams {
   buttonSettingKey?: string;
 }
 
-
 export interface IRequestModelCrudProExt extends IRequestModel {
   filterValue: string | number;
 }
 
 
+
+const DEFAULT_CACHE_LEVEL = CacheLevelEnum.MEMORY;
+const DEFAULT_CACHE_SECOND = 60 * 5;
+
+
 function isNotEmptyStr(str: any): boolean {
   return typeof str === 'string' && str.trim().length > 0;
 }
@@ -85,6 +91,9 @@ export class CrudStdService extends ApiBaseService {
   @Inject()
   protected crudStdRelationService: CrudStdRelationService;
 
+  @Inject()
+  protected cacheServiceFactory: CacheServiceFactory;
+
   /**
    * 执行普通CRUD
    */
@@ -236,7 +245,7 @@ export class CrudStdService extends ApiBaseService {
       const hasOperationPerm = this.ctx.userSession.isAuthPass(update_auth_type as any, authConfig);
       appInfo.settingKeyActionCfg = { settingKey, hasOperationPerm };
 
-    } 
+    }
     // 列表查询或详情查询
     else if (settingKey === SPECIAL_SETTING_KEY.QUERY_LIST || settingKey === SPECIAL_SETTING_KEY.QUERY_ONE) {
       const authSettingValues = _.get(appSchema, 'authSetting.values');
@@ -301,17 +310,24 @@ export class CrudStdService extends ApiBaseService {
 
 
   /**
- * 查询APP信息
- * @param appCode
- * @private
- */
+   * 查询APP信息
+   * @param appCode
+   * @private
+   */
   public async getParsedCrudStdAppInfo(appCode: string): Promise<ICrudStdAppInfo> {
-    const cacheKey = 'getParsedCrudStdAppInfo:' + appCode;
-    let appInfo: ICrudStdAppInfo = this.getFromCtxCache(cacheKey) as any;
-    if (!appInfo) {
-      appInfo = await this.getParsedCrudStdAppInfoPrivate(appCode);
-      this.setToCtxCache(cacheKey, appInfo);
-    }
+    const { crudStdAppInfoCacheLevel, crudStdAppInfoCacheSecond } = this.ctx.workbenchInfoTools.getWorkbenchConfig();
+    const cacheSecond = crudStdAppInfoCacheSecond || DEFAULT_CACHE_SECOND;
+    const cacheLevel = crudStdAppInfoCacheLevel || DEFAULT_CACHE_LEVEL;
+
+    let appInfo = await this.cacheServiceFactory.getJsonObjectCache({
+      cacheLevel,
+      cacheKey: appCode,
+      cacheSecond,
+      cacheName: CacheNameEnum.GetParsedCrudStdAppInfo,
+      getter: async () => {
+        return await this.getParsedCrudStdAppInfoPrivate(appCode);
+      },
+    });
     return appInfo;
   }
 

package/src/service/curd/CurdMixByAccountService.ts

@@ -19,6 +19,7 @@ const TMP_CTX_KEY2 = _.uniqueId('CurdMixByAccountService2');
 
 @Provide()
 export class CurdMixByAccountService implements IExecuteContextHandler {
+  
   @Inject()
   protected ctx: Context;
 

package/src/service/curd/CurdMixByDictService.ts

@@ -8,14 +8,17 @@ import { SystemTables } from '@/models/SystemTables';
 import { KeysOfSimpleSQL } from '@/libs/crud-pro/models/keys';
 import { MultiKeyMap } from '@/libs/crud-pro/utils/MultiKeyMap';
 import { ColumnRelation } from '@/libs/crud-pro/interfaces';
-import { RedisCacheService } from '../base/RedisCacheService';
 import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
-import { RedisKeys } from '@/models/RedisKeys';
+import { CacheServiceFactory } from '../base/cache/CacheServiceFactory';
+import { CacheLevelEnum, CacheNameEnum } from '@/models/SystemEntities';
 
 const TMP_CTX_KEY = _.uniqueId('CurdMixByDictService');
-
 const dictMixUtils = new CrudMixUtils(RelatedType.dict);
 
+
+const DEFAULT_CACHE_LEVEL = CacheLevelEnum.MEMORY;
+const DEFAULT_CACHE_SECOND = 60 * 5;
+
 @Provide()
 export class CurdMixByDictService implements IExecuteContextHandler {
   @Inject()
@@ -25,15 +28,18 @@ export class CurdMixByDictService implements IExecuteContextHandler {
   private curdProService: CurdProService;
 
   @Inject()
-  protected redisCacheService: RedisCacheService;
+  private cacheServiceFactory: CacheServiceFactory;
 
   private async getFromCache(code: string): Promise<any> {
-    const cacheKey = `${RedisKeys.CURD_MIX_BY_DICT_PREFIX}${code}`;
-    return this.redisCacheService.getJsonObject(cacheKey);
+    const { curdMixByCommonCacheLevel } = this.ctx.workbenchInfoTools.getWorkbenchConfig();
+    const cacheService = this.cacheServiceFactory.getCacheService(curdMixByCommonCacheLevel || DEFAULT_CACHE_LEVEL, CacheNameEnum.CurdMixByDict);
+    return cacheService.getJsonObject(code);
   }
+
   private async setToCache(code: string, value: any): Promise<any> {
-    const cacheKey = `${RedisKeys.CURD_MIX_BY_DICT_PREFIX}${code}`;
-    return this.redisCacheService.setJsonObject(cacheKey, value, 60 * 60);
+    const { curdMixByCommonCacheLevel, curdMixByCommonCacheSecond } = this.ctx.workbenchInfoTools.getWorkbenchConfig();
+    const cacheService = this.cacheServiceFactory.getCacheService(curdMixByCommonCacheLevel || DEFAULT_CACHE_LEVEL, CacheNameEnum.CurdMixByDict);
+    return cacheService.setJsonObject(code, value, curdMixByCommonCacheSecond || DEFAULT_CACHE_SECOND);
   }
 
   async handleExecuteContextPrepare(executeContext: HandleExecuteContextType): Promise<void> {

package/src/service/curd/CurdMixByLinkToCustomService.ts

@@ -8,15 +8,21 @@ import { KeysOfSimpleSQL } from '@/libs/crud-pro/models/keys';
 import { ColumnRelation } from '@/libs/crud-pro/interfaces';
 import { BizException } from '@/models/devops';
 import { Exceptions } from '@/libs/crud-pro/exceptions';
-import { RedisCacheService } from '../base/RedisCacheService';
 import { parseDatabaseName } from '@/libs/crud-pro/utils/DatabaseName';
 import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
 import { IRequestCfgModel2 } from '@/models/bizmodels';
-import { RedisKeys } from '@/models/RedisKeys';
+import { CacheLevelEnum, CacheNameEnum } from '@/models/SystemEntities';
+import { CacheServiceFactory } from '../base/cache/CacheServiceFactory';
+import * as md5 from 'md5';
 
 const linkToCustomMixUtils = new CrudMixUtils(RelatedType.linkToCustom);
 const TMP_CTX_KEY = _.uniqueId('CurdMixByLinkToCustomService');
 
+
+const DEFAULT_CACHE_LEVEL = CacheLevelEnum.MEMORY;
+const DEFAULT_CACHE_SECOND = 60 * 5;
+
+
 function toMapObject(rows: any[], fieldsArr: string[]): Map<string, any> {
   const valueKey = fieldsArr[0];
   const labelKey = fieldsArr[1];
@@ -52,7 +58,8 @@ export class CurdMixByLinkToCustomService implements IExecuteContextHandler {
   protected curdProService: CurdProService;
 
   @Inject()
-  protected redisCacheService: RedisCacheService;
+  private cacheServiceFactory: CacheServiceFactory;
+
 
   async handleExecuteContextPrepare(executeContext: HandleExecuteContextType) {
     const relations = linkToCustomMixUtils.pickColumnRelations(executeContext);
@@ -91,17 +98,19 @@ export class CurdMixByLinkToCustomService implements IExecuteContextHandler {
   }
 
   public async queryInfoByLinkToCustom(code: string): Promise<Map<string, any>> {
-    const cacheKey = RedisKeys.LINK_TO_CUSTOM_PREFIX + code;
-    let values;
-    const expireSecond = 2 * 60; // 2分钟
-    const enumMap = await this.redisCacheService.getJsonObject(cacheKey);
-    if (!enumMap || Object.keys(enumMap).length === 0) {
-      values = await this.queryInfoByLinkToCustomImpl(code);
-      await this.redisCacheService.setJsonObject(cacheKey, values, expireSecond);
-    }
-    return values;
+    const { curdMixByCommonCacheLevel, curdMixByCommonCacheSecond } = this.ctx.workbenchInfoTools.getWorkbenchConfig();
+    return this.cacheServiceFactory.getJsonObjectCache({
+      cacheLevel: curdMixByCommonCacheLevel || DEFAULT_CACHE_LEVEL,
+      cacheKey: md5(code),
+      cacheSecond: curdMixByCommonCacheSecond || DEFAULT_CACHE_SECOND,  
+      cacheName: CacheNameEnum.CurdMixByLinkToCustom,
+      getter: async () => {
+        return await this.queryInfoByLinkToCustomImpl(code);
+      },
+    });
   }
 
+
   /**
    * code形如：mysql_________fatcms~~~sys_perm_role~~~role_code,role_name,xxx_name
    * code形如：fatcms~~~sys_perm_role~~~role_code,role_name,xxx_name

package/src/service/curd/CurdMixBySysConfigService.ts

@@ -10,11 +10,19 @@ import { MultiKeyMap } from '@/libs/crud-pro/utils/MultiKeyMap';
 import { ColumnRelation } from '@/libs/crud-pro/interfaces';
 import { parseConfigContentToEnumInfo } from '@/libs/utils/parseConfig';
 import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
+import { CacheServiceFactory } from '../base/cache/CacheServiceFactory';
+import { CacheLevelEnum, CacheNameEnum } from '@/models/SystemEntities';
 
 const dictMixUtils = new CrudMixUtils(RelatedType.sysCfgEnum);
 
 const TMP_CTX_KEY = _.uniqueId('CurdMixBySysConfigService');
 
+const DEFAULT_CACHE_LEVEL = CacheLevelEnum.MEMORY;
+const DEFAULT_CACHE_SECOND = 60 * 5;
+
+
+
+
 @Provide()
 export class CurdMixBySysConfigService implements IExecuteContextHandler {
   @Inject()
@@ -22,18 +30,43 @@ export class CurdMixBySysConfigService implements IExecuteContextHandler {
 
   @Inject()
   protected curdProService: CurdProService;
+  @Inject()
+  private cacheServiceFactory: CacheServiceFactory;
 
-  async handleExecuteContextPrepare(executeContext: HandleExecuteContextType) {
-    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
 
-    const codes = dictMixUtils.pickColumnRelationCodes(executeContext);
-    if (!codes || codes.length === 0) {
-      return;
+  private async getFromCache(code: string): Promise<any> {
+    const { curdMixByCommonCacheLevel } = this.ctx.workbenchInfoTools.getWorkbenchConfig();
+    const cacheService = this.cacheServiceFactory.getCacheService(curdMixByCommonCacheLevel || DEFAULT_CACHE_LEVEL, CacheNameEnum.CurdMixBySysConfig);
+    return cacheService.getJsonObject(code);
+  }
+
+  private async setToCache(code: string, value: any): Promise<any> {
+    const { curdMixByCommonCacheLevel, curdMixByCommonCacheSecond } = this.ctx.workbenchInfoTools.getWorkbenchConfig();
+    const cacheService = this.cacheServiceFactory.getCacheService(curdMixByCommonCacheLevel || DEFAULT_CACHE_LEVEL, CacheNameEnum.CurdMixBySysConfig);
+    return cacheService.setJsonObject(code, value, curdMixByCommonCacheSecond || DEFAULT_CACHE_SECOND);
+  }
+
+
+  private async queryConfigRowsUseCache(codes: string[]): Promise<any[]> {
+
+    const resultRowMap = {} as Record<string, any>;
+    for (let i = 0; i < codes.length; i++) {
+      const code = codes[i];
+      const row = await this.getFromCache(code);
+      if (row) {
+        resultRowMap[code] = row;
+      }
     }
 
+    const notCachedCodes = codes.filter((code) => !resultRowMap[code]);
+    if (notCachedCodes.length === 0) {
+      return Object.values(resultRowMap);
+    }
+
+    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
     const res1 = await this.curdProService.executeCrudByCfg(
       {
-        condition: { config_code: { $in: codes } },
+        condition: { config_code: { $in: notCachedCodes } },
       },
       {
         sqlTable: SystemTables.sys_configs,
@@ -43,16 +76,32 @@ export class CurdMixBySysConfigService implements IExecuteContextHandler {
       }
     );
     const rows = res1.getResRows();
-    const multiKeyMap = new MultiKeyMap();
-
-    if (Array.isArray(rows)) {
+    if (Array.isArray(rows) && rows.length > 0) {
       for (let i = 0; i < rows.length; i++) {
         const row = rows[i];
         const { config_code } = row;
-        const config_content_rows = parseConfigContentToEnumInfo(row); // 数组元素必须有value字段
-        multiKeyMap.addRowsValue1(config_content_rows, config_code, 'value');
+        await this.setToCache(config_code, row);
+        resultRowMap[config_code] = row;
       }
     }
+return Object.values(resultRowMap)
+  }
+
+  async handleExecuteContextPrepare(executeContext: HandleExecuteContextType) {
+    const codes = dictMixUtils.pickColumnRelationCodes(executeContext);
+    if (!codes || codes.length === 0) {
+      return;
+    }
+
+    const multiKeyMap = new MultiKeyMap();
+    const rows = await this.queryConfigRowsUseCache(codes);
+
+    for (let i = 0; i < rows.length; i++) {
+      const row = rows[i];
+      const { config_code } = row;
+      const config_content_rows = parseConfigContentToEnumInfo(row); // 数组元素必须有value字段
+      multiKeyMap.addRowsValue1(config_content_rows, config_code, 'value');
+    }
 
     executeContext[TMP_CTX_KEY] = multiKeyMap;
   }