spring源码解析之ioc-finishBeanFactoryInitialization

1、首先简单看一下监听器的注册

this.registerListeners();

注册监听器

protected void registerListeners() {
        Iterator var1 = this.getApplicationListeners().iterator();

        while(var1.hasNext()) {
            ApplicationListener<?> listener = (ApplicationListener)var1.next();
            this.getApplicationEventMulticaster().addApplicationListener(listener);
        }

		//还是根据类型获取beanName
        String[] listenerBeanNames = this.getBeanNamesForType(ApplicationListener.class, true, false);
        String[] var7 = listenerBeanNames;
        int var3 = listenerBeanNames.length;

        for(int var4 = 0; var4 < var3; ++var4) {
            String listenerBeanName = var7[var4];
            //注册监听器 也就是放置在一个set中 
            this.getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
        }

		//这个earlyApplicationEvents 在哪里用到的？ 就目前我的简单的java环境没用到
		//获取以后的springmvc就知道他的作用了吧
        Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
        this.earlyApplicationEvents = null;
        if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
            Iterator var9 = earlyEventsToProcess.iterator();

            while(var9.hasNext()) {
                ApplicationEvent earlyEvent = (ApplicationEvent)var9.next();
                //执行监听器的onApplicationEvent方法
                this.getApplicationEventMulticaster().multicastEvent(earlyEvent);
            }
        }

    }

2、bean的加载

这里终于到了bean的加载了

在前面我们花费了大量的时间分析了beanDefinition的加载以及注册。在bd中包含了bean的所有的信息。但是我们最终使用的并不是bd，所以在看一起看看bean是怎么加载的，@Autowired、@Resource都是怎么将bean注入到其他bean中，以及ioc到底是怎么管理单例bean与多实例bean的等等

this.finishBeanFactoryInitialization(beanFactory);

首先说明，ioc初始化bean的操作都是一样的 不管是容器自己需要的一些bean，还是实例化我们的xml文件中配置的bean，流程都基本一样 所以我们只需要看我们的bean是如何被创建出来的即可

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    //如果有name为conversionService的bean 并且是ConversionService.class类型，则首先初始化这个bean
    //不是我们的重点  略过
    if (beanFactory.containsBean("conversionService") && beanFactory.isTypeMatch("conversionService", ConversionService.class)) {
        beanFactory.setConversionService((ConversionService)beanFactory.getBean("conversionService", ConversionService.class));
    }
    //如果没有value解析器，则注册一个默认的解析器    略过
    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver((strVal) -> {
            return this.getEnvironment().resolvePlaceholders(strVal);
        });
    }

   // 先初始化 LoadTimeWeaverAware 类型的 Bean
   // 这是 AspectJ 相关的内容，略过
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    String[] var3 = weaverAwareNames;
    int var4 = weaverAwareNames.length;

    for(int var5 = 0; var5 < var4; ++var5) {
        String weaverAwareName = var3[var5];
        this.getBean(weaverAwareName);
    }
	//不知道这个是干嘛的 不过不影响理解整个流程
    beanFactory.setTempClassLoader((ClassLoader)null);
    //冻结   已经开始加载bean了，所以也就不希望做一些beanDefinition的解析定义等
    beanFactory.freezeConfiguration();
    //开始实例化bean  往下看
    beanFactory.preInstantiateSingletons();
}

public void preInstantiateSingletons() throws BeansException {
	//拿到所有bean的id  也就是name
	List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
	// Trigger initialization of all non-lazy singleton beans...
	for (String beanName : beanNames) {
	    //拿到beanDefinition
		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
		//非抽象、并且是单例的、非懒加载的  才进行初始化
		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
		    //判断是不是factoryBean   我们这一块不是  所以走else   后续分析调试这一块是如何进行创建bean的
			if (isFactoryBean(beanName)) {
				Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
				if (bean instanceof FactoryBean) {
					FactoryBean<?> factory = (FactoryBean<?>) bean;
					boolean isEagerInit;
					if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
						isEagerInit = AccessController.doPrivileged(
								(PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
								getAccessControlContext());
					}
					else {
						isEagerInit = (factory instanceof SmartFactoryBean &&
								((SmartFactoryBean<?>) factory).isEagerInit());
					}
					if (isEagerInit) {
						getBean(beanName);
					}
				}
			}
			else {
			    //创建bean   往下看
				getBean(beanName);
			}
		}
	}

	......
	}
}

创建bean

getBean(beanName);

