ReflectiveInjector

class 已弃用

A ReflectiveDependency injection container used for instantiating objects and resolving dependencies.

已弃用: from v5 - slow and brings in a lot of code, Use Injector.create instead.

      
      abstract class ReflectiveInjector implements Injector {
  static resolve(providers: Provider[]): ResolvedReflectiveProvider[]
  static resolveAndCreate(providers: Provider[], parent?: Injector): ReflectiveInjector
  static fromResolvedProviders(providers: ResolvedReflectiveProvider[], parent?: Injector): ReflectiveInjector
  abstract parent: Injector | null
  abstract resolveAndCreateChild(providers: Provider[]): ReflectiveInjector
  abstract createChildFromResolved(providers: ResolvedReflectiveProvider[]): ReflectiveInjector
  abstract resolveAndInstantiate(provider: Provider): any
  abstract instantiateResolved(provider: ResolvedReflectiveProvider): any
  abstract get(token: any, notFoundValue?: any): any
}

说明

An Injector is a replacement for a new operator, which can automatically resolve the constructor dependencies.

In typical use, application code asks for the dependencies in the constructor and they are resolved by the Injector.

静态方法

resolve()

Turns an array of provider definitions into an array of resolved providers.

      
      static resolve(providers: Provider[]): ResolvedReflectiveProvider[]

参数

providers Provider[]

返回值

ResolvedReflectiveProvider[]

A resolution is a process of flattening multiple nested arrays and converting individual providers into an array of ResolvedReflectiveProviders.

使用说明

Example

      
      @Injectable()
class Engine {
}

@Injectable()
class Car {
  constructor(public engine:Engine) {}
}

var providers = ReflectiveInjector.resolve([Car, [[Engine]]]);

expect(providers.length).toEqual(2);

expect(providers[0] instanceof ResolvedReflectiveProvider).toBe(true);
expect(providers[0].key.displayName).toBe("Car");
expect(providers[0].dependencies.length).toEqual(1);
expect(providers[0].factory).toBeDefined();

expect(providers[1].key.displayName).toBe("Engine");
});

resolveAndCreate()

Resolves an array of providers and creates an injector from those providers.

      
      static resolveAndCreate(providers: Provider[], parent?: Injector): ReflectiveInjector

参数

`providers`	`Provider[]`
`parent`	`Injector`	可选. 默认值是 `undefined`.

返回值

ReflectiveInjector

The passed-in providers can be an array of Type, Provider, or a recursive array of more providers.

使用说明

Example

      
      @Injectable()
class Engine {
}

@Injectable()
class Car {
  constructor(public engine:Engine) {}
}

var injector = ReflectiveInjector.resolveAndCreate([Car, Engine]);
expect(injector.get(Car) instanceof Car).toBe(true);

fromResolvedProviders()

Creates an injector from previously resolved providers.

      
      static fromResolvedProviders(providers: ResolvedReflectiveProvider[], parent?: Injector): ReflectiveInjector

参数

`providers`	`ResolvedReflectiveProvider[]`
`parent`	`Injector`	可选. 默认值是 `undefined`.

返回值

ReflectiveInjector

This API is the recommended way to construct injectors in performance-sensitive parts.

使用说明

Example

      
      @Injectable()
class Engine {
}

@Injectable()
class Car {
  constructor(public engine:Engine) {}
}

var providers = ReflectiveInjector.resolve([Car, Engine]);
var injector = ReflectiveInjector.fromResolvedProviders(providers);
expect(injector.get(Car) instanceof Car).toBe(true);

属性

属性	说明
`abstract parent: Injector \| null`	只读 Parent of this injector.

方法

resolveAndCreateChild()

Resolves an array of providers and creates a child injector from those providers.

      
      abstract resolveAndCreateChild(providers: Provider[]): ReflectiveInjector

参数

providers Provider[]

返回值

ReflectiveInjector

The passed-in providers can be an array of Type, Provider, or a recursive array of more providers.

使用说明

Example

      
      class ParentProvider {}
class ChildProvider {}

var parent = ReflectiveInjector.resolveAndCreate([ParentProvider]);
var child = parent.resolveAndCreateChild([ChildProvider]);

