装饰器模式

// ==================== 组件接口 ====================
interface Beverage {
  getDescription(): string;
  cost(): number;
}

// ==================== 具体组件 ====================
class Espresso implements Beverage {
  getDescription(): string {
    return 'Espresso';
  }

  cost(): number {
    return 1.99;
  }
}

class DarkRoast implements Beverage {
  getDescription(): string {
    return 'Dark Roast Coffee';
  }
  cost(): number {
    return 0.99;
  }
}

// ==================== 抽象装饰器 ====================
abstract class CondimentDecorator implements Beverage {
  constructor(protected beverage: Beverage) {}
  abstract getDescription(): string;
  abstract cost(): number;
}

// ==================== 具体装饰器 ====================
class Mocha extends CondimentDecorator {
  getDescription(): string { return this.beverage.getDescription() + ', Mocha'; }
  cost(): number { return 0.20 + this.beverage.cost(); }
}

class Whip extends CondimentDecorator {
  getDescription(): string { return this.beverage.getDescription() + ', Whip'; }
  cost(): number { return 0.10 + this.beverage.cost(); }
}

class Milk extends CondimentDecorator {
  getDescription(): string { return this.beverage.getDescription() + ', Milk'; }
  cost(): number { return 0.15 + this.beverage.cost(); }
}

// ==================== 装饰器构建器 ====================
class BeverageBuilder {
  private constructor(private beverage: Beverage) {}
  static create(beverage: Beverage): BeverageBuilder {
    return new BeverageBuilder(beverage);
  }
  with(Decorator: new (beverage: Beverage) => CondimentDecorator): this {
    this.beverage = new Decorator(this.beverage);
    return this;
  }
  build(): Beverage {
    return this.beverage;
  }
}

// 使用构建器
const myDrink = BeverageBuilder.create(new DarkRoast())
  .with(Mocha)
  .with(Mocha)
  .with(Whip)
  .build();

console.log(`${myDrink.getDescription()} $${myDrink.cost()}`);
// Dark Roast Coffee, Mocha, Mocha, Whip $1.49

type ClassDecoratorValue = new (...args: unknown[]) => unknown;

function sealed<T extends ClassDecoratorValue>(
  value: T,
  context: ClassDecoratorContext
): T {
  context.addInitializer(function (): void {
    Object.seal(value);
    Object.seal(value.prototype);
    console.log(`Class "${String(context.name)}" has been sealed.`);
  });
  return value;
}

// 实例计数装饰器：统计类被实例化的次数
function countInstances<TBase extends new (...args: any[]) => object>(
  value: TBase,
  _context: ClassDecoratorContext
) {
  let count = 0;
  return class extends value {
    constructor(...args: any[]) {
      super(...args);
      count++;
      console.log(`Created instance #${count} of ${String(_context.name)}`);
    }
    static getInstCount(): number { return count; }
  };
}

@sealed
@countInstances
class Repository {
  constructor(public name: string) {}
}

const repo1 = new Repository('users');
const repo2 = new Repository('orders');
console.log((Repository as unknown as { getInstCount: () => number }).getInstCount()); // 2

function log<This, Args extends unknown[], Return>(
  target: (this: This, ...args: Args) => Return,
  context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>
) {
  const methodName = String(context.name);

  return function (this: This, ...args: Args): Return {
    const timestamp = new Date().toISOString();
    console.log(`[${timestamp}] ${methodName} called with args: ${JSON.stringify(args)}`);

    const start = performance.now();
    const result = target.call(this, ...args);
    const duration = performance.now() - start;
    console.log(`[${methodName}] took ${duration.toFixed(2)}ms`);

    return result;
  };
}

// 使用
class UserRepository {
  @log
  async fetchData(url: string): Promise<unknown> {
    const response = await fetch(url);
    if (!response.ok) throw new Error(`HTTP ${response.status}`);
    return response.json();
  }
}

function required<T>(
  value: undefined,
  context: ClassFieldDecoratorContext<unknown, T>
): (this: unknown, initialValue: T) => T {
  return function (this: unknown, initialValue: T): T {
    if (initialValue === null || initialValue === undefined || initialValue === '') {
      throw new Error(`Field "${String(context.name)}" is required but received ${JSON.stringify(initialValue)}`);
    }
    return initialValue;
  };
}

// 使用
// 注意：字段装饰器的校验读取的是字段的初始值（字段初始化时机执行），
// 构造函数中 Object.assign 注入的值不会经过装饰器
class UserForm {
  @required
  username = 'alice';

