依赖注入原理与实现

import { A } from './modA';
import { B } from './modB';

class C {
  a: A;
  b: B;
  
  constructor() {
    this.a = new A();
    this.b = new B();
  }
}

class F {
  d: D;
  
  constructor() {
    this.d = Container.get(D);
  }
}

class Factory {
  private static instances: Map<string, any> = new Map();
  
  static produce(key: string) {
    if (!this.instances.has(key)) {
      // 根据key创建实例
      const instance = this.createInstance(key);
      this.instances.set(key, instance);
    }
    return this.instances.get(key);
  }
  
  private static createInstance(key: string) {
    // 实例化逻辑
  }
}

class F {
  d: D;
  
  constructor() {
    this.d = Factory.produce("D");
  }
}

@Provide()
class F {
  @Inject()
  d!: D;
}

@Controller('/user')
class UserController {
  constructor(private readonly userService: UserService) {}
  
  @Get('/list')
  async userList() {
    return this.userService.findAll();
  }

  @Post('/add')
  async addUser() {}
}

┌─────────────────────────────────────────────────────────────────┐
│                        依赖注入工作流程                           │
└─────────────────────────────────────────────────────────────────┘

  ┌──────────┐    注册     ┌──────────────┐
  │  @Provide │ ────────> │   Container   │
  │  装饰器   │           │   (容器)      │
  └──────────┘           │  ┌─────────┐  │
                         │  │ services│  │
  ┌──────────┐    声明    │  │  Map    │  │
  │  @Inject │ ────────> │  └─────────┘  │
  │  装饰器   │           │  ┌─────────┐  │
  └──────────┘           │  │registry │  │
                         │  │  Map    │  │
  ┌──────────┐    获取    │  └─────────┘  │
  │Container.│ ────────> └──────────────┘
  │  get()   │                  │
  └──────────┘                  │ 自动注入
                                ▼
                         ┌──────────────┐
                         │  实例化对象   │
                         │ (依赖已注入)  │
                         └──────────────┘

┌────────────────────────────────────────────────────────────┐
│                     IoC Container                          │
├────────────────────────────────────────────────────────────┤
│                                                            │
│  services: Map<ServiceKey, ClassStruct>                   │
│  ┌─────────────────────────────────────────────────────┐  │
│  │  'DriverService' → Driver                           │  │
│  │  'Car'           → Car                              │  │
│  │  Driver          → Driver                           │  │
│  │  Car             → Car                              │  │
│  └─────────────────────────────────────────────────────┘  │
│                                                            │
│  propertyRegistry: Map<string, string>                     │
│  ┌─────────────────────────────────────────────────────┐  │
│  │  'Car:driver'     → 'DriverService'                 │  │
│  │  'Car:fuel'       → Fuel                            │  │
│  │  'Bus:driver'     → 'DriverService'                 │  │
│  └─────────────────────────────────────────────────────┘  │
│                                                            │
├────────────────────────────────────────────────────────────┤
│  Methods:                                                  │
│  + set(key, value): void                                   │
│  + get<T>(key): T | undefined                              │
│  + has(key): boolean                                       │
│  + clear(): void                                           │
└────────────────────────────────────────────────────────────┘

@Controller('/user')
class UserController {
  @Get('/list')
  async userList() {}

  @Post('/add')
  async addUser() {}
}

export enum METADATA_KEY {
  METHOD = 'ioc:method',
  PATH = 'ioc:path',
  MIDDLEWARE = 'ioc:middleware',
}

export enum REQUEST_METHOD {
  GET = 'ioc:get',
  POST = 'ioc:post',
  PUT = 'ioc:put',
  DELETE = 'ioc:delete',
}

export const methodDecoratorFactory = (method: string) => {
  return (path: string): MethodDecorator => {
    return (_target, _key, descriptor) => {
      // 在方法实现上注册元数据
      Reflect.defineMetadata(METADATA_KEY.METHOD, method, descriptor.value!);
      Reflect.defineMetadata(METADATA_KEY.PATH, path, descriptor.value!);
    };
  };
};

export const Get = methodDecoratorFactory(REQUEST_METHOD.GET);
export const Post = methodDecoratorFactory(REQUEST_METHOD.POST);
export const Put = methodDecoratorFactory(REQUEST_METHOD.PUT);
export const Delete = methodDecoratorFactory(REQUEST_METHOD.DELETE);

