360SDN.COM

Angular的依赖注入(DI)和依赖注入(Dependency injection)模式

来源:  2018-04-26 09:29:57    评论:0点击:

依赖注入(Dependency injection)模式

依赖注入是一个很重要的设计模式。 它使用得非常广泛,以至于几乎每个人都把它简称为 DI

Angular 有自己的依赖注入框架,离开它,你几乎没办法构建出 Angular 应用。

本页会告诉你 DI 是什么,以及为什么它很有用。

当你学会了这种通用的模式之后,就可以转到 Angular 依赖注入 中去看看它在 Angular 应用中的工作原理了。

为什么需要依赖注入?

要理解为什么依赖注入这么重要,不妨先考虑不使用它的一个例子。想象下列代码:

src/app/car/car.ts (without DI)

      

export class Car {

  public engine: Engine;
  public tires: Tires;
  public description = 'No DI';

  constructor() {
    this.engine = new Engine();
    this.tires = new Tires();
  }

  // Method using the engine and tires
  drive() {
    return `${this.description} car with ` +
      `${this.engine.cylinders} cylinders and ${this.tires.make} tires.`;
  }
}
  

Car 类在自己的构造函数中创建了它所需的一切。 这样做有什么问题? 问题在于 Car 类是脆弱、不灵活以及难于测试的。

Car 类需要一个引擎 (engine) 和一些轮胎 (tire),它没有去请求现成的实例, 而是在构造函数中用具体的 EngineTires 类实例化出自己的副本。

如果 Engine 类升级了,它的构造函数要求传入一个参数,这该怎么办? 这个 Car 类就被破坏了,在把创建引擎的代码重写为 this.engine = new Engine(theNewParameter) 之前,它都是坏的。 当第一次写 Car 类时,你不关心 Engine 构造函数的参数,现在也不想关心。 但是,当 Engine 类的定义发生变化时,就不得不在乎了,Car 类也不得不跟着改变。 这就会让 Car 类过于脆弱。

如果想在 Car 上使用不同品牌的轮胎会怎样?太糟了。 你被锁定在 Tires 类创建时使用的那个品牌上。这让 Car 类缺乏弹性。

现在,每辆车都有它自己的引擎。它不能和其它车辆共享引擎。 虽然这对于汽车来说还算可以理解,但是设想一下那些应该被共享的依赖,比如用来联系厂家服务中心的车载无线电。 这种车缺乏必要的弹性,无法共享当初给其它消费者创建的车载无线电。

当给 Car 类写测试的时候,你就会受制于它背后的那些依赖。 能在测试环境中成功创建新的 Engine 吗? Engine 自己又依赖什么?那些依赖本身又依赖什么? Engine 的新实例会发起到服务器的异步调用吗? 你当然不想在测试期间这么一层层追下去。

如果 Car 应该在轮胎气压低的时候闪动警示灯该怎么办? 如果没法在测试期间换上一个低气压的轮胎,那该如何确认它能正确的闪警示灯?

你没法控制这辆车背后隐藏的依赖。 当不能控制依赖时,类就会变得难以测试。

该如何让 Car 更强壮、有弹性以及可测试?

答案非常简单。把 Car 的构造函数改造成使用 DI 的版本:

src/app/car/car.ts (excerpt with DI)
      

public description = 'DI';

constructor(public engine: Engine, public tires: Tires) {
}





src/app/car/car.ts (excerpt without DI)

public engine: Engine;
public tires: Tires;
public description = 'No DI';

constructor() {
  this.engine = new Engine();
  this.tires = new Tires();
}

发生了什么?现在依赖的定义移到了构造函数中。 Car 类不再创建引擎 engine 或者轮胎 tires。 它仅仅“消费”它们。

这个例子又一次借助 TypeScript 的构造器语法来同时定义参数和属性。

现在,通过往构造函数中传入引擎和轮胎来创建一辆车。

      
// Simple car with 4 cylinders and Flintstone tires.
let car = new Car(new Engine(), new Tires());
    

酷!引擎和轮胎这两个依赖的定义与 Car 类本身解耦了。 只要喜欢,可以传入任何类型的引擎或轮胎,只要它们能满足引擎或轮胎的通用 API 需求。

这样一来,如果有人扩展了 Engine 类,那就不再是 Car 类的烦恼了。

