当前位置：首页 > JavaScript

js ioc实现

2026-02-01 00:36:37JavaScript

依赖注入（IoC）的实现方式

在JavaScript中实现控制反转（IoC）通常通过依赖注入（DI）模式完成。以下是几种常见的实现方法：

构造函数注入

通过构造函数传递依赖对象，这是最直接的依赖注入方式。

class Service {
  constructor(dependency) {
    this.dependency = dependency;
  }

  execute() {
    this.dependency.doSomething();
  }
}

const dependency = { doSomething: () => console.log('Dependency works') };
const service = new Service(dependency);
service.execute(); // 输出: Dependency works

属性注入

依赖通过属性设置而非构造函数注入。

class Service {
  setDependency(dependency) {
    this.dependency = dependency;
  }

  execute() {
    this.dependency.doSomething();
  }
}

const service = new Service();
service.setDependency({ doSomething: () => console.log('Property injection') });
service.execute(); // 输出: Property injection

使用IoC容器

更高级的实现方式是通过IoC容器管理依赖关系。

class Container {
  constructor() {
    this.services = {};
  }

  register(name, callback) {
    this.services[name] = callback;
  }

  resolve(name) {
    if (!this.services[name]) {
      throw new Error(`Service ${name} not found`);
    }
    return this.services[name](this);
  }
}

const container = new Container();
container.register('dependency', () => ({ doSomething: () => console.log('From container') }));
container.register('service', c => new (class {
  constructor() {
    this.dependency = c.resolve('dependency');
  }
  execute() {
    this.dependency.doSomething();
  }
})());

const service = container.resolve('service');
service.execute(); // 输出: From container

使用装饰器实现

在支持装饰器的环境中（如TypeScript），可以通过装饰器简化DI。

function Injectable(target: any) {
  // 标记类为可注入
}

function Inject(dependencyKey: string) {
  return function(target: any, key: string) {
    // 实现注入逻辑
  }
}

@Injectable
class Service {
  @Inject('dependency')
  private dependency: any;

  execute() {
    this.dependency.doSomething();
  }
}

基于接口的DI

通过抽象接口进一步解耦依赖关系。

js ioc实现

// 定义接口
class IDependency {
  doSomething() {}
}

// 实现
class ConcreteDependency extends IDependency {
  doSomething() {
    console.log('Interface-based DI');
  }
}

class Service {
  constructor(dependency) {
    if (!(dependency instanceof IDependency)) {
      throw new Error('Invalid dependency');
    }
    this.dependency = dependency;
  }
}

每种方法各有优劣，构造函数注入适合必需依赖，属性注入适合可选依赖，IoC容器适合复杂应用，装饰器提供更优雅的语法，接口方式增强类型安全。选择取决于项目需求和技术栈。