public Object getBean(String name) throws BeansException {
	return doGetBean(name, null, null, false);
}
//这一块代码较多  只贴出关键代码吧
protected <T> T doGetBean(
			String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
			throws BeansException {
	//拿到bean的id  也就是name
	String beanName = transformedBeanName(name);
	Object bean;

	//判断bean是否已经创建或者正在创建
	Object sharedInstance = getSingleton(beanName);
	if (sharedInstance != null && args == null) {
		//拿到bean
		bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
	}
	else {
		// Fail if we're already creating this bean instance:
		// We're assumably within a circular reference.
		//已经有这个name的property类型的bean，那么抛异常  这一块是在threadlocal中存放的bean，既然有了，还再次创建，说明可能存在循环引用
		if (isPrototypeCurrentlyInCreation(beanName)) {
			throw new BeanCurrentlyInCreationException(beanName);
		}
		// Check if bean definition exists in this factory.
		BeanFactory parentBeanFactory = getParentBeanFactory();
		//检查父类是否有这个bean  有则返回
		if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
			// Not found -> check parent.
			String nameToLookup = originalBeanName(name);
			if (parentBeanFactory instanceof AbstractBeanFactory) {
				return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
						nameToLookup, requiredType, args, typeCheckOnly);
			}
			else if (args != null) {
				// Delegation to parent with explicit args.
				return (T) parentBeanFactory.getBean(nameToLookup, args);
			}
			else if (requiredType != null) {
				// No args -> delegate to standard getBean method.
				return parentBeanFactory.getBean(nameToLookup, requiredType);
			}
			else {
				return (T) parentBeanFactory.getBean(nameToLookup);
			}
		}

		if (!typeCheckOnly) {
		    //将正在创建的beanName放入set   标记该bean正在被加载
			markBeanAsCreated(beanName);
		}

		try {
		    //获取bean的定义信息，并且合并父类的定义信息 <bean id="" class="" parent="" /> 中的 parent
			RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
			checkMergedBeanDefinition(mbd, beanName, args);
			//获取依赖的bean的名字
			String[] dependsOn = mbd.getDependsOn();
			if (dependsOn != null) {
				for (String dep : dependsOn) {
				    //检察是否存在循环依赖
					if (isDependent(beanName, dep)) {
						throw new BeanCreationException(mbd.getResourceDescription(), beanName,
								"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
					}
					//不存在，则注册依赖条件
					registerDependentBean(dep, beanName);
					//解释一下这个依赖如何检查以及如何注册
					//注册： 假如a依赖b
					//dependentBeanMap 将b作为key，值为list，里面存放被依赖的bean
					//dependenciesForBeanMap  将a作为key，里面维护依赖的bean
					//检查：加入b依赖a
					//从dependentBeanMap 中根据key=b查找
					//因为注册时候注册了这个b被a依赖，所以查找出来的list里面肯定包含a，
					//那么再去判断b依赖的a是否存在与查出来的这个list，此时肯定是true，也就是循环依赖
					try {
					    //存在依赖的bean，首先实例化依赖的bean  也就回到了我们最开始初始化bean的时候了
						getBean(dep);
					}
					catch (NoSuchBeanDefinitionException ex) {
						throw new BeanCreationException(mbd.getResourceDescription(), beanName,
								"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
					}
				}
			}

			// 创建单实例的bean  我们就来分析这个
			if (mbd.isSingleton()) {
				sharedInstance = getSingleton(beanName, () -> {
					try {
					    //创建bean  这个也就是重点
						return createBean(beanName, mbd, args);
					}
					catch (BeansException ex) {
						destroySingleton(beanName);
						throw ex;
					}
				});
				bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
			}
			//创建多实例的bean
			else if (mbd.isPrototype()) {
				// It's a prototype -> create a new instance.
				Object prototypeInstance = null;
				try {
					beforePrototypeCreation(beanName);
					prototypeInstance = createBean(beanName, mbd, args);
				}
				finally {
					afterPrototypeCreation(beanName);
				}
				bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
			}

			else {
				String scopeName = mbd.getScope();
				if (!StringUtils.hasLength(scopeName)) {
					throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
				}
				Scope scope = this.scopes.get(scopeName);
				if (scope == null) {
					throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
				}
				try {
					Object scopedInstance = scope.get(beanName, () -> {
						beforePrototypeCreation(beanName);
						try {
							return createBean(beanName, mbd, args);
						}
						finally {
							afterPrototypeCreation(beanName);
						}
					});
					bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
				}
				catch (IllegalStateException ex) {
					throw new BeanCreationException(beanName,
							"Scope '" + scopeName + "' is not active for the current thread; consider " +
							"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
							ex);
				}
			}
		}
	
		......
	return (T) bean;
}

@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
		throws BeanCreationException {
	......
	//直接来看重点
	try {
		Object beanInstance = doCreateBean(beanName, mbdToUse, args);
		if (logger.isTraceEnabled()) {
			logger.trace("Finished creating instance of bean '" + beanName + "'");
		}
		return beanInstance;
	}
	......
}

//在这里哦
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {

		// Instantiate the bean.
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		//创建bean  也就是使用反射，构造一个bean的实例
		if (instanceWrapper == null) {
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		........
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
					//这一块会合并父类里面一些信息，并且拿到自身需要注入的bean的信息，也就是需要注入
					//的bean的名字 以及类型等（忘记了有没有类型了）
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				mbd.postProcessed = true;
			}
		}
		.........
		Object exposedObject = bean;
		try {
			//设置bean的属性， 在这一块就会注入我们需要依赖的其他bean
			//如果其他bean还没有实例化，则首先实例化  这一块的内容也是很丰富的
			populateBean(beanName, mbd, instanceWrapper);
			//实例化完bean之后，执行我们常说的三大方法
			//1  postProcessBeforeInitialization
			//2  invokeInitMethods
			//在这里面  如果bean实现了InitializingBea n接口，则执行
			//afterPropertiesSet 方法
			//3  postProcessAfterInitialization
			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);
			}
		}

		.........
		return exposedObject;
	}