  @required
  email = 'alice@example.com';

  @required
  password = '';

  id: string = crypto.randomUUID();
}

// new UserForm(); // Error: Field "password" is required but received ""

function memoize<This, Return>(
  target: (this: This) => Return,
  context: ClassGetterDecoratorContext<This, Return>
): (this: This) => Return {
  let cached = false;
  let cachedValue: Return;

  return function (this: This): Return {
    if (!cached) {
      cachedValue = target.call(this);
      cached = true;
    }
    return cachedValue!;
  };
}

// 访问器装饰器：校验 setter 值
function modeGuard<This>(
  target: (this: This, value: string) => void,
  context: ClassSetterDecoratorContext<This, string>
): (this: This, value: string) => void {
  const allowed = ['development', 'production', 'test'];
  return function (this: unknown, value: string) {
    if (!allowed.includes(value)) {
      throw new Error(`Mode must be one of: ${allowed.join(', ')}`);
    }
    return target.call(this, value);
  };
}

// 使用
class Configuration {
  private _mode: string = 'development';

  @memoize
  get connectionString(): string {
    console.log('Computing connection string...');
    return `postgres://localhost:3000/${this._mode}`;
  }

  @modeGuard
  set mode(value: string) {
    this._mode = value;
  }
}

const config = new Configuration();
console.log(config.connectionString); // Computing connection string... / postgres://localhost:3000/development
console.log(config.connectionString); // postgres://localhost:3000/development (cached)
config.mode = 'production';
// config.mode = 'staging'; // Error: Mode must be one of: development, production, test

// 通用日志装饰器工厂
function createLogDecorator(options: {
  prefix?: string;
  timestamp?: boolean;
  level?: 'debug' | 'info' | 'warn' | 'error';
}) {
  const { prefix = '[LOG]', timestamp = true, level = 'info' } = options;

  return function <This, Args extends unknown[], Return>(
    target: (this: This, ...args: Args) => Return,
    context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>
  ) {
    const methodName = String(context.name);
    return function (this: This, ...args: Args): Return {
      const time = timestamp ? new Date().toISOString() : '';
      console.log(`${prefix}${time ? ` [${time}]` : ''} [${level}] ${methodName} called`);
      const result = target.call(this, ...args);
      return result;
    };
  };
}

// 缓存装饰器工厂
function createCacheDecorator(options: { ttl?: number; maxSize?: number }) {
  const cache = new Map<string, { value: unknown; expiresAt: number }>();
  return function <This, Args extends unknown[], Return>(
    target: (this: This, ...args: Args) => Return,
    context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>
  ) {
    return function (this: This, ...args: Args): Return {
      const key = JSON.stringify(args);
      const hit = cache.get(key);
      if (hit && Date.now() < hit.expiresAt) {
        return hit.value as Return;
      }
      const value = target.call(this, ...args);
      cache.set(key, { value, expiresAt: Date.now() + (options.ttl ?? 60000) });
      return value;
    };
  };
}

// 权限装饰器工厂
function requirePermission(permission: string) {
  return function <This, Args extends unknown[], Return>(
    target: (this: This, ...args: Args) => Return,
    context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>
  ) {
    return function (this: This, ...args: Args): Return {
      const user = (this as Record<string, unknown>).currentUser as { role: string } | undefined;
      if (!user || user.role !== 'admin') {
        throw new Error(`缺少权限: ${permission}`);
      }
      return target.call(this, ...args);
    };
  };
}

// 使用
class ApiService {
  @createLogDecorator({ prefix: '[API]', timestamp: true, level: 'debug' })
  @createCacheDecorator({ ttl: 60000, maxSize: 500 })
  @requirePermission('admin:read')
  getDashboardData(): Record<string, unknown> {
    return { stats: { users: 1024, orders: 5678 } };
  }
}

// 横切关注点装饰器集合（复用上文 createLogDecorator / createCacheDecorator / requirePermission）
interface User {
  id: string;
  name: string;
}

const db = {
  users: {
    findById: async (id: string): Promise<User> => ({ id, name: `user-${id}` }),
  },
};

const withTiming = createLogDecorator({ prefix: '[TIMING]', timestamp: true });
const withCache = createCacheDecorator({ ttl: 30000 });
const withAuth = requirePermission('user:read');

class DataService {
  @withTiming
  @withCache
  @withAuth
  async queryUser(id: string): Promise<User> {
    return db.users.findById(id);
  }
}