expect(child.get(ParentProvider) instanceof ParentProvider).toBe(true);
expect(child.get(ChildProvider) instanceof ChildProvider).toBe(true);
expect(child.get(ParentProvider)).toBe(parent.get(ParentProvider));

createChildFromResolved()

Creates a child injector from previously resolved providers.

      
      abstract createChildFromResolved(providers: ResolvedReflectiveProvider[]): ReflectiveInjector

参数

providers ResolvedReflectiveProvider[]

返回值

ReflectiveInjector

This API is the recommended way to construct injectors in performance-sensitive parts.

使用说明

Example

      
      class ParentProvider {}
class ChildProvider {}

var parentProviders = ReflectiveInjector.resolve([ParentProvider]);
var childProviders = ReflectiveInjector.resolve([ChildProvider]);

var parent = ReflectiveInjector.fromResolvedProviders(parentProviders);
var child = parent.createChildFromResolved(childProviders);

expect(child.get(ParentProvider) instanceof ParentProvider).toBe(true);
expect(child.get(ChildProvider) instanceof ChildProvider).toBe(true);
expect(child.get(ParentProvider)).toBe(parent.get(ParentProvider));

resolveAndInstantiate()

Resolves a provider and instantiates an object in the context of the injector.

      
      abstract resolveAndInstantiate(provider: Provider): any

参数

provider Provider

返回值

any

The created object does not get cached by the injector.

使用说明

Example

      
      @Injectable()
class Engine {
}

@Injectable()
class Car {
  constructor(public engine:Engine) {}
}

var injector = ReflectiveInjector.resolveAndCreate([Engine]);

var car = injector.resolveAndInstantiate(Car);
expect(car.engine).toBe(injector.get(Engine));
expect(car).not.toBe(injector.resolveAndInstantiate(Car));

instantiateResolved()

Instantiates an object using a resolved provider in the context of the injector.

      
      abstract instantiateResolved(provider: ResolvedReflectiveProvider): any

参数

provider ResolvedReflectiveProvider

返回值

any

The created object does not get cached by the injector.

使用说明

Example

      
      @Injectable()
class Engine {
}

@Injectable()
class Car {
  constructor(public engine:Engine) {}
}

var injector = ReflectiveInjector.resolveAndCreate([Engine]);
var carProvider = ReflectiveInjector.resolve([Car])[0];
var car = injector.instantiateResolved(carProvider);
expect(car.engine).toBe(injector.get(Engine));
expect(car).not.toBe(injector.instantiateResolved(carProvider));

get()

      
      abstract get(token: any, notFoundValue?: any): any

参数

`token`	`any`
`notFoundValue`	`any`	可选. 默认值是 `undefined`.

返回值

any

使用说明

Example

The following example creates an Injector configured to create Engine and Car.

      
      @Injectable()
class Engine {
}

@Injectable()
class Car {
  constructor(public engine:Engine) {}
}

var injector = ReflectiveInjector.resolveAndCreate([Car, Engine]);
var car = injector.get(Car);
expect(car instanceof Car).toBe(true);
expect(car.engine instanceof Engine).toBe(true);

Notice, we don't use the new operator because we explicitly want to have the Injector resolve all of the object's dependencies automatically.

说明link

静态方法link

resolve() link

参数

返回值

使用说明link

Examplelink

resolveAndCreate() link

参数

返回值

使用说明link

Examplelink

fromResolvedProviders() link

参数

返回值

使用说明link

Examplelink

属性link

方法link

resolveAndCreateChild() link

参数

返回值

使用说明link

Examplelink

createChildFromResolved() link

参数

返回值

使用说明link

Examplelink

resolveAndInstantiate() link

参数

返回值

使用说明link

Examplelink

instantiateResolved() link

参数

返回值

使用说明link

Examplelink

get() link

参数

返回值

使用说明link

Examplelink

说明

静态方法

resolve()

使用说明

Example

resolveAndCreate()

使用说明

Example

fromResolvedProviders()

使用说明

Example

属性

方法

resolveAndCreateChild()

使用说明

Example

createChildFromResolved()

使用说明

Example

resolveAndInstantiate()

使用说明

Example

instantiateResolved()

使用说明

Example

get()

使用说明

Example