Car消费者也有这个问题。消费者必须修改创建这辆车的代码,就像这样:

class Engine2 {
  constructor(public cylinders: number) { }
}
// Super car with 12 cylinders and Flintstone tires.
let bigCylinders = 12;
let car = new Car(new Engine2(bigCylinders), new Tires());

这里的要点是:Car 本身不必变化。下面就来解决消费者的问题。

Car 类非常容易测试,因为现在你对它的依赖有了完全的控制权。 在每个测试期间,你可以往构造函数中传入 mock 对象,做想让它们做的事:

class MockEngine extends Engine { cylinders = 8; }
class MockTires  extends Tires  { make = 'YokoGoodStone'; }

// Test car with 8 cylinders and YokoGoodStone tires.
let car = new Car(new MockEngine(), new MockTires());

    

刚刚学习了什么是依赖注入

它是一种编程模式,可以让类从外部源中获得它的依赖,而不必亲自创建它们。

酷!但是,可怜的消费者怎么办? 那些希望得到一个 Car 的人们现在必须创建所有这三部分了:CarEngineTiresCar 类把它的快乐建立在了消费者的痛苦之上。 需要某种机制为你把这三个部分装配好。

可以写一个巨型类来做这件事:src/app/car/car-factory.ts


import { Engine, Tires, Car } from './car';

// BAD pattern!
export class CarFactory {
  createCar() {
    let car = new Car(this.createEngine(), this.createTires());
    car.description = 'Factory';
    return car;
  }

  createEngine() {
    return new Engine();
  }

  createTires() {
    return new Tires();
  }
}

现在只需要三个创建方法,这还不算太坏。 但是当应用规模变大之后,维护它将变得惊险重重。 这个工厂类将变成由相互依赖的工厂方法构成的巨型蜘蛛网。

如果能简单的列出想建造的东西,而不用定义该把哪些依赖注入到哪些对象中,那该多好!

到了依赖注入框架一展身手的时候了! 想象框架中有一个叫做注入器 (injector) 的东西。 用这个注入器注册一些类,它会弄明白如何创建它们。

当需要一个 Car 时,就简单的找注入器取车就可以了。

src/app/car/car-injector.ts
      
let car = injector.get(Car);
    

皆大欢喜。Car 不需要知道如何创建 EngineTires。 消费者不需要知道如何创建 Car。 开发人员不需要维护巨大的工厂类。 Car 和消费者只要简单地请求想要什么,注入器就会交付它们。

这就是“依赖注入框架”存在的原因。

现在,你知道什么是依赖注入以及它有什么优点了吧?那就请到 Angular 依赖注入 中去看看它在 Angular 中是如何实现的。





Angular 依赖注入

依赖注入(DI)是用来创建对象及其依赖的其它对象的一种方式。 当依赖注入系统创建某个对象实例时,会负责提供该对象所依赖的对象(称为该对象的依赖)。

依赖注入模式中讲解了这种通用的方法。 在这里
DI 的例子

在这篇指南中,你将会通过对一个范例应用的讨论来学习 Angular 的依赖注入技术。

先从《英雄指南》中英雄特性区的一个简化版本开始。
src/app/heroes/heroes.component.ts
src/app/heroes/hero-list.component.ts
src/app/heroes/hero.ts
src/app/heroes/mock-heroes.ts

      

import { Component } from '@angular/core';
@Component({
  selector: 'app-heroes',
  template: `
   

Heroes


   
  `
})
export class HeroesComponent { }

    

HeroesComponent 是位于顶级的组件。 它唯一的用途是显示 HeroListComponent,它显示一个英雄名字的列表。

这个版本的 HeroListComponent 从 HEROES 数组(定义在 mock-heroes 文件中的内存数组)中获取 heroes。
src/app/heroes/hero-list.component.ts (class)

      

export class HeroListComponent {
  heroes = HEROES;
}

    

在开发的早期阶段,这就够用了,不过还很不理想。 当要测试这个组件或者要从远端服务器获取英雄数据时,你就不得不去修改 HeroesListComponent 的实现,并要替换所有使用了 HEROES 模拟数据的地方。

最好隐藏服务类的这些内部实现细节,那就先把它定义在自己的文件中。
创建一个可注入的 HeroService

Angular CLI 可以使用下列命令在 src/app/heroes 目录下新建一个 HeroService 类。

      

