create-dp-koa 1.1.1 → 1.1.3

package/template/src/framework/utils/CacheManager.ts

@@ -1,430 +0,0 @@
-import { logger } from '@src/framework/utils/logger';
-
-/**
- * 缓存接口
- * 定义通用的缓存操作
- */
-export interface ICache {
-    /**
-     * 获取缓存值
-     */
-    get<T>(key: string): Promise<T | null>;
-
-    /**
-     * 设置缓存值
-     */
-    set<T>(key: string, value: T, ttl?: number): Promise<boolean>;
-
-    /**
-     * 删除缓存
-     */
-    delete(key: string): Promise<boolean>;
-
-    /**
-     * 检查缓存是否存在
-     */
-    exists(key: string): Promise<boolean>;
-
-    /**
-     * 清空所有缓存
-     */
-    clear(): Promise<boolean>;
-
-    /**
-     * 获取多个缓存值
-     */
-    mget<T>(keys: string[]): Promise<(T | null)[]>;
-
-    /**
-     * 设置多个缓存值
-     */
-    mset<T>(keyValuePairs: Array<{ key: string; value: T; ttl?: number }>): Promise<boolean>;
-
-    /**
-     * 删除多个缓存
-     */
-    mdelete(keys: string[]): Promise<boolean>;
-
-    /**
-     * 获取缓存剩余过期时间
-     */
-    ttl(key: string): Promise<number>;
-
-    /**
-     * 设置缓存过期时间
-     */
-    expire(key: string, ttl: number): Promise<boolean>;
-}
-
-/**
- * 内存缓存实现
- * 用于开发环境和简单场景
- */
-export class MemoryCache implements ICache {
-    private cache: Map<string, { value: any; expiresAt?: number }> = new Map();
-    private static instance: MemoryCache;
-
-    private constructor() {}
-
-    static getInstance(): MemoryCache {
-        if (!MemoryCache.instance) {
-            MemoryCache.instance = new MemoryCache();
-        }
-        return MemoryCache.instance;
-    }
-
-    async get<T>(key: string): Promise<T | null> {
-        const item = this.cache.get(key);
-        if (!item) {
-            return null;
-        }
-
-        // 检查是否过期
-        if (item.expiresAt && Date.now() > item.expiresAt) {
-            this.cache.delete(key);
-            return null;
-        }
-
-        return item.value as T;
-    }
-
-    async set<T>(key: string, value: T, ttl?: number): Promise<boolean> {
-        try {
-            const expiresAt = ttl ? Date.now() + (ttl * 1000) : undefined;
-            this.cache.set(key, { value, expiresAt });
-            return true;
-        } catch (error) {
-            logger.error('设置缓存失败:', error as Error);
-            return false;
-        }
-    }
-
-    async delete(key: string): Promise<boolean> {
-        return this.cache.delete(key);
-    }
-
-    async exists(key: string): Promise<boolean> {
-        const item = this.cache.get(key);
-        if (!item) {
-            return false;
-        }
-
-        // 检查是否过期
-        if (item.expiresAt && Date.now() > item.expiresAt) {
-            this.cache.delete(key);
-            return false;
-        }
-
-        return true;
-    }
-
-    async clear(): Promise<boolean> {
-        this.cache.clear();
-        return true;
-    }
-
-    async mget<T>(keys: string[]): Promise<(T | null)[]> {
-        return Promise.all(keys.map(key => this.get<T>(key)));
-    }
-
-    async mset<T>(keyValuePairs: Array<{ key: string; value: T; ttl?: number }>): Promise<boolean> {
-        try {
-            for (const { key, value, ttl } of keyValuePairs) {
-                await this.set(key, value, ttl);
-            }
-            return true;
-        } catch (error) {
-            logger.error('批量设置缓存失败:', error as Error);
-            return false;
-        }
-    }
-
-    async mdelete(keys: string[]): Promise<boolean> {
-        try {
-            for (const key of keys) {
-                await this.delete(key);
-            }
-            return true;
-        } catch (error) {
-            logger.error('批量删除缓存失败:', error as Error);
-            return false;
-        }
-    }
-
-    async ttl(key: string): Promise<number> {
-        const item = this.cache.get(key);
-        if (!item || !item.expiresAt) {
-            return -1;
-        }
-
-        const remaining = Math.ceil((item.expiresAt - Date.now()) / 1000);
-        return remaining > 0 ? remaining : -2;
-    }
-
-    async expire(key: string, ttl: number): Promise<boolean> {
-        const item = this.cache.get(key);
-        if (!item) {
-            return false;
-        }
-
-        item.expiresAt = Date.now() + (ttl * 1000);
-        return true;
-    }
-
-    /**
-     * 获取缓存统计信息
-     */
-    getStats(): { size: number; keys: string[] } {
-        return {
-            size: this.cache.size,
-            keys: Array.from(this.cache.keys())
-        };
-    }
-}
-
-/**
- * Redis缓存实现
- * 用于生产环境
- */
-export class RedisCache implements ICache {
-    private redis: any;
-    private static instance: RedisCache;
-
-    private constructor() {}
-
-    static getInstance(): RedisCache {
-        if (!RedisCache.instance) {
-            RedisCache.instance = new RedisCache();
-        }
-        return RedisCache.instance;
-    }
-
-    /**
-     * 初始化Redis连接
-     */
-    async initialize(): Promise<void> {
-        try {
-            // 这里应该根据实际的Redis客户端库进行初始化
-            // const Redis = require('ioredis');
-            // this.redis = new Redis({
-            //     host: process.env.REDIS_HOST || 'localhost',
-            //     port: parseInt(process.env.REDIS_PORT || '6379'),
-            //     password: process.env.REDIS_PASSWORD,
-            //     db: parseInt(process.env.REDIS_DB || '0'),
-            // });
-            logger.info('Redis缓存初始化成功');
-        } catch (error) {
-            logger.error('Redis缓存初始化失败:', error as Error);
-            throw error;
-        }
-    }
-
-    async get<T>(key: string): Promise<T | null> {
-        try {
-            const value = await this.redis.get(key);
-            return value ? JSON.parse(value) : null;
-        } catch (error) {
-            logger.error('获取Redis缓存失败:', error as Error);
-            return null;
-        }
-    }
-
-    async set<T>(key: string, value: T, ttl?: number): Promise<boolean> {
-        try {
-            const serializedValue = JSON.stringify(value);
-            if (ttl) {
-                await this.redis.setex(key, ttl, serializedValue);
-            } else {
-                await this.redis.set(key, serializedValue);
-            }
-            return true;
-        } catch (error) {
-            logger.error('设置Redis缓存失败:', error as Error);
-            return false;
-        }
-    }
-
-    async delete(key: string): Promise<boolean> {
-        try {
-            const result = await this.redis.del(key);
-            return result > 0;
-        } catch (error) {
-            logger.error('删除Redis缓存失败:', error as Error);
-            return false;
-        }
-    }
-
-    async exists(key: string): Promise<boolean> {
-        try {
-            const result = await this.redis.exists(key);
-            return result === 1;
-        } catch (error) {
-            logger.error('检查Redis缓存存在性失败:', error as Error);
-            return false;
-        }
-    }
-
-    async clear(): Promise<boolean> {
-        try {
-            await this.redis.flushdb();
-            return true;
-        } catch (error) {
-            logger.error('清空Redis缓存失败:', error as Error);
-            return false;
-        }
-    }
-
-    async mget<T>(keys: string[]): Promise<(T | null)[]> {
-        try {
-            const values = await this.redis.mget(...keys);
-            return values.map((value: string) => value ? JSON.parse(value) : null);
-        } catch (error) {
-            logger.error('批量获取Redis缓存失败:', error as Error);
-            return keys.map(() => null);
-        }
-    }
-
-    async mset<T>(keyValuePairs: Array<{ key: string; value: T; ttl?: number }>): Promise<boolean> {
-        try {
-            const pipeline = this.redis.pipeline();
-            
-            for (const { key, value, ttl } of keyValuePairs) {
-                const serializedValue = JSON.stringify(value);
-                if (ttl) {
-                    pipeline.setex(key, ttl, serializedValue);
-                } else {
-                    pipeline.set(key, serializedValue);
-                }
-            }
-            
-            await pipeline.exec();
-            return true;
-        } catch (error) {
-            logger.error('批量设置Redis缓存失败:', error as Error);
-            return false;
-        }
-    }
-
-    async mdelete(keys: string[]): Promise<boolean> {
-        try {
-            const result = await this.redis.del(...keys);
-            return result > 0;
-        } catch (error) {
-            logger.error('批量删除Redis缓存失败:', error as Error);
-            return false;
-        }
-    }
-
-    async ttl(key: string): Promise<number> {
-        try {
-            return await this.redis.ttl(key);
-        } catch (error) {
-            logger.error('获取Redis缓存TTL失败:', error as Error);
-            return -1;
-        }
-    }
-
-    async expire(key: string, ttl: number): Promise<boolean> {
-        try {
-            const result = await this.redis.expire(key, ttl);
-            return result === 1;
-        } catch (error) {
-            logger.error('设置Redis缓存过期时间失败:', error as Error);
-            return false;
-        }
-    }
-}
-
-/**
- * 缓存管理器
- * 提供统一的缓存接口和策略
- */
-export class CacheManager {
-    private static instance: CacheManager;
-    private cache: ICache;
-    private cacheType: 'memory' | 'redis';
-
-    private constructor() {
-        this.cacheType = process.env.CACHE_TYPE === 'redis' ? 'redis' : 'memory';
-        this.initializeCache();
-    }
-
-    static getInstance(): CacheManager {
-        if (!CacheManager.instance) {
-            CacheManager.instance = new CacheManager();
-        }
-        return CacheManager.instance;
-    }
-
-    /**
-     * 初始化缓存
-     */
-    private initializeCache(): void {
-        if (this.cacheType === 'redis') {
-            this.cache = RedisCache.getInstance();
-        } else {
-            this.cache = MemoryCache.getInstance();
-        }
-        
-        logger.info(`缓存系统初始化完成，类型: ${this.cacheType}`);
-    }
-
-    /**
-     * 获取缓存实例
-     */
-    getCache(): ICache {
-        return this.cache;
-    }
-
-    /**
-     * 获取缓存类型
-     */
-    getCacheType(): string {
-        return this.cacheType;
-    }
-
-    /**
-     * 生成缓存键
-     */
-    generateKey(prefix: string, ...parts: (string | number)[]): string {
-        return `${prefix}:${parts.join(':')}`;
-    }
-
-    /**
-     * 用户缓存键生成器
-     */
-    getUserCacheKey(userId: number): string {
-        return this.generateKey('user', userId);
-    }
-
-    /**
-     * 商品缓存键生成器
-     */
-    getGoodsCacheKey(goodsId: number): string {
-        return this.generateKey('goods', goodsId);
-    }
-
-    /**
-     * 店铺缓存键生成器
-     */
-    getShopCacheKey(shopId: number): string {
-        return this.generateKey('shop', shopId);
-    }
-
-    /**
-     * 清空所有缓存
-     */
-    async clearAllCache(): Promise<boolean> {
-        try {
-            await this.cache.clear();
-            logger.info('所有缓存已清空');
-            return true;
-        } catch (error) {
-            logger.error('清空缓存失败:', error as Error);
-            return false;
-        }
-    }
-}
-
-// 导出单例实例
-export const cacheManager = CacheManager.getInstance();

