The @Inject() decorator is a property and parameter decorator used to resolve dependencies on a property of a class or a constructor parameter. By default it infers the type of the property or argument and initializes an instance of the detected type, however, this behavior can be overwritten via specifying a custom constructable type, Token, or named service as the first parameter.
Property injection
This decorator is mandatory on properties where a class instance is desired (aka: without the decorator, the property will stay undefined). The type of the property is automatically inferred so there is no need to define the desired value as the decorator parameter.
import'reflect-metadata';import { Container, Inject, Service } from'typedi';@Service()classInjectedExampleClass {print() {console.log('I am alive!'); }}@Service()classExampleClass { @Inject() withDecorator:InjectedExampleClass; withoutDecorator:InjectedExampleClass;}constinstance=Container.get(ExampleClass);/** * The `instance` variable is an ExampleClass instance with the `withDecorator` * property containing an InjectedExampleClass instance and `withoutDecorator` * property being undefined. */console.log(instance);instance.withDecorator.print();// prints "I am alive!" (InjectedExampleClass.print function)console.log(instance.withoutDecorator);// logs undefined, as this property was not marked with an @Inject decorator
Constructor Injection
The @Inject decorator is not required in constructor injection when a class is marked with the @Service decorator. TypeDI will automatically infer and inject the correct class instances for every constructor argument. However, it can be used to overwrite the injected type.
import'reflect-metadata';import { Container, Inject, Service } from'typedi';@Service()classInjectedExampleClass {print() {console.log('I am alive!'); }}@Service()classExampleClass {constructor( @Inject()public withDecorator:InjectedExampleClass,public withoutDecorator:InjectedExampleClass ) {}}constinstance=Container.get(ExampleClass);/** * The `instance` variable is an ExampleClass instance with both the * `withDecorator` and `withoutDecorator` property containing an * InjectedExampleClass instance. */console.log(instance);instance.withDecorator.print();// prints "I am alive!" (InjectedExampleClass.print function)instance.withoutDecorator.print();// prints "I am alive!" (InjectedExampleClass.print function)
Explicitly requesting target type
By default, TypeDI will try to infer the type of property and arguments and inject the proper class instance. When this is possible (eg: the property type is an interface) there is three-way to overwrite type of the injected value:
via @Inject(() => type) where type is a constructable value (eg: a class definition)
via @Inject(myToken) where myToken is an instance of Token class
via @Inject(serviceName) where serviceName is a string which is already registered via Container.set(serviceName, value)
import'reflect-metadata';import { Container, Inject, Service } from'typedi';@Service()classInjectedExampleClass {print() {console.log('I am alive!'); }}@Service()classBetterInjectedClass {print() {console.log('I am a different class!'); }}@Service()classExampleClass { @Inject() inferredPropertyInjection:InjectedExampleClass;/** * We tell TypeDI that initialize the `BetterInjectedClass` class * regardless of what is the inferred type. */ @Inject(() => BetterInjectedClass) explicitPropertyInjection:InjectedExampleClass;constructor(public inferredArgumentInjection:InjectedExampleClass,/** * We tell TypeDI that initialize the `BetterInjectedClass` class * regardless of what is the inferred type. */ @Inject(() => BetterInjectedClass)public explicitArgumentInjection:InjectedExampleClass ) {}}/** * The `instance` variable is an ExampleClass instance with both the * - `inferredPropertyInjection` and `inferredArgumentInjection` property * containing an `InjectedExampleClass` instance * - `explicitPropertyInjection` and `explicitArgumentInjection` property * containing a `BetterInjectedClass` instance. */constinstance=Container.get(ExampleClass);instance.inferredPropertyInjection.print();// prints "I am alive!" (InjectedExampleClass.print function)instance.explicitPropertyInjection.print();// prints "I am a different class!" (BetterInjectedClass.print function)instance.inferredArgumentInjection.print();// prints "I am alive!" (InjectedExampleClass.print function)instance.explicitArgumentInjection.print();// prints "I am a different class!" (BetterInjectedClass.print function)