ng generate service heroes/hero

    

这条命令会创建如下的 HeroService 骨架代码:
src/app/heroes/hero.service.ts (CLI-generated)

      

import { Injectable } from '@angular/core';

@Injectable()
export class HeroService {
  constructor() { }
}

    

目前先把 @Injectable 装饰器当做定义每个 Angular 服务时的必备部分。 把该类的其它部分改写为暴露一个返回和以前一样的 mock 数据的 getHeroes 方法。
src/app/heroes/hero.service.ts

      

import { Injectable } from '@angular/core';
import { HEROES }     from './mock-heroes';

@Injectable()
export class HeroService {
  getHeroes() { return HEROES; }
}

    

当然,这还不是真正的数据服务。 如果该应用真的从远端服务器获取数据,那么 getHeroes 的方法签名就应该是异步形式的。

我们可以放心地忽略这个问题,因为这里的焦点在于把服务注入到 HeroListComponent 组件中。
注册服务提供商

在你把 Angular 中的服务注册进依赖注入器(injector)之前,它只是一个普通的类。

Angular 的依赖注入器负责创建服务的实例,并把它们注入到像 HeroListComponent 这样的类中。

你很少需要自己创建 Angular 的依赖注入器。 当 Angular 运行本应用时,它会为你创建这些注入器,首先会在引导过程中创建一个根注入器。

但在注入器能创建服务之前,你得先往注入器中注入这个服务的提供商。

提供商会告诉注入器如何创建该服务。 如果没有提供商,注入器既不知道它该负责创建该服务,也不知道如何创建该服务。

你可以在稍后的部分学到更多关于提供商的知识。 不过目前,只要知道它们用于创建服务,以及它们必须用注入器进行注册就行了。

你可以使用 Angular 中那些支持 providers 数组属性的装饰器来注册提供商。

很多 Angular 的装饰器都支持带有 providers 属性的元数据。 最重要的两个例子是 @Component 和 @NgModule。
在组件中注册提供商

下面是修改过的 HerosComponent,把 HeroService 注册到了它的 providers 数组中。
src/app/heroes/heroes.component.ts

      

import { Component } from '@angular/core';
import { HeroService } from './hero.service';

@Component({
  selector: 'app-heroes',
  providers: [ HeroService ],
  template: `
   

Heroes


   
  `
})
export class HeroesComponent { }

    

@NgModule 中的 providers

在下面的代码片段中,根模块 AppModule 在自己的 providers 数组中注册了两个提供商。
src/app/app.module.ts (providers)

      

providers: [
  UserService,
  { provide: APP_CONFIG, useValue: HERO_DI_CONFIG }
],

    

第一条使用 UserService 这个注入令牌(injection token)注册了 UserService 类(代码中未显示)。 第二条使用 APP_CONFIG 这个注入令牌注册了一个值(HERO_DI_CONFIG)。

得益于这些注册语句,Angular 现在可以向它创建的任何类中注册 UserService 或 HERO_DI_CONFIG 值了。

稍后你就会学到关于注入令牌和服务提供商语法的知识。
@NgModule 还是 @Component?

你该使用 Angular 的模块还是组件来注册服务呢? 这两个选择的差别在于服务的范围和生命周期。

Angular 模块中的 providers(@NgModule.providers)是注册在应用的根注入器下的。 因此,Angular 可以往它所创建的任何类中注入相应的服务。 一旦创建,服务的实例就会存在于该应用的全部生存期中,Angular 会把这一个服务实例注入到需求它的每个类中。

如果你想要把这个 UserService 注入到应用中的很多地方,并且期望每次注入的都是同一个服务实例,那么在 Angular 的模块中提供 UserService 就是不错的选择。

严格来说,Angular 模块中的服务提供商会注册到根注入器上,但是,惰性加载的模块是例外。 在这个例子中,所有模块都是在应用启动时立即加载的,因此模块上的所有服务提供商都注册到了应用的根注入器上。

组件的提供商(@Component.providers)会注册到每个组件实例自己的注入器上。

因此 Angular 只能在该组件及其各级子组件的实例上注入这个服务实例,而不能在其它地方注入这个服务实例。

注意,由组件提供的服务,也同样具有有限的生命周期。组件的每个实例都会有它自己的服务实例,并且,当组件实例被销毁的时候,服务的实例也同样会被销毁。

