3 IoC容器的依赖注入（1）
发布时间：2020-12-13 22:16:58 所属栏目：百科 来源：网络整理
导读：在applicationContext加载的时候，已经将BeanDefition保存在一个concurrentHashMap中，然而这些并不是真正的bean,真正的bean其实还没有初始化以及依赖注入。对于整个依赖注入的过程，大致可以分为两个阶段， 第一阶段是Bean的初始化 ，如何采用设值注入的方
|
在applicationContext加载的时候，已经将BeanDefition保存在一个concurrentHashMap中，然而这些并不是真正的bean,真正的bean其实还没有初始化以及依赖注入。对于整个依赖注入的过程，大致可以分为两个阶段， 第一阶段是Bean的初始化，如何采用设值注入的方式，那么这个阶段就是利用默认构造器去构造一个空对象，等待着注入；如果是构造注入，那么这个过程可能就会触发依赖注入，并递归地初始化依赖对象； 第二个阶段是注入阶段。 下面看看这个初始化阶段触发了哪些关键的方法：
Ioc容器的依赖注入发生的时机是不一样的。对于Singleton的bean，是在refresh()的末尾阶段进行了初始化和注入。对于其他scope的bean,他们的初始化发生在第一次getBean的时候。然后不管是何时发生这些动作，初始化的动作都有getBean方法发起。 1 Singleton的初始化开始在refresh()方法快要结束的地方，调用了这样一个方法finishBeanFactoryInitialization
// Instantiate all remaining (non-lazy-init) singletons. finishBeanFactoryInitialization(beanFactory); 从它的注释就可以看到，这里是用来装载所有非延迟加载的单例（可以设置Bean的属性 lazy-init=true）对象。从这里开始了singleton对象的加载与注入。从这也可以看出，所有非延迟加载的singleton对象在applicationContext初始化完成的时候，就已经加载完毕。这个方法向下调用了DefaultListableBeanFactory中定义的preInstantiateSingletons方法。这个方法是用来初始化singleton对象的。 这个方法其实很简单，遍历所有定义为singgleton的对象，然后调用getBean方法，完成初始化。然后调用定义的后处理方法，完成初始化。
public void preInstantiateSingletons() throws BeansException {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Pre-instantiating singletons in " + this);
}
// Iterate over a copy to allow for init methods which in turn register new bean definitions.
// While this may not be part of the regular factory bootstrap,it does otherwise work fine.
List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
// 遍历所有的singleton对象 实际调用getBean方法
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
if (isFactoryBean(beanName)) {
final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
@Override
public Boolean run() {
return ((SmartFactoryBean<?>) factory).isEagerInit();
}
},getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
else {
getBean(beanName);
}
}
}
// 注册后处理方法...
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
smartSingleton.afterSingletonsInstantiated();
return null;
}
},getAccessControlContext());
}
else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
2 getBean()方法从前面已经看到，即使是随applicationContext初始化过程启动的singleton对象，它也利用getBean方法进行着初始化。可见所有Bean的生命周期都是由这里开始的。
getBean方法很简单，它向下调用了AbstractBeanFactroy类中定义的doGetBean方法。 3doGetBean方法doGetBean方法有点类似于前面章节提到了refresh方法，它是整个依赖注入过程的入口，其实也定义了整个依赖注入过程都发生了哪些动作。
protected Object doCreateBean(final String beanName,final RootBeanDefinition mbd,final Object[] args) {
// 实际创建的Bean的包装容器
BeanWrapper instanceWrapper = null;
//对于单例模式下的Bean，可能在创建过程中断过，暂时放在缓存里
if (mbd.isSingleton()) {
//从缓存中恢复未创建完成的Bean对象
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//真正创建对象的入口
instanceWrapper = createBeanInstance(beanName,mbd,args);
}
final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
// Allow post-processors to modify the merged bean definition.
//Bean创建后处理
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
applyMergedBeanDefinitionPostProcessors(mbd,beanType,beanName);
mbd.postProcessed = true;
}
}
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
// 解决循环引用的地方，当singleton遇到循环引用时，会放入singletonsCurrentlyInCreation中，暂停
// 在此处从singletonsCurrentlyInCreation中再拿到这个未完成初始化的对象
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isDebugEnabled()) {
logger.debug("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
addSingletonFactory(beanName,new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
return getEarlyBeanReference(beanName,bean);
}
});
}
// 下面依赖注入
Object exposedObject = bean;
try {
//依赖注入的方法入口
populateBean(beanName,instanceWrapper);
if (exposedObject != null) {
exposedObject = initializeBean(beanName,exposedObject,mbd);
}
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
}
else {
throw new BeanCreationException(mbd.getResourceDescription(),beanName,"Initialization of bean failed",ex);
}
}
// 处理未完成注入的循环引用的bean
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName,false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName,"Bean with name '" + beanName + "' has been injected into other beans [" +
StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
"] in its raw version as part of a circular reference,but has eventually been " +
"wrapped. This means that said other beans do not use the final version of the " +
"bean. This is often the result of over-eager type matching - consider using " +
"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off,for example.");
}
}
}
}
// Register bean as disposable.
try {
registerDisposableBeanIfNecessary(beanName,bean,mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(mbd.getResourceDescription(),"Invalid destruction signature",ex);
}
return exposedObject;
}
4 createBeanInstance 创建Bean的入口在上面的“纲领性”的代码块中，可以看到创建Bean实例的入口是createBeanInstance。在这里完成了对所有的Bean的实例化工作。它的整个过程如下：
这个过程主要完成了对一些用于实例化Bean的方法的调用。它主要分为四种情况 （1） 如果指定了工厂方法，向下调用instantiateUsingFactoryMethod方法实例化 （2）如果存在缓存过的构造器或者工厂方法，就使用这个缓存的方法进行实例化。在这个过程中，我们经常能看resolvedXXX，例如在源代码里有resolvedConstructorOrFactoryMethod，这是在RootBeanDefinition类中定义的一个属性，类似的属性还有很多。它是一种缓存机制，缓存了实例化的时候需要调用哪个构造方法或者工厂方法。这是非常有用的，对于一个类如果采用了构造注入或者自动装配的方式，在初始化的时候需要对所有构造方法进行适配，这个搜索的过程是耗时的，如果搜索完的结果可以记录下来，下一次直接利用，就减少了搜索的时间。对于这种存在缓存的方法，根据类型选择调用autowireConstructor或者instantiateBean进行实例化。 （3） 如果没有缓存方法，就要选择需要使用的构造器，如果存在适配的构造器，就向下调用autowireConstructor （4） 否则使用无参的构造方法，向下调用instantiateBean。
protected BeanWrapper createBeanInstance(String beanName,RootBeanDefinition mbd,Object[] args) {
//获得需要创建的Bean的Class
Class<?> beanClass = resolveBeanClass(mbd,beanName);
// 确定需要创建的Bean的实例的类可以实例化
if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
throw new BeanCreationException(mbd.getResourceDescription(),"Bean class isn't public,and non-public access not allowed: " + beanClass.getName());
}
//如果存在工厂方法，则使用工厂方法去实例化类
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName,args);
}
// 使用自动状态的构造方式进行实例化
// 下面10行的代码是在减少重复创建bean的工作量。如果已经创建过同样的bean，直接使用上一次的配置属性
boolean resolved = false;
boolean autowireNecessary = false;
if (args == null) {
synchronized (mbd.constructorArgumentLock) {
if (mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
//自动装配构造实例
if (resolved) {
if (autowireNecessary) {
//返回自动装配的实例化结果
return autowireConstructor(beanName,null,null);
}
else {
//使用构造方法进行构造
return instantiateBean(beanName,mbd);
}
}
// 确定需要使用的构造方法
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass,beanName);
if (ctors != null ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
//自动装配构造方法
return autowireConstructor(beanName,ctors,args);
}
// 使用默认的无参数的构造方法
return instantiateBean(beanName,mbd);
}
5autowireConstructor
|