package/template/src/framework/utils/CacheService.ts

@@ -1,248 +0,0 @@
-import { Injectable } from "dp-ioc2";
-import { cacheManager } from "@src/framework/utils/CacheManager";
-import { logger } from "@src/framework/utils/logger";
-
-/**
- * 缓存装饰器
- * 提供方法级别的缓存功能
- */
-export function Cacheable(options: {
-    key?: string;
-    ttl?: number;
-    condition?: (args: any[]) => boolean;
-    cacheManager?: any;
-}) {
-    return function (target: any, propertyName: string, descriptor: PropertyDescriptor) {
-        const method = descriptor.value;
-        const cache = options.cacheManager || cacheManager.getCache();
-
-        descriptor.value = async function (...args: any[]) {
-            // 检查缓存条件
-            if (options.condition && !options.condition(args)) {
-                return await method.apply(this, args);
-            }
-
-            // 生成缓存键
-            const cacheKey = options.key || `${target.constructor.name}:${propertyName}:${JSON.stringify(args)}`;
-
-            try {
-                // 尝试从缓存获取
-                const cachedResult = await cache.get(cacheKey);
-                if (cachedResult !== null) {
-                    logger.debug(`缓存命中: ${cacheKey}`);
-                    return cachedResult;
-                }
-
-                // 执行原方法
-                const result = await method.apply(this, args);
-
-                // 存储到缓存
-                await cache.set(cacheKey, result, options.ttl);
-                logger.debug(`缓存存储: ${cacheKey}`);
-
-                return result;
-            } catch (error) {
-                logger.error(`缓存操作失败: ${cacheKey}`, error as Error);
-                // 缓存失败时仍然执行原方法
-                return await method.apply(this, args);
-            }
-        };
-    };
-}
-
-/**
- * 缓存失效装饰器
- * 在方法执行后清除相关缓存
- */
-export function CacheEvict(options: {
-    keys?: string[];
-    keyPattern?: string;
-    allEntries?: boolean;
-    cacheManager?: any;
-}) {
-    return function (target: any, propertyName: string, descriptor: PropertyDescriptor) {
-        const method = descriptor.value;
-        const cache = options.cacheManager || cacheManager.getCache();
-
-        descriptor.value = async function (...args: any[]) {
-            try {
-                // 执行原方法
-                const result = await method.apply(this, args);
-
-                // 清除缓存
-                if (options.allEntries) {
-                    await cache.clear();
-                    logger.debug(`清空所有缓存`);
-                } else if (options.keyPattern) {
-                    // 这里需要根据具体的缓存实现来处理模式匹配
-                    logger.debug(`清除匹配模式的缓存: ${options.keyPattern}`);
-                } else if (options.keys) {
-                    await cache.mdelete(options.keys);
-                    logger.debug(`清除指定缓存: ${options.keys.join(', ')}`);
-                }
-
-                return result;
-            } catch (error) {
-                logger.error(`缓存清除失败`, error as Error);
-                // 清除缓存失败时仍然返回原方法结果
-                return await method.apply(this, args);
-            }
-        };
-    };
-}
-
-/**
- * 缓存更新装饰器
- * 在方法执行后更新相关缓存
- */
-export function CachePut(options: {
-    key: string;
-    ttl?: number;
-    cacheManager?: any;
-}) {
-    return function (target: any, propertyName: string, descriptor: PropertyDescriptor) {
-        const method = descriptor.value;
-        const cache = options.cacheManager || cacheManager.getCache();
-
-        descriptor.value = async function (...args: any[]) {
-            try {
-                // 执行原方法
-                const result = await method.apply(this, args);
-
-                // 更新缓存
-                await cache.set(options.key, result, options.ttl);
-                logger.debug(`缓存更新: ${options.key}`);
-
-                return result;
-            } catch (error) {
-                logger.error(`缓存更新失败: ${options.key}`, error as Error);
-                // 更新缓存失败时仍然返回原方法结果
-                return await method.apply(this, args);
-            }
-        };
-    };
-}
-
-/**
- * 缓存服务
- * 提供业务级别的缓存管理
- */
-@Injectable()
-export class CacheService {
-    private cache = cacheManager.getCache();
-
-    /**
-     * 缓存用户信息
-     */
-    async cacheUser(userId: number, userData: any, ttl: number = 3600): Promise<boolean> {
-        const key = cacheManager.getUserCacheKey(userId);
-        return await this.cache.set(key, userData, ttl);
-    }
-
-    /**
-     * 获取缓存的用户信息
-     */
-    async getCachedUser(userId: number): Promise<any | null> {
-        const key = cacheManager.getUserCacheKey(userId);
-        return await this.cache.get(key);
-    }
-
-    /**
-     * 清除用户缓存
-     */
-    async evictUserCache(userId: number): Promise<boolean> {
-        const key = cacheManager.getUserCacheKey(userId);
-        return await this.cache.delete(key);
-    }
-
-    /**
-     * 缓存商品信息
-     */
-    async cacheGoods(goodsId: number, goodsData: any, ttl: number = 1800): Promise<boolean> {
-        const key = cacheManager.getGoodsCacheKey(goodsId);
-        return await this.cache.set(key, goodsData, ttl);
-    }
-
-    /**
-     * 获取缓存的商品信息
-     */
-    async getCachedGoods(goodsId: number): Promise<any | null> {
-        const key = cacheManager.getGoodsCacheKey(goodsId);
-        return await this.cache.get(key);
-    }
-
-    /**
-     * 清除商品缓存
-     */
-    async evictGoodsCache(goodsId: number): Promise<boolean> {
-        const key = cacheManager.getGoodsCacheKey(goodsId);
-        return await this.cache.delete(key);
-    }
-
-    /**
-     * 缓存店铺信息
-     */
-    async cacheShop(shopId: number, shopData: any, ttl: number = 3600): Promise<boolean> {
-        const key = cacheManager.getShopCacheKey(shopId);
-        return await this.cache.set(key, shopData, ttl);
-    }
-
-    /**
-     * 获取缓存的店铺信息
-     */
-    async getCachedShop(shopId: number): Promise<any | null> {
-        const key = cacheManager.getShopCacheKey(shopId);
-        return await this.cache.get(key);
-    }
-
-    /**
-     * 清除店铺缓存
-     */
-    async evictShopCache(shopId: number): Promise<boolean> {
-        const key = cacheManager.getShopCacheKey(shopId);
-        return await this.cache.delete(key);
-    }
-
-    /**
-     * 批量清除相关缓存
-     */
-    async evictRelatedCaches(keys: string[]): Promise<boolean> {
-        return await this.cache.mdelete(keys);
-    }
-
-    /**
-     * 预热缓存
-     */
-    async warmupCache(): Promise<void> {
-        try {
-            logger.info('开始缓存预热...');
-            
-            // 这里可以添加具体的预热逻辑
-            // 例如：预加载热门商品、用户信息等
-            
-            logger.info('缓存预热完成');
-        } catch (error) {
-            logger.error('缓存预热失败:', error as Error);
-        }
-    }
-
-    /**
-     * 获取缓存统计信息
-     */
-    async getCacheStats(): Promise<any> {
-        try {
-            if (cacheManager.getCacheType() === 'memory') {
-                const memoryCache = cacheManager.getCache() as any;
-                return memoryCache.getStats();
-            }
-            
-            return {
-                type: cacheManager.getCacheType(),
-                status: 'active'
-            };
-        } catch (error) {
-            logger.error('获取缓存统计信息失败:', error as Error);
-            return null;
-        }
-    }
-}