midway-fatcms 0.0.15 → 0.0.17

package/src/service/SysConfigService.ts

@@ -1,57 +1,24 @@
-import { Inject, Provide } from '@midwayjs/core';
-import { Context } from '@midwayjs/koa';
-import { SystemTables } from '@/models/SystemTables';
+import { Provide } from '@midwayjs/core';
 import { BaseService } from './base/BaseService';
-import { CurdProService } from './curd/CurdProService';
-import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
-import { CacheNameEnum } from "@/models/bizmodels";
-import { CacheServiceFactory } from "@/service/base/cache/CacheServiceFactory";
+import { bizMemCacheStore } from '@/service/base/bizmemcache/BizMemCacheStore';
 
 @Provide()
 export class SysConfigService extends BaseService {
-  @Inject()
-  ctx: Context;
-
-  @Inject()
-  private curdProService: CurdProService;
-
-  @Inject()
-  private cacheServiceFactory: CacheServiceFactory;
-
-  private get sysConfigsDao(){
-    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
-    return this.curdProService.getQuickCrud({
-      sqlDatabase: SystemDbName,
-      sqlDbType: SystemDbType,
-      sqlTable: SystemTables.sys_configs,
-    })
-  }
 
   async getSysConfigOne(config_code: string): Promise<Record<string, any>> {
     if (!config_code || typeof config_code !== 'string') {
       throw new Error('[getSysAppOne] config_code required');
     }
-    return await this.cacheServiceFactory.getJsonObjectCache({
-      cacheKey: config_code,
-      cacheName: CacheNameEnum.GetSysConfigOne,
-      getter: async (ctx) => {
-        const service: SysConfigService = await ctx.requestContext.getAsync(SysConfigService);
-        const res = await service.sysConfigsDao.findOne({
-          condition: {config_code, deleted_at: 0}
-        });
-        return res.row;
-      },
-    });
+    const sysConfigCodeMap = bizMemCacheStore.getSysConfig()?.sysConfigCodeMap || {};
+    return sysConfigCodeMap[config_code];
   }
 
+
   async removeSysConfigOneCache(config_code: string) {
     if (!config_code || typeof config_code !== 'string') {
       throw new Error('[removeSysConfigOneCache] config_code required');
     }
 
-    return await this.cacheServiceFactory.removeItemCache({
-      cacheKey: config_code,
-      cacheName: CacheNameEnum.GetSysConfigOne,
-    });
+    await bizMemCacheStore.markDirty('sysConfgCacheObj', this.redisService);
   }
 }

package/src/service/SysDictDataService.ts

@@ -1,74 +1,29 @@
-import { Inject, Provide } from '@midwayjs/core';
-import { SystemTables } from '@/models/SystemTables';
+import { Provide } from '@midwayjs/core';
 import { BaseService } from './base/BaseService';