// AOP 切面定义
type Aspect = {
  before?: (context: MethodInvocation) => void;
  after?: (context: MethodInvocation, result: unknown) => void;
  afterThrow?: (context: MethodInvocation, error: Error) => void;
  around?: (context: MethodInvocation, proceed: () => unknown) => unknown;
};

interface MethodInvocation {
  target: unknown;
  method: string;
  args: unknown[];
  returnValue?: unknown;
  error?: Error;
}

// AOP 装饰器：将切面织入目标方法
function applyAspect(aspect: Aspect) {
  return function <This, Args extends unknown[], Return>(
    target: (this: This, ...args: Args) => Return,
    context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>
  ) {
    return function (this: This, ...args: Args): Return {
      const invocation: MethodInvocation = { target: this, method: String(context.name), args };
      aspect.before?.(invocation);
      try {
        const result = aspect.around
          ? aspect.around(invocation, () => target.call(this, ...args))
          : target.call(this, ...args);
        invocation.returnValue = result;
        aspect.after?.(invocation, result);
        return result as Return;
      } catch (err) {
        invocation.error = err as Error;
        aspect.afterThrow?.(invocation, err as Error);
        throw err;
      }
    };
  };
}

// 切面定义
const loggingAspect: Aspect = {
  before: (ctx) => console.log(`[LOG] ${ctx.method} 开始，参数: ${JSON.stringify(ctx.args)}`),
  after: (ctx, result) => console.log(`[LOG] ${ctx.method} 完成，结果: ${String(result)}`),
};

const timingAspect: Aspect = {
  around: (ctx, proceed) => {
    const start = performance.now();
    const result = proceed();
    console.log(`[TIMING] ${ctx.method} 耗时 ${(performance.now() - start).toFixed(2)}ms`);
    return result;
  },
};

// 使用
class OrderService {
  @applyAspect(loggingAspect)
  @applyAspect(timingAspect)
  createOrder(items: string[]): string {
    return `order-${Date.now()}`;
  }
}

import { Component, Input, Output, EventEmitter, Injectable, NgModule } from '@angular/core';

@Component({
  selector: 'app-user-list',
  template: `
    <ul>
      <li *ngFor="let user of users" (click)="selectUser.emit(user)">
        {{ user.name }}
      </li>
    </ul>
  `,
  styles: [`ul { list-style: none; padding: 0; }`],
})
export class UserListComponent {
  @Input() users: Array<{ id: number; name: string }> = [];
  @Output() selectUser = new EventEmitter<{ id: number; name: string }>();
  constructor() {}
}

@NgModule({
  declarations: [UserListComponent],
  exports: [UserListComponent],
})
export class UserModule {}

import React, { ComponentType, useState, useEffect } from 'react';

// 假设存在 useRoute hook（由具体路由库提供）
declare function useRouter(): { pathname: string };

// 被增强的基础组件
function UserListComponent(props: { users?: Array<{ id: number; name: string }> }) {
  return <ul>{(props.users ?? []).map((u) => <li key={u.id}>{u.name}</li>)}</ul>;
}

// withRouter：注入路由信息的 HOC
function withRouter<P extends object>(
  WrappedComponent: ComponentType<P>
): ComponentType<Omit<P, 'router'>> {
  return function WithRouterProps(props: Omit<P, 'router'>) {
    const router = useRouter(); // 假设存在 useRoute hook
    return <WrappedComponent {...(props as P)} router={router} />;
  };
}

// withStyles：注入样式类的 HOC
function withStyles(styles: Record<string, string>) {
  return function <P extends object>(WrappedComponent: ComponentType<P>): ComponentType<P & { styles: Record<string, string> }> {
    return function WithStyles(props: P & { styles: Record<string, string> }) {
      return <WrappedComponent {...props} styles={styles} />;
    };
  };
}

// connect：注入 Redux 状态的 HOC
function connect(mapState: (s: unknown) => Record<string, unknown>, mapDispatch: (d: unknown) => Record<string, unknown>) {
  return function <P extends object>(WrappedComponent: ComponentType<P>): ComponentType<P> {
    return function ConnectedComponent(props: P) {
      const state = { /* 从 store 读取 */ };
      const dispatch = { /* dispatch 包装 */ };
      const injected = { ...mapState(state), ...mapDispatch(dispatch) };
      return <WrappedComponent {...props} {...injected} />;
    };
  };
}

