Lazy Loading and the Dependency Injection Tree

Lazy loaded modules create their own branch on the Dependency Injection (DI) tree. This means that it's possible to have services that belong to a lazy loaded module, that are not accessible by the root module or any other eagerly loaded module of our application.

To show this behaviour, let's continue with the example of the previous section and add a CounterService to our LazyModule.

app/lazy/lazy.module.ts

  1. ...
  2. import { CounterService } from './counter.service';
  4. @NgModule({
  5.   ...
  6.   providers: [CounterService]
  7. })
  8. export class LazyModule {}

Here we added the CounterService to the providers array. Our CounterService is a simple class that holds a reference to a counter property.

app/lazy/counter.service.ts

  1. import { Injectable } from '@angular/core';
  3. @Injectable()
  4. export class CounterService {
  5.   counter = 0;
  6. }

We can modify the LazyComponent to use this service with a button to increment the counter property.

app/lazy/lazy.component.ts

  1. import { Component } from '@angular/core';
  3. import { CounterService } from './counter.service';
  5. @Component({
  6.   template: `
  7.     <p>Lazy Component</p>
  8.     <button (click)="increaseCounter()">Increase Counter</button>
  9.     <p>Counter: {{ counterService.counter }}</p>
  10.   `
  11. })
  12. export class LazyComponent {
  14.   constructor(public counterService: CounterService) {}
  16.   increaseCounter() {
  17.     this.counterService.counter += 1;
  18.   }
  19. }

View Example

The service is working. If we increment the counter and then navigate back and forth between the eager and the lazy routes, the counter value will persist in the lazy loaded module.

But the question is, how can we verify that the service is isolated and cannot be used in a component that belongs to a different module? Let's try to use the same service in the EagerComponent.

app/eager.component.ts

  1. import { Component } from '@angular/core';
  2. import { CounterService } from './lazy/counter.service';
  4. @Component({
  5.   template: `
  6.     <p>Eager Component</p>
  7.     <button (click)="increaseCounter()">Increase Counter</button>
  8.     <p>Counter: {{ counterService.counter }}</p>
  9.   `
  10. })
  11. export class EagerComponent {
  12.   constructor(public counterService: CounterService) {}
  14.   increaseCounter() {
  15.     this.counterService.counter += 1;
  16.   }
  17. }

If we try to run this new version of our code, we are going to get an error message in the browser console:

  1. No provider for CounterService!

What this error tells us is that the AppModule, where the EagerComponent is defined, has no knowledge of a service called CounterService. CounterService lives in a different branch of the DI tree created for LazyModule when it was lazy loaded in the browser.

原文: https://angular-2-training-book.rangle.io/handout/modules/lazy-load-di.html