在这个范例应用中,HeroComponent 会在应用启动时创建,并且它从未销毁,因此,由 HeroComponent 创建的 HeroService 也同样会活在应用的整个生命周期中。

如果你要把 HeroService 的访问权限定在 HeroesComponent 及其嵌套的 HeroListComponent 中,那么在 HeroesComponent 中提供这个 HeroService 就是一个好选择。

由组件提供的服务,其范围和生命周期是 Angular 如何创建组件实例 的必然结果。
注入某个服务

HeroListComponent 应该从 HeroService 中获取这些英雄数据。

该组件不应该使用 new 来创建 HeroService。 它应该要求注入 HeroService。

你可以通过在构造函数中添加一个带有该依赖类型的参数来要求 Angular 把这个依赖注入到组件的构造函数中。 下面是 HeroListComponent 的构造函数,它要求注入 HeroService。
src/app/heroes/hero-list.component (constructor signature)

      

constructor(heroService: HeroService)

    

当然,HeroListComponent 还应该使用注入的这个 HeroService 做点什么。 下面输出修改过的组件,改用注入的服务,与前一个版本对比一下。
hero-list.component (with DI)
hero-list.component (without DI)

      

    import { Component }   from '@angular/core';
    import { Hero }        from './hero';
    import { HeroService } from './hero.service';
     
    @Component({
      selector: 'app-hero-list',
      template: `
       

          {{hero.id}} - {{hero.name}}
       

      `
    })
    export class HeroListComponent {
      heroes: Hero[];
     
      constructor(heroService: HeroService) {
        this.heroes = heroService.getHeroes();
      }
    }


    

注意,HeroListComponent 并不知道 HeroService 来自哪里。 当然你自己知道它来自父组件 HeroesComponent。 但是如果你决定改在 AppModule 中提供 HeroService,HeroListComponent 不用做任何修改。 它唯一需要关心的事情是 HeroService 是由某个父注入器提供的。
单例服务

服务在每个注入器的范围内是单例的。 在任何一个注入器中,最多只会有同一个服务的一个实例。

这里只有一个根注入器,而 UserService 就是在该注入器中注册的。 所以,在整个应用中只能有一个 UserService 实例,每个要求注入 UserService 的类都会得到这个服务实例。

不过,Angular DI 是一个 多级注入系统,这意味着各级注入器都可以创建它们自己的服务实例。 Angular 总会创建多级注入器。
组件的子注入器

例如,当 Angular 创建一个带有 @Component.providers 的组件实例时,也会同时为这个实例创建一个新的子注入器。

组件注入器是彼此独立的,每一个都会为这些组件提供的服务创建单独的实例。

当 Angular 销毁任何一个组件实例时,也会同时销毁组件的注入器以及该注入器中的那些服务实例。

在注入器继承机制的帮助下,你仍然可以把全应用级的服务注入到这些组件中。 组件的注入器也是其父组件的注入器的子注入器,这同样适用于其父组件的父组件的注入器,以此类推,最终会回到应用的根注入器。 Angular 可以注入由这个注入器谱系提供的任何一个注入器。

比如,Angular 可以把由 HeroComponent 提供的 HeroService 和由 AppModule 提供的 UserService 注入到 HeroService 中。
测试组件

前面强调过,设计一个适合依赖注入的类,可以让这个类更容易测试。 要有效的测试应用中的一部分,只需要在构造函数的参数中列出依赖。

例如,新建的 HeroListComponent 实例使用一个模拟 (mock) 服务,以便可以在测试中操纵它:
src/app/test.component.ts

      

const expectedHeroes = [{name: 'A'}, {name: 'B'}]
const mockService = {getHeroes: () => expectedHeroes }

it('should have heroes when HeroListComponent created', () => {
  // Pass the mock to the constructor as the Angular injector would
  const component = new HeroListComponent(mockService);
  expect(component.heroes.length).toEqual(expectedHeroes.length);
});

    

要学习更多知识,参见测试一章。
当服务需要别的服务时

这个 HeroService 非常简单。它本身不需要任何依赖。

如果它也有依赖,该怎么办呢?例如,它需要通过日志服务来汇报自己的活动。 你同样用构造函数注入模式,来添加一个带有 Logger 参数的构造函数。