export const Controller = (path?: string): ClassDecorator => {
  return (target) => {
    Reflect.defineMetadata(METADATA_KEY.PATH, path ?? '', target);
  };
};

type AsyncFunc = (...args: any[]) => Promise<any>;

interface ICollected {
  path: string;
  requestMethod: string;
  requestHandler: AsyncFunc;
}

export const routerFactory = <T extends object>(ins: T): ICollected[] => {
  const prototype = Reflect.getPrototypeOf(ins) as any;
  
  // 获取根路径
  const rootPath = <string>(
    Reflect.getMetadata(METADATA_KEY.PATH, prototype.constructor)
  );

  // 获取所有方法名（排除 constructor）
  const methods = <string[]>(
    Reflect.ownKeys(prototype).filter((item) => item !== 'constructor')
  );

  // 收集路由信息
  const collected = methods.map((m) => {
    const requestHandler = prototype[m];
    const path = <string>Reflect.getMetadata(METADATA_KEY.PATH, requestHandler);
    const requestMethod = <string>(
      Reflect.getMetadata(METADATA_KEY.METHOD, requestHandler).replace('ioc:', '')
    );

    return {
      path: `${rootPath}${path}`,
      requestMethod,
      requestHandler,
    };
  });
  
  return collected;
};

[
  {
    "path": "/user/list",
    "requestMethod": "get",
    "requestHandler": "[AsyncFunction: userList]"
  },
  {
    "path": "/user/add",
    "requestMethod": "post",
    "requestHandler": "[AsyncFunction: addUser]"
  }
]

import http from 'http';

// 创建 Controller 实例并收集路由信息
const collected = routerFactory(new UserController());

http
  .createServer((req, res) => {
    for (const info of collected) {
      if (
        req.url === info.path &&
        req.method === info.requestMethod.toLocaleUpperCase()
      ) {
        info.requestHandler().then((data) => {
          res.writeHead(200, { 'Content-Type': 'application/json' });
          res.end(JSON.stringify(data));
        });
        return;
      }
    }
    
    // 404 处理
    res.writeHead(404, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ error: 'Not Found' }));
  })
  .listen(3000)
  .on('listening', () => {
    console.log('Server ready at http://localhost:3000');
    console.log('GET  http://localhost:3000/user/list');
    console.log('POST http://localhost:3000/user/add');
  });

@Controller('/user')
class UserController {
  @Get('/list')
  async userList() {
    return {
      success: true,
      code: 10000,
      data: [
        { name: 'linbudu', age: 18 },
        { name: '林不渡', age: 28 },
      ],
    };
  }

  @Post('/add')
  async addUser() {
    return {
      success: true,
      code: 10000,
    };
  }
}

@Provide()
class Driver {
  adapt(consumer: string) {
    console.log(`驱动已生效于 ${consumer}！`);
  }
}

@Provide()
class Car {
  @Inject()
  driver!: Driver;

  run() {
    this.driver.adapt('Car');
  }
}

const car = Container.get(Car);
car.run(); // 驱动已生效于 Car！

type ClassStruct<T = any> = new (...args: any[]) => T;

class Container {
  // 存储注册的服务
  private static services: Map<string, ClassStruct> = new Map();
  
  // 存储属性注入信息
  public static propertyRegistry: Map<string, string> = new Map();
  
  // 注册服务
  public static set(key: string, value: ClassStruct): void {
    Container.services.set(key, value);
  }

  // 获取服务实例
  public static get<T = any>(key: string): T | undefined {
    return this.resolve(key);
  }
  
  // 检查服务是否存在
  public static has(key: string): boolean {
    return Container.services.has(key);
  }
  
  // 清空容器
  public static clear(): void {
    Container.services.clear();
    Container.propertyRegistry.clear();
  }

  private constructor() {}
}

function Provide(key: string): ClassDecorator {
  return (Target) => {
    Container.set(key, Target as unknown as ClassStruct);
  };
}

function Inject(key: string): PropertyDecorator {
  return (target, propertyKey) => {
    // 注册：'类名:属性名' -> '服务标识符'
    Container.propertyRegistry.set(
      `${target.constructor.name}:${String(propertyKey)}`,
      key
    );
  };
}

