W3cubDocs

/Angular

Dependency Injection

Dependency injection is an important application design pattern. Angular has its own dependency injection framework, and you really can't build an Angular application without it. It's used so widely that almost everyone just calls it DI.

This page covers what DI is, why it's so useful, and how to use it in an Angular app.

Run the live example.

Why dependency injection?

To understand why dependency injection is so important, consider an example without it. Imagine writing the following code:

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.`;
  }
}

The Car class creates everything it needs inside its constructor. What's the problem? The problem is that the Car class is brittle, inflexible, and hard to test.

This Car needs an engine and tires. Instead of asking for them, the Car constructor instantiates its own copies from the very specific classes Engine and Tires.

What if the Engine class evolves and its constructor requires a parameter? That would break the Car class and it would stay broken until you rewrote it along the lines of this.engine = new Engine(theNewParameter). The Engine constructor parameters weren't even a consideration when you first wrote Car. You may not anticipate them even now. But you'll have to start caring because when the definition of Engine changes, the Car class must change. That makes Car brittle.

What if you want to put a different brand of tires on your Car? Too bad. You're locked into whatever brand the Tires class creates. That makes the Car class inflexible.

Right now each new car gets its own engine. It can't share an engine with other cars. While that makes sense for an automobile engine, surely you can think of other dependencies that should be shared, such as the onboard wireless connection to the manufacturer's service center. This Car lacks the flexibility to share services that have been created previously for other consumers.

When you write tests for Car you're at the mercy of its hidden dependencies. Is it even possible to create a new Engine in a test environment? What does Engine depend upon? What does that dependency depend on? Will a new instance of Engine make an asynchronous call to the server? You certainly don't want that going on during tests.

What if the Car should flash a warning signal when tire pressure is low? How do you confirm that it actually does flash a warning if you can't swap in low-pressure tires during the test?

You have no control over the car's hidden dependencies. When you can't control the dependencies, a class becomes difficult to test.

How can you make Car more robust, flexible, and testable?

That's super easy. Change the Car constructor to a version with 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();
}

See what happened? The definition of the dependencies are now in the constructor. The Car class no longer creates an engine or tires. It just consumes them.

This example leverages TypeScript's constructor syntax for declaring parameters and properties simultaneously.

Now you can create a car by passing the engine and tires to the constructor.

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

How cool is that? The definition of the engine and tire dependencies are decoupled from the Car class. You can pass in any kind of engine or tires you like, as long as they conform to the general API requirements of an engine or tires.

Now, if someone extends the Engine class, that is not Car's problem.

The consumer of Car has the problem. The consumer must update the car creation code to something like this:

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());

The critical point is this: the Car class did not have to change. You'll take care of the consumer's problem shortly.

The Car class is much easier to test now because you are in complete control of its dependencies. You can pass mocks to the constructor that do exactly what you want them to do during each test:

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());

You just learned what dependency injection is.

It's a coding pattern in which a class receives its dependencies from external sources rather than creating them itself.

Cool! But what about that poor consumer? Anyone who wants a Car must now create all three parts: the Car, Engine, and Tires. The Car class shed its problems at the consumer's expense. You need something that takes care of assembling these parts.

You could write a giant class to do that:

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();
  }
}

It's not so bad now with only three creation methods. But maintaining it will be hairy as the application grows. This factory is going to become a huge spiderweb of interdependent factory methods!

Wouldn't it be nice if you could simply list the things you want to build without having to define which dependency gets injected into what?

This is where the dependency injection framework comes into play. Imagine the framework had something called an injector. You register some classes with this injector, and it figures out how to create them.

When you need a Car, you simply ask the injector to get it for you and you're good to go.

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

Everyone wins. The Car knows nothing about creating an Engine or Tires. The consumer knows nothing about creating a Car. You don't have a gigantic factory class to maintain. Both Car and consumer simply ask for what they need and the injector delivers.

This is what a dependency injection framework is all about.

Now that you know what dependency injection is and appreciate its benefits, read on to see how it is implemented in Angular.

Angular dependency injection

Angular ships with its own dependency injection framework. This framework can also be used as a standalone module by other applications and frameworks.

To see what it can do when building components in Angular, start with a simplified version of the HeroesComponent that from the The Tour of Heroes.

src/app/heroes/heroes.component.ts
import { Component }          from '@angular/core';

@Component({
  selector: 'my-heroes',
  template: `
  <h2>Heroes</h2>
  <hero-list></hero-list>
  `
})
export class HeroesComponent { }
src/app/heroes/hero-list.component.ts
import { Component }   from '@angular/core';

import { HEROES }      from './mock-heroes';

@Component({
  selector: 'hero-list',
  template: `
  <div *ngFor="let hero of heroes">
    {{hero.id}} - {{hero.name}}
  </div>
  `
})
export class HeroListComponent {
  heroes = HEROES;
}
src/app/heroes/hero.ts
export class Hero {
  id: number;
  name: string;
  isSecret = false;
}
src/app/heroes/mock-heroes.ts
import { Hero } from './hero';

export const HEROES: Hero[] = [
  { id: 11, isSecret: false, name: 'Mr. Nice' },
  { id: 12, isSecret: false, name: 'Narco' },
  { id: 13, isSecret: false, name: 'Bombasto' },
  { id: 14, isSecret: false, name: 'Celeritas' },
  { id: 15, isSecret: false, name: 'Magneta' },
  { id: 16, isSecret: false, name: 'RubberMan' },
  { id: 17, isSecret: false, name: 'Dynama' },
  { id: 18, isSecret: true,  name: 'Dr IQ' },
  { id: 19, isSecret: true,  name: 'Magma' },
  { id: 20, isSecret: true,  name: 'Tornado' }
];

The HeroesComponent is the root component of the Heroes feature area. It governs all the child components of this area. This stripped down version has only one child, HeroListComponent, which displays a list of heroes.

Right now HeroListComponent gets heroes from HEROES, an in-memory collection defined in another file. That may suffice in the early stages of development, but it's far from ideal. As soon as you try to test this component or want to get your heroes data from a remote server, you'll have to change the implementation of heroes and fix every other use of the HEROES mock data.

It's better to make a service that hides how the app gets hero data.

Given that the service is a separate concern, consider writing the service code in its own file.

See this note for details.

The following HeroService exposes a getHeroes method that returns the same mock data as before, but none of its consumers need to know that.

src/app/heroes/hero.service.ts
import { Injectable } from '@angular/core';

import { HEROES }     from './mock-heroes';

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

The @Injectable() decorator above the service class is covered shortly.

Of course, this isn't a real service. If the app were actually getting data from a remote server, the API would have to be asynchronous, perhaps returning a Promise. You'd also have to rewrite the way components consume the service. This is important in general, but not in this example.

A service is nothing more than a class in Angular. It remains nothing more than a class until you register it with an Angular injector.

Configuring the injector

You don't have to create an Angular injector. Angular creates an application-wide injector for you during the bootstrap process.

src/main.ts (bootstrap)
platformBrowserDynamic().bootstrapModule(AppModule);

You do have to configure the injector by registering the providers that create the services the application requires. This guide explains what providers are later.

You can either register a provider within an NgModule or in application components.

Registering providers in an NgModule

Here's the AppModule that registers two providers, UserService and an APP_CONFIG provider, in its providers array.

src/app/app.module.ts (excerpt)
@NgModule({
  imports: [
    BrowserModule
  ],
  declarations: [
    AppComponent,
    CarComponent,
    HeroesComponent,
/* . . . */
  ],
  providers: [
    UserService,
    { provide: APP_CONFIG, useValue: HERO_DI_CONFIG }
  ],
  bootstrap: [ AppComponent ]
})
export class AppModule { }

Because the HeroService is used only within the HeroesComponent and its subcomponents, the top-level HeroesComponent is the ideal place to register it.

Registering providers in a component

Here's a revised HeroesComponent that registers the HeroService in its providers array.

src/app/heroes/heroes.component.ts
import { Component }          from '@angular/core';

import { HeroService }        from './hero.service';

@Component({
  selector: 'my-heroes',
  providers: [HeroService],
  template: `
  <h2>Heroes</h2>
  <hero-list></hero-list>
  `
})
export class HeroesComponent { }

When to use NgModule versus an application component

On the one hand, a provider in an NgModule is registered in the root injector. That means that every provider registered within an NgModule will be accessible in the entire application.

On the other hand, a provider registered in an application component is available only on that component and all its children.

Here, the APP_CONFIG service needs to be available all across the application, so it's registered in the AppModule @NgModule providers array. But since the HeroService is only used within the Heroes feature area and nowhere else, it makes sense to register it in the HeroesComponent.

Also see "Should I add app-wide providers to the root AppModule or the root AppComponent?" in the NgModule FAQ.

Preparing the HeroListComponent for injection

The HeroListComponent should get heroes from the injected HeroService. Per the dependency injection pattern, the component must ask for the service in its constructor, as discussed earlier. It's a small change:

src/app/heroes/hero-list.component (with DI)
import { Component }   from '@angular/core';

import { Hero }        from './hero';
import { HeroService } from './hero.service';

@Component({
  selector: 'hero-list',
  template: `
  <div *ngFor="let hero of heroes">
    {{hero.id}} - {{hero.name}}
  </div>
  `
})
export class HeroListComponent {
  heroes: Hero[];

  constructor(heroService: HeroService) {
    this.heroes = heroService.getHeroes();
  }
}
src/app/heroes/hero-list.component (without DI)
import { Component }   from '@angular/core';

import { HEROES }      from './mock-heroes';

@Component({
  selector: 'hero-list',
  template: `
  <div *ngFor="let hero of heroes">
    {{hero.id}} - {{hero.name}}
  </div>
  `
})
export class HeroListComponent {
  heroes = HEROES;
}

Focus on the constructor

Adding a parameter to the constructor isn't all that's happening here.

src/app/heroes/hero-list.component.ts
constructor(heroService: HeroService) {
  this.heroes = heroService.getHeroes();
}

Note that the constructor parameter has the type HeroService, and that the HeroListComponent class has an @Component decorator (scroll up to confirm that fact). Also recall that the parent component (HeroesComponent) has providers information for HeroService.

The constructor parameter type, the @Component decorator, and the parent's providers information combine to tell the Angular injector to inject an instance of HeroService whenever it creates a new HeroListComponent.

Implicit injector creation

You saw how to use an injector to create a new Car earlier in this guide. You could create such an injector explicitly:

src/app/car/car-injector.ts
injector = ReflectiveInjector.resolveAndCreate([Car, Engine, Tires]);
let car = injector.get(Car);

You won't find code like that in the Tour of Heroes or any of the other documentation samples. You could write code that explicitly creates an injector if you had to, but it's not always the best choice. Angular takes care of creating and calling injectors when it creates components for you—whether through HTML markup, as in <hero-list></hero-list>, or after navigating to a component with the router. If you let Angular do its job, you'll enjoy the benefits of automated dependency injection.

Singleton services

Dependencies are singletons within the scope of an injector. In this guide's example, a single HeroService instance is shared among the HeroesComponent and its HeroListComponent children.

However, Angular DI is a hierarchical injection system, which means that nested injectors can create their own service instances. For more information, see Hierarchical Injectors.

Testing the component

Earlier you saw that designing a class for dependency injection makes the class easier to test. Listing dependencies as constructor parameters may be all you need to test application parts effectively.

For example, you can create a new HeroListComponent with a mock service that you can manipulate under test:

src/app/test.component.ts
let expectedHeroes = [{name: 'A'}, {name: 'B'}]
let mockService = <HeroService> {getHeroes: () => expectedHeroes }

it('should have heroes when HeroListComponent created', () => {
  let hlc = new HeroListComponent(mockService);
  expect(hlc.heroes.length).toEqual(expectedHeroes.length);
});

Learn more in Testing.

When the service needs a service

The HeroService is very simple. It doesn't have any dependencies of its own.

What if it had a dependency? What if it reported its activities through a logging service? You'd apply the same constructor injection pattern, adding a constructor that takes a Logger parameter.

Here is the revision compared to the original.

src/app/heroes/hero.service (v2)
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;
  }
}
src/app/heroes/hero.service (v1)
import { Injectable } from '@angular/core';

import { HEROES }     from './mock-heroes';

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

The constructor now asks for an injected instance of a Logger and stores it in a private property called logger. You call that property within the getHeroes() method when anyone asks for heroes.

Why @Injectable()?

@Injectable() marks a class as available to an injector for instantiation. Generally speaking, an injector reports an error when trying to instantiate a class that is not marked as @Injectable().

As it happens, you could have omitted @Injectable() from the first version of HeroService because it had no injected parameters. But you must have it now that the service has an injected dependency. You need it because Angular requires constructor parameter metadata in order to inject a Logger.

Suggestion: add @Injectable() to every service class

Consider adding @Injectable() to every service class, even those that don't have dependencies and, therefore, do not technically require it. Here's why:

  • Future proofing: No need to remember @Injectable() when you add a dependency later.
  • Consistency: All services follow the same rules, and you don't have to wonder why a decorator is missing.

Injectors are also responsible for instantiating components like HeroesComponent. So why doesn't HeroesComponent have @Injectable()?

You can add it if you really want to. It isn't necessary because the HeroesComponent is already marked with @Component, and this decorator class (like @Directive and @Pipe, which you learn about later) is a subtype of @Injectable(). It is in fact @Injectable() decorators that identify a class as a target for instantiation by an injector.

At runtime, injectors can read class metadata in the transpiled JavaScript code and use the constructor parameter type information to determine what things to inject.

Not every JavaScript class has metadata. The TypeScript compiler discards metadata by default. If the emitDecoratorMetadata compiler option is true (as it should be in the tsconfig.json), the compiler adds the metadata to the generated JavaScript for every class with at least one decorator.

While any decorator will trigger this effect, mark the service class with the @Injectable() decorator to make the intent clear.

Always include the parentheses

Always write @Injectable(), not just @Injectable. The application will fail mysteriously if you forget the parentheses.

Creating and registering a logger service

Inject a logger into HeroService in two steps:

  1. Create the logger service.
  2. Register it with the application.

The logger service is quite simple:

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);
  }
}

You're likely to need the same logger service everywhere in your application, so put it in the project's app folder and register it in the providers array of the application module, AppModule.

src/app/providers.component.ts (excerpt)
providers: [Logger]

If you forget to register the logger, Angular throws an exception when it first looks for the logger:

EXCEPTION: No provider for Logger! (HeroListComponent -> HeroService -> Logger)

That's Angular telling you that the dependency injector couldn't find the provider for the logger. It needed that provider to create a Logger to inject into a new HeroService, which it needed to create and inject into a new HeroListComponent.

The chain of creations started with the Logger provider. Providers are the subject of the next section.

Injector providers

A provider provides the concrete, runtime version of a dependency value. The injector relies on providers to create instances of the services that the injector injects into components and other services.

You must register a service provider with the injector, or it won't know how to create the service.

Earlier you registered the Logger service in the providers array of the metadata for the AppModule like this:

src/app/providers.component.ts
providers: [Logger]

There are many ways to provide something that looks and behaves like a Logger. The Logger class itself is an obvious and natural provider. But it's not the only way.

You can configure the injector with alternative providers that can deliver an object that behaves like a Logger. You could provide a substitute class. You could provide a logger-like object. You could give it a provider that calls a logger factory function. Any of these approaches might be a good choice under the right circumstances.

What matters is that the injector has a provider to go to when it needs a Logger.

The Provider class and provide object literal

You wrote the providers array like this:

src/app/providers.component.ts
providers: [Logger]

This is actually a shorthand expression for a provider registration using a provider object literal with two properties:

src/app/providers.component.ts
[{ provide: Logger, useClass: Logger }]

The first is the token that serves as the key for both locating a dependency value and registering the provider.

The second is a provider definition object, which you can think of as a recipe for creating the dependency value. There are many ways to create dependency values just as there are many ways to write a recipe.

Alternative class providers

Occasionally you'll ask a different class to provide the service. The following code tells the injector to return a BetterLogger when something asks for the Logger.

src/app/providers.component.ts
[{ provide: Logger, useClass: BetterLogger }]

Class provider with dependencies

Maybe an EvenBetterLogger could display the user name in the log message. This logger gets the user from the injected UserService, which is also injected at the application level.

src/app/providers.component.ts
@Injectable()
class EvenBetterLogger extends Logger {
  constructor(private userService: UserService) { super(); }

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

Configure it like BetterLogger.

src/app/providers.component.ts
[ UserService,
  { provide: Logger, useClass: EvenBetterLogger }]

Aliased class providers

Suppose an old component depends upon an OldLogger class. OldLogger has the same interface as the NewLogger, but for some reason you can't update the old component to use it.

When the old component logs a message with OldLogger, you'd like the singleton instance of NewLogger to handle it instead.

The dependency injector should inject that singleton instance when a component asks for either the new or the old logger. The OldLogger should be an alias for NewLogger.

You certainly do not want two different NewLogger instances in your app. Unfortunately, that's what you get if you try to alias OldLogger to NewLogger with useClass.

src/app/providers.component.ts
[ NewLogger,
  // Not aliased! Creates two instances of `NewLogger`
  { provide: OldLogger, useClass: NewLogger}]

The solution: alias with the useExisting option.

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

Value providers

Sometimes it's easier to provide a ready-made object rather than ask the injector to create it from a class.

src/app/providers.component.ts
// An object in the shape of the logger service
let silentLogger = {
  logs: ['Silent logger says "Shhhhh!". Provided via "useValue"'],
  log: () => {}
};

Then you register a provider with the useValue option, which makes this object play the logger role.

[{ provide: Logger, useValue: silentLogger }]

See more useValue examples in the Non-class dependencies and InjectionToken sections.

Factory providers

Sometimes you need to create the dependent value dynamically, based on information you won't have until the last possible moment. Maybe the information changes repeatedly in the course of the browser session.

Suppose also that the injectable service has no independent access to the source of this information.

This situation calls for a factory provider.

To illustrate the point, add a new business requirement: the HeroService must hide secret heroes from normal users. Only authorized users should see secret heroes.

Like the EvenBetterLogger, the HeroService needs a fact about the user. It needs to know if the user is authorized to see secret heroes. That authorization can change during the course of a single application session, as when you log in a different user.

Unlike EvenBetterLogger, you can't inject the UserService into the HeroService. The HeroService won't have direct access to the user information to decide who is authorized and who is not.

Instead, the HeroService constructor takes a boolean flag to control display of secret heroes.

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);
}

You can inject the Logger, but you can't inject the boolean isAuthorized. You'll have to take over the creation of new instances of this HeroService with a factory provider.

A factory provider needs a factory function:

src/app/heroes/hero.service.provider.ts (excerpt)
let heroServiceFactory = (logger: Logger, userService: UserService) => {
  return new HeroService(logger, userService.user.isAuthorized);
};

Although the HeroService has no access to the UserService, the factory function does.

You inject both the Logger and the UserService into the factory provider and let the injector pass them along to the factory function:

src/app/heroes/hero.service.provider.ts (excerpt)
export let heroServiceProvider =
  { provide: HeroService,
    useFactory: heroServiceFactory,
    deps: [Logger, UserService]
  };

The useFactory field tells Angular that the provider is a factory function whose implementation is the heroServiceFactory.

The deps property is an array of provider tokens. The Logger and UserService classes serve as tokens for their own class providers. The injector resolves these tokens and injects the corresponding services into the matching factory function parameters.

Notice that you captured the factory provider in an exported variable, heroServiceProvider. This extra step makes the factory provider reusable. You can register the HeroService with this variable wherever you need it.

In this sample, you need it only in the HeroesComponent, where it replaces the previous HeroService registration in the metadata providers array. Here you see the new and the old implementation side-by-side:

src/app/heroes/heroes.component (v3)
import { Component }          from '@angular/core';

import { heroServiceProvider } from './hero.service.provider';

@Component({
  selector: 'my-heroes',
  template: `
  <h2>Heroes</h2>
  <hero-list></hero-list>
  `,
  providers: [heroServiceProvider]
})
export class HeroesComponent { }
src/app/heroes/heroes.component (v2)
import { Component }          from '@angular/core';

import { HeroService }        from './hero.service';

@Component({
  selector: 'my-heroes',
  providers: [HeroService],
  template: `
  <h2>Heroes</h2>
  <hero-list></hero-list>
  `
})
export class HeroesComponent { }

Dependency injection tokens

When you register a provider with an injector, you associate that provider with a dependency injection token. The injector maintains an internal token-provider map that it references when asked for a dependency. The token is the key to the map.

In all previous examples, the dependency value has been a class instance, and the class type served as its own lookup key. Here you get a HeroService directly from the injector by supplying the HeroService type as the token:

src/app/injector.component.ts
heroService: HeroService;

You have similar good fortune when you write a constructor that requires an injected class-based dependency. When you define a constructor parameter with the HeroService class type, Angular knows to inject the service associated with that HeroService class token:

src/app/heroes/hero-list.component.ts
constructor(heroService: HeroService)

This is especially convenient when you consider that most dependency values are provided by classes.

Non-class dependencies

What if the dependency value isn't a class? Sometimes the thing you want to inject is a string, function, or object.

Applications often define configuration objects with lots of small facts (like the title of the application or the address of a web API endpoint) but these configuration objects aren't always instances of a class. They can be object literals such as this one:

src/app/app-config.ts (excerpt)
export interface AppConfig {
  apiEndpoint: string;
  title: string;
}

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

What if you'd like to make this configuration object available for injection? You know you can register an object with a value provider.

But what should you use as the token? You don't have a class to serve as a token. There is no AppConfig class.

TypeScript interfaces aren't valid tokens

The HERO_DI_CONFIG constant has an interface, AppConfig. Unfortunately, you cannot use a TypeScript interface as a token:

src/app/providers.component.ts
// FAIL! Can't use interface as provider token
[{ provide: AppConfig, useValue: HERO_DI_CONFIG })]
src/app/providers.component.ts
// FAIL! Can't inject using the interface as the parameter type
constructor(private config: AppConfig){ }

That seems strange if you're used to dependency injection in strongly typed languages, where an interface is the preferred dependency lookup key.

It's not Angular's doing. An interface is a TypeScript design-time artifact. JavaScript doesn't have interfaces. The TypeScript interface disappears from the generated JavaScript. There is no interface type information left for Angular to find at runtime.

InjectionToken

One solution to choosing a provider token for non-class dependencies is to define and use an InjectionToken. The definition of such a token looks like this:

src/app/app.config.ts
import { InjectionToken } from '@angular/core';

export let APP_CONFIG = new InjectionToken<AppConfig>('app.config');

The type parameter, while optional, conveys the dependency's type to developers and tooling. The token description is another developer aid.

Register the dependency provider using the InjectionToken object:

src/app/providers.component.ts
providers: [{ provide: APP_CONFIG, useValue: HERO_DI_CONFIG }]

Now you can inject the configuration object into any constructor that needs it, with the help of an @Inject decorator:

src/app/app.component.ts
constructor(@Inject(APP_CONFIG) config: AppConfig) {
  this.title = config.title;
}

Although the AppConfig interface plays no role in dependency injection, it supports typing of the configuration object within the class.

Alternatively, you can provide and inject the configuration object in an ngModule like AppModule.

src/app/app.module.ts (ngmodule-providers)
providers: [
  UserService,
  { provide: APP_CONFIG, useValue: HERO_DI_CONFIG }
],

Optional dependencies

The HeroService requires a Logger, but what if it could get by without a logger? You can tell Angular that the dependency is optional by annotating the constructor argument with @Optional():

import { Optional } from '@angular/core';
constructor(@Optional() private logger: Logger) {
  if (this.logger) {
    this.logger.log(some_message);
  }
}

When using @Optional(), your code must be prepared for a null value. If you don't register a logger somewhere up the line, the injector will set the value of logger to null.

Summary

You learned the basics of Angular dependency injection in this page. You can register various kinds of providers, and you know how to ask for an injected object (such as a service) by adding a parameter to a constructor.

Angular dependency injection is more capable than this guide has described. You can learn more about its advanced features, beginning with its support for nested injectors, in Hierarchical Dependency Injection.

Appendix: Working with injectors directly

Developers rarely work directly with an injector, but here's an InjectorComponent that does.

src/app/injector.component.ts
@Component({
  selector: 'my-injectors',
  template: `
  <h2>Other Injections</h2>
  <div id="car">{{car.drive()}}</div>
  <div id="hero">{{hero.name}}</div>
  <div id="rodent">{{rodent}}</div>
  `,
  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);
  }
}

An Injector is itself an injectable service.

In this example, Angular injects the component's own Injector into the component's constructor. The component then asks the injected injector for the services it wants in ngOnInit().

Note that the services themselves are not injected into the component. They are retrieved by calling injector.get().

The get() method throws an error if it can't resolve the requested service. You can call get() with a second parameter, which is the value to return if the service is not found. Angular can't find the service if it's not registered with this or any ancestor injector.

The technique is an example of the service locator pattern.

Avoid this technique unless you genuinely need it. It encourages a careless grab-bag approach such as you see here. It's difficult to explain, understand, and test. You can't know by inspecting the constructor what this class requires or what it will do. It could acquire services from any ancestor component, not just its own. You're forced to spelunk the implementation to discover what it does.

Framework developers may take this approach when they must acquire services generically and dynamically.

Appendix: Why have one class per file

Having multiple classes in the same file is confusing and best avoided. Developers expect one class per file. Keep them happy.

If you combine the HeroService class with the HeroesComponent in the same file, define the component last. If you define the component before the service, you'll get a runtime null reference error.

You actually can define the component first with the help of the forwardRef() method as explained in this blog post. But why flirt with trouble? Avoid the problem altogether by defining components and services in separate files.

© 2010–2017 Google, Inc.
Licensed under the Creative Commons Attribution License 4.0.
https://angular.io/guide/dependency-injection