const mapStateToProps = (state: unknown) => ({ users: state });
const mapDispatchToProps = (dispatch: unknown) => ({ loadUsers: dispatch });
const userListStyles = { list: 'list-container' };

// HOC 组合使用
const EnhancedUserList = withStyles(userListStyles)(
  connect(mapStateToProps, mapDispatchToProps)(
    withRouter(UserListComponent)
  )
);

import 'reflect-metadata';
import { Request, Response, NextFunction } from 'express';
import {
  Controller, Get, Post, Put, Delete,
  Body, Param, Query, UseGuards, UseInterceptors,
  Injectable, NestMiddleware,
} from '@nestjs/common';

// 自定义装饰器：合并参数提取
function User(): ParameterDecorator {
  return function (
    target: object,
    propertyKey: string | symbol | undefined,
    parameterIndex: number
  ) {
    const existing: number[] = Reflect.getMetadata('user:params', target, propertyKey as string) ?? [];
    existing.push(parameterIndex);
    Reflect.defineMetadata('user:params', existing, target, propertyKey as string);
  };
}

// 订单服务（由 Nest 依赖注入容器提供）
class OrderService {
  findAll(): string[] { return ['order-1', 'order-2']; }
  create(items: string[]): string { return `已创建包含 ${items.length} 项的订单`; }
}

// 控制器：通过装饰器声明路由与依赖
@Controller('orders')
export class OrderController {
  constructor(private readonly orderService: OrderService) {}

  @Get()
  findAll(): string[] {
    return this.orderService.findAll();
  }

  @Post()
  create(@Body() dto: { items: string[] }): string {
    return this.orderService.create(dto.items);
  }

  @Get(':id')
  findOne(@Param('id') id: string, @User() user: { id: number }): string {
    return `订单 ${id}，操作者 ${user.id}`;
  }
}

// 中间件：使用装饰器声明全局/路由中间件
@Injectable()
export class LoggingMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction): void {
    console.log(`[${new Date().toISOString()}] ${req.method} ${req.path}`);
    next();
  }
}

// 执行时间统计
function measure<This, Args extends unknown[], Return>(
  target: (this: This, ...args: Args) => Return,
  context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>
) {
  return function (this: This, ...args: Args): Return {
    const start = performance.now();
    const result = target.call(this, ...args);
    const duration = performance.now() - start;

    if (duration > 100) {
      console.warn(
        `[PERF] ${String(context.name)} 耗时 ${duration.toFixed(2)}ms，超过阈值 100ms`
      );
    }
    return result;
  };
}

// 权限校验装饰器
function adminOnly<This, Args extends unknown[], Return>(
  target: (this: This, ...args: Args) => Return,
  context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>
) {
  return function (this: This, ...args: Args): Return {
    const user = (this as Record<string, unknown>).currentUser as { role: string };
    if (user?.role !== 'admin') throw new Error('需要管理员权限');
    return target.call(this, ...args);
  };
}

// 异常捕获装饰器
function catchError<This, Args extends unknown[], Return>(
  target: (this: This, ...args: Args) => Return,
  context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>
) {
  return function (this: This, ...args: Args): Return {
    try {
      return target.call(this, ...args);
    } catch (err) {
      console.error(`[ERROR] ${String(context.name)} 抛出异常:`, err);
      return { success: false, error: err } as Return;
    }
  };
}

// 组合使用：统计 + 权限 + 异常
class PaymentService {
  @measure
  @adminOnly
  @catchError
  processPayment(orderId: string, amount: number): Record<string, unknown> {
    // 业务逻辑
    return { success: true, orderId, amount };
  }
}

// 原始实例与装饰后实例的 identity 差异（复用上文的咖啡示例）
const base = new DarkRoast();
const decorated = new Whip(base);

console.log(base === decorated);                      // false -- 它们是不同的对象
console.log(decorated instanceof CondimentDecorator); // true -- 装饰器实例仍属于装饰器抽象层次
console.log(decorated instanceof DarkRoast);          // false -- instanceof 无法还原被包装的原始类型

interface User { id: number; name: string }
interface UserService { getUsers(): User[] }

class RealUserService implements UserService {
  getUsers(): User[] { return [{ id: 1, name: 'alice' }]; }
}

class CacheDecorator implements UserService {
  private cachedResult: User[] | null = null;
  constructor(private inner: UserService) {}
  getUsers(): User[] {
    if (!this.cachedResult) this.cachedResult = this.inner.getUsers();
    return this.cachedResult;
  }
}

