java injector_Injector的实现原理

在分析bootstrapModule方法时，我们发现当需要一个类的事例的时候只需要调用injector.get方法就能够得到。这个Injector就是Angular依赖注入的基础，任何可以被注入的类都是都可以通过injector.get方法来获取。

调用injector.get方法的时候会出现一下几种情况：

1、如果以前没有创建过，就会new一个事例，并返回。

2、如果以前创建过，就返回以前创建的那个事例，相当于单例模式。

Injector.get方法的调用过程

Injector是一个接口，实际实例化的类为ReflectiveInjector_。继承关系为

ReflectiveInjector_ -> ReflectiveInjector -> Injector。

查看ReflectiveInjector_.get方法的代码，我们可以发现其调用关系为：

get -> _getByKey -> _getByKeyDefault -> _getObjByKeyId

如果调用自己的_getObjByKeyId没有找到实例，就会查找父Injector的_getObjByKeyId，一直向上查找。

在_getObjByKeyId如果具有声明但是没有事例化，就会去实例化并返回，具体代码如下：

private _getObjByKeyId(keyId: number): any {

for (let i = 0; i < this.keyIds.length; i++) {

if (this.keyIds[i] === keyId) {

if (this.objs[i] === UNDEFINED) {

this.objs[i] = this._new(this._providers[i]);

}

return this.objs[i];

}

}

return UNDEFINED;

}

实例化的过程

实例化是通过调用_new方法来完成的，具体代码为：

_new(provider: ResolvedReflectiveProvider): any {

if (this._constructionCounter++ > this._getMaxNumberOfObjects()) {

throw cyclicDependencyError(this, provider.key);

}

return this._instantiateProvider(provider);

}

在这段代码中具有一个防止循环依赖的检验。

接下来就是使用provider中的创建工厂来创建实例了，具体代码为：

private _instantiate(

provider: ResolvedReflectiveProvider,

ResolvedReflectiveFactory: ResolvedReflectiveFactory): any {

const factory = ResolvedReflectiveFactory.factory;

let deps: any[];

try {

deps =

ResolvedReflectiveFactory.dependencies.map(dep => this._getByReflectiveDependency(dep));

} catch (e) {

if (e.addKey) {

e.addKey(this, provider.key);

}

throw e;

}

let obj: any;

try {

obj = factory(...deps);

} catch (e) {

throw instantiationError(this, e, e.stack, provider.key);

}

return obj;

}

其中_getByReflectiveDependency方法会去查找依赖的事例，如果依赖的事例没有被创建，就会先去创建，这里就会有可能造成循环依赖。

什么是Provider

Provider可以理解为是Angular对于依赖注入项的一个描述，一个对象可以被依赖注入，就必须有一个Provider对其进行描述。Injector根据这个Provider才能够创建实例。

Provider源码：

export interface TypeProvider extends Type {}

export interface ValueProvider {

provide: any;

useValue: any;

multi?: boolean;

}

export interface ClassProvider {

provide: any;

useClass: Type;

multi?: boolean;

}

export interface ExistingProvider {

provide: any;

useExisting: any;

multi?: boolean;

}

export interface FactoryProvider {

provide: any;

useFactory: Function;

deps?: any[];

multi?: boolean;

}

export type Provider =

TypeProvider | ValueProvider | ClassProvider | ExistingProvider | FactoryProvider | any[];

从源码我们可以知道总共可以有5中类型的Provider以及一个数组类型的Provider。对于不同类型的Provider也有各自的定义和用法。

类型

说明

TypeProvider

任意类型的类，任意一个类都可以成为一个Provider，Angular会对其进行包装，Factory就是new一个这个类型的事例，都是单例的

ValueProvider

使用具体的值作为实例的

ClassProvider

使用具体class来创建事例，和TypeProvider类似，但是可以设置为multi

ExistingProvider

使用一个已有的Provider，相当于给已有的Provider设置一个别名

FactoryProvider

使用自己的创建工厂来实例化Provider，可以设置创建的依赖项

Injector在创建一个事例的时候就是使用Provider的Factory和deps来实例化(具体如上面的代码所示)。

每一种Provider的Factory是怎么来的

从上面的分析我们可以发现，这么多种Provider中只有FactoryProvider是需要设置Factory和deps的，然而在Injector创建实例的时候是必须需要Factory的，那么其它类型的Provider的Factory又是怎么来的呢？

通过跟踪代码，我们可以发现如下代码：

function resolveReflectiveFactory(provider: NormalizedProvider): ResolvedReflectiveFactory {

let factoryFn: Function;

let resolvedDeps: ReflectiveDependency[];

if (provider.useClass) {

const useClass = resolveForwardRef(provider.useClass);

factoryFn = reflector.factory(useClass);

resolvedDeps = _dependenciesFor(useClass);

} else if (provider.useExisting) {

factoryFn = (aliasInstance: any) => aliasInstance;

resolvedDeps = [ReflectiveDependency.fromKey(ReflectiveKey.get(provider.useExisting))];

} else if (provider.useFactory) {

factoryFn = provider.useFactory;

resolvedDeps = constructDependencies(provider.useFactory, provider.deps);

} else {

factoryFn = () => provider.useValue;

resolvedDeps = _EMPTY_LIST;

}

return new ResolvedReflectiveFactory(factoryFn, resolvedDeps);

}

从这段代码可以发现，Angular我们定义的Provider从新计算了他们的Factory和deps。

Inectory自身的创建过程

通过调用ReflectiveInjector.resolveAndCreate方法可以创建一个Injector，这个方法的第一个参数就是我们需要使用到的Provider列表，第二个参数就是父Injector。

static resolveAndCreate(providers: Provider[], parent: Injector = null): ReflectiveInjector {

const ResolvedReflectiveProviders = ReflectiveInjector.resolve(providers);

return ReflectiveInjector.fromResolvedProviders(ResolvedReflectiveProviders, parent);

}

这个方法里面主要完成两个动作：

1、格式化Provider。

2、new一个Injector事例。

第二步比较清晰，下面主要分析第一步。

第二步主要的代码：

export function resolveReflectiveProviders(providers: Provider[]): ResolvedReflectiveProvider[] {

const normalized = _normalizeProviders(providers, []);

const resolved = normalized.map(resolveReflectiveProvider);

const resolvedProviderMap = mergeResolvedReflectiveProviders(resolved, new Map());

return Array.from(resolvedProviderMap.values());

}

这里主要做的事情有：

1、把provider列表理顺，如：[[p1,p2],p3,[p4,p5]]理顺为[p1,p2,p3,p4,p5]

2、封装provider，就是上面添加Factory和deps的内容。

3、合并相同的Provider，如果不支持multi的Provider声明的了多个，就会抛出异常。