Typescript中的装饰器模式

装饰器模式概述

装饰器模式是一种结构型设计模式，它允许向一个现有的对象添加新的功能，同时又不改变其结构。在面向对象编程中，我们常常会遇到需要为对象添加额外功能的情况，传统的继承方式可能会导致类的层次结构变得复杂，而装饰器模式提供了一种更为灵活的解决方案。

在TypeScript中，装饰器是一种特殊类型的声明，它能够对类、方法、属性或参数进行注解和修改。通过使用装饰器，我们可以在不修改原有代码的基础上，为对象添加新的行为或功能。这在实际开发中非常有用，例如在日志记录、权限控制、性能监测等场景中。

TypeScript装饰器基础

类装饰器

类装饰器应用于类的定义。它接收一个参数，即被装饰的类的构造函数。以下是一个简单的类装饰器示例：

function logClass(target: Function) {
    console.log(target);
    target.prototype.apiUrl = 'http://localhost:3000';
}

@logClass
class HttpClient {
    constructor() { }
    getData() { }
}

const http = new HttpClient();
console.log(http.apiUrl); 

在上述代码中，logClass是一个类装饰器。当它应用到HttpClient类上时，它会在控制台打印出HttpClient类的构造函数，并为HttpClient的原型添加一个apiUrl属性。

方法装饰器

方法装饰器应用于类的方法。它接收三个参数：目标对象（类的原型）、方法名称和属性描述符。属性描述符包含了方法的一些元信息，如是否可枚举、是否可写等。

function log(target: any, key: string, descriptor: PropertyDescriptor) {
    const originalMethod = descriptor.value;
    descriptor.value = function (...args: any[]) {
        console.log(`Calling method ${key} with arguments:`, args);
        const result = originalMethod.apply(this, args);
        console.log(`Method ${key} returned:`, result);
        return result;
    };
    return descriptor;
}

class MathUtils {
    @log
    add(a: number, b: number) {
        return a + b;
    }
}

const math = new MathUtils();
math.add(2, 3); 

在这个例子中，log装饰器对MathUtils类的add方法进行了包装。在方法调用前后，分别打印出方法调用的参数和返回值。

属性装饰器

属性装饰器应用于类的属性。它接收两个参数：目标对象（类的原型）和属性名称。

function readonly(target: any, key: string) {
    Object.defineProperty(target, key, {
        writable: false
    });
}

class User {
    @readonly
    name: string = 'John';
}

const user = new User();
// user.name = 'Jane'; // 这将导致运行时错误，因为name属性是只读的

上述代码中，readonly装饰器使User类的name属性变为只读，试图修改该属性会导致运行时错误。

参数装饰器

参数装饰器应用于类方法的参数。它接收三个参数：目标对象（类的原型）、方法名称和参数在参数列表中的索引。

function validateNumber(target: any, key: string, index: number) {
    return function (...args: any[]) {
        if (typeof args[index]!== 'number') {
            throw new Error(`Argument at index ${index} must be a number`);
        }
        return Reflect.apply(target[key], this, args);
    };
}

class Calculator {
    calculate(@validateNumber num1: number, num2: number) {
        return num1 + num2;
    }
}

const calculator = new Calculator();
calculator.calculate(2, 3); 
// calculator.calculate('2', 3); // 这将抛出错误

在这个例子中，validateNumber装饰器确保calculate方法的第一个参数是数字类型，否则抛出错误。

装饰器的执行顺序

当一个类有多个装饰器时，它们的执行顺序是从下往上的。例如：

function first() {
    console.log('first decorator');
    return function (target: Function) { };
}

function second() {
    console.log('second decorator');
    return function (target: Function) { };
}

@first()
@second()
class MyClass { }

在上述代码中，second装饰器会先执行，然后是first装饰器。

对于类的方法、属性和参数的装饰器，它们在类实例化时执行。例如，对于方法装饰器，在类实例化时，装饰器会对方法进行包装，之后每次调用该方法时，都会执行装饰器中定义的逻辑。