class Container {
  // ... 其他代码

  private static resolve<T = any>(key: string): T | undefined {
    // 1. 检查是否注册
    const Cons = Container.services.get(key);
    if (!Cons) {
      return undefined;
    }

    // 2. 实例化
    const ins = new Cons();

    // 3. 遍历属性注册表，注入依赖
    for (const [injectKey, serviceKey] of Container.propertyRegistry) {
      const [classKey, propKey] = injectKey.split(':');

      // 只处理当前类的属性
      if (classKey !== Cons.name) continue;

      // 递归获取依赖实例
      const target = Container.resolve(serviceKey);

      if (target) {
        (ins as any)[propKey] = target;
      }
    }

    return ins;
  }
}

@Provide('DriverService')
class Driver {
  adapt(consumer: string) {
    console.log(`\n=== 驱动已生效于 ${consumer}！===\n`);
  }
}

@Provide('Car')
class Car {
  @Inject('DriverService')
  driver!: Driver;

  run() {
    this.driver.adapt('Car');
  }
}

const car = Container.get<Car>('Car')!;
car.run(); // === 驱动已生效于 Car！===

type ServiceKey<T = any> = string | ClassStruct<T> | Function;

class Container {
  private static services: Map<ServiceKey, ClassStruct> = new Map();
  
  public static propertyRegistry: Map<string, ServiceKey> = new Map();

  public static set(key: ServiceKey, value: ClassStruct): void {
    Container.services.set(key, value);
  }

  public static get<T = any>(key: ServiceKey): T | undefined {
    return this.resolve(key);
  }
  
  private constructor() {}
}

function Provide(key?: string): ClassDecorator {
  return (Target) => {
    // 使用传入的 key 或类名注册
    Container.set(key ?? Target.name, Target as unknown as ClassStruct);
    // 同时使用类本身作为 key 注册一份，支持通过类获取
    Container.set(Target, Target as unknown as ClassStruct);
  };
}

function Inject(key?: string): PropertyDecorator {
  return (target, propertyKey) => {
    // 如果没有传入 key，使用内置元数据获取类型
    const serviceKey = key ?? Reflect.getMetadata('design:type', target, propertyKey);
    
    Container.propertyRegistry.set(
      `${target.constructor.name}:${String(propertyKey)}`,
      serviceKey
    );
  };
}

@Provide('DriverService')
class Driver {
  adapt(consumer: string) {
    console.log(`\n=== 驱动已生效于 ${consumer}！===\n`);
  }
}

@Provide()
class Fuel {
  fill(consumer: string) {
    console.log(`\n=== 燃料已填充完毕 ${consumer}！===\n`);
  }
}

@Provide()
class Car {
  @Inject()           // 自动使用 Driver 类作为标识符
  driver!: Driver;

  @Inject()           // 自动使用 Fuel 类作为标识符
  fuel!: Fuel;

  run() {
    this.fuel.fill('Car');
    this.driver.adapt('Car');
  }
}

@Provide()
class Bus {
  @Inject('DriverService')  // 也可以显式指定字符串标识符
  driver!: Driver;

  @Inject('Fuel')
  fuel!: Fuel;

  run() {
    this.fuel.fill('Bus');
    this.driver.adapt('Bus');
  }
}

// 测试
const car = Container.get(Car)!;
const bus = Container.get(Bus)!;

car.run();
bus.run();

=== 燃料已填充完毕 Car！===
=== 驱动已生效于 Car！===
=== 燃料已填充完毕 Bus！===
=== 驱动已生效于 Bus！===

import 'reflect-metadata';

// ==================== 类型定义 ====================

type ClassStruct<T = any> = new (...args: any[]) => T;
type ServiceKey<T = any> = string | ClassStruct<T> | Function;
type AsyncFunc = (...args: any[]) => Promise<any>;

// ==================== 元数据键定义 ====================

export enum METADATA_KEY {
  METHOD = 'ioc:method',
  PATH = 'ioc:path',
  MIDDLEWARE = 'ioc:middleware',
}

export enum REQUEST_METHOD {
  GET = 'ioc:get',
  POST = 'ioc:post',
  PUT = 'ioc:put',
  DELETE = 'ioc:delete',
}

