Spring可以轻松创建Java企业应用程序，它提供了在企业环境中使用Java语言所需的一切 。要使用Spring 必须要先构建 IOC容器，没有它Spring无法正常工作。本文将详细讲解Spring IOC 初始化机制及学习总结。
如下图所示：
定义了一个Person对象，和一个实现BeanPostProcessor接口的自定义类，本文将以此代码为基础来深入学习Spring IOC初始化流程：
//XML Bean 配置
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="testService" class="com.ssm.TestApplication.TestService" lazyinit="false"/>
</beans>
/**
* <p>
* Test Spring IOC
* </p>
* @author chengxiaonan (jackcheng1117@163.com)
*/
public class TestApplication {
static class TestService {}
public static void main(String[] args) {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
}
}
XML 方式配置元数据：
以 ApplicationContext 子类ClassPathXmlApplicationContext为切入点解析XML元数据
注解方式配置元数据：
以 ApplicationContext 子类 AnnotationConfigApplicationContext 为切入点解析注解元数据
不管是使用XMl 方式还是使用注解的方式配置元数据，其底层核心实现都是一样的。本章以XML配置文件形式来了解Spring Ioc容器。
1. Spring IOC 容器初始化流程
首先通过 new ClassPathXmlApplicationContext 这句代码可以找到 IOC 容器初始化入口方法：
//IOC 初始化入口
@Override
public void refresh() throws BeansException,IllegalStateException {
synchronized(this.startupShutdownMonitor) {
// 开启初始化标志，为刷新做准备
prepareRefresh();
// Step1：生成IOC的BeanFactory 并解析XML配置将Bean转换为Beandefinition
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
//Step2： 准备beanFactory需要的依赖及相关属性
prepareBeanFactory(beanFactory);
try {
//Step3： 注入 beanFactory持有的BeanPostProcessor
postProcessBeanFactory(beanFactory);
//Step4：执行 beanFactory持有的BeanPostProcessor
invokeBeanFactoryPostProcessors(beanFactory);
//Step5：注册拦截 Bean创建 的BeanPostProcessor
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
initMessageSource();
// Initialize event multicaster for this context.
initApplicationEventMulticaster();
//刷新由子类实现的方法
onRefresh();
// Check for listener beans and register them.
registerListeners();
//Step6：实例化所有剩余的（非延迟初始化）单例。
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
finishRefresh();
}
catch(BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " + "cancelling refresh attempt: " + ex);
}
// Destroy already created singletons to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
}
}
}上图展示了Spring IOC 初始化过程中要执行的所有流程，总的来说ApplicationContext必须要完成一下几件事：
Step1：生成IOC BeanFactory
生成IOC BeanFactory过程最核心的流程是将 xml配置Bean 转为 Spring Bean
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory() 这行代码比较关键，因为它做了足够多的事情：
- 准备BeanFactory
- 将XML中的Bean配置转换为Spring可以识别的 BeanDefinition： 加载 applicationContext.xml ---> 解析XML中的Bean配置 -----> 将XML中Bean配置转为Spring中识别的 BeanDefinition
其中将 XML Bean配置转为 BeanDefinition 后，会将解析的Bean定义放入beanDefinitionMap、beanDefinitionNames中
Step2: 准备beanFactory需要的依赖及相关属性
如下图所示，prepareBeanFactory()方法 主要注入beanFactory需要的依赖及相关属性及IOC启动所需要的Bean
这个过程找到IOC启动所需要依赖的Bean，并将这些Bean实例化放入singletonObjects 和 registeredSingleton 中
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// 配置IOC相关属性
beanFactory.setBeanClassLoader(getClassLoader());
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// Configure the bean factory with context callbacks.
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
// 添加要忽视的依赖Bean
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
// BeanFactory interface not registered as resolvable type in a plain factory.
// MessageSource registered (and found for autowiring) as a bean.
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// Register early post-processor for detecting inner beans as ApplicationListeners.
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// 注册IOC环境相关Bean
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
}
Step3、4： 注入并执行 beanFactory 持有的BeanPostProcessor
postProcessBeanFactory(beanFactory);
invokeBeanFactoryPostProcessors(beanFactory);
这个两个方法主要注入并执行IOC启动过程所依赖的 ‘必须’ Bean的BeanPostProcessor。
如: ServletConfig、ServletContext 等。
Step5：注册拦截 Bean创建 的BeanPostProcessor
‘注册拦截Bean创建的BeanPostProcessor (比如AOP、拦截器等， 即注入需要在bean注入之前对bean进行拦截操作的处理器)’
若有上述的处理器，则会初始化该bean 。Bean初始化完之后会将bean 放入 singletonObjects registeredSingleton 中
如下图代码所示，
首先注册 implement PriorityOrdered 接口的 beanPostProcessor
然后注册 implement Ordered 接口的 beanPostProcessor
其次注册一般的 beanPostProcessor（没有顺序的beanPostProcessor） 最 最后会重新吧内部的BeanPostProcessor注册一遍
上述涉及到的BeanPostProcessor最终都会放进 IOC BeanFactory的 beanPostProcessors 属性中
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
//遍历BeanPostProcessor将其分类
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
//首先注册实现PriorityOrdered接口的BeanPostProcessor
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
//紧接着会注册实现Ordered接口的 BeanPostProcessors
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
for (String ppName : orderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
sortPostProcessors(orderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
//然后注册其他普通的BeanPostProcessor
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
for (String ppName : nonOrderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
//最后重新注册所有内部的BeanPostProcessor
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}Step6：实例化所有剩余的（非延迟初始化）单例
方法 finishBeanFactoryInitialization(beanFactory); 是 IOC初始化阶段最关键的一个方法，因为这个方法是Bean注入最关键的一个方法。
finishBeanFactoryInitialization(beanFactory)这个方法嵌套非常深，准备继续阅读的同学做好准备集中精神。
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// Initialize conversion service for this context.
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}
// Register a default embedded value resolver if no bean post-processor
// (such as a PropertyPlaceholderConfigurer bean) registered any before:
// at this point, primarily for resolution in annotation attribute values.
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
// Stop using the temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(null);
// Allow for caching all bean definition metadata, not expecting further changes.
beanFactory.freezeConfiguration();
// 实例化所有剩余的（非延迟初始化）单例。
beanFactory.preInstantiateSingletons();
}如上图所示是 finishBeanFactoryInitialization()方法的所有代码，这个方法看着好像也不太长啊？
方法最关键的一行的代码在最后一行 beanFactory.preInstantiateSingletons();
该方法完全诠释了IOC是如何将Bean注入到容器中的，由于Spring 默认会懒实例化Bean，所以事先在applicationContext.xml将Bean配置成 lazy-init="false"，方便学习注入过程。
如下如所示是 preInstantiateSingletons 方法，该方法主要有两个for循环，第一个for是我们需要关注的，第二个for循环是Bean初始化后的回调。在第一个for循环中debug发现，当循环时，判断 if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) 不通过，会直接执行else中的 getBean(beanName)方法
public void preInstantiateSingletons() throws BeansException {
if (logger.isDebugEnabled()) {
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 < >(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
for (String beanName: beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
if (isFactoryBean(beanName)) {
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
final 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 {
getBean(beanName);
}
}
}
// Trigger post-initialization callback for all applicable beans...
for (String beanName: beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction < Object > )() - >{
smartSingleton.afterSingletonsInstantiated();
return null;
},
getAccessControlContext());
} else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
}通过getBean(beanName)方法找到最终要调用的方法 AbstractBeanFactory.doGetBean(final String name, @Nullable final Class<T> requiredType, @Nullable final Object[] args, boolean typeCheckOnly) 方法。
protected < T > T doGetBean(final String name, @Nullable final Class < T > requiredType, @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
final String beanName = transformedBeanName(name);
Object bean;
//首先尝试从缓存中获得Bean
Object sharedInstance = getSingleton(beanName);
// 若命中缓存Bean，则返回缓存中的bean
if (sharedInstance != null && args == null) {
if (logger.isDebugEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.debug("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
} else {
logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
}
}
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
//没有命中缓存，开始初始化该Bean
else {
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
String nameToLookup = originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
} else if (args != null) {
return (T) parentBeanFactory.getBean(nameToLookup, args);
} else {
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
//初始化该Bean之前检查该Bean的依赖bean是否注入，若没有注入则先注入依赖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);
try {
getBean(dep);
} catch(NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
//根据bean的scope 开始初始化Bean
if (mbd.isSingleton()) {//单例scope
sharedInstance = getSingleton(beanName, () - >{
try {
return createBean(beanName, mbd, args);
} catch(BeansException ex) {
destroySingleton(beanName);
throw ex;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
else if (mbd.isPrototype()) {//多例scope
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
} finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else { //其他scope
String scopeName = mbd.getScope();
final 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);
}
}
} catch(BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// Check if required type matches the type of the actual bean instance.
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
} catch(TypeMismatchException ex) {
if (logger.isDebugEnabled()) {
logger.debug("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}由于是第一次实例化testService这个Bean，该Bean默认又是单例Bean，所以肯定会走 if (mdb.isSingleton()) 这个逻辑
发现这个if逻辑主要是调用了getSingleton(beanName,objectFactory)这个逻辑。
需要注意的是：调用该方法之前，先会通过一个lambda表达式获取到第二个参数值，即会先调用 createBean()回去第二个参数。
下面我们就来看一下 createBean()方法到底做了什么：
如下图所示，该方法主要是调用 doCreateBean去创建Bean .但是需要注意的是：
在调用该方法之前，有一行代码极为重要：
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
接下来我们看一下这个方法做了什么事情
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
if (logger.isDebugEnabled()) {
logger.debug("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
Class < ?>resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
try {
mbdToUse.prepareMethodOverrides();
} catch(BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", ex);
}
try {
// 给BeanPostProcessors一个返回代理而不是目标bean实例的机会。
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
} catch(Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", ex);
}
try {
//创建Bean实例
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
} catch(BeanCreationException | ImplicitlyAppearedSingletonException ex) {
// A previously detected exception with proper bean creation context already,
// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
throw ex;
} catch(Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}如下图所示是 resolveBeforeInstantiation 方法的实现：
通过debug发现每个将要注入的bean都会走到 if (targetType != null) 逻辑，那我们就来看下if逻辑中到底做了什么事情。
该逻辑首先会执行 bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
那我们就来看看该逻辑到底做了什么
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = null;
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
// Make sure bean class is actually resolved at this point.
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
Class < ?>targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}如下图所示是 applyBeanPostProcessorsBeforeInstantiation 方法的实现：
该方法主要获取获取正在注入的Bean的 BeanPostProcessor,然后遍历所有的beanPostProcessor，判断当前beanPostProcessor是的属于 InstantiationAwareBeanPostProcessor 类型的beanPostProcessor.
为什么偏偏要检查这个类型的BeanPostProcessor呢？那我们就看一下InstantiationAwareBeanPostProcessor 的实现类有哪些
protected Object applyBeanPostProcessorsBeforeInstantiation(Class < ?>beanClass, String beanName) {
for (BeanPostProcessor bp: getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
if (result != null) {
return result;
}
}
}
return null;
}如下图所示是InstantiationAwareBeanPostProcessor 接口的实现类：
可以发现大部分实现类都是 spring-aop包下的，再加上 resolveBeforeInstantiation 方法上的注解 ： “给BeanPostProcessors一个返回代理而不是目标bean实例的机会。” 笔者猜想resolveBeforeInstantiation 就是为了解决 spring-aop 或其他功能代理对象的生成。为了验证笔者的猜想，尝试做了一个demo通过debug方法走流程发现和我猜想的是一样。也就是说Spring是下将要真正实例化正在注入的Bean之前，会先去判断是否需要生成该Bean的代理对象，若需要则直接生成代理对象返回，就不再继续原生Bean的实例化。
若当前注入的Bean不需要返回代理对象，则继续走 resolveBeforeInstantiation 方法之后的流程。再往下执行流程，就会调用
AbstractAutowireCapableBeanFactory.doCreateBean()方法执行创建Bean流程并逐层返回Bean。
该方法有三个地方需要注意：
1.instanceWrapper = createBeanInstance(beanName, mbd, args);
2.populateBean(beanName, mbd, instanceWrapper);
3.exposedObject = initializeBean(beanName, exposedObject, mbd);
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) {
//实例化包装Bean
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;
}
}
//判断该Bean是支持循环依赖
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");
}
// 将创建好的Bean放入 singletonFactorys中
addSingletonFactory(beanName, () - >getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
//填充Bean中的属性
populateBean(beanName, mbd, instanceWrapper);
//执行Bean的 Aware、BeanPostProcessor、init方法
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;
}第一个关注点 ： instanceWrapper = createBeanInstance(beanName, mbd, args);
由于是第一次实例化Bean，所以 if (mbd.isSingleton) 逻辑中从缓存中获取到的Bean肯定为null.所以会执行下面的if判断 if (instanceWrapper == null) ，该if逻辑主要是调用 AbstractAutpwireCapableBeanFactory.createBeanInstance()方法进行Bean的实例化。查看createBeanInstance方法实现，发现最终是调用 jdk反射或者Cglib进行初始化。
第二个关注点：populateBean(beanName, mbd, instanceWrapper);
该方法主要是处理bean 中的属性，那么最经典的问题就是解决Spring Bean之间的循环依赖问题，所以这也是一个要注意的点。感兴趣的读者可以后续关注笔者更新讲解Spring的循环依赖
第三个关注点 ： exposedObject = initializeBean(beanName, exposedObject, mbd);
如下图所示，该方法主要执行了Bean调用的 Aware接口实现、BeanPostProcessor实现、init实现。
从这个方法源码中也解释了Bean的生命周期中的某些执行顺序：
Aware -----> BeanPostProcessor postProcessBeforeInitialization ----> init方法 -----> BeanPostProcessor postProcessAfterInitialization
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction < Object > )() - >{
invokeAwareMethods(beanName, bean);
return null;
},
getAccessControlContext());
} else {
//执行实现Aware接口方法
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
//执行Bean实现的 BeanPostProcessor before逻辑
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
//执行 Bean的 init 方法
invokeInitMethods(beanName, wrappedBean, mbd);
} catch(Throwable ex) {
throw new BeanCreationException((mbd != null ? mbd.getResourceDescription() : null), beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
//执行Bean实现的 BeanPostProcessor after逻辑
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;综上所述：
Spring创建Bean的流程图如下：
对Bean的创建最为核心三个方法解释如下：
createBeanInstance：例化，其实也就是调用对象的构造方法实例化对象populateBean：填充属性，这一步主要是对bean的依赖属性进行注入(@Autowired)initializeBean：回到一些形如initMethod、InitializingBean等方法
上述内容如有不妥之处，还请读者指出，共同探讨，共同进步！
@author : jackcheng1117@163.com
2623
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
