Spring Bean的生命周期

概括

解析获取class文件 -> JVM实例化方法 -> 属性填充（@Autowired）->初始化 -> 放入容器当中 -> 容器关闭的时候销毁

Bean的⽣命周期指的就是：在Spring中，Bean是如何⽣成的？
被Spring管理的对象叫做Bean。Bean的⽣成步骤如下：

1. Spring扫描class得到BeanDefinition
2. 根据得到的BeanDefinition去⽣成bean
3. ⾸先根据class推断构造⽅法
4. 根据推断出来的构造⽅法，反射，得到⼀个对象（暂时叫做原始对象）
5. 填充原始对象中的属性（依赖注⼊）
6. 如果原始对象中的某个⽅法被AOP了，那么则需要根据原始对象⽣成⼀个代理对象(就是PostProcessor方法实现的)
7. 把最终⽣成的代理对象放⼊单例池（源码中叫做singletonObjects）中，下次getBean时就直接从单例池拿即可可以看到，对于Spring中的Bean的⽣成过程，步骤还是很多的，并且不仅仅只有上⾯的7步，还有很多很多，⽐如Aware回调、初始化等等，这⾥不详细讨论。

实例化和初始化区别？

实例化是JVM虚拟机创建对象，初始化是对虚拟机创建出来的对象进行属性填充以后执行初始化过程。

构造方法推断

如果有无参构造，就是用无参构造方法，如果没有，并且只有一个构造方法，就会使用那个单独的构造方法，构造方法参数会从Ioc容器当中去寻找，通过byType和byName寻找（依次查找），如果有多个有参构造，且没有无参构造，就会导致抛出异常。
注意：如果Ioc当中如果只有一个对象，先同通过类型查找到对应的对象以后，就不会再根据名称查找。但是如果有不止一个对象，会按名称进行配置，没有对应的名字就会报错（当使用@Bean注解注入多个同类型对象）

后置增强方法（实现aop所在）

public interface BeanPostProcessor {
    @Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

有一个子类AbstractAutoProxyCreator 实现动态代理，子类实现了after方法方法，实现了aop

public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
        if (bean != null) {
            Object cacheKey = this.getCacheKey(bean.getClass(), beanName);
            if (this.earlyProxyReferences.remove(cacheKey) != bean) {
            //如果需要进行增强，就执行
                return this.wrapIfNecessary(bean, beanName, cacheKey);
            }
        }

        return bean;
    }

*Aware接口的作用

bean实现个某某Aware接口，然后这个bean就可以通过实现接口的方法，来接收接口方法传递过来的资源。
原文链接

过程源码

AbstractAutowireCapableBeanFactory.java
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {

		// Instantiate the bean.
		BeanWrapper instanceWrapper = null;
		//确保单例模式
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		//获取实例对象
		final Object bean = instanceWrapper.getWrappedInstance();
		Class<?> beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

		// Allow post-processors to modify the merged bean definition.
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				mbd.postProcessed = true;
			}
		}

		// Eagerly cache singletons to be able to resolve circular references
		// even when triggered by lifecycle interfaces like BeanFactoryAware.
		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, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

		// Initialize the bean instance.
		Object exposedObject = bean;
		try {
		//给实例对象填充属性@Autowired
			populateBean(beanName, mbd, instanceWrapper);
			//在这里执行aop(如果需要)
			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);
			}
		}

		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<>(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(), beanName, "Invalid destruction signature", ex);
		}

		return exposedObject;
	}