// ==================== IoC 容器 ====================

export class Container {
  private static services: Map<ServiceKey, ClassStruct> = new Map();
  public static propertyRegistry: Map<string, ServiceKey> = new Map();

  /**
   * 注册服务到容器
   */
  public static set(key: ServiceKey, value: ClassStruct): void {
    Container.services.set(key, value);
  }

  /**
   * 从容器获取服务实例
   */
  public static get<T = any>(key: ServiceKey): T | undefined {
    return this.resolve<T>(key);
  }

  /**
   * 检查服务是否已注册
   */
  public static has(key: ServiceKey): boolean {
    return Container.services.has(key);
  }

  /**
   * 清空容器
   */
  public static clear(): void {
    Container.services.clear();
    Container.propertyRegistry.clear();
  }

  /**
   * 解析并创建服务实例
   */
  private static resolve<T = any>(key: ServiceKey): T | undefined {
    const Cons = Container.services.get(key);
    if (!Cons) return undefined;

    const ins = new Cons();

    // 注入属性依赖
    for (const [injectKey, serviceKey] of Container.propertyRegistry) {
      const [className, propName] = injectKey.split(':');
      
      if (className === Cons.name) {
        const dependency = Container.resolve(serviceKey);
        if (dependency) {
          (ins as any)[propName] = dependency;
        }
      }
    }

    return ins;
  }

  private constructor() {}
}

// ==================== 装饰器 ====================

/**
 * 类装饰器：将类注册到容器
 */
export function Provide(key?: string): ClassDecorator {
  return (Target) => {
    const classStruct = Target as unknown as ClassStruct;
    Container.set(key ?? Target.name, classStruct);
    Container.set(Target, classStruct);
  };
}

/**
 * 属性装饰器：标记需要注入的属性
 */
export function Inject(key?: string): PropertyDecorator {
  return (target, propertyKey) => {
    const serviceKey = key ?? Reflect.getMetadata('design:type', target, propertyKey);
    Container.propertyRegistry.set(
      `${target.constructor.name}:${String(propertyKey)}`,
      serviceKey
    );
  };
}

/**
 * Controller 装饰器
 */
export const Controller = (path?: string): ClassDecorator => {
  return (target) => {
    Reflect.defineMetadata(METADATA_KEY.PATH, path ?? '', target);
  };
};

/**
 * 方法装饰器工厂
 */
export const methodDecoratorFactory = (method: string) => {
  return (path: string): MethodDecorator => {
    return (_target, _key, descriptor) => {
      Reflect.defineMetadata(METADATA_KEY.METHOD, method, descriptor.value!);
      Reflect.defineMetadata(METADATA_KEY.PATH, path, descriptor.value!);
    };
  };
};

export const Get = methodDecoratorFactory(REQUEST_METHOD.GET);
export const Post = methodDecoratorFactory(REQUEST_METHOD.POST);
export const Put = methodDecoratorFactory(REQUEST_METHOD.PUT);
export const Delete = methodDecoratorFactory(REQUEST_METHOD.DELETE);

// ==================== 路由工厂 ====================

export interface ICollected {
  path: string;
  requestMethod: string;
  requestHandler: AsyncFunc;
}

export const routerFactory = <T extends object>(ins: T): ICollected[] => {
  const prototype = Reflect.getPrototypeOf(ins) as any;
  const rootPath = Reflect.getMetadata(METADATA_KEY.PATH, prototype.constructor) ?? '';
  const methods = Reflect.ownKeys(prototype).filter((item) => item !== 'constructor');

  return methods.map((m) => {
    const requestHandler = prototype[m];
    const path = Reflect.getMetadata(METADATA_KEY.PATH, requestHandler) ?? '';
    const requestMethod = (Reflect.getMetadata(METADATA_KEY.METHOD, requestHandler) ?? '').replace('ioc:', '');

    return {
      path: `${rootPath}${path}`,
      requestMethod,
      requestHandler,
    };
  });
};

// 类构造函数类型
type ClassStruct<T = any> = new (...args: any[]) => T;

// 服务标识符类型
type ServiceKey<T = any> = string | ClassStruct<T> | Function;

// 异步函数类型
type AsyncFunc = (...args: any[]) => Promise<any>;