装饰器工厂

有时候，我们需要为装饰器传递参数，这就需要使用装饰器工厂。装饰器工厂是一个返回装饰器的函数。

function logWithPrefix(prefix: string) {
    return function (target: any, key: string, descriptor: PropertyDescriptor) {
        const originalMethod = descriptor.value;
        descriptor.value = function (...args: any[]) {
            console.log(`${prefix} Calling method ${key} with arguments:`, args);
            const result = originalMethod.apply(this, args);
            console.log(`${prefix} Method ${key} returned:`, result);
            return result;
        };
        return descriptor;
    };
}

class AnotherMathUtils {
    @logWithPrefix('DEBUG: ')
    multiply(a: number, b: number) {
        return a * b;
    }
}

const anotherMath = new AnotherMathUtils();
anotherMath.multiply(2, 3); 

在这个例子中，logWithPrefix是一个装饰器工厂，它接收一个prefix参数，并返回一个装饰器。这个装饰器在方法调用前后打印带有前缀的日志信息。

装饰器与AOP（面向切面编程）

装饰器模式与AOP有着紧密的联系。AOP的核心思想是将横切关注点（如日志记录、权限控制、事务管理等）从业务逻辑中分离出来，通过“切面”的方式将这些关注点应用到多个对象或方法上。

在TypeScript中，装饰器为实现AOP提供了一种有效的手段。例如，通过使用方法装饰器来实现日志记录，我们可以将日志记录的逻辑从业务方法中分离出来，使得业务方法更加专注于自身的功能实现。

以一个电商系统为例，我们可能有多个服务类，如ProductService、OrderService等。每个服务类可能都有一些需要记录日志的方法。通过使用装饰器，我们可以定义一个通用的日志记录装饰器，并将其应用到这些方法上，而无需在每个方法内部编写重复的日志记录代码。

function logMethod(target: any, key: string, descriptor: PropertyDescriptor) {
    const originalMethod = descriptor.value;
    descriptor.value = function (...args: any[]) {
        console.log(`[${new Date().toISOString()}] Calling method ${key} in class ${target.constructor.name}`);
        const result = originalMethod.apply(this, args);
        console.log(`[${new Date().toISOString()}] Method ${key} in class ${target.constructor.name} returned:`, result);
        return result;
    };
    return descriptor;
}

class ProductService {
    @logMethod
    getProductById(id: number) {
        // 模拟获取产品逻辑
        return { id, name: 'Sample Product' };
    }
}

class OrderService {
    @logMethod
    placeOrder(order: any) {
        // 模拟下单逻辑
        return 'Order placed successfully';
    }
}

const productService = new ProductService();
const orderService = new OrderService();

productService.getProductById(1);
orderService.placeOrder({}); 

在这个例子中，logMethod装饰器实现了对ProductService和OrderService类中方法的日志记录。这体现了AOP的思想，将日志记录这个横切关注点从业务逻辑中分离出来，通过装饰器统一应用到多个方法上。

装饰器在实际项目中的应用场景

日志记录

日志记录是装饰器非常常见的应用场景。通过在方法上使用装饰器，我们可以方便地记录方法的调用信息，包括参数和返回值，这对于调试和监控系统运行状态非常有帮助。

权限控制

在企业级应用中，权限控制是至关重要的。我们可以使用装饰器来实现对方法的权限验证。例如，只有具有特定权限的用户才能调用某些方法。

function requirePermission(permission: string) {
    return function (target: any, key: string, descriptor: PropertyDescriptor) {
        const originalMethod = descriptor.value;
        descriptor.value = function (...args: any[]) {
            // 假设这里有一个函数getCurrentUserPermissions用于获取当前用户的权限
            const userPermissions = getCurrentUserPermissions();
            if (!userPermissions.includes(permission)) {
                throw new Error('Permission denied');
            }
            return originalMethod.apply(this, args);
        };
        return descriptor;
    };
}

class AdminService {
    @requirePermission('admin:edit')
    editUser(user: any) {
        // 编辑用户的逻辑
    }
}

