服务相互依赖

在我的Angular 2应用程序中，我有两个相互依赖的服务（服务A从服务B调用方法，反之亦然）。

以下是相关代码：

app.component.ts：

import {Component} from 'angular2/core';
import {TempService} from '../services/tmp';
import {Temp2Service} from '../services/tmp2';

@Component({
    selector: 'my-app',
    templateUrl: 'app/app/app.component.html',
    providers: [TempService, Temp2Service]
})
export class AppComponent { (...) }

服务一：

import {Injectable} from 'angular2/core';
import {Temp2Service} from './tmp2';

@Injectable()
export class TempService {
  constructor (private _sessionService: Temp2Service) {}
}

服务二：

import {Injectable} from 'angular2/core';
import {TempService} from './tmp';

@Injectable()
export class Temp2Service {
  constructor (private _sessionService: TempService) {}
}

运行该应用程序会导致以下错误：

例外：无法解析“ Temp2Service”的所有参数（未定义）。确保所有参数都用Inject装饰或具有有效的类型注释，并且'Temp2Service'用Injectable装饰

在其中一项服务中注释构造函数时，该应用程序运行良好。因此，我的猜测是两个服务的“交叉引用”导致了问题。

您知道这里出了什么问题吗？还是我的方法已经错误？

这称为循环依赖。Angular2本身不是问题。我所知道的任何语言都不允许使用。

您将需要重构代码以删除此循环依赖项。您可能需要将这些服务之一分解为新服务。

如果您遵循单一责任原则，您将发现您不会陷入循环依赖陷阱。

构造函数注入可防止循环依赖。

可以通过注入Injector和请求强制性依赖来分解它，例如：

private payrollService:PayrollService;
constructor(/*private payrollService:PayrollService*/ injector:Injector) {
  setTimeout(() => this.payrollService = injector.get(PayrollService));
}

另请参见圆弧依赖注入角度2

这里的关键不是通过构造函数注入服务，而是使用显式的setter和getter。我将在Angular 4中使用以下模式：

app.component.ts

import { FooService } from './foo/foo.service';
import { BarService } from './bar/bar.service';

export class AppComponent {

  constructor(public fooService: FooService, public barService: BarService) {

    this.fooService.setBarService(barService);

  }

}

foo.service.ts

@Injectable()
export class FooService {

    barService: any;

    constructor(){
    }

    setBarService(barService: any): void {
        this.barService = barService;
    }

    getBarService(): any {
        return this.barService;
    }

}

我更新了此解决方案以使其与Angular> 4配合使用。使用Injector类，您可以将服务注入到另一个服务中。

import { Injector } from '@angular/core';
import { TempService } from './tmp';


@Injectable()
export class Temp2Service {

  private tempService: any;

  constructor (private injector: Injector) { }

  public funcA() {
     this.tempService = this.injector.get(TempService);
     this.tempService.doSomething();
  }
}

这是一个循环依赖关系，不幸的是，这是一个基本的计算机科学问题或信息问题，而Angular无法解决。尝试做这样的事情：

export class ServiceA{
 constructor(private b: ServiceB){
    b.setA(this);
 }
}

export class ServiceB {

 private a: ServiceA

 constructor(){

 }

 setA(a){
   this.a = a;
 }

}

那可能是最好的方法。

我们可以解决forwordRef函数来解决这个问题。

//允许引用尚未定义的引用。

@Inject（forwardRef（（）=> MyService））私有httpProxy：MyService

如果您使用的是Angular 2，并且需要循环依赖关系以在某些事件上彼此调用函数，则可以使用Observables并在注入了其他服务的Service中对其进行订阅。

例：

@Injectable()
class Service1 {

  observeEvents() {
    return Obsevable.create((o) => {
      //store `o` it in any class variable
      //whenever you want to call function of Service2 from this class, do this `o.next('method_name');`
    });
  }
}

@Injectable()
class Service2 {
  constructor(private service1: Service1) {
    this.service1.subscribe((method) => {
      this[method]();
    });
  }
}

使用接口-这是许多语言中的常见模式。

看到古特斯答案

Angular 2和SystemJS的循环依赖

我尝试使用setTimeout修复循环依赖关系警告或使用注入器并将注入从构造函数移至另一个函数的所有方法对角度7都不起作用。

这是我的工作解决方案：

我创建了另一个服务，只是为了将服务引用保留给第一个服务：

@Injectable()
export class AnotherService {

  private _service: AService;

  get service(): AService {
    return this._service;
  }
  set service(service: AService) {
    this._service = service;
  }
}

然后我可以像这样使用它：

@Injectable()
export class AService {

  constructor(private anotherService: AnotherService) {
    anotherService.service = this;
  }
  ...
}

和这里：

@Injectable()
export class BService {
  private aService: AService;

  constructor(private injector: Injector) {
    const anotherService = injector.get(AnotherService);
    this.aService = anotherService.service;
  }
  ...
}

我遇到了循环依赖问题，找到了很多答案，下面是找到解决该问题的最佳方法。

据我了解，当您尝试传递a: A到b: B 构造函数时，就会出现问题。因此避免这种情况的方法是创建您的对象，然后仅将其设置a为b

至于我A和B并不是在自言自语，我的例子就是我的案子

注意，进口不影响循环依赖问题。

rabbit.component.ts

export class RabbitComponent {

    public rabbitsArray: Rabbit[] = []

    constructor(){
        let lRabbit: Rabbit = new Rabbit(God.rabbitMotherFromEve())
        lRabbit.setRabbitComponent(this)
        rabbits.push(lRabbit)
    }
}

兔子

export class Rabbit {
    public feetsArray: Foot[] // I know its not the best practices but more concise for example
    public rabbitComponent: RabbitComponent

    constructor (anyThingYouWantButRabbitComponent: RabbitMother){
    }
}

查询API时遇到问题。A可以有很多B，B有一个A父母。在建立这些模型时，需要避免其中一种关系，以避免循环依赖。然后，当您查询时，只需将类型转换为any：

this.repositoryService.Query<A>(`$filter=Id eq ${B.AId}`).subscribe(As=>this.importantProp = (As[0] as any).C.property;)

然后在您对A的定义中：

@JsonProperty('B', [Object], true) Bs = new Array<Object>();
@JsonProperty('C', [Object], true) C = null;

如果不接受单身人士，则可以尝试在其中一项服务上调用NEW。喜欢

this._sessionService = new TempService(this);

这是我采用的方法，因为这两种服务都未使用未定义的成员变量。