// 路由信息接口
interface ICollected {
  path: string;
  requestMethod: string;
  requestHandler: AsyncFunc;
}

// ✅ 推荐：使用类名作为标识符
@Provide()
class UserService {
  // ...
}

// ✅ 推荐：使用接口+实现类模式
interface ILogger {
  log(message: string): void;
}

@Provide('Logger')
class ConsoleLogger implements ILogger {
  log(message: string) {
    console.log(message);
  }
}

// ✅ 使用时通过接口注入
@Provide()
class AppController {
  @Inject('Logger')
  private logger!: ILogger;
}

// ❌ 避免：过度使用字符串标识符
@Provide('service.user')  // 不推荐
class UserService {}

// ❌ 避免：循环依赖
@Provide()
class A {
  @Inject() b!: B;
}

@Provide()
class B {
  @Inject() a!: A;  // 循环依赖！
}

// ✅ 解决方案：使用延迟注入或重构依赖关系
@Provide()
class A {
  private _b?: B;
  
  @Inject()
  get b(): B {
    if (!this._b) {
      this._b = Container.get(B);
    }
    return this._b;
  }
}

class Container {
  private static instances: Map<ServiceKey, any> = new Map();

  private static resolve<T = any>(key: ServiceKey): T | undefined {
    // 检查是否已有实例
    if (Container.instances.has(key)) {
      return Container.instances.get(key);
    }

    const Cons = Container.services.get(key);
    if (!Cons) return undefined;

    const ins = new Cons();
    Container.instances.set(key, ins);  // 缓存实例

    // ... 注入依赖

    return ins;
  }
}

enum Lifecycle {
  TRANSIENT,  // 每次获取都创建新实例
  SINGLETON,  // 单例模式
}

class Container {
  private static lifecycle: Map<ServiceKey, Lifecycle> = new Map();
  private static instances: Map<ServiceKey, any> = new Map();

  public static register<T>(
    key: ServiceKey,
    value: ClassStruct<T>,
    lifecycle: Lifecycle = Lifecycle.TRANSIENT
  ): void {
    Container.services.set(key, value);
    Container.lifecycle.set(key, lifecycle);
  }
}

// 使用泛型确保类型安全
function Inject<T>(): PropertyDecorator {
  return (target, propertyKey) => {
    const type = Reflect.getMetadata('design:type', target, propertyKey);
    Container.propertyRegistry.set(
      `${target.constructor.name}:${String(propertyKey)}`,
      type
    );
  };
}

@Provide()
class UserService {
  // TypeScript 会自动推断 driver 的类型
  @Inject<Driver>()
  driver!: Driver;
}

// ✅ 推荐：使用接口 + Symbol 作为标识符
const TYPES = {
  UserService: Symbol.for('UserService'),
  DatabaseService: Symbol.for('DatabaseService'),
  CacheService: Symbol.for('CacheService'),
};

// 注意：使用 Symbol 标识符时，ServiceKey 以及
// Provide / Inject 的 key 参数需要同步扩展为 string | symbol

interface IUserService {
  findById(id: string): Promise<User>;
}

@Provide(TYPES.UserService)
class UserServiceImpl implements IUserService {
  // ...
}

// 使用时
@Provide()
class UserController {
  @Inject(TYPES.UserService)
  userService!: IUserService;
}

// 定义服务注册表类型
// 作为接口计算属性键的 Symbol 必须是 unique symbol（const 声明的 Symbol()）
const UserServiceToken = Symbol('UserService');
const DatabaseServiceToken = Symbol('DatabaseService');
const CacheServiceToken = Symbol('CacheService');

interface ServiceRegistry {
  [UserServiceToken]: IUserService;
  [DatabaseServiceToken]: IDatabaseService;
  [CacheServiceToken]: ICacheService;
}

// 类型安全的 get 方法
class Container {
  static get<K extends keyof ServiceRegistry>(
    key: K
  ): ServiceRegistry[K] | undefined {
    return this.resolve(key);
  }
}

// 使用时有完整的类型提示
const userService = Container.get(UserServiceToken);  // IUserService | undefined

// 支持测试时替换服务
class Container {
  static replace<K extends keyof ServiceRegistry>(
    key: K,
    factory: () => ServiceRegistry[K]
  ): void {
    this.factories.set(key, factory);
    this.instances.delete(key);  // 清除缓存实例
  }
}

