Dependency injection 反循环单态注入

我试着用两个单身汉，让他们可以这样互相打电话

import 'reflect-metadata';
import { Container, inject, injectable } from 'inversify';

let container = new Container();

@injectable()
class Dom {
  private domUi: DomUi;

  constructor (domUi: DomUi) {
    this.domUi = domUi;
  }
}

@injectable()
class DomUi {
  private dom: Dom;

  constructor (dom: Dom) {
    this.dom = dom;
  }
}

@injectable()
class Test {
  constructor (dom: Dom) {
    console.log(dom);
  }
}

container.bind<Dom>(Dom).toSelf().inSingletonScope();
container.bind<DomUi>(DomUi).toSelf().inSingletonScope();

const test = container.resolve(Test);

如何解决这个问题？我尝试了

@inject

和

@multiInject

，但没有成功

---

有没有更好的方法从设计模式的角度来考虑这个问题？

我认为您发现了一个bug，您可以使用以下方法作为解决方法：

import "reflect-metadata";
import { Container, inject, injectable } from "inversify";
import getDecorators from "inversify-inject-decorators";

let container = new Container();
let { lazyInject } = getDecorators(container);

@injectable()
class DomUi {
    private _dom: Dom;

    public constructor (dom: Dom) {
        this._dom = dom;
    }
}

@injectable()
class Dom {
    @lazyInject(DomUi) private domUi: DomUi;
}

@injectable()
    class Test {
    constructor(dom: Dom) {
        console.log(dom);
    }
}

container.bind<Dom>(Dom).toSelf().inSingletonScope();
container.bind<DomUi>(DomUi).toSelf().inSingletonScope();
const dom = container.resolve(Test);

导入“反映元数据”；
从“inversify”导入{Container，inject，injectable}；
从“inversify inject decorators”导入getDecorators；
让容器=新容器（）；
让{lazyInject}=getDecorators（容器）；
@可注射（）
类DomUi{
私有：dom；
公共构造函数（dom:dom）{
这个。_dom=dom；
}
}
@可注射（）
类Dom{
@lazyInject（DomUi）私有DomUi:DomUi；
}
@可注射（）
课堂测试{
构造函数（dom:dom）{
console.log（dom）；
}
}
container.bind（Dom.toSelf（）.inSingletonScope（）；
container.bind（DomUi.toSelf（）.inSingletonScope（）；
const dom=container.resolve（测试）；

建议使用符号而不是类作为ID：

import "reflect-metadata";
import { Container, inject, injectable } from "inversify";
import getDecorators from "inversify-inject-decorators";

let container = new Container();
let { lazyInject } = getDecorators(container);

const TYPE = {
    Dom: Symbol("Dom"),
    DomUi: Symbol("DomUi"),
    Test: Symbol("Test")
};

interface Dom {}
interface DomUi {}
interface Test {}

@injectable()
class DomUi {
    public dom: Dom;

    public constructor (
        @inject(TYPE.Dom) d: Dom
    ) {
        this.dom = d;
    }
}

@injectable()
class Dom {
    @lazyInject(TYPE.DomUi) public domUi: DomUi;
}

@injectable()
class Test {
    constructor(
        @inject(TYPE.Dom) d: Dom
    ) {
        console.log(d, d.domUi.dom);
    }
}

container.bind<Dom>(TYPE.Dom).to(Dom).inSingletonScope();
container.bind<DomUi>(TYPE.DomUi).to(DomUi).inSingletonScope();
container.bind<Test>(TYPE.Test).to(Test);
const dom = container.get(TYPE.Test);

导入“反映元数据”；
从“inversify”导入{Container，inject，injectable}；
从“inversify inject decorators”导入getDecorators；
让容器=新容器（）；
让{lazyInject}=getDecorators（容器）；
常量类型={
Dom:Symbol（“Dom”），
DomUi:Symbol（“DomUi”），
测试：符号（“测试”）
};
接口Dom{}
接口DomUi{}
接口测试{}
@可注射（）
类DomUi{
公共dom:dom；
公共构造函数(
@注入（TYPE.Dom）d:Dom
) {
this.dom=d；
}
}
@可注射（）
类Dom{
@lazyInject（TYPE.DomUi）公共DomUi:DomUi；
}
@可注射（）
课堂测试{
建造师(
@注入（TYPE.Dom）d:Dom
) {
log（d，d.domUi.dom）；
}
}
bind（TYPE.Dom）.to（Dom.inSingletonScope（）；
bind（TYPE.DomUi）.to（DomUi.inSingletonScope（）；
容器。绑定（型式试验）。至（试验）；
const dom=container.get（TYPE.Test）；

