主要会涉及到的原理部分：
1.BeanPostProcessor 的注册
2.bean 的实例化动作及方式
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
prepareRefresh();
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
prepareBeanFactory(beanFactory);
try {
postProcessBeanFactory(beanFactory);
invokeBeanFactoryPostProcessors(beanFactory);
// 6. 注册BeanPostProcessor
registerBeanPostProcessors(beanFactory);
initMessageSource();
initApplicationEventMulticaster();
onRefresh();
registerListeners();
// 11. 初始化剩余的单实例Bean
finishBeanFactoryInitialization(beanFactory);
finishRefresh();
}
// catch ......
finally {
resetCommonCaches();
}
}
}
注册BeanPostProcessor
//AbstractApplicaitonContext#registerBeanPostProcessors
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}
又是走了 PostProcessorRegistrationDelegate 的方法。
//PostProcessorRegistrationDelegate#registerBeanPostProcessors
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// Register BeanPostProcessorChecker that logs an info message when
// a bean is created during BeanPostProcessor instantiation, i.e. when
// a bean is not eligible for getting processed by all BeanPostProcessors.
// 1.1 此处会先注册一个BeanPostProcessorChecker
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// Separate between BeanPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
// 根据排序规则，给所有的后置处理器分类
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 1.2 注意此处，PriorityOrdered类型的后置处理器被提前初始化了
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
// MergedBeanDefinitionPostProcessor要额外筛出来
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, register the BeanPostProcessors that implement PriorityOrdered.
// 首先，注册所有实现了PriorityOrdered接口的后置处理器
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// Next, register the BeanPostProcessors that implement Ordered.
// 其次，注册所有实现了Ordered接口的后置处理器
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
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);
// Now, register all regular BeanPostProcessors.
// 最后，注册所有普通的后置处理器
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String ppName : nonOrderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// Finally, re-register all internal BeanPostProcessors.
// 1.3 注意此处，所有MergedBeanDefinitionPostProcessor又被注册了一次
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
// Re-register post-processor for detecting inner beans as ApplicationListeners,
// moving it to the end of the processor chain (for picking up proxies etc).
// 最后又注册了一个ApplicationListenerDetector（27章3.2节）
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
理一下这个方法的整体逻辑脉络：
1.首先它会先获取到 IOC 容器中已经有的 BeanPostProcessor 的 name ，获取到之后先不处理，先注册一个 BeanPostProcessorChecker。
2.然后才是处理那些 BeanPostProcessor 。处理 BeanPostProcessor 的过程跟 BeanFactoryPostProcessor 部分十分相似，不过对比起这三个逻辑处理，实现了 PriorityOrdered 接口的后置处理器似乎有 “特权” ，它们会在所有的 BeanPostProcessor 注册之前先初始化好。当这三种后置处理器都注册完成后，它又将所有的 MergedBeanDefinitionPostProcessor 类型的后置处理器重新注册了一遍。
3.后又注册了一个 ApplicationListenerDetector 。
BeanPostProcessorChecker
从类名上看，它是一个后置处理器的检查器。它本身也是个后置处理器，那它检查个啥咧？
它的作用是检查 BeanPostProcessor 的初始化阶段中是否有 bean 的意外创建。
如果在 BeanPostProcessor 中有注入其它的普通 bean ，根据依赖注入的原则，会在 BeanPostProcessor 的创建之前，先把这些注入的普通 bean 先初始化出来，又因为当前阶段 BeanPostProcessor 还没有初始化完毕，这些普通 bean 还没有来得及被 BeanPostProcessor 处理，导致出现 bean 的 “残缺不全” 。BeanPostProcessorChecker 的作用，就是用来提醒我们开发者对该问题引起注意。
在开发时遇到这种日志：xxxxxx is not eligible for getting processed by all BeanPostProcessors (for example: not eligible for auto-proxying) ，这就意味着你的 BeanPostProcessor 中有注入普通 bean 了，需要给代码作出调整。
从源码的角度上分析，它将所有的 BeanPostProcessor 都取出来，随后计算出了所有的 BeanPostProcessor 的数量是 beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length ，即所有的后置处理器数量 + 1。
在 BeanPostProcessorChecker 的 postProcessAfterInitialization 方法中，它会检查当前 BeanFactory 中的后置处理器数量是否少于一开始计算的预计后置处理器数量，如果少了，那就代表有 bean 被提前创建了。
public Object postProcessAfterInitialization(Object bean, String beanName) {
// 此处判断是否有普通bean被提前创建
if (!(bean instanceof BeanPostProcessor) && !isInfrastructureBean(beanName) &&
this.beanFactory.getBeanPostProcessorCount() < this.beanPostProcessorTargetCount) {
if (logger.isInfoEnabled()) {
logger.info("Bean '" + beanName + "' of type [" + bean.getClass().getName() +
"] is not eligible for getting processed by all BeanPostProcessors " +
"(for example: not eligible for auto-proxying)");
}
}
return bean;
}
PriorityOrdered类型的后置处理器被提前创建的目的
从上面的源码中，可以看到。实现了PriorityOrdered接口的BeanPostProcessor被提前创建。
如果 BeanPostProcessor 的初始化逻辑是一边循环一边初始化，则可能会导致优先级低的 BeanPostProcessor 干预了优先级高的 BeanPostProcessor ，从而引发程序的运行情况异常。而正确的做法就是只初始化最高优先级的 BeanPostProcessor ，其余的都只是记录下全限定名，等所有最高优先级的 BeanPostProcessor 都初始化完成后，再依次初始化低优先级的 BeanPostProcessor （优先级低的 BeanPostProcessor 可能也需要被优先级高的 BeanPostProcessor 处理）。
实现PriorityOrdered接口的后置处理器都有哪些？
1.AutowiredAnnotationBeanPostProcessor --处理@Autowired注解
2.CommonAnnotationBeanPostProcessor–处理JSP250规范的注解。
等。
如果两个后置处理器不先初始化好的话，后面的东西就别想用我们平常用的@Autowired，@PostConstruct等等的注解了。所以说这些实现了 PriorityOrdered 接口的组件通常都是些内置的核心组件，Spring框架为了保证功能的正常运转，就必须要让这些核心组件都正常到位才可以。
MergedBeanDefinitionPostProcessor被重复注册
进入 registerBeanPostProcessors 方法中看一眼：
private static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {
for (BeanPostProcessor postProcessor : postProcessors) {
beanFactory.addBeanPostProcessor(postProcessor);
}
}
public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");
// Remove from old position, if any
// 如果后置处理器已经存在，则移除
this.beanPostProcessors.remove(beanPostProcessor);
// Track whether it is instantiation/destruction aware
if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
this.hasInstantiationAwareBeanPostProcessors = true;
}
if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {
this.hasDestructionAwareBeanPostProcessors = true;
}
// Add to end of list
// 添加至后置处理器列表的末尾
this.beanPostProcessors.add(beanPostProcessor);
}
它是将这些 MergedBeanDefinitionPostProcessor 类型的后置处理器都放到了整个后置处理器列表的最后了！仅此而已。
MergedBeanDefinitionPostProcessor后置的目的
AutowiredAnnotationBeanPostProcessor 会根据merge后的BeanDefinition，给bean对象进行依赖注入。
ApplicationListenerDetector后置的目的
判断bean是不是ApplicationListener，如果是加入到ApplicationContext的
ApplicationEventMulticaster中。
finishBeanFactoryInitialization
整个方法中，唯一处理单实例 bean 初始化的动作是最后一行。
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// ......
// Instantiate all remaining (non-lazy-init) singletons.
beanFactory.preInstantiateSingletons();
}
进入preInstantiateSingletons 方法
preInstantiateSingletons方法实现在DefaultListableBeanFactory
//DefaultListableBeanFactory#preInstantiateSingletons
public void preInstantiateSingletons() throws BeansException {
// logger ......
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
// 此处循环初始化剩余的非延迟加载的单实例bean
for (String beanName : beanNames) {
// 先合并BeanDefinition
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// 不是抽象的、不是延迟加载的单实例bean要初始化
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// FactoryBean默认不立即初始化，除非指定isEagerInit=true
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 {
// 普通的初始化，就是getBean方法
getBean(beanName);
}
}
}
// 初始化的最后阶段 ......
}
getBean → doGetBean
getBean 方法，发现它直接调用了 doGetBean 方法。
//AbstractBeanFactory#getBean
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
//AbstractBeanFactory#doGetBean
protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
throws BeansException {
// 处理bean的alias
String beanName = transformedBeanName(name);
Object bean;
// Eagerly check singleton cache for manually registered singletons.
// 循环依赖的探测（boot小册第15章专门有讲）
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
// logger ......
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
// 如果原型bean之间互相依赖，则一定会引发无限循环，此处会抛出循环依赖的异常
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// Check if bean definition exists in this factory.
// 如果本地不存在当前bean的定义信息，则尝试让父容器实例化bean
// 此举可以保证每个BeanFactory持有它应该有的bean，而不是所有的bean都集中在某一个BeanFactory中
BeanFactory parentBeanFactory = getParentBeanFactory();
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 parentBeanFactory.getBean ......
}
// 标记当前bean已经开始被创建了
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
// 此处会合并BeanDefinition，并检查是否为抽象类(abstract则会抛出无法实例化的异常)
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
// 此处会处理
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
// 循环依赖的检查：如果两个bean互相显式依赖，也会引发循环依赖的问题
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
registerDependentBean(dep, beanName);
try {
// 迫切初始化显式依赖的bean
getBean(dep);
} // catch ......
}
}
// Create bean instance.
// 单实例bean的初始化，最终调用createBean
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
} // catch ......
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// 原型bean的初始化，直接调用createBean
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);
}
// 处理自定义的scope ......
}
// catch ......
}
// 类型强转前的检查 ......
return (T) bean;
}
简单概述：
1.getMergedLocalBeanDefinition合并BeanDefinition为RootBeanDefinition
2.检查是否有依赖的bean，实例化依赖的bean。调用getBean(依赖的beanName)
3.调用createBean创建bean。单例与原型bean分开处理。
最重要的部分是中间的 getMergedLocalBeanDefinition 合并 BeanDefinition ，以及下面的 createBean 方法。下面我们分述这两个重要的方法。
getMergedLocalBeanDefinition
进入到 getMergedLocalBeanDefinition 方法中，发现它又是在折腾重载的方法，最终调用的是三参数的方法：
//AbstractBeanFactory#getMergedLocalBeanDefinition
protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
// Quick check on the concurrent map first, with minimal locking.
//一个缓存Map(ConcurrentHashMap)
RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
if (mbd != null && !mbd.stale) {
return mbd;
}
return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
}
//AbstractBeanFactory#getMergedBeanDefinition
protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd)
throws BeanDefinitionStoreException {
return getMergedBeanDefinition(beanName, bd, null);
}
最上面的调用位置上做了一个缓存的获取动作,由此可见合并后的 BeanDefinition 也是会缓存在 BeanFactory 中的。
//AbstractBeanFactory#getMergedBeanDefinition
protected RootBeanDefinition getMergedBeanDefinition(
String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
throws BeanDefinitionStoreException {
synchronized (this.mergedBeanDefinitions) {
RootBeanDefinition mbd = null;
RootBeanDefinition previous = null;
// Check with full lock now in order to enforce the same merged instance.
if (containingBd == null) {
mbd = this.mergedBeanDefinitions.get(beanName);
}
if (mbd == null || mbd.stale) {
previous = mbd;
// 此处会判断BeanDefinition是否没有父定义（即独立的GenericBeanDefinition或RootBeanDefinition）
if (bd.getParentName() == null) {
// Use copy of given root bean definition.
if (bd instanceof RootBeanDefinition) {
mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
} else {
mbd = new RootBeanDefinition(bd);
}
}
else {
// Child bean definition: needs to be merged with parent.
// 否则，此处需要合并BeanDefinition了
BeanDefinition pbd;
try {
String parentBeanName = transformedBeanName(bd.getParentName());
if (!beanName.equals(parentBeanName)) {
pbd = getMergedBeanDefinition(parentBeanName);
}
else {
BeanFactory parent = getParentBeanFactory();
if (parent instanceof ConfigurableBeanFactory) {
// 此处会递归合并
pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
} // else throw ex ......
}
} // catch ......
// Deep copy with overridden values.
// 合并完成后，生成一个新的RootBeanDefinition
mbd = new RootBeanDefinition(pbd);
mbd.overrideFrom(bd);
}
// Set default singleton scope, if not configured before.
// 配置scope（如果自己和父定义都没有定义scope，则此处默认singleton）
if (!StringUtils.hasLength(mbd.getScope())) {
mbd.setScope(SCOPE_SINGLETON);
}
if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
mbd.setScope(containingBd.getScope());
}
if (containingBd == null && isCacheBeanMetadata()) {
this.mergedBeanDefinitions.put(beanName, mbd);
}
}
if (previous != null) {
copyRelevantMergedBeanDefinitionCaches(previous, mbd);
}
return mbd;
}
}
核心逻辑：它会自下而上递归寻找父BeanDefinition，再从上而下合并获取最终的BeanDefinition。
createBean的调用区别
这个 createBean 方法又是 bean 的实例化中巨重要的方法了。注意看单实例 bean 跟原型 bean 对于 createBean 方法的调用方式：
// Create bean instance.
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
} // catch ......
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
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);
}
单实例 bean 的调用，是在 getSingleton 方法的 lambda 参数中调用的，而这个 lambda表达式的底层是一个 ObjectFactory 。
原型 bean 没有缓存的必要，每次获取必定会创建新的 bean 对象出来；而单实例 bean 只能创建一次，第二次再获取就需要从缓存中获取了，所以这里会多一步操作。
getSingleton
//DefaultSingletonBeanRegistry#getSingleton
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
// 加锁后再查一次单实例bean的缓存
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
if (this.singletonsCurrentlyInDestruction) {
// throw ex ......
}
// ......
try {
// 【createBean】如果单实例bean的缓存中真的没有，那就创建对象
singletonObject = singletonFactory.getObject();
newSingleton = true;
} // catch finally ......
// 新创建的单实例bean要存入单实例bean的缓存中
if (newSingleton) {
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
这段源码一点也不神秘，无非就是加锁之后再判断一次单例（双检锁的设计），如果没有，那就调用 ObjectFactory 的 getObject 方法，而这个 ObjectFactory 就是前面看到的 lambda 表达式。
createBean
//AbstractAutowireCapableBeanFactory#createBean
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// logger ......
RootBeanDefinition mbdToUse = mbd;
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
try {
// 前置校验，不重要
mbdToUse.prepareMethodOverrides();
} // catch ......
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
// 【后置处理器拦截创建bean】
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
} // catch ......
try {
// 【真正的创建bean】
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
// logger ......
return beanInstance;
} // catch ......
}
createBean 的方法中，除了最底下的 doCreateBean 真正创建 bean 之外，在上面还有一步：resolveBeforeInstantiation ，而且看注释也能获得这句代码的关键用途：Give BeanPostProcessors a chance to return a proxy instead of the target bean instance. （给后置处理器一个机会来创建代理 bean 而不是目标 bean 实例）。
resolveBeforeInstantiation
InstantiationAwareBeanPostProcessor后置处理器的postProcessBeforeInstantiation方法调用。如果bean被实例化出来。调用BeanPostProcessor后置处理器的PostProcessorsAfterInitialization方法。
//AbstractAutowireCapableBeanFactory#resolveBeforeInstantiation
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) {
// 执行所有InstantiationAwareBeanPostProcessor
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
// 如果成功创建出了bean，则执行BeanPostProcessor的后置初始化
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
//AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInstantiation
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
// 循环找出所有的InstantiationAwareBeanPostProcessor
if (bp instanceof InstantiationAwareBeanPostProcessor) {
// 调用它们的postProcessBeforeInstantiation尝试实例化bean对象
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
if (result != null) {
return result;
}
}
}
return null;
}
InstantiationAwareBeanPostProcessor 的 postProcessBeforeInstantiation 方法了。
如果 postProcessBeforeInstantiation 方法真的实例化出来了 bean 对象，为什么还需要回调 BeanPostProcessor 的 postProcessAfterInitialization 呢？
postProcessAfterInitialization 方法的一个关键的作用是生成代理对象，如果一个 bean 被 InstantiationAwareBeanPostProcessor 提前创建出 bean 了，但又需要创建代理对象，这个时候就必须要回调 BeanPostProcessor 的 postProcessAfterInitialization 方法了。
doCreateBean
这个方法有三个步骤：
1.实例化 bean 对象（此时 bean 中所有属性均为空）
2.属性赋值 & 依赖注入
3.bean 对象的初始化（执行完该步骤后 bean 已经完整）
第一步 实例化 bean 对象
//AbstractAutowireCapableBeanFactory#doCreateBean
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
// 处理FactoryBean的小细节问题
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// 【真正的bean对象创建】
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// 得到真实的bean对象引用
Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// ...... ...... ......
核心步骤：createBeanInstance 。它会把真正的bean对象实例化出来。
不过在此之前有一个小细节处理：this.factoryBeanInstanceCache.remove(beanName)。
factoryBeanInstanceCache的作用
借助 IDEA ，观察 factoryBeanInstanceCache 的使用位置，唯一可以找到的 put 方法调用是在 AbstractAutowireCapableBeanFactory 的 getSingletonFactoryBeanForTypeCheck 方法末尾部分：
FactoryBean<?> fb = getFactoryBean(beanName, instance);
if (bw != null) {
this.factoryBeanInstanceCache.put(beanName, bw);
}
return fb;
getSingletonFactoryBeanForTypeCheck 方法的调用，可以发现进入到 getTypeForFactoryBean 中了。它可以获取到 FactoryBean 中生成的 bean 的类型！
FactoryBean是单例的话不能创建第二次，如果提前调用了getTypeForFactoryBean 确认了FactroyBean中生成的bean的类型，则它会把这个 FactoryBean 本身先存在一个 factoryBeanInstanceCache 中。等后续真的需要由 FactoryBean 生成 bean 的时候，它会直接从 factoryBeanInstanceCache 中取出刚才已经实例化的 FactoryBean ，继续执行 bean 的初始化动作（属性赋值、依赖注入等）。
createBeanInstance
正常情况下第一次执行 doCreateBean 时，一定会走 createBeanInstance 方法的。
解析bean类型
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// 解析出bean的类型
Class<?> beanClass = resolveBeanClass(mbd, beanName);
// bean无法被访问，则抛出异常
if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
}
// ......
第一步倒是很简单了，它会把当前即将实例化的 bean 的类型先确定出来。确定出来之后有一个校验，校验完成就可以进行下一步了。
工厂方法创建
// ......
// SpringFramework5的新特性
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return obtainFromSupplier(instanceSupplier, beanName);
}
// 【工厂方法创建】
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
// ......
这两段源码，本质都是干一件事：如果在 BeanDefinition 中指定了工厂类型的创建逻辑，则直接走工厂创建。注意这里面的工厂包含两种情况，咱一一解释。
InstanceSupplier
这个设计来自于 AbstractBeanDefinition 中，是 SpringFramework 5.0 之后出现的新 API 。jdk 8 之后多了几个很重要很实用的 lambda ，其中之一就是 Supplier ，它是一个生产型接口。跟工厂的思路类似，Supplier 也可以完成构造 bean 的工作，所以在 BeanDefinition 中加入了这样一个设计，作为 factory-method 的一个替代方案。不过一般情况下我们也不会操纵 BeanDefinition 。
factoryMethod
这个 factoryMethod ，除了在 xml 配置文件中定义的 factory-method 之外，注解配置类中被 @Bean 标注的方法，本质上也是一个工厂方法。源码中它会执行 instantiateUsingFactoryMethod 方法来触发这个 factoryMethod ，它会根据工厂名称，找到对应的静态工厂 / 实例工厂 / 注解配置类对象，，随后反射执行工厂方法，生成 bean 对象。
实例化bean
// Candidate constructors for autowiring?
// 当满足任一条件，就会执行基于构造器的实例化
// 1. 通过SmartInstantiationAwareBeanPostProcessor找到了构造器
// 2. 配置了注入方式是AUTOWIRE_CONSTRUCTOR
// 3. 定义bean的时候指定了constructor-arg
// 4. 构造bean时传入了args参数
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, ctors, args);
}
// Preferred constructors for default construction?
ctors = mbd.getPreferredConstructors();
if (ctors != null) {
return autowireConstructor(beanName, mbd, ctors, null);
}
// No special handling: simply use no-arg constructor.
return instantiateBean(beanName, mbd);
}
这部分就是解析构造器、给构造器参数注入，以及反射实例化 bean 的步骤了。
1.首先它会解析实例化 bean 需要的构造器。
2.如果 bean 中有显式的声明非空参数的构造器，则会依次解析构造器参数列表，并进行注入，最后反射创建 bean 对象。
3.如果没有声明，则会调用最后一行的 instantiateBean 方法，使用默认空参构造器反射创建 bean 对象。
最后一行的 instantiateBean 方法中，最终会借助 InstantiationStrategy ，调用 BeanUtils.instantiateClass 方法反射实例化 bean 对象
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
try {
Object beanInstance;
final BeanFactory parent = this;
if // ......
else {
// 借助InstantiationStrategy
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
initBeanWrapper(bw);
return bw;
}
// ......
}
当 createBeanInstance 方法执行完之后，就可以得到一个光秃秃的 bean 对象了。
总结：
在所有非延迟加载的单实例 bean 初始化之前，会先初始化所有的 BeanPostProcessor 。
在 ApplicationContext 的 refresh 方法中，finishBeanFactoryInitialization 步骤会初始化所有的非延迟加载的单实例 bean 。实例化 bean 的入口是 getBean → doGetBean ，该阶段会合并 BeanDefinition ，并根据 bean 的 scope 选择实例化 bean 的策略。
创建 bean 的逻辑会走 createBean 方法，该方法中会先执行所有 InstantiationAwareBeanPostProcessor 的 postProcessBeforeInstantiation 方法尝试创建 bean 实例，如果成功创建，则会直接调用 postProcessAfterInitialization 方法初始化 bean 后返回；如果 InstantiationAwareBeanPostProcessor 没有创建 bean 实例，则会调用 doCreateBean 方法创建 bean 实例。在 doCreateBean 方法中，会先根据 bean 的 Class 中的构造器定义，决定如何实例化 bean ，如果没有定义构造器，则会使用无参构造器，反射创建 bean 对象。
1346
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