下面是修改后的 HeroService,它注入了 Logger,对比前后这两个版本:
src/app/heroes/hero.service (v2)
src/app/heroes/hero.service (v1)

      

    import { Injectable } from '@angular/core';
    import { HEROES }     from './mock-heroes';
    import { Logger }     from '../logger.service';
     
    @Injectable()
    export class HeroService {
     
      constructor(private logger: Logger) {  }
     
      getHeroes() {
        this.logger.log('Getting heroes ...');
        return HEROES;
      }
    }


    

这个构造函数要求注入一个 Logger 类的实例,并把它存到名为 logger 的私有字段中。 当请求英雄数据时,getHeroes() 中就会记录一个消息。
被依赖的 Logger 服务

这个范例应用的 Logger 服务非常简单:
src/app/logger.service.ts

      

import { Injectable } from '@angular/core';

@Injectable()
export class Logger {
  logs: string[] = []; // capture logs for testing

  log(message: string) {
    this.logs.push(message);
    console.log(message);
  }
}

    

如果该应用没有提供这个 Logger 服务,当 Angular 试图把 Logger 注入到 HeroService 中时,就会抛出一个异常。

      

ERROR Error: No provider for Logger!

    

因为 Logger 服务的单例应该随处可用,所以要在根模块 AppModule 中提供它。
src/app/app.module.ts (providers)

      

providers: [
  Logger,
  UserService,
  { provide: APP_CONFIG, useValue: HERO_DI_CONFIG }
],

    

@Injectable()

@Injectable() 装饰器表示可能需要往这个服务类中注入其它依赖。

HeroService 必须带有 @Injectable() 装饰器,因为它需要把 Logger 注入进来。

写 @Injectable() 时必须带括号,不能只写 @Injectable。

当 Angular 要创建一个构造函数中带参数的类时,会先查找这些参数的类型,以便根据这些参数的元数据注入正确的服务。

如果不能找到该参数的信息,Angular 就会报错。

Angular 只能在带有某种装饰器的类上查找参数信息。任何装饰器都可以,而 @Injectable() 装饰器是各种服务类的标准装饰器。

之所以必须有装饰器,是因为 TypeScript 强制要求的。

当把 TypeScript 转译成 JavaScript 时,通常会丢弃参数的类型信息。 但当该类带有装饰器并且当 tsconfig.json 配置文件中的 emitDecoratorMetadata 编译选项为 true 时,它就会保留这些信息。

CLI 生成的 tsconfig.json 中已经有 emitDecoratorMetadata: true 选项了,你只要把 @Injectable() 加到你的服务类上就可以了。

Logger 服务也带有 @Injectable() 装饰器,不过它没有构造器,也没有依赖。

该应用中的每个 Angular 服务类不管有没有构造器和依赖,都带有 @Injectable() 装饰器。 事实上,@Injectable() 是风格指南中对服务类的要求。
服务提供商们

服务提供商提供依赖值的一个具体的、运行时的版本。 注入器依靠提供商来创建服务的实例,注入器再将服务的实例注入组件、管道或其它服务。

必须为注入器注册一个服务的提供商,否则它就不知道该如何创建该服务。

在下面的几节中会解释指定提供商的多种方式。

几乎所有的代码片段都是从范例应用的 providers.component.ts 文件中提取出来的。
把类作为它自己的提供商

有很多方式可以提供一些实现 Logger 类的东西。 Logger 类本身是一个显而易见而且自然而然的提供商。

      

providers: [Logger]

    

但它不是唯一的途径。

可以用其它备选提供商来配置注入器,只要它们能交付一个行为类似于 Logger 的对象就可以了。 可以提供一个替代类。你可以提供一个类似日志的对象。 可以给它一个提供商,让它调用可以创建日志服务的工厂函数。 所有这些方法,只要用在正确的场合,都可能是一个好的选择。

重点是,当注入器需要一个 Logger 时,它得先有一个提供商。
provide 对象字面量

下面是类提供商的另一种语法。

      

providers: [Logger]

    

这其实是用于注册提供商的简写表达式。 使用的是一个带有两个属性的提供商对象字面量:

      

[{ provide: Logger, useClass: Logger }]

    

provide 属性保存的是令牌 (token),它作为键值 (key) 使用,用于定位依赖值和注册提供商。

第二个是一个提供商定义对象。 可以把它看做是指导如何创建依赖值的配方。 有很多方式创建依赖值…… 也有很多方式可以写配方。
备选的类提供商