我认为您发现了一个bug，您可以使用以下解决方法：

import "reflect-metadata";
import { Container, inject, injectable } from "inversify";
import getDecorators from "inversify-inject-decorators";

let container = new Container();
let { lazyInject } = getDecorators(container);

@injectable()
class DomUi {
    private _dom: Dom;

    public constructor (dom: Dom) {
        this._dom = dom;
    }
}

@injectable()
class Dom {
    @lazyInject(DomUi) private domUi: DomUi;
}

@injectable()
    class Test {
    constructor(dom: Dom) {
        console.log(dom);
    }
}

container.bind<Dom>(Dom).toSelf().inSingletonScope();
container.bind<DomUi>(DomUi).toSelf().inSingletonScope();
const dom = container.resolve(Test);

导入“反映元数据”；
从“inversify”导入{Container，inject，injectable}；
从“inversify inject decorators”导入getDecorators；
让容器=新容器（）；
让{lazyInject}=getDecorators（容器）；
@可注射（）
类DomUi{
私有：dom；
公共构造函数（dom:dom）{
这个。_dom=dom；
}
}
@可注射（）
类Dom{
@lazyInject（DomUi）私有DomUi:DomUi；
}
@可注射（）
课堂测试{
构造函数（dom:dom）{
console.log（dom）；
}
}
container.bind（Dom.toSelf（）.inSingletonScope（）；
container.bind（DomUi.toSelf（）.inSingletonScope（）；
const dom=container.resolve（测试）；

建议使用符号而不是类作为ID：

import "reflect-metadata";
import { Container, inject, injectable } from "inversify";
import getDecorators from "inversify-inject-decorators";

let container = new Container();
let { lazyInject } = getDecorators(container);

const TYPE = {
    Dom: Symbol("Dom"),
    DomUi: Symbol("DomUi"),
    Test: Symbol("Test")
};

interface Dom {}
interface DomUi {}
interface Test {}

@injectable()
class DomUi {
    public dom: Dom;

    public constructor (
        @inject(TYPE.Dom) d: Dom
    ) {
        this.dom = d;
    }
}

@injectable()
class Dom {
    @lazyInject(TYPE.DomUi) public domUi: DomUi;
}

@injectable()
class Test {
    constructor(
        @inject(TYPE.Dom) d: Dom
    ) {
        console.log(d, d.domUi.dom);
    }
}

container.bind<Dom>(TYPE.Dom).to(Dom).inSingletonScope();
container.bind<DomUi>(TYPE.DomUi).to(DomUi).inSingletonScope();
container.bind<Test>(TYPE.Test).to(Test);
const dom = container.get(TYPE.Test);

导入“反映元数据”；
从“inversify”导入{Container，inject，injectable}；
从“inversify inject decorators”导入getDecorators；
让容器=新容器（）；
让{lazyInject}=getDecorators（容器）；
常量类型={
Dom:Symbol（“Dom”），
DomUi:Symbol（“DomUi”），
测试：符号（“测试”）
};
接口Dom{}
接口DomUi{}
接口测试{}
@可注射（）
类DomUi{
公共dom:dom；
公共构造函数(
@注入（TYPE.Dom）d:Dom
) {
this.dom=d；
}
}
@可注射（）
类Dom{
@lazyInject（TYPE.DomUi）公共DomUi:DomUi；
}
@可注射（）
课堂测试{
建造师(
@注入（TYPE.Dom）d:Dom
) {
log（d，d.domUi.dom）；
}
}
bind（TYPE.Dom）.to（Dom.inSingletonScope（）；
bind（TYPE.DomUi）.to（DomUi.inSingletonScope（）；
容器。绑定（型式试验）。至（试验）；
const dom=container.get（TYPE.Test）；

谢谢，您的解决方案工作正常！这是一个人为的再现性示例，但我将在实际项目中使用符号。我在GitHub上创建了一个问题来跟踪此错误。谢谢，您的解决方案工作正常！这是一个人为的再现性示例，但我将在实际项目中使用符号。我在GitHub上创建了一个问题来跟踪这个bug