create-dp-koa 1.1.2 → 1.1.4

package/template/src/examples/InterceptorExampleRunner.ts

@@ -1,284 +0,0 @@
-/**
- * 完整Service拦截器使用示例
- * 展示基础拦截器和高级拦截器的使用
- */
-
-import { Injectable, Interceptor } from "dp-ioc2";
-import { createServiceCallInterceptor } from '@src/framework/interceptors/ServiceCallInterceptor';
-import { createAdvancedServiceCallInterceptor, InterceptorOptions } from '@src/framework/interceptors/AdvancedServiceCallInterceptor';
-import { logger } from '@src/framework/utils/logger';
-
-/**
- * 用户服务示例 - 使用基础拦截器
- */
-@Injectable()
-export class UserService {
-    
-    @Interceptor(createServiceCallInterceptor())
-    async getUserById(id: number): Promise<{ id: number; name: string; email: string }> {
-        logger.info(`获取用户信息: ${id}`);
-        
-        // 模拟数据库查询
-        await new Promise(resolve => setTimeout(resolve, 100));
-        
-        return {
-            id,
-            name: `用户${id}`,
-            email: `user${id}@example.com`
-        };
-    }
-    
-    @Interceptor(createServiceCallInterceptor())
-    async createUser(userData: { name: string; email: string; password: string }): Promise<{ id: number; name: string; email: string }> {
-        logger.info(`创建用户:`, userData);
-        
-        // 模拟创建用户
-        await new Promise(resolve => setTimeout(resolve, 200));
-        
-        const newUser = {
-            id: Math.floor(Math.random() * 1000),
-            name: userData.name,
-            email: userData.email
-        };
-        
-        return newUser;
-    }
-}
-
-/**
- * 订单服务示例 - 使用高级拦截器
- */
-@Injectable()
-export class OrderService {
-    
-    @Interceptor(createAdvancedServiceCallInterceptor({
-        enablePerformanceMonitoring: true,
-        enableCaching: true,
-        enableRetry: true,
-        enableCircuitBreaker: true,
-        cacheTTL: 300000, // 5分钟
-        maxRetries: 3,
-        retryDelay: 1000,
-        circuitBreakerThreshold: 3,
-        slowCallThreshold: 500
-    }))
-    async getOrderById(orderId: number): Promise<{ id: number; status: string; amount: number }> {
-        logger.info(`获取订单信息: ${orderId}`);
-        
-        // 模拟可能失败的外部API调用
-        if (Math.random() < 0.3) {
-            throw new Error('外部API调用失败');
-        }
-        
-        await new Promise(resolve => setTimeout(resolve, 300));
-        
-        return {
-            id: orderId,
-            status: 'completed',
-            amount: Math.floor(Math.random() * 1000) + 100
-        };
-    }
-    
-    @Interceptor(createAdvancedServiceCallInterceptor({
-        enablePerformanceMonitoring: true,
-        enableCaching: false,
-        enableRetry: true,
-        enableCircuitBreaker: false,
-        maxRetries: 2,
-        retryDelay: 500,
-        slowCallThreshold: 1000
-    }))
-    async createOrder(orderData: { userId: number; items: any[]; total: number }): Promise<{ id: number; status: string }> {
-        logger.info(`创建订单:`, orderData);
-        
-        // 模拟创建订单
-        await new Promise(resolve => setTimeout(resolve, 150));
-        
-        return {
-            id: Math.floor(Math.random() * 10000),
-            status: 'pending'
-        };
-    }
-}
-
-/**
- * 支付服务示例 - 使用高级拦截器（熔断器测试）
- */
-@Injectable()
-export class PaymentService {
-    
-    @Interceptor(createAdvancedServiceCallInterceptor({
-        enablePerformanceMonitoring: true,
-        enableCaching: false,
-        enableRetry: true,
-        enableCircuitBreaker: true,
-        maxRetries: 2,
-        retryDelay: 1000,
-        circuitBreakerThreshold: 2, // 低阈值，容易触发熔断
-        slowCallThreshold: 200
-    }))
-    async processPayment(paymentData: { orderId: number; amount: number; cardToken: string }): Promise<{ transactionId: string; status: string }> {
-        logger.info(`处理支付:`, paymentData);
-        
-        // 模拟支付服务不稳定（70%失败率）
-        if (Math.random() < 0.7) {
-            throw new Error('支付服务暂时不可用');
-        }
-        
-        await new Promise(resolve => setTimeout(resolve, 100));
-        
-        return {
-            transactionId: `txn_${Date.now()}`,
-            status: 'success'
-        };
-    }
-}
-
-/**
- * 拦截器示例运行器
- */
-export class InterceptorExampleRunner {
-    
-    /**
-     * 运行基础拦截器示例
-     */
-    static async runBasicInterceptorExample() {
-        logger.info('=== 基础拦截器示例 ===');
-        
-        const userService = new UserService();
-        
-        try {
-            // 测试正常调用
-            const user = await userService.getUserById(123);
-            logger.info('获取用户成功:', user);
-            
-            // 测试创建用户
-            const newUser = await userService.createUser({
-                name: '张三',
-                email: 'zhangsan@example.com',
-                password: 'password123'
-            });
-            logger.info('创建用户成功:', newUser);
-            
-        } catch (error) {
-            logger.error('基础拦截器示例失败:', error as Error);
-        }
-    }
-    
-    /**
-     * 运行高级拦截器示例
-     */
-    static async runAdvancedInterceptorExample() {
-        logger.info('=== 高级拦截器示例 ===');
-        
-        const orderService = new OrderService();
-        
-        try {
-            // 测试缓存和重试
-            logger.info('--- 测试缓存和重试 ---');
-            for (let i = 0; i < 3; i++) {
-                try {
-                    const order = await orderService.getOrderById(456);
-                    logger.info(`第${i + 1}次调用成功:`, order);
-                } catch (error) {
-                    logger.info(`第${i + 1}次调用失败:`, (error as Error).message);
-                }
-            }
-            
-            // 测试创建订单
-            logger.info('--- 测试创建订单 ---');
-            const order = await orderService.createOrder({
-                userId: 123,
-                items: [{ id: 1, quantity: 2 }],
-                total: 299.99
-            });
-            logger.info('创建订单成功:', order);
-            
-        } catch (error) {
-            logger.error('高级拦截器示例失败:', error as Error);
-        }
-    }
-    
-    /**
-     * 运行熔断器示例
-     */
-    static async runCircuitBreakerExample() {
-        logger.info('=== 熔断器示例 ===');
-        
-        const paymentService = new PaymentService();
-        
-        try {
-            // 连续失败调用，触发熔断器
-            logger.info('--- 触发熔断器 ---');
-            for (let i = 0; i < 5; i++) {
-                try {
-                    const payment = await paymentService.processPayment({
-                        orderId: 789,
-                        amount: 99.99,
-                        cardToken: 'card_token_123'
-                    });
-                    logger.info(`第${i + 1}次支付成功:`, payment);
-                } catch (error) {
-                    logger.info(`第${i + 1}次支付失败:`, (error as Error).message);
-                }
-                
-                // 短暂延迟
-                await new Promise(resolve => setTimeout(resolve, 100));
-            }
-            
-            // 等待熔断器恢复
-            logger.info('--- 等待熔断器恢复 ---');
-            await new Promise(resolve => setTimeout(resolve, 2000));
-            
-            // 尝试恢复调用
-            try {
-                const payment = await paymentService.processPayment({
-                    orderId: 999,
-                    amount: 199.99,
-                    cardToken: 'card_token_456'
-                });
-                logger.info('熔断器恢复后支付成功:', payment);
-            } catch (error) {
-                logger.info('熔断器恢复后支付仍然失败:', (error as Error).message);
-            }
-            
-        } catch (error) {
-            logger.error('熔断器示例失败:', error as Error);
-        }
-    }
-    
-    /**
-     * 显示拦截器统计信息
-     */
-    static showInterceptorStats() {
-        logger.info('=== 拦截器统计信息 ===');
-        
-        // 显示基础拦截器统计
-        const { serviceCallInterceptor } = require('@src/framework/interceptors/ServiceCallInterceptor');
-        logger.info('基础拦截器统计:');
-        logger.info(serviceCallInterceptor.generateReport());
-        
-        // 显示高级拦截器状态
-        const { advancedServiceCallInterceptor } = require('@src/framework/interceptors/AdvancedServiceCallInterceptor');
-        logger.info('高级拦截器状态:');
-        logger.info(JSON.stringify(advancedServiceCallInterceptor.getStatus(), null, 2));
-    }
-    
-    /**
-     * 运行所有示例
-     */
-    static async runAllExamples() {
-        try {
-            await this.runBasicInterceptorExample();
-            await this.runAdvancedInterceptorExample();
-            await this.runCircuitBreakerExample();
-            this.showInterceptorStats();
-            
-            logger.info('=== 所有拦截器示例运行完成 ===');
-            
-        } catch (error) {
-            logger.error('运行拦截器示例失败:', error as Error);
-        }
-    }
-}
-