-import { CurdProService } from './curd/CurdProService';
-import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
-import { CacheServiceFactory } from "@/service/base/cache/CacheServiceFactory";
-import { CacheNameEnum } from "@/models/bizmodels";
+import { bizMemCacheStore } from '@/service/base/bizmemcache/BizMemCacheStore';
 
 @Provide()
 export class SysDictDataService extends BaseService {
 
-  @Inject()
-  private curdProService: CurdProService;
-
-  @Inject()
-  private cacheServiceFactory: CacheServiceFactory;
-
-  private get sys_data_dict_item() {
-    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
-    return this.curdProService.getQuickCrud({
-      sqlDatabase: SystemDbName,
-      sqlDbType: SystemDbType,
-      sqlTable: SystemTables.sys_data_dict_item,
-    })
-  }
-
-  // private get sys_data_dict(){
-  //   const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
-  //   return this.curdProService.getQuickCrud({
-  //     sqlDatabase: SystemDbName,
-  //     sqlDbType: SystemDbType,
-  //     sqlTable: SystemTables.sys_data_dict,
-  //   })
-  // }
-
-
   public async getDataDictItemsByDictCode(dict_code: string): Promise<any[]> {
     if (!dict_code || typeof dict_code !== 'string') {
-      throw new Error('[getDataDictItemsByDictCode] page_path required');
+      throw new Error('[getDataDictItemsByDictCode] dict_code required');
     }
-    return await this.cacheServiceFactory.getJsonObjectCache({
-      cacheKey: dict_code,
-      cacheName: CacheNameEnum.GetDataDictItemsByDictCode,
-      getter: async (ctx) => {
-        const service: SysDictDataService = await ctx.requestContext.getAsync(SysDictDataService);
-        const res =  await service.sys_data_dict_item.findList({
-          condition: { dict_code, status: 1, deleted_at: 0 }
-        });
-        return res.rows;
-      },
-    });
+    const dictCodeMap = bizMemCacheStore.getDataDictItem()?.dictCodeMap || {};
+    return dictCodeMap[dict_code] || [];
   }
 
   public async removeCacheByDictItemId(dict_item_id: string) {
-    const res = await this.sys_data_dict_item.findOne({ condition: { id: dict_item_id } });
-    const dictItemObj = res.row;
-    return this.removeCacheByDictCode(dictItemObj['dict_code']);
+    if (!dict_item_id) {
+      throw new Error('[removeCacheByDictItemId] dict_item_id required');
+    }
+    await bizMemCacheStore.markDirty('dataDictItemCacheObj', this.redisService);
   }
 
-  // public async removeCacheByDictId(dict_id: string) {
-  //   const dictObj = await this.sys_data_dict.getUniqueOne({condition: {id: dict_id}});
-  //   return this.removeCacheByDictCode(dictObj['dict_code']);
-  // }
-
   public async removeCacheByDictCode(dict_code: string) {
     if (!dict_code || typeof dict_code !== 'string') {
-      throw new Error('[removeSysAppOneCache] app_code required');
+      throw new Error('[removeCacheByDictCode] dict_code required');
     }
-    return await this.cacheServiceFactory.removeItemCache({
-      cacheKey: dict_code,
-      cacheName: CacheNameEnum.GetDataDictItemsByDictCode
-    });
+    await bizMemCacheStore.markDirty('dataDictItemCacheObj', this.redisService);
   }
 }

package/src/service/SysMenuService.ts

@@ -1,10 +1,6 @@
-import { Inject, Provide } from '@midwayjs/core';
-import { SystemTables } from '@/models/SystemTables';
+import { Provide } from '@midwayjs/core';
 import { BaseService } from './base/BaseService';
-import { CurdProService } from './curd/CurdProService';
-import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
-import { CacheServiceFactory } from "@/service/base/cache/CacheServiceFactory";
-import { CacheNameEnum } from "@/models/bizmodels";
+import { bizMemCacheStore } from '@/service/base/bizmemcache/BizMemCacheStore';
 
 /**
  * 菜单表接口定义
@@ -49,45 +45,16 @@ interface SysMenus {
 @Provide()
 export class SysMenuService extends BaseService {
 
-  @Inject()
-  private curdProService: CurdProService;
-
-  @Inject()
-  private cacheServiceFactory: CacheServiceFactory;
-
-  private get sys_menus_table() {
-    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
-    return this.curdProService.getQuickCrud({
-      sqlDatabase: SystemDbName,
-      sqlDbType: SystemDbType,
-      sqlTable: SystemTables.sys_menus,
-    })
-  }
-
-
   /**
    * 获取所有菜单列表
    * @returns
    */
   async getCachedMenusList(): Promise<SysMenus[]> {
-    return await this.cacheServiceFactory.getJsonObjectCache({
-      cacheKey: CacheNameEnum.GetSysMenusList,
-      cacheName: CacheNameEnum.GetSysMenusList,
-      getter: async (ctx) => {
-        const service: SysMenuService = await ctx.requestContext.getAsync(SysMenuService);
-        const res =  await service.sys_menus_table.findList({
-          condition: { deleted_at: 0 }
-        });
-        return res.rows;
-      },
-    });
+    return bizMemCacheStore.getSysMenu()?.sysMenuList || [];
   }
 
 
   async removeSysMenuCache() {
-    return await this.cacheServiceFactory.removeItemCache({
-      cacheKey: CacheNameEnum.GetSysMenusList,
-      cacheName: CacheNameEnum.GetSysMenusList,
-    });
+    await bizMemCacheStore.markDirty('sysMenuCacheObj', this.redisService);
   }
 }