// 测试代码
describe('UserController', () => {
  beforeEach(() => {
    // 替换为 Mock 服务
    Container.replace(UserServiceToken, () => mockUserService);
  });

  afterEach(() => {
    Container.clear();
  });

  it('should get user list', async () => {
    const controller = Container.get(UserController);
    // ...
  });
});

// 方式一：使用条件检查
@Provide()
class Service {
  @Inject()
  optionalDependency?: OptionalService;

  doSomething() {
    if (this.optionalDependency) {
      this.optionalDependency.doWork();
    }
  }
}

// 方式二：使用默认值
@Provide()
class Service {
  private logger = Container.get('Logger') ?? new ConsoleLogger();
}

// 方式三：使用 @Optional() 装饰器标记可选依赖
function Optional(): PropertyDecorator {
  return (target, propertyKey) => {
    // 标记为可选
    Reflect.defineMetadata('optional', true, target, propertyKey);
  };
}

// 在容器解析时，标记为可选的依赖未注册时返回 undefined 而非报错
@Provide()
class Service {
  @Inject()
  @Optional()
  cache?: CacheService;  // 如果 CacheService 未注册，不会报错
}

// tsconfig.json
{
  "compilerOptions": {
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true
  }
}

function Injectable(): ClassDecorator {
  return (target) => {
    // 获取构造函数参数类型
    const paramTypes = Reflect.getMetadata('design:paramtypes', target) || [];
    // 存储参数类型信息
    Reflect.defineMetadata('design:injectparams', paramTypes, target);
    Container.set(target, target as any);
  };
}

@Provide()
class DatabaseService {}

@Injectable()
class UserService {
  constructor(private db: DatabaseService) {}
}

// 容器解析时需要处理构造函数参数
class Container {
  private static resolve<T>(key: ServiceKey): T | undefined {
    const Cons = Container.services.get(key);
    if (!Cons) return undefined;

    // 获取构造函数参数
    const paramTypes = Reflect.getMetadata('design:injectparams', Cons) || [];
    const params = paramTypes.map((type: any) => Container.resolve(type));

    return new Cons(...params);
  }
}

// 扩展 Provide 以支持生命周期选项（示意）
@Provide({ lifetime: 'transient' })
class RequestHandler {
  // 每次获取都是新实例
}

// 容器实现
class Container {
  private static lifetimes: Map<ServiceKey, 'singleton' | 'transient'> = new Map();
  private static singletons: Map<ServiceKey, any> = new Map();

  static get<T>(key: ServiceKey): T {
    const lifetime = this.lifetimes.get(key);
    
    if (lifetime === 'transient') {
      return this.createInstance(key);
    }
    
    // 单例模式
    if (!this.singletons.has(key)) {
      this.singletons.set(key, this.createInstance(key));
    }
    return this.singletons.get(key);
  }
}

interface AsyncInitializable {
  init(): Promise<void>;
}

class Container {
  static async getAsync<T>(key: ServiceKey): Promise<T> {
    const instance = this.get<T>(key);
    
    if (instance && typeof (instance as any).init === 'function') {
      await (instance as AsyncInitializable).init();
    }
    
    return instance!;
  }
}

// 使用
@Provide()
class DatabaseService implements AsyncInitializable {
  private connection!: Connection;
  
  async init(): Promise<void> {
    this.connection = await createConnection();
  }
}

// 获取时
const db = await Container.getAsync(TYPES.DatabaseService);

function ConditionalInject(
  condition: () => boolean,
  trueKey: ServiceKey,
  falseKey?: ServiceKey
): PropertyDecorator {
  return (target, propertyKey) => {
    const key = condition() ? trueKey : falseKey;
    if (key) {
      Container.propertyRegistry.set(
        `${target.constructor.name}:${String(propertyKey)}`,
        key
      );
    }
  };
}

// 使用
@Provide()
class PaymentService {
  @ConditionalInject(
    () => process.env.NODE_ENV === 'production',
    'RealPaymentGateway',
    'MockPaymentGateway'
  )
  gateway!: IPaymentGateway;
}