package/template/src/examples/ServiceInterceptorExample.ts

@@ -1,214 +0,0 @@
-/**
- * Service调用拦截器使用示例
- * 展示如何在Service中使用Interceptor注解来监控方法调用
- */
-
-import { Injectable, Interceptor } from "dp-ioc2";
-import { createServiceCallInterceptor } from '@src/framework/interceptors/ServiceCallInterceptor';
-import { logger } from '@src/framework/utils/logger';
-
-/**
- * 示例Service - 展示拦截器的使用
- */
-@Injectable()
-export class ExampleService {
-    
-    /**
-     * 示例方法1：同步方法
-     * 使用拦截器监控调用
-     */
-    @Interceptor(createServiceCallInterceptor())
-    getUserInfo(userId: number): { id: number; name: string; email: string } {
-        logger.info(`执行getUserInfo方法，参数: ${userId}`);
-        
-        // 模拟业务逻辑
-        return {
-            id: userId,
-            name: `用户${userId}`,
-            email: `user${userId}@example.com`
-        };
-    }
-    
-    /**
-     * 示例方法2：异步方法
-     * 使用拦截器监控调用
-     */
-    @Interceptor(createServiceCallInterceptor())
-    async createUser(userData: { name: string; email: string; password: string }): Promise<{ id: number; name: string; email: string }> {
-        logger.info(`执行createUser方法，参数:`, userData);
-        
-        // 模拟异步业务逻辑
-        await new Promise(resolve => setTimeout(resolve, 100));
-        
-        const newUser = {
-            id: Math.floor(Math.random() * 1000),
-            name: userData.name,
-            email: userData.email
-        };
-        
-        logger.info(`创建用户成功:`, newUser);
-        return newUser;
-    }
-    
-    /**
-     * 示例方法3：可能抛出异常的方法
-     * 使用拦截器监控调用
-     */
-    @Interceptor(createServiceCallInterceptor())
-    async deleteUser(userId: number): Promise<boolean> {
-        logger.info(`执行deleteUser方法，参数: ${userId}`);
-        
-        // 模拟业务逻辑
-        if (userId <= 0) {
-            throw new Error('无效的用户ID');
-        }
-        
-        // 模拟异步操作
-        await new Promise(resolve => setTimeout(resolve, 50));
-        
-        logger.info(`删除用户成功: ${userId}`);
-        return true;
-    }
-    
-    /**
-     * 示例方法4：复杂参数的方法
-     * 使用拦截器监控调用
-     */
-    @Interceptor(createServiceCallInterceptor())
-    async updateUser(userId: number, updateData: { 
-        name?: string; 
-        email?: string; 
-        password?: string;
-        preferences?: any;
-    }): Promise<{ id: number; name: string; email: string; updated: string[] }> {
-        logger.info(`执行updateUser方法，参数:`, { userId, updateData });
-        
-        // 模拟业务逻辑
-        await new Promise(resolve => setTimeout(resolve, 80));
-        
-        const updatedFields = Object.keys(updateData).filter(key => updateData[key as keyof typeof updateData] !== undefined);
-        
-        const result = {
-            id: userId,
-            name: updateData.name || `用户${userId}`,
-            email: updateData.email || `user${userId}@example.com`,
-            updated: updatedFields
-        };
-        
-        logger.info(`更新用户成功:`, result);
-        return result;
-    }
-    
-    /**
-     * 示例方法5：批量操作
-     * 使用拦截器监控调用
-     */
-    @Interceptor(createServiceCallInterceptor())
-    async batchCreateUsers(usersData: Array<{ name: string; email: string; password: string }>): Promise<Array<{ id: number; name: string; email: string }>> {
-        logger.info(`执行batchCreateUsers方法，参数数量: ${usersData.length}`);
-        
-        const results = [];
-        
-        for (let i = 0; i < usersData.length; i++) {
-            const userData = usersData[i];
-            logger.info(`处理第${i + 1}个用户:`, userData);
-            
-            // 模拟异步操作
-            await new Promise(resolve => setTimeout(resolve, 30));
-            
-            const newUser = {
-                id: Math.floor(Math.random() * 1000) + i * 1000,
-                name: userData.name,
-                email: userData.email
-            };
-            
-            results.push(newUser);
-        }
-        
-        logger.info(`批量创建用户完成，共创建${results.length}个用户`);
-        return results;
-    }
-}
-
-/**
- * 拦截器使用示例类
- */
-export class ServiceInterceptorExample {
-    
-    /**
-     * 运行拦截器示例
-     */
-    static async runExample() {
-        try {
-            logger.info('=== Service调用拦截器示例开始 ===');
-            
-            // 创建Service实例
-            const exampleService = new ExampleService();
-            
-            // 测试同步方法
-            logger.info('\n--- 测试同步方法 ---');
-            const userInfo = exampleService.getUserInfo(123);
-            logger.info('同步方法结果:', userInfo);
-            
-            // 测试异步方法
-            logger.info('\n--- 测试异步方法 ---');
-            const newUser = await exampleService.createUser({
-                name: '张三',
-                email: 'zhangsan@example.com',
-                password: 'password123'
-            });
-            logger.info('异步方法结果:', newUser);
-            
-            // 测试异常方法
-            logger.info('\n--- 测试异常方法 ---');
-            try {
-                await exampleService.deleteUser(-1);
-            } catch (error) {
-                logger.info('捕获到预期的异常:', (error as Error).message);
-            }
-            
-            // 测试正常删除
-            await exampleService.deleteUser(456);
-            
-            // 测试复杂参数方法
-            logger.info('\n--- 测试复杂参数方法 ---');
-            const updateResult = await exampleService.updateUser(789, {
-                name: '李四',
-                email: 'lisi@example.com',
-                preferences: { theme: 'dark', language: 'zh-CN' }
-            });
-            logger.info('更新方法结果:', updateResult);
-            
-            // 测试批量操作
-            logger.info('\n--- 测试批量操作方法 ---');
-            const batchResult = await exampleService.batchCreateUsers([
-                { name: '王五', email: 'wangwu@example.com', password: 'pass123' },
-                { name: '赵六', email: 'zhaoliu@example.com', password: 'pass456' },
-                { name: '钱七', email: 'qianqi@example.com', password: 'pass789' }
-            ]);
-            logger.info('批量操作结果:', batchResult);
-            
-            logger.info('\n=== Service调用拦截器示例完成 ===');
-            
-        } catch (error) {
-            logger.error('运行拦截器示例失败:', error as Error);
-        }
-    }
-    
-    /**
-     * 显示拦截器统计信息
-     */
-    static showInterceptorStats() {
-        const { serviceCallInterceptor } = require('@src/framework/interceptors/ServiceCallInterceptor');
-        
-        logger.info('\n=== 拦截器统计信息 ===');
-        logger.info(serviceCallInterceptor.generateReport());
-        
-        logger.info('\n=== 最近调用历史 ===');
-        const history = serviceCallInterceptor.getCallHistory();
-        history.slice(-5).forEach((call: any, index: number) => {
-            logger.info(`${index + 1}. ${call.serviceName}.${call.methodName} - ${call.duration}ms - ${call.error ? '失败' : '成功'}`);
-        });
-    }
-}
-