package/src/service/WorkbenchService.ts

@@ -1,89 +1,31 @@
 import { Config, Inject, Provide } from '@midwayjs/core';
 import { Context } from '@midwayjs/koa';
-import { KeysOfSimpleSQL } from '@/libs/crud-pro/models/keys';
-import { SystemTables } from '@/models/SystemTables';
 import { BaseService } from './base/BaseService';
-import { CurdProService } from './curd/CurdProService';
 import { CommonException } from '@/libs/crud-pro/exceptions';
 import { parseJsonObject } from '@/libs/utils/functions';
 import { IWorkbenchConfig, IWorkbenchEntity } from '@/models/SystemEntities';
-import { IScheduleService } from '@/interface';
 import { getDebugWorkbenchCode } from '@/libs/utils/fatcms-request';
-import { MixinUtils } from '@/libs/crud-pro/utils/MixinUtils';
-import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
 import { HEADER_KEY_RUN_BY_ASYNC_TASK_WORKBENCH_CODE } from '@/models/AsyncTaskModel';
 import { formatHost } from '@/libs/utils/format-url';
-import { CacheServiceFactory } from "@/service/base/cache/CacheServiceFactory";
-import { CacheNameEnum } from "@/models/bizmodels";
+import { bizMemCacheStore } from '@/service/base/bizmemcache/BizMemCacheStore';
+import { IWorkbenchCachedObj } from '@/service/base/bizmemcache/BizMemCacheTypes';
 
 
-interface IWorkbenchCachedObj {
-  workbenchList: IWorkbenchEntity[];
-  workbenchDomainMap: Record<string, IWorkbenchEntity>; // key是domain
-}
-
 @Provide()
