DI和IOC

依赖注入（Dependency Injection, DI）和控制反转（Inversion of Control, IoC）是面向对象编程中的两个重要概念，它们紧密相关并在现代软件开发中经常结合使用。

依赖注入： 依赖注入是一种设计模式，它旨在解决类之间的耦合问题。在传统的编程方式中，一个类如果需要使用另一个类的服务（即有依赖关系），通常会自己去创建或查找这个依赖对象。而在依赖注入的模式下，创建和管理依赖关系的责任从被依赖的对象转移到了外部容器或者客户端代码中。具体来说，不是对象自己创建或查找依赖，而是通过构造函数、属性或方法将依赖传递给它。这样做的好处包括提高代码的可测试性、可复用性和松耦合度。

控制反转： 控制反转是一个更抽象的概念，它描述了一种程序设计原则，在这种原则下，对象不再负责自身的生命周期管理和依赖获取，而把这些控制权“反转”交给了一个第三方框架或容器来处理。IoC 容器负责创建对象，管理它们的生命周期，并在适当的时候自动将依赖注入到各个对象中。

两者的关系： 依赖注入是实现控制反转的一种常见手段或者说具体实践形式。也就是说，当我们在谈论控制反转时，我们关注的是设计理念层面，即如何把对象的控制权转移出去；而依赖注入则是这一理念在实际编程中的体现，它是控制反转的具体实现途径之一，通过注入依赖对象的方式达到解耦的目的。

总结起来，IoC 是一种高层次的设计思想，强调的是对象之间责任的归属变化；DI 则是 IoC 的一种具体应用，通过依赖注入机制实现了控制权的反转，降低了组件间的耦合度，提高了系统的灵活性和可维护性。

在Node.js环境中，我们可以使用一个简单的工厂函数或者依赖注入容器（DI Container）来实现依赖注入和控制反转的概念。以下是一个Node.js应用中依赖注入和控制反转的简单示例：

// 定义一个日志服务接口与其实现
interface Logger {
  log(message: string): void;
}

class ConsoleLogger implements Logger {
  log(message: string) {
    console.log(`Logging to console: ${message}`);
  }
}

// 假设这是我们的业务逻辑类，在没有依赖注入时它会自行创建并管理日志器
class BusinessServiceWithoutDI {
  private logger: Logger;

  constructor() {
    // 在这里直接创建了依赖对象
    this.logger = new ConsoleLogger();
  }

  doSomeBusinessLogic() {
    this.logger.log('Doing some business logic');
  }
}

// 使用依赖注入后，业务逻辑类不再直接创建日志器实例
class BusinessServiceWithDI {
  private logger: Logger;

  // 构造函数注入
  constructor(logger: Logger) {
    // 日志器由外部传入
    this.logger = logger;
  }

  doSomeBusinessLogic() {
    this.logger.log('Doing some business logic with DI');
  }
}

// 创建一个简易的IoC容器模拟
class DependencyContainer {
  createBusinessService(): BusinessServiceWithDI {
    const logger = new ConsoleLogger();

    // 容器负责创建并注入依赖
    return new BusinessServiceWithDI(logger);
  }
}

// 使用IoC容器获取业务服务，并执行逻辑
const container = new DependencyContainer();
const service = container.createBusinessService();
service.doSomeBusinessLogic();

在这个Node.js示例中：

• BusinessServiceWithoutDI 类展示了不使用依赖注入的情况，其中日志器是硬编码到业务类内部的。
• BusinessServiceWithDI 类通过构造函数接受 Logger 实例作为参数，实现了依赖注入。
• DependencyContainer 类作为一个简单的IoC容器实现，它负责创建依赖（例如 ConsoleLogger）并将其注入到业务服务中，从而实现了控制反转。

通过这样的方式，我们可以灵活地更换不同的日志实现，只需要在容器中更改创建的日志器实例即可，而无需修改业务逻辑类本身，增强了代码的可测试性和模块间的解耦。在实际大型项目中，可能还会使用更复杂的IoC容器库来管理服务和依赖关系。

在Node.js中，装饰器（Decorator）是一种特殊类型的声明，它可以被附加到类声明、方法、访问器、属性或参数上。结合装饰器和依赖注入（DI）的概念，我们可以创建一个更加简洁、直观的方式来管理对象的依赖关系，并实现控制反转（IoC）。以下是一个使用TypeScript和装饰器实现依赖注入的简化示例：

// 假设我们有一个日志服务接口及其实现
interface Logger {
  log(message: string): void;
}

class ConsoleLogger implements Logger {
  log(message: string) {
    console.log(`Logging to console: ${message}`);
  }
}

// 装饰器工厂函数来注入依赖
function Injectable(target: any, key: string, descriptor: PropertyDescriptor) {
  // 在这里可以模拟从容器获取依赖
  const logger = new ConsoleLogger();

  // 将依赖注入到目标对象的属性上
  target[key] = logger;

  return descriptor;
}

// 使用装饰器的业务逻辑类
class BusinessService {
  @Injectable
  private logger!: Logger; // TypeScript中的可选断言表示此属性将在运行时被装饰器填充

  doSomeBusinessLogic() {
    this.logger.log('Doing some business logic with DI');
  }
}

// 创建业务服务实例并执行逻辑
const service = new BusinessService();
service.doSomeBusinessLogic();

上述代码虽然展示了装饰器如何用于注入依赖，但它并不完全实现了完整的IoC容器的功能。在实际应用中，装饰器通常会配合元数据和反射API（如reflect-metadata库），以及一个真正的IoC容器来完成更复杂的依赖注入过程。

例如，如果要模拟一个更接近于真实IoC容器的行为，装饰器可能会用来标记哪些属性需要从容器中注入，然后在容器解析阶段通过反射API收集这些信息并自动注入依赖：

import 'reflect-metadata';

// 定义注入元数据键
const InjectableMetadataKey = Symbol('injectable');

// 装饰器用于标记需要注入的依赖类型
function Injectable(target: any, propertyKey: string | symbol) {
  Reflect.defineMetadata(InjectableMetadataKey, true, target, propertyKey);
}

// IoC容器模拟（简化版）
class Container {
  private registry: Map<any, any> = new Map();

  register<T>(service: new (...args: any[]) => T, instance: T) {
    this.registry.set(service, instance);
  }

  resolve<T>(target: new (...args: any[]) => T): T {
    const targetPrototype = target.prototype;
    const propertiesToInject = Reflect.getOwnMetadata(InjectableMetadataKey, targetPrototype) || [];
    
    const instance = new target();
    
    for (const prop of propertiesToInject) {
      if (this.registry.has(prop)) {
        (instance as any)[prop] = this.registry.get(prop);
      } else {
        throw new Error(`No registered service found for ${prop.toString()}`);
      }
    }

    return instance;
  }
}

// 注册服务到容器
const container = new Container();
container.register(Logger, new ConsoleLogger());

// 业务逻辑类
@Reflect.metadata(InjectableMetadataKey, ['logger'])
class BetterBusinessService {
  constructor(private logger: Logger) {}

  doSomeBusinessLogic() {
    this.logger.log('Doing some business logic with DI from a container');
  }
}

// 从IoC容器中获取并执行业务逻辑
const betterService = container.resolve(BetterBusinessService);
betterService.doSomeBusinessLogic();

在这个改进后的示例中，装饰器 @Injectable 标记了需要注入的属性，并且 Container 类负责解析这些依赖并在创建业务类实例时进行注入。这样就更好地体现了IoC容器的角色和依赖注入的机制。