midway-fatcms 0.0.16 → 0.0.17

package/src/controller/manage/SysConfigMangeApi.ts

@@ -3,8 +3,8 @@ import { Context } from '@midwayjs/koa';
 import { KeysOfSimpleSQL, KeysOfValidators } from '@/libs/crud-pro/models/keys';
 import { BaseApiController } from '../base/BaseApiController';
 import { checkPermission } from '@/middleware/permission.middleware';
-import { refreshCache } from '@/middleware/cacherefresh.middleware';
-import { CacheNameEnum, CTX_WORKBENCH_CODE } from '@/models/bizmodels';
+import { refreshBizMemCache } from '@/middleware/cacherefresh.middleware';
+import { CTX_WORKBENCH_CODE } from '@/models/bizmodels';
 import { SystemFuncCode } from '@/models/SystemPerm';
 import { SystemTables } from '@/models/SystemTables';
 import { CommonResult } from '@/libs/utils/common-dto';
@@ -35,7 +35,7 @@ export class SysConfigMangeApi extends BaseApiController {
     });
   }
 
-  @Post('/createSysConfig', { middleware: [checkPermission(SystemFuncCode.SysConfigMangeWrite), refreshCache(CacheNameEnum.GetSysConfigOne)] })
+  @Post('/createSysConfig', { middleware: [checkPermission(SystemFuncCode.SysConfigMangeWrite), refreshBizMemCache('sysConfgCacheObj')] })
   async createSysConfig() {
     return this.executeSysSimpleSQL('sys_configs', KeysOfSimpleSQL.SIMPLE_INSERT, {
       enableSoftDelete: true,
@@ -51,7 +51,7 @@ export class SysConfigMangeApi extends BaseApiController {
     });
   }
 
-  @Post('/updateSysConfig', { middleware: [checkPermission(SystemFuncCode.SysConfigMangeWrite), refreshCache(CacheNameEnum.GetSysConfigOne)] })
+  @Post('/updateSysConfig', { middleware: [checkPermission(SystemFuncCode.SysConfigMangeWrite), refreshBizMemCache('sysConfgCacheObj')] })
   async updateSysConfig() {
     const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
 
@@ -94,7 +94,7 @@ export class SysConfigMangeApi extends BaseApiController {
     return result;
   }
 
-  @Post('/deleteSysConfig', { middleware: [checkPermission(SystemFuncCode.SysConfigMangeWrite), refreshCache(CacheNameEnum.GetSysConfigOne)] })
+  @Post('/deleteSysConfig', { middleware: [checkPermission(SystemFuncCode.SysConfigMangeWrite), refreshBizMemCache('sysConfgCacheObj')] })
   async deleteSysConfig() {
     return this.executeSysSimpleSQL('sys_configs', KeysOfSimpleSQL.SIMPLE_DELETE, {
       enableSoftDelete: true,

package/src/controller/manage/SystemInfoManageApi.ts

@@ -5,6 +5,7 @@ import { BaseApiController } from '../base/BaseApiController';
 import { SystemFuncCode } from '@/models/SystemPerm';
 import { CommonResult } from '@/libs/utils/common-dto';
 import { CrudMonitor } from "@/libs/crud-pro/utils/CrudMonitor";
+import { bizMemCacheStore } from '@/service/base/bizmemcache/BizMemCacheStore';
 
 @Controller('/ns/api/manage/systemInfo',)
 export class SystemInfoManageApi extends BaseApiController {
@@ -59,7 +60,8 @@ export class SystemInfoManageApi extends BaseApiController {
       timeInfo,
       envInfo,
       networkInfo,
-      crudMonitorInfo: CrudMonitor
+      crudMonitorInfo: CrudMonitor,
+      bizMemCacheLastTime: bizMemCacheStore.getLastTimeSnapshot(),
     });
   }
 }

package/src/controller/manage/WorkbenchMangeApi.ts

@@ -3,8 +3,7 @@ import { Context } from '@midwayjs/koa';
 import { KeysOfSimpleSQL, KeysOfValidators } from '@/libs/crud-pro/models/keys';
 import { BaseApiController } from '../base/BaseApiController';
 import { checkPermission } from '@/middleware/permission.middleware';
-import { refreshCache } from '@/middleware/cacherefresh.middleware';
-import { CacheNameEnum } from '@/models/bizmodels';
+import { refreshBizMemCache } from '@/middleware/cacherefresh.middleware';
 import { SystemFuncCode } from '@/models/SystemPerm';
 import { SystemTables } from '@/models/SystemTables';
 
@@ -27,7 +26,7 @@ export class WorkbenchMangeApi extends BaseApiController {
     });
   }
 
-  @Post('/createWorkbench', { middleware: [checkPermission(SystemFuncCode.WorkbenchMangeWrite), refreshCache([CacheNameEnum.GetWorkbenchCachedObj, CacheNameEnum.CurdMixByWorkbench])] })
+  @Post('/createWorkbench', { middleware: [checkPermission(SystemFuncCode.WorkbenchMangeWrite), refreshBizMemCache('workbenchCachedObj')] })
   async createWorkbench() {
 
     const body = this.ctx.request.body as any;
@@ -45,7 +44,7 @@ export class WorkbenchMangeApi extends BaseApiController {
     });
   }
 