package/template/src/examples/cacheExamples.ts

@@ -1,155 +0,0 @@
-/**
- * 缓存使用示例
- * 展示如何使用统一的缓存管理系统
- */
-
-import { createCache, CacheType, getCacheStats, getCacheMemoryUsage } from '@src/framework/utils/cache';
-
-// 示例1: 创建不同类型的缓存
-export class CacheExamples {
-    
-    // 创建用户缓存
-    private userCache = createCache('user-cache', CacheType.USER);
-    
-    // 创建会话缓存
-    private sessionCache = createCache('session-cache', CacheType.SESSION);
-    
-    // 创建验证码缓存
-    private captchaCache = createCache('captcha-cache', CacheType.CAPTCHA);
-    
-    // 创建临时缓存
-    private tempCache = createCache('temp-cache', CacheType.TEMP);
-
-    /**
-     * 用户缓存示例
-     */
-    async getUserInfo(userId: string) {
-        const cacheKey = `user:${userId}`;
-        
-        // 尝试从缓存获取
-        let userInfo = this.userCache.get(cacheKey);
-        
-        if (!userInfo) {
-            // 缓存未命中，从数据库获取
-            userInfo = await this.fetchUserFromDatabase(userId);
-            
-            // 存储到缓存，30分钟过期
-            this.userCache.set(cacheKey, userInfo, 1800);
-        }
-        
-        return userInfo;
-    }
-
-    /**
-     * 会话缓存示例
-     */
-    async getSession(sessionId: string) {
-        const cacheKey = `session:${sessionId}`;
-        
-        let session = this.sessionCache.get(cacheKey);
-        
-        if (!session) {
-            session = await this.fetchSessionFromDatabase(sessionId);
-            if (session) {
-                // 会话缓存1小时过期
-                this.sessionCache.set(cacheKey, session, 3600);
-            }
-        }
-        
-        return session;
-    }
-
-    /**
-     * 验证码缓存示例
-     */
-    async storeCaptcha(token: string, code: string) {
-        const cacheKey = `captcha:${token}`;
-        
-        // 验证码5分钟过期
-        this.captchaCache.set(cacheKey, code, 300);
-    }
-
-    async verifyCaptcha(token: string, inputCode: string): Promise<boolean> {
-        const cacheKey = `captcha:${token}`;
-        const storedCode = this.captchaCache.get(cacheKey);
-        
-        if (!storedCode) {
-            return false; // 验证码不存在或已过期
-        }
-        
-        const isValid = storedCode === inputCode;
-        
-        if (isValid) {
-            // 验证成功后删除验证码
-            this.captchaCache.del(cacheKey);
-        }
-        
-        return isValid;
-    }
-
-    /**
-     * 临时缓存示例（用于API限流等）
-     */
-    async checkRateLimit(ip: string): Promise<boolean> {
-        const cacheKey = `rate_limit:${ip}`;
-        const count = this.tempCache.get(cacheKey) || 0;
-        
-        if (count >= 10) { // 每分钟最多10次请求
-            return false;
-        }
-        
-        // 增加计数，1分钟过期
-        this.tempCache.set(cacheKey, count + 1, 60);
-        return true;
-    }
-
-    /**
-     * 获取缓存统计信息
-     */
-    getCacheStatistics() {
-        return {
-            stats: getCacheStats(),
-            memory: getCacheMemoryUsage()
-        };
-    }
-
-    // 模拟数据库查询方法
-    private async fetchUserFromDatabase(userId: string) {
-        // 模拟数据库查询
-        return { id: userId, name: `User ${userId}`, email: `${userId}@example.com` };
-    }
-
-    private async fetchSessionFromDatabase(sessionId: string) {
-        // 模拟数据库查询
-        return { id: sessionId, userId: '123', expiresAt: new Date() };
-    }
-}
-
-/**
- * 缓存配置示例
- * 展示如何为特定场景创建自定义配置的缓存
- */
-export class CustomCacheExamples {
-    
-    // 创建高频率访问的缓存（更多条目，更短过期时间）
-    private highFrequencyCache = createCache('high-freq', CacheType.CONTROLLER, {
-        stdTTL: 30, // 30秒过期
-        maxKeys: 5000, // 最多5000个条目
-        checkperiod: 60 // 每分钟检查过期
-    });
-
-    // 创建长期存储的缓存（更少条目，更长过期时间）
-    private longTermCache = createCache('long-term', CacheType.USER, {
-        stdTTL: 7200, // 2小时过期
-        maxKeys: 100, // 最多100个条目
-        checkperiod: 300 // 每5分钟检查过期
-    });
-
-    // 创建严格限制的缓存（用于敏感数据）
-    private strictCache = createCache('strict', CacheType.CAPTCHA, {
-        stdTTL: 60, // 1分钟过期
-        maxKeys: 50, // 最多50个条目
-        useClones: true, // 使用克隆模式，确保数据安全
-        deleteOnExpire: true // 严格删除过期数据
-    });
-}