//此时bean已经被创建出来哦了

//如果bean是单例的化 那个接着执行这个代码 然后将其加入到一个map中 此时bean已经创建出来了

/** Cache of singleton objects: bean name to bean instance. */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

protected void addSingleton(String beanName, Object singletonObject) {
	synchronized (this.singletonObjects) {
		this.singletonObjects.put(beanName, singletonObject);
		this.singletonFactories.remove(beanName);
		this.earlySingletonObjects.remove(beanName);
		this.registeredSingletons.add(beanName);
	}
}

在来看看bean的属性的设置 这里也会涉及到@Autowired等注解对于bean的注入 重点咯

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
        //bean没创建，但是却有bean的定义信息里面却有其他属性，直接抛异常
        if (bw == null) {
            if (mbd.hasPropertyValues()) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
            }
        } else {
            if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
                Iterator var4 = this.getBeanPostProcessors().iterator();
				//对于InstantiationAwareBeanPostProcessor类型的bean的处理
                while(var4.hasNext()) {
                    BeanPostProcessor bp = (BeanPostProcessor)var4.next();
                    if (bp instanceof InstantiationAwareBeanPostProcessor) {
                        InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
                        if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                            return;
                        }
                    }
                }
            }

			//我们的bean会走到这里
			//获取bean的属性名称
            PropertyValues pvs = mbd.hasPropertyValues() ? mbd.getPropertyValues() : null;
            //bean的注入的模式    1  根据名字注入    2   根据类型注入  我们是0  往后面看
            int resolvedAutowireMode = mbd.getResolvedAutowireMode();
            if (resolvedAutowireMode == 1 || resolvedAutowireMode == 2) {
                MutablePropertyValues newPvs = new MutablePropertyValues((PropertyValues)pvs);
                if (resolvedAutowireMode == 1) {
                    this.autowireByName(beanName, mbd, bw, newPvs);
                }

                if (resolvedAutowireMode == 2) {
                    this.autowireByType(beanName, mbd, bw, newPvs);
                }

                pvs = newPvs;
            }
			//是否有bean需要注入
            boolean hasInstAwareBpps = this.hasInstantiationAwareBeanPostProcessors();
            boolean needsDepCheck = mbd.getDependencyCheck() != 0;
            PropertyDescriptor[] filteredPds = null;
            if (hasInstAwareBpps) {
                if (pvs == null) {
                    pvs = mbd.getPropertyValues();
                }

                Iterator var9 = this.getBeanPostProcessors().iterator();
				//遍历beanPostProcessor，
                while(var9.hasNext()) {
                    BeanPostProcessor bp = (BeanPostProcessor)var9.next();
                    if (bp instanceof InstantiationAwareBeanPostProcessor) {
                        InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
                        //bean的注入
                        //这里主要使用的有两个beanPostProcessor：
                        //1 AutowiredAnnotationBeanPostProcessor 注入@Autowired注解标注的bean
                        //2 CommonAnnotationBeanPostprocessor 注入@Resource等注解标注的bean
                        //这里使用不同的processor主要是为了拿到需要注入的bean的名字，类的路径等信息
                        //然后调用反射等方式去注入这个bean  注入就不分析了
                        PropertyValues pvsToUse = ibp.postProcessProperties((PropertyValues)pvs, bw.getWrappedInstance(), beanName);
                        if (pvsToUse == null) {
                            if (filteredPds == null) {
                                filteredPds = this.filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
                            }

                            pvsToUse = ibp.postProcessPropertyValues((PropertyValues)pvs, filteredPds, bw.getWrappedInstance(), beanName);
                            if (pvsToUse == null) {
                                return;
                            }
                        }

                        pvs = pvsToUse;
                    }
                }
            }

            if (needsDepCheck) {
                if (filteredPds == null) {
                    filteredPds = this.filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
                }
				//检查bean的一些字段的依赖信息
                this.checkDependencies(beanName, mbd, filteredPds, (PropertyValues)pvs);
            }

            if (pvs != null) {
            	//设置bean的一些其他字段值， 这些字段以及值都在pvs中以map形式保存着。key为字段名字，值为字段的具体的信息。
                this.applyPropertyValues(beanName, mbd, bw, (PropertyValues)pvs);
            }

        }
    }

这一块分析的比较简单，但是也大致知道了流程了