class LogDecorator implements UserService {
  constructor(private inner: UserService) {}
  getUsers(): User[] {
    console.log('[LOG] getUsers');
    return this.inner.getUsers();
  }
}

class AuthDecorator implements UserService {
  constructor(private inner: UserService) {}
  getUsers(): User[] {
    if (!this.checkPermission()) throw new Error('Access denied');
    return this.inner.getUsers();
  }
  private checkPermission(): boolean { return true; }
}

// 装饰器模式：客户端主动叠加
const service = new RealUserService();
const withCache = new CacheDecorator(service);
const withLog = new LogDecorator(withCache);
const withAuth = new AuthDecorator(withLog);
withAuth.getUsers();

// 代理模式：代理方控制访问
class UserServiceProxy implements UserService {
  private realService: UserService | null = null;
  private cachedResult: User[] | null = null;

  getUsers(): User[] {
    if (!this.realService) {
      this.realService = new RealUserService(); // 代理控制创建
    }
    if (this.checkCache()) return this.cachedResult as User[];
    if (!this.checkPermission()) throw new Error('Access denied');
    return this.realService.getUsers();
  }

  private checkCache(): boolean { return this.cachedResult !== null; }
  private checkPermission(): boolean { return true; }
}

// 对客户端透明
const serviceProxy = new UserServiceProxy();
serviceProxy.getUsers(); // 客户端不知道代理的存在

// 组件接口
interface Coffee {
    double cost();
    String description();
}

// 具体组件：基础咖啡
class Espresso implements Coffee {
    public double cost() { return 15.0; }
    public String description() { return "浓缩咖啡"; }
}

// 装饰器基类：持有被装饰组件，转发方法
abstract class CoffeeDecorator implements Coffee {
    protected final Coffee coffee;

    protected CoffeeDecorator(Coffee coffee) {
        this.coffee = coffee;
    }

    public double cost() { return coffee.cost(); }
    public String description() { return coffee.description(); }
}

// 具体装饰器：加牛奶
class MilkDecorator extends CoffeeDecorator {
    public MilkDecorator(Coffee coffee) {
        super(coffee);
    }

    @Override
    public double cost() { return coffee.cost() + 3.0; }

    @Override
    public String description() { return coffee.description() + " + 牛奶"; }
}

// 具体装饰器：加糖
class SugarDecorator extends CoffeeDecorator {
    public SugarDecorator(Coffee coffee) {
        super(coffee);
    }

    @Override
    public double cost() { return coffee.cost() + 1.5; }

    @Override
    public String description() { return coffee.description() + " + 糖"; }
}

// 使用：可以层层叠加装饰器
public class Client {
    public static void main(String[] args) {
        Coffee coffee = new Espresso();
        coffee = new MilkDecorator(coffee);
        coffee = new SugarDecorator(coffee);
        System.out.println(coffee.description() + "：" + coffee.cost() + " 元");
    }
}

# 组件接口（Python 中常用协议/鸭子类型）
class Coffee:
    def cost(self) -> float:
        raise NotImplementedError

    def description(self) -> str:
        raise NotImplementedError

# 具体组件
class Espresso(Coffee):
    def cost(self) -> float:
        return 15.0

    def description(self) -> str:
        return "浓缩咖啡"

# 装饰器基类
class CoffeeDecorator(Coffee):
    def __init__(self, coffee: Coffee):
        self._coffee = coffee

    def cost(self) -> float:
        return self._coffee.cost()

    def description(self) -> str:
        return self._coffee.description()

class MilkDecorator(CoffeeDecorator):
    def cost(self) -> float:
        return self._coffee.cost() + 3.0

    def description(self) -> str:
        return self._coffee.description() + " + 牛奶"

class SugarDecorator(CoffeeDecorator):
    def cost(self) -> float:
        return self._coffee.cost() + 1.5

    def description(self) -> str:
        return self._coffee.description() + " + 糖"

# 使用：层层叠加
coffee = Espresso()
coffee = MilkDecorator(coffee)
coffee = SugarDecorator(coffee)
print(f"{coffee.description()}：{coffee.cost()} 元")

from functools import wraps
import time

def timer(func):
    """函数装饰器：为函数附加计时能力"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        print(f"{func.__name__} 耗时 {time.time() - start:.3f}s")
        return result
    return wrapper

@timer
def heavy_task():
    time.sleep(0.1)
    return "done"

heavy_task()