JavaScript中的依赖注入与控制反转

描述
依赖注入（Dependency Injection，DI）和控制反转（Inversion of Control，IoC）是软件工程中用于解耦组件的重要设计模式。在JavaScript中，它们帮助管理模块间的依赖关系，提高代码的可测试性、可维护性和灵活性。依赖注入是将依赖项从外部"注入"到组件中，而不是在内部创建；控制反转是将依赖的控制权从组件内部转移到外部容器。

解题过程

1. 理解问题本质

   • 传统方式中，组件直接创建其依赖（如new Service()），导致紧耦合
   • 依赖注入通过外部提供依赖，实现组件与依赖的解耦
   • 控制反转是更广泛的原则，依赖注入是其一种具体实现

2. 基础实现：手动依赖注入

   // 传统紧耦合方式
   class UserService {
     constructor() {
       this.db = new Database(); // 内部直接创建依赖
     }
   }
   
   // 依赖注入方式
   class UserService {
     constructor(database) { // 依赖通过参数传入
       this.db = database;
     }
   }
   
   const db = new Database();
   const userService = new UserService(db); // 依赖从外部注入
   

3. 进阶：依赖注入容器

   • 手动注入在大型应用中变得繁琐
   • 容器负责管理依赖的创建和生命周期

   class Container {
     constructor() {
       this.dependencies = new Map();
     }
   
     register(key, factory) {
       this.dependencies.set(key, { factory, instance: null });
     }
   
     resolve(key) {
       const dependency = this.dependencies.get(key);
       if (!dependency) throw new Error(`未注册的依赖: ${key}`);
   
       if (!dependency.instance) {
         dependency.instance = dependency.factory(this);
       }
       return dependency.instance;
     }
   }
   
   // 使用示例
   const container = new Container();
   container.register('database', () => new Database());
   container.register('userService', (c) => new UserService(c.resolve('database')));
   
   const userService = container.resolve('userService');
   

4. 高级特性：生命周期管理

   • 单例：整个应用共享一个实例
   • 瞬态：每次解析都创建新实例

   class Container {
     register(key, factory, lifecycle = 'singleton') {
       this.dependencies.set(key, { factory, instance: null, lifecycle });
     }
   
     resolve(key) {
       const dependency = this.dependencies.get(key);
       if (!dependency) throw new Error(`未注册的依赖: ${key}`);
   
       if (dependency.lifecycle === 'transient') {
         return dependency.factory(this); // 总是返回新实例
       }
   
       if (!dependency.instance) {
         dependency.instance = dependency.factory(this);
       }
       return dependency.instance;
     }
   }
   

5. 实际应用：装饰器实现

   • 使用装饰器简化依赖注入配置

   function injectable(key) {
     return function(target) {
       Container.register(key, () => new target());
     };
   }
   
   function inject(key) {
     return function(target, propertyName) {
       Object.defineProperty(target, propertyName, {
         get: () => Container.resolve(key),
         enumerable: true,
         configurable: true
       });
     };
   }
   
   // 使用装饰器
   @injectable('userService')
   class UserService {
     @inject('database') db;
   }
   

6. 最佳实践与注意事项

   • 接口抽象：依赖抽象而非具体实现
   • 配置集中化：所有依赖配置在应用入口处管理
   • 错误处理：处理循环依赖和未注册依赖的情况
   • 测试友好：通过注入模拟对象简化单元测试

通过这种渐进式的依赖管理方式，JavaScript应用可以获得更好的模块化程度和可测试性，同时降低组件间的耦合度。