某些时候,你会请求一个不同的类来提供服务。 下列代码告诉注入器,当有人请求 Logger 时,返回 BetterLogger。

      

[{ provide: Logger, useClass: BetterLogger }]

    

带依赖的类提供商

假设 EvenBetterLogger 可以在日志消息中显示用户名。 这个日志服务从注入的 UserService 中取得用户, UserService 通常也会在应用级注入。

      

@Injectable()
export class EvenBetterLogger extends Logger {
  constructor(private userService: UserService) { super(); }

  log(message: string) {
    let name = this.userService.user.name;
    super.log(`Message to ${name}: ${message}`);
  }
}

    

就像之前在 BetterLogger 中那样配置它。

      

[ UserService,
  { provide: Logger, useClass: EvenBetterLogger }]

    

别名类提供商

假设某个旧组件依赖一个 OldLogger 类。 OldLogger 和 NewLogger 具有相同的接口,但是由于某些原因, 你不能升级这个旧组件并使用它。

当旧组件想使用 OldLogger 记录消息时,你希望改用 NewLogger 的单例对象来记录。

不管组件请求的是新的还是旧的日志服务,依赖注入器注入的都应该是同一个单例对象。 也就是说,OldLogger 应该是 NewLogger 的别名。

你当然不会希望应用中有两个不同的 NewLogger 实例。 不幸的是,如果尝试通过 useClass 来把 OldLogger 作为 NewLogger 的别名,就会导致这样的后果。

      

[ NewLogger,
  // Not aliased! Creates two instances of `NewLogger`
  { provide: OldLogger, useClass: NewLogger}]

    

解决方案:使用 useExisting 选项指定别名。

      

[ NewLogger,
  // Alias OldLogger w/ reference to NewLogger
  { provide: OldLogger, useExisting: NewLogger}]

    

值提供商

有时,提供一个预先做好的对象会比请求注入器从类中创建它更容易。

      

// An object in the shape of the logger service
export function SilentLoggerFn() {}

const silentLogger = {
  logs: ['Silent logger says "Shhhhh!". Provided via "useValue"'],
  log: SilentLoggerFn
};

    

于是可以通过 useValue 选项来注册提供商,它会让这个对象直接扮演 logger 的角色。

      

[{ provide: Logger, useValue: silentLogger }]

    

查看更多 useValue 的例子,见非类依赖和 InjectionToken部分。
工厂提供商

有时,你需要动态创建这个依赖值,因为它所需要的信息直到最后一刻才能确定。 也许这个信息会在浏览器的会话中不停地变化。

还假设这个可注入的服务没法通过独立的源访问此信息。

这种情况下,请调用工厂提供商。

下面通过添加新的业务需求来说明这一点: HeroService 必须对普通用户隐藏掉秘密英雄。 只有授权用户才能看到秘密英雄。

就像 EvenBetterLogger 那样,HeroService 需要了解此用户的身份。 它需要知道,这个用户是否有权看到隐藏英雄。 这个授权可能在单一的应用会话中被改变,例如,改用另一个用户的身份登录时。

与 EvenBetterLogger 不同,不能把 UserService 注入到 HeroService 中。 HeroService 无权访问用户信息,来决定谁有授权谁没有授权。

让 HeroService 的构造函数带上一个布尔型的标志,来控制是否显示隐藏的英雄。
src/app/heroes/hero.service.ts (excerpt)

      

constructor(
  private logger: Logger,
  private isAuthorized: boolean) { }

getHeroes() {
  let auth = this.isAuthorized ? 'authorized ' : 'unauthorized';
  this.logger.log(`Getting heroes for ${auth} user.`);
  return HEROES.filter(hero => this.isAuthorized || !hero.isSecret);
}

    

你可以注入 Logger,但是不能注入逻辑型的 isAuthorized。 你不得不通过通过工厂提供商创建这个 HeroService 的新实例。

工厂提供商需要一个工厂方法:
src/app/heroes/hero.service.provider.ts (excerpt)

      

let heroServiceFactory = (logger: Logger, userService: UserService) => {
  return new HeroService(logger, userService.user.isAuthorized);
};

    

虽然 HeroService 不能访问 UserService,但是工厂方法可以。