-export class WorkbenchService extends BaseService implements IScheduleService {
+export class WorkbenchService extends BaseService {
   @Inject()
   ctx: Context;
 
-  @Inject()
-  private curdProService: CurdProService;
-
-  @Inject()
-  private cacheServiceFactory: CacheServiceFactory;
-
   @Config('fatcmsTargetWorkbenchCode')
   private fatcmsTargetWorkbenchCode: string;
 
 
   public async clearCache() {
-
-    await this.cacheServiceFactory.removeItemCache({
-      cacheKey: CacheNameEnum.CurdMixByWorkbench,
-      cacheName: CacheNameEnum.CurdMixByWorkbench,
-    });
-
-    await this.cacheServiceFactory.removeItemCache({
-      cacheKey: CacheNameEnum.GetWorkbenchCachedObj,
-      cacheName: CacheNameEnum.GetWorkbenchCachedObj,
-    });
-
-    await this.getWorkbenchCachedObj(true);
-  }
-
-  public async runBySchedule() {
-    await this.getWorkbenchCachedObj(true);
+    await bizMemCacheStore.markDirty('workbenchCachedObj', this.redisService);
   }
 
-  private async getWorkbenchCachedObj(isForceRefresh?: boolean): Promise<IWorkbenchCachedObj> {
-    return this.cacheServiceFactory.getJsonObjectCache({
-      cacheKey: CacheNameEnum.GetWorkbenchCachedObj,
-      cacheName: CacheNameEnum.GetWorkbenchCachedObj,
-      refreshCache: isForceRefresh,
-      getter: async (ctx) => {
-        const service: WorkbenchService = await ctx.requestContext.getAsync(WorkbenchService);
-        const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
-        const reqJson = { condition: { deleted_at: 0 }, pageSize: 1000, limit: 1000 };
-        const res = await service.curdProService.executeCrudByCfg(reqJson, {
-          sqlTable: SystemTables.sys_workbench,
-          sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
-          sqlDatabase: SystemDbName,
-          sqlDbType: SystemDbType,
-        });
-        const listData = res.getResRows() as IWorkbenchEntity[];
-
-        const domainMap1 = MixinUtils.toMap(listData, (e: any) => e.workbench_domain); // 主域名。其他两个域名。
-        const domainMap2 = MixinUtils.toMap(listData, (e: any) => e.workbench_domain2);
-        const domainMap3 = MixinUtils.toMap(listData, (e: any) => e.workbench_domain3);
-        const domainMap = { ...domainMap1, ...domainMap2, ...domainMap3 };
-        const cacheObj: IWorkbenchCachedObj = {
-          workbenchList: listData,
-          workbenchDomainMap: domainMap
-        }
-        return cacheObj;
-      },
-    });
+  private getWorkbenchCachedObj(): IWorkbenchCachedObj {
+    return bizMemCacheStore.getWorkbench();
   }
 
   /**
@@ -91,8 +33,8 @@ export class WorkbenchService extends BaseService implements IScheduleService {
    * @returns
    */
   public async getAllWorkbenchInfoList(): Promise<IWorkbenchEntity[]> {
-    const cachedObj = await this.getWorkbenchCachedObj();
-    return cachedObj.workbenchList;
+    const cachedObj = this.getWorkbenchCachedObj();
+    return cachedObj?.workbenchList || [];
   }
 
   /**
@@ -100,8 +42,8 @@ export class WorkbenchService extends BaseService implements IScheduleService {
    * @returns
    */
   public async getAllWorkbenchInfoMap(): Promise<Record<string, IWorkbenchEntity>> {
-    const cachedObj = await this.getWorkbenchCachedObj();
-    return cachedObj.workbenchDomainMap;
+    const cachedObj = this.getWorkbenchCachedObj();
+    return cachedObj?.workbenchDomainMap || {};
   }
 
   /**

package/src/service/anyapi/AnyApiService.ts

@@ -2,7 +2,6 @@ import { Inject, Provide } from '@midwayjs/core';
 import { Context } from '@midwayjs/koa';
 import { KeysOfSimpleSQL } from '@/libs/crud-pro/models/keys';
 import { SystemTables } from '@/models/SystemTables';
-import { LRUCache } from 'lru-cache';
 import { BizException } from '@/models/devops';
 import { CurdMixService } from '../curd/CurdMixService';
 import { ISysAnyApiEntity } from '@/models/SystemEntities';
@@ -14,12 +13,7 @@ import { WorkbenchService } from '../WorkbenchService';
 import { validateByCfgString } from '@/libs/crud-pro/utils/ValidateUtils';
 import { API_BASE_TYPE, ApiBaseService } from '../base/ApiBaseService';
 import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
-
-const lruCache = new LRUCache<string, any>({
-  max: 500,
-  ttl: 1000 * 60,
-  ttlAutopurge: true,
-});
+import { bizMemCacheStore } from '@/service/base/bizmemcache/BizMemCacheStore';
 
 @Provide()
 export class AnyApiService extends ApiBaseService {
@@ -65,21 +59,15 @@ export class AnyApiService extends ApiBaseService {
   }
 
   private async getAnyApiMethod(methodCode: string): Promise<ISysAnyApiEntity> {
-    // 开发环境，不使用缓存
     if (this.isEnableDebug()) {
-      return this._getAnyApiMethod(methodCode);
+      return this.loadAnyApiMethodFromDb(methodCode);
     }
 
-    // 线上环境可以使用缓存
-    let anyApi = lruCache.get(methodCode);
-    if (!anyApi) {
-      anyApi = await this._getAnyApiMethod(methodCode);
-      lruCache.set(methodCode, anyApi);
-    }
-    return anyApi;
+    const sysAnyApiMethodMap = bizMemCacheStore.getSysAnyApi()?.sysAnyApiMethodMap || {};
+    return sysAnyApiMethodMap[methodCode] || null;
   }
 
-  private async _getAnyApiMethod(methodCode: string): Promise<ISysAnyApiEntity> {
+  private async loadAnyApiMethodFromDb(methodCode: string): Promise<ISysAnyApiEntity> {
     const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
 
     const res = await this.curdMixService.executeCrudByCfg(

package/src/service/base/bizmemcache/BizMemCacheService.ts

@@ -0,0 +1,288 @@
+import * as _ from 'lodash';
+import { Inject, Provide } from '@midwayjs/core';
+import { IScheduleService } from '@/interface';
+import { SystemTables } from '@/models/SystemTables';
+import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
+import { BaseService } from "@/service/base/BaseService";
+import { CurdProService } from '../../curd/CurdProService';
+import { KeysOfSimpleSQL } from '@/libs/crud-pro/models/keys';
+import { MixinUtils } from '@/libs/crud-pro/utils/MixinUtils';
+import { IWorkbenchEntity } from '@/models/SystemEntities';
+import { bizMemCacheStore } from './BizMemCacheStore';
+import { BizMemCacheKey, buildSysAppPageCacheKey, ICrudMethodCacheObj, IDataDictItemCacheObj, IWorkbenchCachedObj, ISysConfgCacheObj, ISysMenuCacheObj, ISysAppCacheObj, ISysAppPageCacheObj, ISysAnyApiCacheObj, ISysProxyApiCacheObj } from './BizMemCacheTypes';
+import { parseJsonObject } from '@/libs/utils/functions';
+import { parseCrudMethodInfo, setMethodCache } from '@/libs/crud-pro/services/CrudProCachedCfgService';
+
+
+
+
+@Provide()
+export class BizMemCacheService extends BaseService implements IScheduleService {
+
+  @Inject()
+  private curdProService: CurdProService;
+
+  public async runBySchedule(): Promise<void> {
+    await this.reloadIfRedisChanged('workbenchCachedObj', () => this.loadWorkbenchCachedObj());
+    await this.reloadIfRedisChanged('sysConfgCacheObj', () => this.loadSysConfigObj());
+    await this.reloadIfRedisChanged('dataDictItemCacheObj', () => this.loadDataDictItemCacheObj());
+    await this.reloadIfRedisChanged('sysMenuCacheObj', () => this.loadSysMenuCacheObj());
+    await this.reloadIfRedisChanged('sysAppCacheObj', () => this.loadSysAppCacheObj());
+    await this.reloadIfRedisChanged('sysAppPageCacheObj', () => this.loadSysAppPageCacheObj());
+    await this.reloadIfRedisChanged('sysAnyApiCacheObj', () => this.loadSysAnyApiCacheObj());
+    await this.reloadIfRedisChanged('sysProxyApiCacheObj', () => this.loadSysProxyApiCacheObj());
+    await this.reloadIfRedisChanged('crudMethodCacheObj', () => this.loadCrudMethodCacheObj());
+  }
+
+  private async reloadIfRedisChanged(key: BizMemCacheKey, loader: () => Promise<void>) {
+    const redisTime = Number(await this.redisService.get(bizMemCacheStore.getRedisKey(key))) || 0;
+    if (redisTime !== bizMemCacheStore.getLastTime(key)) {
+      await loader();
+      bizMemCacheStore.setLastTime(key, redisTime);
+    }
+  }
+
+  private async loadSysMenuCacheObj() {
+
+    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+
+    const res1 = await this.curdProService.executeCrudByCfg(
+      {
+        condition: { deleted_at: 0, status: 1 },
+      },
+      {
+        sqlTable: SystemTables.sys_menus,
+        sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
+        sqlDatabase: SystemDbName,
+        sqlDbType: SystemDbType,
+        maxLimit: 10 * 10000
+      }
+    );
+
+    const rows = res1.getResRows();
+    const cacheObj: ISysMenuCacheObj = {
+      sysMenuList: rows,
+      sysMenuCodeMap: _.keyBy(rows, 'menu_code')
+    }
+    bizMemCacheStore.setSysMenu(cacheObj);
+
+  }
+
+
+  private async loadDataDictItemCacheObj() {
+    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+    const res1 = await this.curdProService.executeCrudByCfg(
+      {
+        columns: ['dict_code', 'label', 'value', 'style', 'code'],
+        condition: { deleted_at: 0, status: 1 },
+      },
+      {
+        sqlTable: SystemTables.sys_data_dict_item,
+        sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
+        sqlDatabase: SystemDbName,
+        sqlDbType: SystemDbType,
+        maxLimit: 10 * 10000
+      }
+    );
+
+    const rows = res1.getResRows();
+
+    const dictCodeMap: Record<string, any[]> = _.groupBy(rows, 'dict_code');
+
+    const cacheObj: IDataDictItemCacheObj = {
+      dictCodeMap: dictCodeMap
+    }
+    bizMemCacheStore.setDataDictItem(cacheObj);
+
+  }
+
+
+
+
+
+  private async loadSysConfigObj() {
+    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+    const res1 = await this.curdProService.executeCrudByCfg(
+      {
+        condition: { deleted_at: 0, status: 1 },
+      },
+      {
+        sqlTable: SystemTables.sys_configs,
+        sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
+        sqlDatabase: SystemDbName,
+        sqlDbType: SystemDbType,
+      }
+    );
+    const sysConfigCodeMap = {};
+    const rows = res1.getResRows();
+    if (Array.isArray(rows) && rows.length > 0) {
+      for (let i = 0; i < rows.length; i++) {
+        const row = rows[i];
+        const { config_code } = row;
+        sysConfigCodeMap[config_code] = row;
+      }
+    }
+
+    const cacheObj: ISysConfgCacheObj = {
+      sysConfigList: rows,
+      sysConfigCodeMap: sysConfigCodeMap
+    }
+    bizMemCacheStore.setSysConfig(cacheObj);
+
+  }
+
+
+
+
+
+  private async loadWorkbenchCachedObj(): Promise<any> {
+    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+    const reqJson = { condition: { deleted_at: 0 }, pageSize: 1000, limit: 1000 };
+    const res = await this.curdProService.executeCrudByCfg(reqJson, {
+      sqlTable: SystemTables.sys_workbench,
+      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
+      sqlDatabase: SystemDbName,
+      sqlDbType: SystemDbType,
+    });
+    const listData = res.getResRows() as IWorkbenchEntity[];
+
+    const domainMap1 = MixinUtils.toMap(listData, (e: any) => e.workbench_domain); // 主域名。其他两个域名。
+    const domainMap2 = MixinUtils.toMap(listData, (e: any) => e.workbench_domain2);
+    const domainMap3 = MixinUtils.toMap(listData, (e: any) => e.workbench_domain3);
+    const domainMap = { ...domainMap1, ...domainMap2, ...domainMap3 };
+    const cacheObj: IWorkbenchCachedObj = {
+      workbenchList: listData,
+      workbenchDomainMap: domainMap
+    }
+    bizMemCacheStore.setWorkbench(cacheObj);
+  }
+
+  private async loadSysAppCacheObj() {
+    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+    const res = await this.curdProService.executeCrudByCfg(
+      {
+        condition: { deleted_at: 0 },
+      },
+      {
+        sqlTable: SystemTables.sys_app,
+        sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
+        sqlDatabase: SystemDbName,
+        sqlDbType: SystemDbType,
+        maxLimit: 10 * 10000,
+      }
+    );
+    const rows = res.getResRows();
+    const cacheObj: ISysAppCacheObj = {
+      sysAppList: rows,
+      sysAppCodeMap: _.keyBy(rows, 'app_code'),
+    };
+    bizMemCacheStore.setSysApp(cacheObj);
+  }
+
+  private async loadSysAppPageCacheObj() {
+    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+    const res = await this.curdProService.executeCrudByCfg(
+      {
+        condition: { deleted_at: 0 },
+      },
+      {
+        sqlTable: SystemTables.sys_app_page,
+        sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
+        sqlDatabase: SystemDbName,
+        sqlDbType: SystemDbType,
+        maxLimit: 10 * 10000,
+      }
+    );
+    const rows = res.getResRows();
+    const sysAppPageMap: Record<string, any> = {};
+    for (let i = 0; i < rows.length; i++) {
+      const row = rows[i];
+      const cacheKey = buildSysAppPageCacheKey(row.workbench_code, row.page_path);
+      sysAppPageMap[cacheKey] = row;
+    }
+    const cacheObj: ISysAppPageCacheObj = {
+      sysAppPageList: rows,
+      sysAppPageMap,
+    };
+    bizMemCacheStore.setSysAppPage(cacheObj);
+  }
+
+  private async loadSysAnyApiCacheObj() {
+    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+    const res = await this.curdProService.executeCrudByCfg(
+      {
+        condition: { deleted_at: 0 },
+      },
+      {
+        sqlTable: SystemTables.sys_anyapi,
+        sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
+        sqlDatabase: SystemDbName,
+        sqlDbType: SystemDbType,
+        maxLimit: 10 * 10000,
+      }
+    );
+    const rows = res.getResRows();
+    const sysAnyApiMethodMap: Record<string, any> = {};
+    for (let i = 0; i < rows.length; i++) {
+      const row = rows[i];
+      const obj = { ...row };
+      obj.parsedOthers = parseJsonObject(obj.others);
+      sysAnyApiMethodMap[row.method] = obj;
+    }
+    const cacheObj: ISysAnyApiCacheObj = {
+      sysAnyApiList: rows,
+      sysAnyApiMethodMap,
+    };
+    bizMemCacheStore.setSysAnyApi(cacheObj);
+  }
+
+  private async loadSysProxyApiCacheObj() {
+    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+    const res = await this.curdProService.executeCrudByCfg(
+      {
+        condition: { deleted_at: 0 },
+      },
+      {
+        sqlTable: SystemTables.sys_proxyapi,
+        sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
+        sqlDatabase: SystemDbName,
+        sqlDbType: SystemDbType,
+        maxLimit: 10 * 10000,
+      }
+    );
+    const rows = res.getResRows();
+    const cacheObj: ISysProxyApiCacheObj = {
+      sysProxyApiList: rows,
+      routeTrieMap: null,
+    };
+    bizMemCacheStore.setSysProxyApi(cacheObj);
+  }
+
+  private async loadCrudMethodCacheObj() {
+    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+    const res = await this.curdProService.executeCrudByCfg(
+      {
+        condition: { deleted_at: 0 },
+      },
+      {
+        sqlTable: SystemTables.sys_crud_methods,
+        sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
+        sqlDatabase: SystemDbName,
+        sqlDbType: SystemDbType,
+        maxLimit: 10 * 10000,
+      }
+    );
+    const rows = res.getResRows();
+    const crudMethodList = rows.map(row => parseCrudMethodInfo(row));
+    const cacheObj: ICrudMethodCacheObj = {
+      crudMethodList,
+      crudMethodMap: _.keyBy(crudMethodList, 'method'),
+    };
+    bizMemCacheStore.setCrudMethod(cacheObj);
+    setMethodCache(crudMethodList);
+  }
+
+
+
+
+}