const adminService = new AdminService();
try {
    adminService.editUser({}); 
} catch (error) {
    console.error(error.message); 
}

在上述代码中，requirePermission装饰器确保只有具有admin:edit权限的用户才能调用editUser方法。

性能监测

我们可以使用装饰器来监测方法的执行时间，从而找出性能瓶颈。

function measurePerformance(target: any, key: string, descriptor: PropertyDescriptor) {
    const originalMethod = descriptor.value;
    descriptor.value = function (...args: any[]) {
        const start = Date.now();
        const result = originalMethod.apply(this, args);
        const end = Date.now();
        console.log(`Method ${key} took ${end - start} ms to execute`);
        return result;
    };
    return descriptor;
}

class DataProcessor {
    @measurePerformance
    processData(data: any) {
        // 模拟数据处理逻辑
        return data;
    }
}

const dataProcessor = new DataProcessor();
dataProcessor.processData({}); 

在这个例子中，measurePerformance装饰器记录了processData方法的执行时间。

装饰器的局限性

虽然装饰器在很多场景下非常有用，但它也存在一些局限性。

首先，装饰器在运行时执行，这意味着它们会增加代码的执行开销。尤其是在频繁调用被装饰的方法时，这种开销可能会变得比较明显。

其次，装饰器的语法在不同的JavaScript运行环境中可能存在兼容性问题。虽然TypeScript对装饰器提供了支持，但在一些旧版本的JavaScript引擎中，可能需要使用特定的转译工具来确保装饰器能够正常工作。

另外，过多地使用装饰器可能会导致代码的可读性下降。特别是当一个类或方法上应用了多个装饰器时，理解这些装饰器之间的相互作用和整体逻辑可能会变得困难。

装饰器与元数据

在TypeScript中，装饰器常常与元数据一起使用。元数据是关于数据的数据，它可以用来存储一些与类、方法、属性或参数相关的额外信息。

TypeScript提供了reflect - metadata库来支持元数据。通过使用这个库，我们可以在装饰器中定义和读取元数据。

import 'reflect - metadata';

const metadataKey = 'description';

function addDescription(description: string) {
    return function (target: any, key: string) {
        Reflect.defineMetadata(metadataKey, description, target, key);
    };
}

class MyClass {
    @addDescription('This is a sample method')
    sampleMethod() { }
}

const description = Reflect.getMetadata(metadataKey, MyClass.prototype,'sampleMethod');
console.log(description); 

在上述代码中，addDescription装饰器使用Reflect.defineMetadata方法为MyClass类的sampleMethod方法定义了一个元数据，键为description，值为This is a sample method。之后，通过Reflect.getMetadata方法可以读取这个元数据。

元数据与装饰器的结合使用，为我们提供了一种强大的机制，可以在运行时获取关于代码结构和行为的额外信息，这在很多场景下（如依赖注入、路由配置等）都非常有用。

总结装饰器模式在TypeScript中的应用

装饰器模式在TypeScript中为我们提供了一种灵活且强大的方式来为对象添加新功能，同时保持原有代码结构的清晰和可维护性。通过类装饰器、方法装饰器、属性装饰器和参数装饰器，我们可以实现诸如日志记录、权限控制、性能监测等各种功能。

装饰器与AOP的紧密联系使得横切关注点能够从业务逻辑中分离出来，提高了代码的模块化和可复用性。在实际项目中，装饰器在日志记录、权限控制、性能监测等场景中有着广泛的应用。

然而，我们也需要注意装饰器的局限性，如运行时开销、兼容性问题以及可能对代码可读性产生的影响。同时，合理地使用装饰器与元数据的结合，可以进一步增强我们代码的功能和灵活性。

在使用装饰器时，应该根据项目的实际需求和规模，谨慎地选择是否使用以及如何使用装饰器，以确保代码的质量和性能。通过深入理解装饰器模式在TypeScript中的应用，我们能够更好地利用这一强大的工具来构建高质量的软件系统。