同时把 Logger 和 UserService 注入到工厂提供商中,并且让注入器把它们传给工厂方法:
src/app/heroes/hero.service.provider.ts (excerpt)

      

export let heroServiceProvider =
  { provide: HeroService,
    useFactory: heroServiceFactory,
    deps: [Logger, UserService]
  };

    

useFactory 字段告诉 Angular:这个提供商是一个工厂方法,它的实现是 heroServiceFactory。

deps 属性是提供商令牌数组。 Logger 和 UserService 类作为它们自身类提供商的令牌。 注入器解析这些令牌,把相应的服务注入到工厂函数中相应的参数中去。

注意,你在一个导出的变量中捕获了这个工厂提供商:heroServiceProvider。 这个额外的步骤让工厂提供商可被复用。 无论哪里需要,都可以使用这个变量注册 HeroService。

在这个例子中,只在 HeroesComponent 中需要它, 这里,它代替了元数据 providers 数组中原来的 HeroService 注册。 对比一下新的和旧的实现:
src/app/heroes/heroes.component (v3)
src/app/heroes/heroes.component (v2)

      

    import { Component }          from '@angular/core';
    import { heroServiceProvider } from './hero.service.provider';
     
    @Component({
      selector: 'app-heroes',
      providers: [ heroServiceProvider ],
      template: `
       

Heroes


       
      `
    })
    export class HeroesComponent { }


    

依赖注入令牌

当向注入器注册提供商时,实际上是把这个提供商和一个 DI 令牌关联起来了。 注入器维护一个内部的令牌-提供商映射表,这个映射表会在请求依赖时被引用到。 令牌就是这个映射表中的键值。

在前面的所有例子中,依赖值都是一个类实例,并且类的类型作为它自己的查找键值。 在下面的代码中,HeroService 类型作为令牌,直接从注入器中获取 HeroService 实例:
src/app/injector.component.ts

      

heroService: HeroService;

    

编写需要基于类的依赖注入的构造函数对你来说是很幸运的。 只要定义一个 HeroService 类型的构造函数参数, Angular 就会知道把跟 HeroService 类令牌关联的服务注入进来:
src/app/heroes/hero-list.component.ts

      

constructor(heroService: HeroService)

    

这是一个特殊的规约,因为大多数依赖值都是以类的形式提供的。
非类依赖

如果依赖值不是一个类呢?有时候想要注入的东西是一个字符串,函数或者对象。

应用程序经常为很多很小的因素定义配置对象(例如应用程序的标题或网络 API 终点的地址)。 但是这些配置对象不总是类的实例,它们可能是对象,如下面这个:
src/app/app.config.ts (excerpt)

      

export const HERO_DI_CONFIG: AppConfig = {
  apiEndpoint: 'api.heroes.com',
  title: 'Dependency Injection'
};

    

如果想让这个配置对象在注入时可用该怎么办?你知道你可以用值提供商来注册一个对象。

但是,这种情况下用什么作令牌呢? 你没办法找一个类来当作令牌,因为没有 Config 类。
TypeScript 接口不是一个有效的令牌

HERO_DI_CONFIG 常量有一个接口:AppConfig。不幸的是,不能把 TypeScript 接口用作令牌:

      

// FAIL! Can't use interface as provider token
[{ provide: AppConfig, useValue: HERO_DI_CONFIG })]

    

      

// FAIL! Can't inject using the interface as the parameter type
constructor(private config: AppConfig){ }

    

对于习惯于在强类型的语言中使用依赖注入的开发人员,这会看起来很奇怪, 因为在强类型语言中,接口是首选的用于查找依赖的主键。

这不是 Angular 的错。接口只是 TypeScript 设计时 (design-time) 的概念。JavaScript 没有接口。 TypeScript 接口不会出现在生成的 JavaScript 代码中。 在运行期,没有接口类型信息可供 Angular 查找。
InjectionToken 值

解决方案是为非类依赖定义和使用InjectionToken作为提供商令牌。 定义方式是这样的:
src/app/app.config.ts

      

import { InjectionToken } from '@angular/core';

export const APP_CONFIG = new InjectionToken('app.config');

    

类型参数,虽然是可选的,但可以向开发者和开发工具传达类型信息。 而且这个令牌的描述信息也可以为开发者提供帮助。

使用这个 InjectionToken 对象注册依赖的提供商:

      

