function myDecorator(target: any) {
  // 裝飾器邏輯
}
@myDecorator
class MyClass {
  // 類的定義
}

function outerDecorator(target: any) {
  console.log("Outer decorator");
}
function innerDecorator(target: any) {
  console.log("Inner decorator");
}
@outerDecorator
@innerDecorator
class MyDecoratedClass {
  // 類的定義
}

@Component({
  selector: 'app-my-component',
  templateUrl: './my-component.html'
})
class MyComponent {
  // 組件的定義
}

class UserController {
  @Get('/users')
  getUsers(req: Request, res: Response) {
    // 處理GET請求的邏輯
  }
}

class User {
  @Column()
  username: string;
  @Column()
  email: string;
}

class MyService {
  constructor(@Inject('MyDependency') private myDependency: MyDependency) {
    // 構(gòu)造函數(shù)的定義
  }
}

// 定義一個依賴注入裝飾器
function Injectable(target: any) {
  // 在這里可以執(zhí)行依賴注入的邏輯
}
// 使用依賴注入裝飾器
@Injectable
class MyService {
  constructor(private myDependency: MyDependency) {
    //
在上述示例中，我們定義了一個名為 `Injectable` 的裝飾器，它標(biāo)記了 `MyService` 類。該裝飾器通常與依賴注入容器一起使用，容器會根據(jù)裝飾器的信息來實例化 `MyService` 類，并注入 `myDependency` 依賴。
#### 3.2 路由控制
在Web應(yīng)用程序中，路由控制是一項重要的功能，它允許我們定義不同路徑下的頁面或資源，并指定與之相關(guān)聯(lián)的處理函數(shù)。裝飾器可以用于定義路由信息，使路由管理更加簡單和直觀。
```typescript
// 定義一個路由處理函數(shù)裝飾器
function RouteHandler(path: string) {
  return function(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    // 在這里可以將路由信息與處理函數(shù)關(guān)聯(lián)起來
  };
}
class MyController {
  @RouteHandler('/users')
  getUsers(req: Request, res: Response) {
    // 處理GET請求的邏輯
  }
}

// 定義一個元數(shù)據(jù)裝飾器
function Metadata(key: string, value: any) {
  return function(target: any, propertyKey: string) {
    // 在這里可以將元數(shù)據(jù)關(guān)聯(lián)到目標(biāo)對象上
  };
}
class MyModel {
  @Metadata('version', '1.0')
  version: string;
}

// 定義一個緩存裝飾器
function Cache(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;
  const cache = new Map();
  descriptor.value = function (...args: any[]) {
    const key = JSON.stringify(args);
    if (cache.has(key)) {
      return cache.get(key);
    } else {
      const result = originalMethod.apply(this, args);
      cache.set(key, result);
      return result;
    }
  };
  return descriptor;
}
class MathService {
  @Cache
  fibonacci(n: number): number {
    if (n <= 1) {
      return n;
    }
    return this.fibonacci(n - 1) + this.fibonacci(n - 2);
  }
}

function MyDecorator(target: Function) {
  // 訪問類的原型對象
  const prototype = target.prototype;
  // 修改原型對象，添加新方法
  prototype.newMethod = function() {
    // 新方法的實現(xiàn)
  };
  // 返回一個新的構(gòu)造函數(shù)
  return class extends target {
    constructor(...args: any[]) {
      super(...args);
      // 在新構(gòu)造函數(shù)中可以執(zhí)行額外邏輯
    }
  };
}
@MyDecorator
class MyClass {
  // 類的定義
}
const instance = new MyClass();
instance.newMethod(); // 調(diào)用通過裝飾器添加的方法

// 方法裝飾器的原理
function MyMethodDecorator(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  // 可以訪問目標(biāo)方法的信息
在方法裝飾器的原理中，`target` 表示裝飾器應(yīng)用的目標(biāo)類的原型對象，`propertyKey` 表示被裝飾的方法的名稱，`descriptor` 是一個描述目標(biāo)方法的對象，它包含方法的配置和屬性。
通過訪問這些信息，方法裝飾器可以在不修改原始方法定義的情況下，對方法進(jìn)行修改、攔截、增強(qiáng)或添加元數(shù)據(jù)。例如，可以在方法裝飾器中修改方法的實現(xiàn)，添加參數(shù)驗證，或者記錄方法的調(diào)用日志。
```typescript
function MyMethodDecorator(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  // 訪問目標(biāo)方法的原始實現(xiàn)
  const originalMethod = descriptor.value;
  // 修改目標(biāo)方法的實現(xiàn)
  descriptor.value = function (...args: any[]) {
    // 在調(diào)用原始方法之前可以執(zhí)行一些邏輯
    console.log(`Calling method ${propertyKey} with arguments: ${JSON.stringify(args)}`);
    // 調(diào)用原始方法
    const result = originalMethod.apply(this, args);
    // 在調(diào)用原始方法之后可以執(zhí)行一些邏輯
    console.log(`Method ${propertyKey} returned: ${result}`);
    return result;
  };
}
class MyClass {
  @MyMethodDecorator
  myMethod(arg1: number, arg2: string): number {
    return arg1 + arg2.length;
  }
}
const instance = new MyClass();
const result = instance.myMethod(42, "Hello");

function Model(tableName: string) {
  return function(target: any) {
    // 在這里可以處理模型的元數(shù)據(jù)，例如表名
    Reflect.defineMetadata('tableName', tableName, target);
  };
}
@Model('users')
class User {
  id: number;
  username: string;
  email: string;
}

function Column(columnName: string) {
  return function(target: any, propertyKey: string) {
    // 在這里可以處理列的元數(shù)據(jù)，例如列名
    const columns = Reflect.getMetadata('columns', target) || [];
    columns.push({ property: propertyKey, column: columnName });
    Reflect.defineMetadata('columns', columns, target);
  };
}
@Model('users')
class User {
  @Column('user_id')
  id: number;
  @Column('user_name')
  username: string;
  @Column('user_email')
  email: string;
}

function Query(query: string) {
  return function(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    // 在這里可以處理查詢的元數(shù)據(jù)，例如查詢語句
    Reflect.defineMetadata('query', query, descriptor.value);
  };
}
@Model('users')
class User {
  @Column('user_id')
  id: number;
  @Column('user_name')
  username: string;
  @Column('user_email')
  email: string;
  @Query('SELECT * FROM users WHERE user_id = ?')
  static findById(id: number): User {
    // 查詢邏輯
  }
}

// 查詢用戶
const user = User.findById(1);
console.log(user);
// 插入用戶
const newUser = new User();
newUser.username = 'john_doe';
newUser.email = 'john@example.com';
newUser.save(); // 假設(shè)我們有一個保存方法來將用戶插入數(shù)據(jù)庫