spring源码学习：spring初始化流程

首先借个图，说明一下spring的bean的整个生命流程。

销毁什么的这个看图就知道怎么回事，使用的话一般都是纯业务，而且我们更关心spring是怎么初始化的，初始化成我们定义的那个样子。我们就是以这个出发点来看一下spring的大概流程。

spring的创建过程主要哪些步骤：

主要是对象的创建和对象的初始化

其实有人会疑问对象创建和对象初始化有什么区别？

其实就是先后次序的问题。
首先你要是用一个对象，要创建他，这里我们常见的是直接new一个。但是spring利用的是反射。
对象有时候不是创建好了，就可以用，尤其是spring，会出现要用到A对象，A对象以来别的B，C，D对象。毕竟你atowire的这些就是要用到的，你不希望拿到的这些都是null。所以初始化，就是让这个对象按照你设计的那样可以获得对应的值这些，可以去使用，很多程序都需要你自己初始化才能使用，或者说设计的人已经替你弄了一套默认的配置来让你使用。

创建解决的是有没有的问题，初始化决定的是能不能用的问题。否则仅是在内存中站一块空间，这是没啥作用的。

spring的初始化方式
一种是最早的配置文件的方式，里面会有一个 init-method，配置的是对应的这个类的初始化方法。这种初始化方式有一个缺点，初始化函数并不固定，由用户随意定义，这就需要 Spring 通过反射，在运行时动态地调用这个初始化函数。而反射又会影响代码执行的性能。（反射确实会影响性能，像做导入导出文件时，实际上有时候直接给一个确定的要比反射的模板类要快一些）

public class DemoClass {//...public void initDemo() {//...初始化..}
}// 配置：需要通过init-method显式地指定初始化方法
<bean id="demoBean" class="com.xzg.cd.DemoClass" init-method="initDemo"></bean>

另一种就是解决这个，Spring 提供了另外一个定义初始化函数的方法，那就是让类实现 Initializingbean 接口。

这个接口包含一个固定的初始化函数定义（afterPropertiesSet() 函数）。Spring 在初始化 Bean 的时候，可以直接通过 bean.afterPropertiesSet() 的方式，调用 Bean 对象上的这个函数，而不需要使用反射来调用了。


public class DemoClass implements InitializingBean{@Overridepublic void afterPropertiesSet() throws Exception {//...初始化...      }
}// 配置：不需要显式地指定初始化方法
<bean id="demoBean" class="com.xzg.cd.DemoClass"></bean>

spring初始化的细分

实际上分的更细一点，将初始化分为初始化前置操作、初始化、初始化后置操作这三个步骤。

前置操作和后置操作怎么回事，虽然从字面理解就能了解到他们的作用。一个是在初始化前要做的事，一个是初始化后的要做的事。但怎么实现，毕竟spring倡导的是“约定大于配置”。

中间的部分，初始化是在 InitializingBean里面。那他前后的操作在哪里。

同样也是一个接口BeanPostProcesso，里面postProcessBeforeInitialization和postProcessAfterInitialization看到名字就知道那个是前，那个是后。

我们只需要定义一个实现了 BeanPostProcessor 接口的处理器类，并在配置文件中像配置普通 Bean 一样去配置就可以了。Spring 中的 ApplicationContext 会自动检测在配置文件中实现了 BeanPostProcessor 接口的所有 Bean，并把它们注册到 BeanPostProcessor 处理器列表中。在 Spring 容器创建 Bean 的过程中，Spring 会逐一去调用这些处理器。

spring源码的相关初始化的部分
这里很多人还拿的是老的版本代码，一摸一样的文章转载来转载去的，而且还不严谨，我这里建议还是自己去代码里看具体的实现过程。

具体的部分位置是：AbstractAutowireCapableBeanFactory这个类，这个是我们自动装载bean的一个类

很多人看别人的文档直接支到doCreateBean方法，也不能说错，但我个人建议还是从她的公共入库public修饰的createBean开始一步一步的点，直到最后的实现方法doCreateBean方法。

    protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {BeanWrapper instanceWrapper = null;if (mbd.isSingleton()) {instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);}if (instanceWrapper == null) {instanceWrapper = this.createBeanInstance(beanName, mbd, args);}Object bean = instanceWrapper.getWrappedInstance();Class<?> beanType = instanceWrapper.getWrappedClass();if (beanType != NullBean.class) {mbd.resolvedTargetType = beanType;}synchronized(mbd.postProcessingLock) {if (!mbd.postProcessed) {try {this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);} catch (Throwable var17) {throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", var17);}mbd.postProcessed = true;}}boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);if (earlySingletonExposure) {if (this.logger.isTraceEnabled()) {this.logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");}this.addSingletonFactory(beanName, () -> {return this.getEarlyBeanReference(beanName, mbd, bean);});}Object exposedObject = bean;try {this.populateBean(beanName, mbd, instanceWrapper);exposedObject = this.initializeBean(beanName, exposedObject, mbd);} catch (Throwable var18) {if (var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) {throw (BeanCreationException)var18;}throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18);}if (earlySingletonExposure) {Object earlySingletonReference = this.getSingleton(beanName, false);if (earlySingletonReference != null) {if (exposedObject == bean) {exposedObject = earlySingletonReference;} else if (!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {String[] dependentBeans = this.getDependentBeans(beanName);Set<String> actualDependentBeans = new LinkedHashSet(dependentBeans.length);String[] var12 = dependentBeans;int var13 = dependentBeans.length;for(int var14 = 0; var14 < var13; ++var14) {String dependentBean = var12[var14];if (!this.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.");}}}}try {this.registerDisposableBeanIfNecessary(beanName, bean, mbd);return exposedObject;} catch (BeanDefinitionValidationException var16) {throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);}}

当然了，这个创建bean的方法外，里面还提供了销毁bean，处理bean的前置操作和bean的后置操作的公共方法。