providers: [{ provide: APP_CONFIG, useValue: HERO_DI_CONFIG }]

    

现在,在 @Inject 装饰器的帮助下,这个配置对象可以注入到任何需要它的构造函数中:
src/app/app.component.ts

      

constructor(@Inject(APP_CONFIG) config: AppConfig) {
  this.title = config.title;
}

    

虽然 AppConfig 接口在依赖注入过程中没有任何作用,但它为该类中的配置对象提供了强类型信息。

或者在 ngModule 中提供并注入这个配置对象,如 AppModule。
src/app/app.module.ts (providers)

      

providers: [
  UserService,
  { provide: APP_CONFIG, useValue: HERO_DI_CONFIG }
],

    

可选依赖

HeroService需要一个 Logger,但是如果想不提供 Logger 也能得到它,该怎么办呢? 可以把构造函数的参数标记为 @Optional(),告诉 Angular 该依赖是可选的:

      

import { Optional } from '@angular/core';

    

      

constructor(@Optional() private logger: Logger) {
  if (this.logger) {
    this.logger.log(some_message);
  }
}

    

当使用 @Optional() 时,代码必须准备好如何处理空值。 如果其它的代码没有注册一个 logger,注入器会设置该 logger 的值为空 null。
小结

本章,你学习了 Angular 依赖注入的基础知识。 你可以注册很多种类的提供商,知道如何通过添加构造函数的参数来请求一个注入对象(例如一个服务)。

Angular 依赖注入比前面描述的更能干。 学习更多高级特性,如对嵌套注入器的支持,见多级依赖注入一章。
附录:直接使用注入器

这里的 InjectorComponent 直接使用了注入器, 但开发者很少直接使用它。
src/app/injector.component.ts

      

@Component({
  selector: 'app-injectors',
  template: `
 

Other Injections


 
{{car.drive()}}

 
{{hero.name}}

 
{{rodent}}

  `,
  providers: [Car, Engine, Tires, heroServiceProvider, Logger]
})
export class InjectorComponent implements OnInit {
  car: Car;

  heroService: HeroService;
  hero: Hero;

  constructor(private injector: Injector) { }

  ngOnInit() {
    this.car = this.injector.get(Car);
    this.heroService = this.injector.get(HeroService);
    this.hero = this.heroService.getHeroes()[0];
  }

  get rodent() {
    let rousDontExist = `R.O.U.S.'s? I don't think they exist!`;
    return this.injector.get(ROUS, rousDontExist);
  }
}

    

Injector 本身是可注入的服务。

在这个例子中,Angular 把组件自身的 Injector 注入到了组件的构造函数中。 然后,组件在 ngOnInit() 中向注入的注入器请求它所需的服务。

注意,这些服务本身没有注入到组件,它们是通过调用 injector.get() 获得的。

get() 方法如果不能解析所请求的服务,会抛出异常。 调用 get() 时,还可以使用第二个参数,一旦获取的服务没有在当前或任何祖先注入器中注册过, 就把它作为返回值。

刚描述的这项技术是服务定位器模式的一个范例。

要避免使用此技术,除非确实需要它。 它会鼓励鲁莽的方式,就像在这里看到的。 它难以解释、理解和测试。 仅通过阅读构造函数,没法知道这个类需要什么或者它将做什么。 它可以从任何祖先组件中获得服务,而不仅仅是它自己。 会迫使你深入它的实现,才可能明白它都做了啥。

框架开发人员必须采用通用的或者动态的方式获取服务时,可能采用这个方法。
附录:为什么建议每个文件只放一个类

在同一个文件中有多个类容易造成混淆,最好避免。 开发人员期望每个文件只放一个类。这会让它们开心点。

如果你把 HeroService 和 HeroesComponent 组合在同一个文件里, 就得把组件定义放在最后面! 如果把组件定义在了服务的前面, 在运行时抛出空指针错误。

在 forwardRef() 方法的帮助下,实际上也可以先定义组件, 具体说明见这篇博客。

但是为什么要先给自己找麻烦呢? 还是通过在独立的文件中定义组件和服务,完全避免此问题吧。


来源:https://www.angular.cn/guide/dependency-injection

 

为您推荐

友情链接 |九搜汽车网 |手机ok生活信息网|ok生活信息网|ok微生活
 Powered by www.360SDN.COM   京ICP备11022651号-4 © 2012-2016 版权