如何修复InversifyJs的too much recursion递归错误？

你遇到的递归错误是因为直接在构造函数中互相注入实例，导致Inversify在实例化时陷入无限循环。处理这种循环依赖，必须使用延迟注入或工厂模式，而不是常规的构造函数注入，以下是两种可行的解决方式：

方式一：工厂函数注入 #

通过注入工厂函数来延迟实例化依赖，避免直接在构造函数中触发对方的实例化：

首先定义类型标识符：

const TYPES = {
  A: Symbol.for("A"),
  B: Symbol.for("B")
};

实现类A和类B：

import { injectable, inject, interfaces } from "inversify";

@injectable()
export class A {
  private _bFactory: () => B;

  constructor(@inject(TYPES.B) bFactory: interfaces.Factory<B>) {
    this._bFactory = bFactory;
  }

  // 通过getter延迟获取B实例
  get b(): B {
    return this._bFactory();
  }
}

@injectable()
export class B {
  private _aFactory: () => A;

  constructor(@inject(TYPES.A) aFactory: interfaces.Factory<A>) {
    this._aFactory = aFactory;
  }

  get a(): A {
    return this._aFactory();
  }
}

容器绑定需要同时绑定类和对应的工厂：

import { Container } from "inversify";

const container = new Container();
// 绑定类
container.bind<A>(TYPES.A).to(A);
container.bind<B>(TYPES.B).to(B);
// 绑定工厂函数
container.bind<interfaces.Factory<A>>(TYPES.A).toFactory<A>(context => {
  return () => context.container.get<A>(TYPES.A);
});
container.bind<interfaces.Factory<B>>(TYPES.B).toFactory<B>(context => {
  return () => context.container.get<B>(TYPES.B);
});

方式二：属性延迟注入（@lazyInject） #

使用@lazyInject装饰器实现属性级别的延迟注入，无需修改构造函数：

import { injectable, lazyInject } from "inversify";

@injectable()
export class A {
  @lazyInject(TYPES.B)
  private _b: B;

  get b(): B {
    return this._b;
  }
}

@injectable()
export class B {
  @lazyInject(TYPES.A)
  private _a: A;

  get a(): A {
    return this._a;
  }
}

容器只需常规绑定类即可：

const container = new Container();
container.bind<A>(TYPES.A).to(A);
container.bind<B>(TYPES.B).to(B);

常见错误原因 #

如果仍出现问题，大概率是你没有按照官方文档的要求使用延迟注入逻辑，而是继续在构造函数中直接注入对方的实例，导致实例化过程无限递归。确保依赖的获取是延迟触发的（比如通过getter或工厂调用），而不是在构造阶段直接实例化。

内容的提问来源于stack exchange，提问作者Zied Hf