class Container {
  // 1. 使用 WeakMap 避免内存泄漏
  private static instances: WeakMap<object, any> = new WeakMap();
  
  // 2. 缓存反射结果
  private static metadataCache: Map<string, any> = new Map();
  
  // 3. 延迟初始化
  static getLazy<T>(key: ServiceKey): () => T {
    let instance: T;
    return () => {
      if (!instance) {
        instance = this.get<T>(key)!;
      }
      return instance;
    };
  }
  
  // 4. 批量注册
  static registerBatch(services: ServiceDescriptor[]): void {
    services.forEach(s => this.register(s));
  }
}

declare type ClassDecorator = <TFunction extends Function>(
  target: TFunction
) => TFunction | void;

declare type PropertyDecorator = (
  target: Object,
  propertyKey: string | symbol
) => void;

type ClassStruct<T = any> = new (...args: any[]) => T;

type RestrictedClassDecorator<TClass extends object> = (
  target: ClassStruct<TClass>
) => ClassStruct<TClass> | void;

function OnlyFoo(): RestrictedClassDecorator<Foo> {
  return (target: ClassStruct<Foo>) => {};
}

@OnlyFoo()  // ✅ 正确
class Foo {
  foo!: string;
}

@OnlyFoo()  // ❌ 类型错误
class Bar {
  bar!: string;
}

type AsyncFunc = (...args: any[]) => Promise<any>;

type OnlyAsyncMethodDecorator = (
  target: Object,
  propertyKey: string | symbol,
  descriptor: TypedPropertyDescriptor<AsyncFunc>
) => void;

function OnlyAsyncFunc(): OnlyAsyncMethodDecorator {
  return (target, propKey, descriptor) => {};
}

class Example {
  @OnlyAsyncFunc()
  async asyncHandler() {}  // ✅ 正确

  @OnlyAsyncFunc()
  handler() {}  // ❌ 类型错误
}

type PickByValueType<T, Value> = {
  [Key in keyof T]: T[Key] extends Value ? Key : never;
}[keyof T];

type StringTypePropertyDecorator = <T extends object>(
  target: T,
  propertyKey: PickByValueType<T, string>
) => void;

function OnlyStringTypeProperty(): StringTypePropertyDecorator {
  return (target, propertyKey) => {};
}

class Example {
  @OnlyStringTypeProperty()
  str!: string;  // ✅ 正确

  @OnlyStringTypeProperty()
  bool: boolean = true;  // ❌ 类型错误
}

┌─────────────────────────────────────────────────────────────────┐
│                     依赖注入架构全景                              │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│                         应用层                                   │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐             │
│  │ Controller  │  │  Service    │  │ Repository  │             │
│  │ @Controller │  │ @Provide    │  │ @Provide    │             │
│  └──────┬──────┘  └──────┬──────┘  └──────┬──────┘             │
│         │                │                │                     │
│         │    @Inject     │    @Inject     │                     │
│         └────────────────┼────────────────┘                     │
│                          │                                      │
└──────────────────────────┼──────────────────────────────────────┘
                           │
┌──────────────────────────┼──────────────────────────────────────┐
│                          ▼                                      │
│  ┌────────────────────────────────────────────────────────────┐ │
│  │                    IoC Container                            │ │
│  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐        │ │
│  │  │  Registry   │  │  Resolver   │  │  Factory    │        │ │
│  │  │  服务注册表  │  │  依赖解析器  │  │  实例工厂   │        │ │
│  │  └─────────────┘  └─────────────┘  └─────────────┘        │ │
│  └────────────────────────────────────────────────────────────┘ │
│                         容器层                                   │
└─────────────────────────────────────────────────────────────────┘
                           │
┌──────────────────────────┼──────────────────────────────────────┐
│                          ▼                                      │
│  ┌────────────────────────────────────────────────────────────┐ │
│  │                 Reflect Metadata                            │ │
│  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐        │ │
│  │  │ design:type │  │design:param │  │ design:ret  │        │ │
│  │  │  类型元数据  │  │  参数元数据  │  │ 返回值元数据 │        │ │
│  │  └─────────────┘  └─────────────┘  └─────────────┘        │ │
│  └────────────────────────────────────────────────────────────┘ │
│                        基础设施层                                │
└─────────────────────────────────────────────────────────────────┘