-  @Post('/updateWorkbench', { middleware: [checkPermission(SystemFuncCode.WorkbenchMangeWrite), refreshCache([CacheNameEnum.GetWorkbenchCachedObj, CacheNameEnum.CurdMixByWorkbench])] })
+  @Post('/updateWorkbench', { middleware: [checkPermission(SystemFuncCode.WorkbenchMangeWrite), refreshBizMemCache('workbenchCachedObj')] })
   async updateWorkbench() {
 
     return this.executeSysSimpleSQL(SystemTables.sys_workbench, KeysOfSimpleSQL.SIMPLE_UPDATE, {
@@ -57,7 +56,7 @@ export class WorkbenchMangeApi extends BaseApiController {
     });
   }
 
-  @Post('/deleteWorkbench', { middleware: [checkPermission(SystemFuncCode.WorkbenchMangeWrite), refreshCache([CacheNameEnum.GetWorkbenchCachedObj, CacheNameEnum.CurdMixByWorkbench])] })
+  @Post('/deleteWorkbench', { middleware: [checkPermission(SystemFuncCode.WorkbenchMangeWrite), refreshBizMemCache('workbenchCachedObj')] })
   async deleteWorkbench() {
 
     return this.executeSysSimpleSQL(SystemTables.sys_workbench, KeysOfSimpleSQL.SIMPLE_DELETE, {

package/src/index.ts

@@ -59,6 +59,9 @@ export * from './service/UserAccountService';
 export * from './service/UserSessionService';
 export * from './service/VisitStatService';
 export * from './service/WorkbenchService';
+export * from './service/base/bizmemcache/BizMemCacheService';
+export * from './service/base/bizmemcache/BizMemCacheTypes';
+export * from './service/base/bizmemcache/BizMemCacheStore';
 export * from './service/anyapi/AnyApiSandboxService';
 export * from './service/anyapi/AnyApiService';
 export * from './service/base/ApiBaseService';

package/src/libs/crud-pro/models/TransactionSqlServer.ts

@@ -8,11 +8,16 @@ import * as _ from 'lodash';
 class SqlServerConnectionClient implements IPoolConnectionClient {
   originConnection: ConnectionPool;
   private sqlServerTransaction: Transaction;
+  private isReleased: boolean = false;
   constructor(originConnection: ConnectionPool) {
     this.originConnection = originConnection;
+    CrudMonitor.mssqlGetConnectionCount++;
   }
   async query(sql: string, values: any[]): Promise<IPoolConnectionQueryResult> {
-    const request = new Request(this.originConnection);
+    // 如果存在活跃的事务，请求应该绑定到事务上，否则事务不生效
+    const request = this.sqlServerTransaction
+      ? new Request(this.sqlServerTransaction)
+      : new Request(this.originConnection);
 
     if (Array.isArray(values)) {
       for (let i = 0; i < values.length; i++) {
@@ -41,18 +46,35 @@ class SqlServerConnectionClient implements IPoolConnectionClient {
 
   async commit() {
     const tmpTx = this.sqlServerTransaction;
-    await tmpTx.commit();
+    if (tmpTx) {
+      await tmpTx.commit();
+    }
   }
 
   async rollback() {
     const tmpTx = this.sqlServerTransaction;
-     await tmpTx.rollback();
+    if (tmpTx) {
+      await tmpTx.rollback();
+    }
   }
 
 
   async release() {
+    if (this.isReleased) {
+      return;
+    }
+    this.isReleased = true;
     try {
-      CrudMonitor.postgresReleaseConnectionCount++;
+      // 如果有未结束的事务，先回滚
+      if (this.sqlServerTransaction) {
+        try {
+          await this.sqlServerTransaction.rollback();
+        } catch (e) {
+          // 事务可能已经回滚或提交，忽略错误
+        }
+        this.sqlServerTransaction = null;
+      }
+      CrudMonitor.mssqlReleaseConnectionCount++;
     } catch (e) {
       console.log('[crud-pro] SqlServerConnectionClient release ', e);
     }

package/src/libs/crud-pro/services/CrudProCachedCfgService.ts

@@ -3,19 +3,28 @@ import { CrudProServiceBase } from './CrudProServiceBase';
 import { IRequestCfgModel } from '../interfaces';
 import { MixinUtils } from '../utils/MixinUtils';
 import { ICurdProServiceHub } from '../models/ServiceHub';
-// import { pickAndConvertRowsByMix } from '../utils/sqlConvert/convertMix';
-import MemoryRefreshCache from '../utils/MemoryRefreshCache';
-const DEFAULT_KEEP_TIME = 1000 * 60 * 60 * 24 * 365; // 内存缓存时间默认 1年
 
-const methodCache = new MemoryRefreshCache();
+/** 由上层 BizMemCache 注入的方法配置缓存，key 为 method */
+let externalMethodCacheMap: Record<string, IRequestCfgModel> | null = null;
 
-function parseMethodInfo(row: any): any {
-  const methodInfo: any = camelizeKeys(row); //转换成驼峰
+export function parseCrudMethodInfo(row: any): IRequestCfgModel {
+  const methodInfo: any = camelizeKeys(row);
   const configObject = MixinUtils.parseJsonObject(methodInfo.moreConfig) || {};
   const sqlCfgList = MixinUtils.parseJsonObject(methodInfo.sqlCfgList) || [];
   return { ...configObject, ...methodInfo, sqlCfgList };
 }
 
+/**
+ * 注入 CRUD 方法配置缓存（由 BizMemCache 加载后调用）
+ */
+export function setMethodCache(methodInfoList: IRequestCfgModel[] | null): void {
+  if (!methodInfoList) {
+    externalMethodCacheMap = null;
+    return;
+  }
+  externalMethodCacheMap = MixinUtils.toMap(methodInfoList, item => item.method);
+}
+
 class CrudProCachedCfgService extends CrudProServiceBase {
   constructor(serviceHub: ICurdProServiceHub) {
     super(serviceHub);
@@ -30,26 +39,24 @@ class CrudProCachedCfgService extends CrudProServiceBase {
   }
 
   private async getCachedCfgByMethodInner(method: string, isEnableCache: boolean): Promise<IRequestCfgModel | null> {
-    // 不使用缓存
     if (!isEnableCache) {
       return await this.loadMethodInfo(method);
     }
 
-    methodCache.setProps({
-      keepTime: DEFAULT_KEEP_TIME, // 1年
-      requestFn: () => this.loadMethodInfoList(),
-      getKeyFn: item => item.method,
-    });
-    const methodInfo = await methodCache.getItem(method);
-    if (methodInfo) {
-      return methodInfo;
+    if (externalMethodCacheMap) {
+      const methodInfo = externalMethodCacheMap[method];
+      if (methodInfo) {
+        return methodInfo;
+      }
     }
+
+    // 缓存未就绪或未命中时，降级单条查询
     return await this.loadMethodInfo(method);
   }
 
-  private async loadMethodInfo(method: string): Promise<any> {
+  private async loadMethodInfo(method: string): Promise<IRequestCfgModel | null> {
     const { methodsTableName, sysDatabaseName, sysDatabaseDbType } = this.getContextCfg();
-    const sql = `select * from ${methodsTableName} where method = ? `; // 全部加载到内存
+    const sql = `select * from ${methodsTableName} where method = ? `;
 
     const baseInfo = {
       sqlTable: methodsTableName,
@@ -60,35 +67,10 @@ class CrudProCachedCfgService extends CrudProServiceBase {
     const queryRes = await this.executeUnsafeQuery(baseInfo, sql, [method]);
     const rows2: any[] = queryRes.rows || [];
     if (rows2.length > 0) {
-      return parseMethodInfo(rows2[0]);
+      return parseCrudMethodInfo(rows2[0]);
     }
     return null;
   }
-
-  private async loadMethodInfoList(): Promise<any[]> {
-    const { methodsTableName, sysDatabaseName, sysDatabaseDbType } = this.getContextCfg();
-    const sql = `select * from ${methodsTableName}`; // 全部加载到内存
-    const baseInfo = {
-      sqlTable: methodsTableName,
-      sqlDatabase: sysDatabaseName,
-      sqlDbType: sysDatabaseDbType,
-    };
-    const queryRes = await this.executeUnsafeQuery(baseInfo, sql);
-    const rows2: any[] = queryRes.rows || [];
-    return rows2.map(row => {
-      return parseMethodInfo(row);
-    });
-  }
 }
 
 export { CrudProCachedCfgService };
-
-/**
- * 清空 CRUD 方法配置缓存（独立函数，无需实例化 Service 即可调用）
- *
- * 清空后，下次请求会自动从数据库重新加载（懒加载刷新）。
- * 适用于 manage 增删改触发刷新、定时刷新等场景。
- */
-export function clearMethodCache(): void {
-  methodCache.clear();
-}

package/src/libs/crud-pro/utils/CrudMonitor.ts

@@ -3,10 +3,8 @@ import { CacheNameEnum } from '@/models/bizmodels';
 import { CacheRefreshCategory } from '@/models/CacheRefreshCategory';
 
 export type CacheLastRefreshTimeMap = {
-  // CacheRefreshCategory 缓存类别
   [K in CacheRefreshCategory]: number | null;
 } & {
-  // CacheNameEnum 业务缓存
   [K in CacheNameEnum]: number | null;
 };
 
@@ -20,42 +18,21 @@ const CrudMonitor = {
   mssqlGetConnectionCount: 0,
   mssqlReleaseConnectionCount: 0,
 
-  /** 每个缓存项的最近一次刷新时间（时间戳 ms），null 表示尚未刷新 */
   cacheLastRefreshTime: {
-    // CacheRefreshCategory
     [CacheRefreshCategory.TableMeta]: null,
     [CacheRefreshCategory.CacheService]: null,
     [CacheRefreshCategory.LinkToCustom]: null,
-    [CacheRefreshCategory.ProxyApiRoute]: null,
-    [CacheRefreshCategory.CrudMethodConfig]: null,
-    // CacheNameEnum
     [CacheNameEnum.CurdMixByAccount]: null,
-    [CacheNameEnum.CurdMixByDict]: null,
     [CacheNameEnum.CurdMixByLinkToCustom]: null,
-    [CacheNameEnum.CurdMixByWorkbench]: null,
-    [CacheNameEnum.GetSysConfigOne]: null,
-    [CacheNameEnum.GetDataDictItemsByDictCode]: null,
-    [CacheNameEnum.GetWorkbenchCachedObj]: null,
-    [CacheNameEnum.GetSysAppOne]: null,
-    [CacheNameEnum.GetSysAppPageOne]: null,
-    [CacheNameEnum.GetSysMenusList]: null,
     [CacheNameEnum.GetFlowConfigOne]: null,
     [CacheNameEnum.UserSessionBySessionId]: null,
     [CacheNameEnum.UserSessionByAsyncTaskId]: null,
   } as CacheLastRefreshTimeMap,
 
-  /**
-   * 记录缓存刷新时间
-   * @param key 缓存类别或缓存名
-   */
   markCacheRefreshed(key: CacheRefreshKey): void {
     (this.cacheLastRefreshTime as any)[key] = Date.now();
   },
 
-  /**
-   * 获取缓存最近刷新时间
-   * @param key 缓存类别或缓存名
-   */
   getCacheLastRefreshTime(key: CacheRefreshKey): number | null {
     return (this.cacheLastRefreshTime as any)[key] ?? null;
   },

package/src/libs/crud-pro/utils/pool/SqlServerUtils.ts

@@ -3,12 +3,43 @@ import { IConnectionPool } from '../../interfaces';
 import { SqlDbType } from '../../models/keys';
 
 const POOL_CACHE_MAP: Record<string, IConnectionPool> = {};
+const POOL_CONNECTING_MAP: Record<string, Promise<ConnectionPool>> = {};
+
+async function doConnectPool(poolName: string, poolObj: ConnectionPool): Promise<ConnectionPool> {
+  // 避免重复连接同一个池
+  if (POOL_CONNECTING_MAP[poolName]) {
+    return POOL_CONNECTING_MAP[poolName];
+  }
+
+  const connectPromise = poolObj.connect().then((connectedPool) => {
+    console.log(`[crud-pro] SQL Server connection pool "${poolName}" connected successfully.`);
+    return connectedPool;
+  }).catch((err) => {
+    console.error(`[crud-pro] SQL Server connection pool "${poolName}" connect failed:`, err);
+    throw err;
+  }).finally(() => {
+    delete POOL_CONNECTING_MAP[poolName];
+  });
+
+  POOL_CONNECTING_MAP[poolName] = connectPromise;
+  return connectPromise;
+}
 
 function getConnectionPool(poolName: string, poolOptions: any): IConnectionPool {
   let pool = POOL_CACHE_MAP[poolName];
   if (!pool) {
     const poolObj = new ConnectionPool(poolOptions);
 
+    // 监听连接池错误，避免未捕获的异常导致进程崩溃
+    poolObj.on('error', (err) => {
+      console.error(`[crud-pro] SQL Server connection pool "${poolName}" error:`, err);
+    });
+
+    // 预连接池，避免首次请求时才建立连接导致延迟
+    doConnectPool(poolName, poolObj).catch(() => {
+      // 错误已在 doConnectPool 中打印，此处无需重复处理
+    });
+
     pool = {
       dbType: SqlDbType.sqlserver,
       poolName: poolName,

package/src/middleware/cacherefresh.middleware.ts

@@ -1,80 +1,19 @@
-import { NextFunction, Context, IMidwayKoaContext } from '@midwayjs/koa';
-import { CacheNameEnum } from '@/models/bizmodels';
-import { CacheRefreshCategory } from '@/models/CacheRefreshCategory';
-import { CacheServiceFactory } from '@/service/base/cache/CacheServiceFactory';
-import { CacheRefreshHub } from '@/service/base/cache-refresh/CacheRefreshHub';
+import { NextFunction, Context } from '@midwayjs/koa';
+import { RedisService } from '@midwayjs/redis';
+import { bizMemCacheStore } from '@/service/base/bizmemcache/BizMemCacheStore';
+import { BizMemCacheKey } from '@/service/base/bizmemcache/BizMemCacheTypes';
 
-/**
- * 缓存刷新中间件
- *
- * 在路由处理成功完成后，自动触发指定缓存项的刷新。
- * 采用后置刷新模式：先 await next() 让业务逻辑执行完毕，再刷新缓存。
- *
- * 应用场景：
- * 1. manage 增删改操作后自动刷新关联的业务缓存
- * 2. 精准刷新：只刷新与本次操作相关的缓存项，避免全量刷新
- *
- * 使用示例：
- * ```typescript
- * // 刷新全部业务缓存（向后兼容，等同原来的 refreshCache()）
- * @Post('/createRole', { middleware: [checkPermission('write'), refreshCache()] })
- * async createRole() { ... }
- *
- * // 精准刷新：只刷新指定缓存项
- * @Post('/createMenu', { middleware: [checkPermission('write'), refreshCache(CacheNameEnum.GetSysMenusList)] })
- * async createMenu() { ... }
- *
- * // 同时刷新多个缓存项
- * @Post('/createApp', { middleware: [checkPermission('write'), refreshCache([CacheNameEnum.GetSysAppOne, CacheNameEnum.GetSysAppPageOne])] })
- * async createApp() { ... }
- * ```
- *
- * @param cacheName 缓存名称，不传则刷新全部，支持单个或数组
- */
-function refreshCache(cacheName?: CacheNameEnum | CacheNameEnum[]) {
-  const cacheNames = cacheName ? (Array.isArray(cacheName) ? cacheName : [cacheName]) : null;
+function refreshBizMemCache(cacheKey: BizMemCacheKey | BizMemCacheKey[]) {
+  const cacheKeys = Array.isArray(cacheKey) ? cacheKey : [cacheKey];
 
   return async (ctx: Context, next: NextFunction) => {
     await next();
 
-    const cacheServiceFactory = await ctx.requestContext.getAsync(CacheServiceFactory);
-
-    if (cacheNames) {
-      // 精准刷新：只刷新指定的缓存项
-      for (const name of cacheNames) {
-        await cacheServiceFactory.refreshByCacheName(name, ctx as IMidwayKoaContext);
-      }
-    } else {
-      // 全量刷新：刷新所有已注册的业务缓存
-      await cacheServiceFactory.refreshAllCache(ctx as IMidwayKoaContext);
-    }
-  };
-}
-
-/**
- * 缓存类别刷新中间件
- *
- * 通过 CacheRefreshHub 刷新指定类别的缓存（TableMeta / LinkToCustom / ProxyApiRoute 等）。
- * 适用于非 CacheNameEnum 管理的缓存类别。
- *
- * 使用示例：
- * ```typescript
- * @Post('/createProxyApi', { middleware: [checkPermission('write'), refreshCategory(CacheRefreshCategory.ProxyApiRoute)] })
- * async createProxyApi() { ... }
- * ```
- *
- * @param category 缓存类别，支持单个或数组
- */
-function refreshCategory(category: CacheRefreshCategory | CacheRefreshCategory[]) {
-  const categories = Array.isArray(category) ? category : [category];
-
-  return async (ctx: Context, next: NextFunction) => {
-    await next();
-
-    for (const cat of categories) {
-      await CacheRefreshHub.refresh(cat, ctx as IMidwayKoaContext);
+    const redisService = await ctx.requestContext.getAsync(RedisService);
+    for (const key of cacheKeys) {
+      await bizMemCacheStore.markDirty(key, redisService);
     }
   };
 }
 
-export { refreshCache, refreshCategory };
+export { refreshBizMemCache };

package/src/models/CacheRefreshCategory.ts

@@ -1,24 +1,7 @@
-/**
- * 缓存刷新类型枚举
- *
- * 用于统一标识项目中的各类缓存，支持：
- * - 定时刷新（10分钟自动刷新）
- * - API 主动刷新（helpers/refreshCache?category=xxx）
- * - manage 增删改触发刷新
- * - Redis Pub/Sub 集群广播刷新
- */
 export enum CacheRefreshCategory {
-  /** 表元数据缓存（CrudProTableMetaService 的 metaCache + tableInfoCache） */
   TableMeta = 'TableMeta',
-  /** CacheServiceFactory 管理的业务缓存（CacheNameEnum 定义的所有缓存） */
   CacheService = 'CacheService',
-  /** linkToCustom 关联枚举缓存（CurdMixByLinkToCustomService 管理的关联数据缓存） */
   LinkToCustom = 'LinkToCustom',
-  /** 代理API路由缓存（ProxyApiLoadService 的 RouteTrie + UpstreamMap） */
-  ProxyApiRoute = 'ProxyApiRoute',
-  /** CRUD 方法配置缓存（CrudProCachedCfgService 的 methodCache） */
-  CrudMethodConfig = 'CrudMethodConfig',
 }
 
-/** 所有缓存刷新类型列表，用于全量刷新 */
 export const ALL_CACHE_REFRESH_CATEGORIES = Object.values(CacheRefreshCategory);

package/src/models/SystemEntities.ts

@@ -95,6 +95,8 @@ export interface IProxyApiEntity extends IApiBaseEntity {
   pass_real_ip: number; // DONE
   change_origin: string; // DONE
   change_host: string; // DONE
+  custom_header: string;
+  custom_body: string;
 
   balanceStrategy: string; // 负载均衡策略
   targetList: IUpstreamItem[]; // 运行时根据upstream_code计算的

package/src/models/bizmodels.ts

@@ -152,15 +152,7 @@ export interface ICacheService {
 
 export enum CacheNameEnum {
   CurdMixByAccount = 'CurdMixByAccount',
-  CurdMixByDict = 'CurdMixByDict',
   CurdMixByLinkToCustom = 'CurdMixByLinkToCustom',
-  CurdMixByWorkbench = 'CurdMixByWorkbench',
-  GetSysConfigOne = 'GetSysConfigOne',
-  GetDataDictItemsByDictCode = 'GetDataDictItemsByDictCode',
-  GetWorkbenchCachedObj = 'GetWorkbenchCachedObj',
-  GetSysAppOne = 'GetSysAppOne',
-  GetSysAppPageOne = 'GetSysAppPageOne',
-  GetSysMenusList = 'GetSysMenusList',
   GetFlowConfigOne = 'GetFlowConfigOne',
 
   UserSessionBySessionId = 'UserSessionBySessionId', // 只能是Redis

package/src/schedule/scheduleNames.ts

@@ -1,13 +1,15 @@
 const INNER_SCHEDULE_INTERVAL = {
-  cacheRefreshHubScheduleService: 10 * 60 * 1000, // 10分钟刷新一次所有缓存
-  visitStatService: 10 * 60 * 1000, // 10分钟重新加载一次访问统计
-  asyncTaskRunnerService: 1000, // 1s可以执行
+  cacheRefreshHubScheduleService: 10 * 60 * 1000,
+  visitStatService: 10 * 60 * 1000,
+  asyncTaskRunnerService: 1000,
+  bizMemCacheService: 1000,
 };
 
 const INNER_SCHEDULE_NAMES = {
   cacheRefreshHubScheduleService: 'cacheRefreshHubScheduleService',
   visitStatService: 'visitStatService',
   asyncTaskRunnerService: 'asyncTaskRunnerService',
+  bizMemCacheService: 'bizMemCacheService',
 };
 
 export { INNER_SCHEDULE_INTERVAL, INNER_SCHEDULE_NAMES };

package/src/service/SysAppService.ts

@@ -1,39 +1,11 @@
-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';
+import { buildSysAppPageCacheKey } from '@/service/base/bizmemcache/BizMemCacheTypes';
 
 @Provide()
 export class SysAppService extends BaseService {
 
-  @Inject()
-  private curdProService: CurdProService;
-
-  @Inject()
-  private cacheServiceFactory: CacheServiceFactory;
-
-  private get sysAppDao() {
-    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
-    return this.curdProService.getQuickCrud({
-      sqlDatabase: SystemDbName,
-      sqlDbType: SystemDbType,
-      sqlTable: SystemTables.sys_app,
-    })
-  }
-
-  private get sysAppPageDao() {
-    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
-    return this.curdProService.getQuickCrud({
-      sqlDatabase: SystemDbName,
-      sqlDbType: SystemDbType,
-      sqlTable: SystemTables.sys_app_page,
-    })
-  }
-
-
   async getSysAppPageOne({ page_path, workbench_code }: { page_path: string, workbench_code: string }): Promise<Record<string, any>> {
     if (!page_path || typeof page_path !== 'string') {
       throw new Error('[getSysAppPageOne] page_path required');
@@ -41,17 +13,8 @@ export class SysAppService extends BaseService {
     if (!workbench_code || typeof workbench_code !== 'string') {
       throw new Error('[getSysAppPageOne] workbench_code required');
     }
-    return await this.cacheServiceFactory.getJsonObjectCache({
-      cacheKey: `${workbench_code}#${page_path}`,
-      cacheName: CacheNameEnum.GetSysAppPageOne,
-      getter: async (ctx) => {
-        const service: SysAppService = await ctx.requestContext.getAsync(SysAppService);
-        const res = await service.sysAppPageDao.findOne({
-          condition: { page_path, workbench_code, deleted_at: 0 }
-        });
-        return res.row;
-      },
-    });
+    const sysAppPageMap = bizMemCacheStore.getSysAppPage()?.sysAppPageMap || {};
+    return sysAppPageMap[buildSysAppPageCacheKey(workbench_code, page_path)];
   }
 
 
@@ -59,17 +22,8 @@ export class SysAppService extends BaseService {
     if (!app_code || typeof app_code !== 'string') {
       throw new Error('[getSysAppOne] app_code required');
     }
-    return await this.cacheServiceFactory.getJsonObjectCache({
-      cacheKey: app_code,
-      cacheName: CacheNameEnum.GetSysAppOne,
-      getter: async (ctx) => {
-        const service: SysAppService = await ctx.requestContext.getAsync(SysAppService);
-        const res = await service.sysAppDao.findOne({
-          condition: { app_code, deleted_at: 0 }
-        });
-        return res.row;
-      },
-    });
+    const sysAppCodeMap = bizMemCacheStore.getSysApp()?.sysAppCodeMap || {};
+    return sysAppCodeMap[app_code];
   }
 
   public deletePrivateField(parsedAppInfo: any) {
@@ -92,25 +46,18 @@ export class SysAppService extends BaseService {
     if (!app_code || typeof app_code !== 'string') {
       throw new Error('[removeSysAppOneCache] app_code required');
     }
-    return await this.cacheServiceFactory.removeItemCache({
-      cacheKey: app_code,
-      cacheName: CacheNameEnum.GetSysAppOne
-    });
+    await bizMemCacheStore.markDirty('sysAppCacheObj', this.redisService);
   }
 
+  async removeSysAppPageCache() {
+    await bizMemCacheStore.markDirty('sysAppPageCacheObj', this.redisService);
+  }
 
-  async removeSysAppCacheByCondition({condition} : any){
+  async removeSysAppCacheByCondition({ condition }: any) {
     if (!condition) {
       throw new Error('[removeSysAppCacheByCondition] condition required');
     }
-    const res = await this.sysAppDao.findList({
-      condition: { ...condition, deleted_at: 0 },
-      columns: ['id','app_code']
-    });
-    const appList = res.rows;
-    for (const app of appList) {
-      await this.removeSysAppOneCache(app.app_code);
-    }
+    await bizMemCacheStore.markDirty('sysAppCacheObj', this.redisService);
   }
 
 }