文章目录
Spring中Bean的加载
在前面使用：
BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("org/springframework/example/bean-factory-demo.xml"));
获取到BeanFactory之后，我们就可以对需要的bean进行获取：
User user = (User)beanFactory.getBean("user");
所以bean加载的流程应该就在调用的getBean()方法中：
Object getBean(String name) throws BeansException;
AbstractBeanFactory.java
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 {
// 获取对应的beanName（这里传入的参数可能是别名，也可能是FactoryBean，需要进行一系列的解析），包括：
// 1. 对FactoryBean的修饰符的解析，（name="&aa"，取出&，解析成name="aa"）
// 2. 取alias表示的最终的beanName（别名A指向id为B的bean，则最终beanName为B）
String beanName = transformedBeanName(name);
Object bean;
/**
* 这段代码存在的原因：
* 创建单例bean的时候会存在依赖注入的情况，而在创建依赖的时候为了避免循环依赖，Spring的选择是：
* 创建bean的时候不等bean创建完成，就会先将创建bean的 ObjectFactory提早曝光到缓存中，
* 如果下一个bean创建时需要依赖上一个bean的话，直接使用ObjectFactory；
*/
// Eagerly check singleton cache for manually registered singletons.
// 首先尝试从缓存中加载单例，如果加载不成功则尝试从singletonFactories中记载
// 这里获取的可能是原始的bean 形态，并不是最终想要的bean
// （例如 对FactoryBean进行处理，这里返回的是FactoryBean本身的bean，真正需要的是getObject()方法中指定返回的bean）
Object sharedInstance = getSingleton(beanName);
// 从缓存中获取到了
if (sharedInstance != null && args == null) {
if (logger.isTraceEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
// 检测当前bean是否是FactoryBean类型的bean，如果是则调用该bean对应的FactoryBean中的getObject()来真正获取bean
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
// 没有获取到，就需要从头开始bean的加载过程（可能是prototype的bean）
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.
BeanFactory parentBeanFactory = getParentBeanFactory();
// parentBeanFactory存在，
// 且containsBeanDefinition 检测如果当前加载的XML配置文件中不包含beanName所对应的配置，就只能到parentBeanFactory去尝试下了，然后再递归调用getBean
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
// 返回原始的bean名称
String nameToLookup = originalBeanName(name);
// 递归到 BeanFactory中寻找
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);
}
}
// 如果不仅仅是做类型检查，而是创建bean的话，进行一下标记 alreadyCreated.add(beanName);
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
// 将XML配置文件的存储载体 GenericBeanDefinition 转换成 RootBeanDefinition，如果指定beanName是子Bean的话，合并父类相关属性
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) {
// 如果存在依赖，需要先初始化依赖的bean
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 {
// 递归，先实例化依赖的bean
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// 实例化依赖的bean后，就可以实例化 bean本身了
// Create bean instance.
if (mbd.isSingleton()) {
// 如果是单例，使用 getSingleton的重载方法创建bean（函数式接口，getObject()方法的实现）
sharedInstance = getSingleton(beanName, () -> {
try {
// 创建bean的核心部分
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
destroySingleton(beanName);
throw ex;
}
});
// 检测当前bean是否是FactoryBean类型的bean，如果是则调用该bean对应的FactoryBean中的getObject()来真正获取bean
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
else if (mbd.isPrototype()) {
// 如果是 proto type，使用new 创建
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
// 检测当前bean是否是FactoryBean类型的bean，如果是则调用该bean对应的FactoryBean中的getObject()来真正获取bean
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
// 指定的scope上实例化bean
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是否是FactoryBean类型的bean，如果是则调用该bean对应的FactoryBean中的getObject()来真正获取bean
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;
}
}
// 检查需要的类型是否符合bean的实际类型
// 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.isTraceEnabled()) {
logger.trace("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
从以上代码中可以看到，Spring中bean的加载经历了一个相当复杂的过程，下面就来一步一步的分析这个过程。
1. 转换对应的beanName
String beanName = transformedBeanName(name);
Q：这里传入进来的参数不就是beanName吗？为什么还要转换一次呢？
A：传入进来的参数不一定就是beanName，还可能是别名，或者是FactoryBean，所以需要进行处理和转换。
说到这里，先来了解一下什么是FactoryBean。
1.1 FactoryBean
1.1.1 FactoryBean的作用
首先，FactoryBean也是bean，如果只是想简单的去构造一个bean，不需要实现大量的方法时，它可以单纯地作为bean进行注入。
另外，FactoryBean还有如下功能：
- FactoryBean可以生成其他的bean，对其他的bean进行修饰：
一般情况下，在Spring中通过反射机制利用bean的class属性指定实现类来实例化bean；如果这个bean的属性特别多的话，如果按照正常配置bean的方法，我们需要在标签中书写大量的配置信息，实现和维护起来都比较复杂。
这个时候，就可以通过实现FactoryBean的接口，在代码中实现实例化复杂bean的逻辑。 - FactoryBean可以便于集成第三方的框架：
在一个项目中除了使用Spring，可能还要用到其他的框架，例如orm框架mybatis；为了使用mybatis就需要把它的一些核心类（例如SqlSessionFactory）注入到Spring中。
我们常用的注入方式一种是使用@Component注解（不能去改第三方框架的源码，无法实现），一种是在xml文件中使用标签进行配置（但是我们可以看到SqlSessionFactory中的属性非常多，而且还要根据一些环境信息动态生成，实现太过麻烦）。
这个时候，就可以使用FactoryBean接口，在其中去实现实例化SqlSessionFactory的过程，并且把它注入到Spring中。（其实说到底跟上一点功能的本质相同…）- 使用示例：
Spring在这里会通过这个标签注入SqlSessionFactoryBean这个实现了FactoryBean的工厂bean，并且使用我们配置的几个属性在这个工厂bean中对SqlSessionFactory进行实例化，并且把生成的SqlSessionFactory注入到Spring的IOC容器中。<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="dataSource" ref="dataSource" /> <property name="configLocation" value="classpath:sql-map-config.xml" /> <property name="mapperLocations" value="classpath:sql-mapping/*.xml" /> </bean>
1.1.2 FactoryBean的使用
FactoryBean接口：
public interface FactoryBean<T> {
String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";
@Nullable
T getObject() throws Exception;
@Nullable
Class<?> getObjectType();
default boolean isSingleton() {
return true;
}
}
- T getObject()：返回由FactoryBean创建的bean实例，如果isSingleton()返回true，会把创建的实例放到Spring容器的单例缓存池中；
- boolean isSingleton()：返回由FactoryBean创建的bean实例的作用域（singleton/prototype）；
- Class<?> getObjectType()：返回由FactoryBean创建的bean的类型；
使用示例：
- 首先创建一个需要被注入的“假装复杂”的bean：
public class Car {
private String brand;
private double price;
private int maxSpeed;
// 省略 set/get 方法
}
- 创建一个实现了FactoryBean的工厂bean：
public class CarFactoryBean implements FactoryBean<Car> {
private String carInfo;
public String getCarInfo() {
return carInfo;
}
public void setCarInfo(String carInfo) {
this.carInfo = carInfo;
}
public Car getObject() throws Exception {
Car car = new Car();
String[] infos = carInfo.split(",");
car.setBrand(infos[0]);
car.setPrice(Double.valueOf(infos[1]));
car.setMaxSpeed(Integer.valueOf(infos[2]));
return car;
}
public Class<?> getObjectType() {
return Car.class;
}
public boolean isSingleton() {
return true;
}
}
- xml配置文件：
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="car" class="org.bgy.spring.study.spring.bean.definition.factory.bean.CarFactoryBean">
<property name="carInfo" value="奥迪,20.00,200"/>
</bean>
</beans>
- 测试类：
public class FactoryBeanDemo {
public static void main(String[] args) {
// 配置XML文件
BeanFactory beanFactory = new ClassPathXmlApplicationContext("classpath:bean-definition-context.xml");
Car car = (Car)beanFactory.getBean("car");
System.out.println(car);
}
}
// output: Car{brand='奥迪', price=20.0, maxSpeed=200}
我们并没有哪个地方去注入了“car”的bean，但是我们最终使用getBean(“car”)获取到了这个bean。
所以在这里是CarFactoryBean这个工厂bean为我们注入了我们需要的bean，当调用getBean(“car”)时，获取到标签中class属性对应的CarFactoryBean类，Spring通过反射机制发现CarFactoryBean实现了FactoryBean接口，这个时候Spring容器就调用接口方法 CarFactoryBean#getObject()返回生成的bean。
如果希望获取到CarFactoryBean这个bean，需要在调用getBean(beanName)方法时在beanName的前面显示地加上“&”前缀：getBean("&car")。
1.2 转换beanName
String beanName = transformedBeanName(name);
protected String transformedBeanName(String name) {
return canonicalName(BeanFactoryUtils.transformedBeanName(name));
}
BeanFactoryUtils.java
public static String transformedBeanName(String name) {
Assert.notNull(name, "'name' must not be null");
if (!name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
return name;
}
return transformedBeanNameCache.computeIfAbsent(name, beanName -> {
do {
beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
}
while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));
return beanName;
});
}
如果这个beanName不是以"&“前缀开头的，则直接返回；如果这个beanName是以”&“前缀开头的，则去掉”&"前缀。
public String canonicalName(String name) {
String canonicalName = name;
// Handle aliasing...
String resolvedName;
do {
resolvedName = this.aliasMap.get(canonicalName);
if (resolvedName != null) {
canonicalName = resolvedName;
}
}
while (resolvedName != null);
return canonicalName;
}
这里就是处理别名了，从前面解析标签中设置的别名的缓存aliasMap中去寻找是否存在别名对应的原始名称，如果找到了就返回原始名称，没有找到就直接返回当前beanName。
2. 缓存中获取单例bean
Object sharedInstance = getSingleton(beanName);
单例bean在Spring的同一个容器中只会被创建一次，后面再需要的话直接从单列缓存中去获取。
所以在这里如果从缓存中获取到了，则证明已经被创建过了，只需要再经过一些处理就可以直接返回；如果没有的话再继续后面的逻辑。
DefaultSingletonBeanRegistry.java
public Object getSingleton(String beanName) {
// 设置为true标识，允许早期依赖
return getSingleton(beanName, true);
}
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 检查缓存中是否存在实例
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
// 不存在的情况下，加锁进行处理（全局变量，保证线程安全）
synchronized (this.singletonObjects) {
// 获取这个bean是否正在创建
singletonObject = this.earlySingletonObjects.get(beanName);
// 如果没有创建，才进行处理
if (singletonObject == null && allowEarlyReference) {
// 从 singletonFactories 中获取 beanName对应的ObjectFactory
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
// 调用ObjectFactory的 getObject() 方法来创建bean
singletonObject = singletonFactory.getObject();
// 放入正在创建的缓存（earlySingletonObjects和 singletonFactories 互斥）
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
因为这个方法涉及到循环依赖的检测，所以使用了几个缓存map来记录beanName和bean实例之间的关系，也就是所谓的Spring用来解决循环依赖问题的“三级缓存”：
Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
用于保存beanName和创建的bean实例之间的关系；Map<String, Object> earlySingletonObjects = new HashMap<>(16);
也是保存beanName和创建的bean实例之间的关系，但是不同点是：这里放置的bean可以是创建过程中的，属性还没有被填充的原始bean，目的是：提前曝光，用于检测循环依赖；Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
用于保存beanName和创建bean的工厂之间的关系；
这里的执行步骤为：
- 首先从一级缓存singletonObjects中去获取bean，如果获取到则直接返回；
- 如果没有获取到并且这个bean正在创建中，则从二级缓存earlySingletonObjects中去获取bean，如果获取到也是直接返回；
- 如果还是没有获取到，并且在允许早期依赖（allowEarlyReference）的情况下，从三级缓存singletonFactories 中获取beanName对应的singletonFactory ，然后再调用singletonFactory 的getObject()方法来创建bean；同时把bean实例添加到二级缓存中，并从三级缓存中移除；
3. 从bean实例中获取真正的bean对象
AbstractBeanFactory.java
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
无论是从缓存中获取到的bean还是通过不同的scope策略创建的bean，都并不一定是我们最终想要的bean。
例如：如果是FactoryBean类型的bean，这里获取到的就是FactoryBean本身，但是我们真正想要的是FactoryBean中生成的bean，所以就需要进行处理：
protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
// Don't let calling code try to dereference the factory if the bean isn't a factory.
// 以 & 前缀判断，用户想要获取的是 FactoryBean
if (BeanFactoryUtils.isFactoryDereference(name)) {
if (beanInstance instanceof NullBean) {
return beanInstance;
}
// 如果beanInstance 又不是 FactoryBean类型的，检验不通过，直接抛出异常
if (!(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
}
if (mbd != null) {
mbd.isFactoryBean = true;
}
// 直接返回 FactoryBean 实例
return beanInstance;
}
// Now we have the bean instance, which may be a normal bean or a FactoryBean. 这个实例可能是正常bean也可能是 FactoryBean
// If it's a FactoryBean, we use it to create a bean instance, unless the
// caller actually wants a reference to the factory.
if (!(beanInstance instanceof FactoryBean)) {
// 如果这个bean不是FactoryBean类型，直接返回
return beanInstance;
}
// 到这里已经明确 beanInstance是 FactoryBean类型的了
Object object = null;
if (mbd != null) {
mbd.isFactoryBean = true;
}
else {
// 当mbd为空时，尝试从缓存中加载 bean
object = getCachedObjectForFactoryBean(beanName);
}
if (object == null) {
// Return bean instance from factory.
// 转换成 FactoryBean
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
// Caches object obtained from FactoryBean if it is a singleton.
// containsBeanDefinition 检测 beanDefinitionMap（所有已经加载的类）中检测是否定义 beanName
if (mbd == null && containsBeanDefinition(beanName)) {
// 将XML配置文件的存储载体 GenericBeanDefinition 转换成 RootBeanDefinition，如果指定beanName是子Bean的话，合并父类相关属性
mbd = getMergedLocalBeanDefinition(beanName);
}
// 是否是用户定义的，而不是应用程序本身定义的
boolean synthetic = (mbd != null && mbd.isSynthetic());
// 解析真正的bean
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
上面代码主要实现了：
- 如果name（不是转换之后的beanName）是以“&”开头的，则判断beanInstance：
- 不是FactoryBean类型，则检验不通过抛出异常；
- 是FactoryBean类型则直接返回beanInstance（意味着用户指定获取FactoryBean本身，而不是FactoryBean中生成的bean）；
- 如果beanInstance不是FactoryBean类型，则直接返回beanInstance；
- beanInstance是FactoryBean类型，并且不在factoryBeanObjectCache的缓存中时，就需要去创建bean：
- 首先将beanInstance转换成FactoryBean，并且注册了BeanDefinition的话则合并XML配置文件中的相关属性；
- 将从FactoryBean中解析真正的bean的工作委托给了getObjectFromFactoryBean()方法。
FactoryBeanRegistrySupport.java
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
if (factory.isSingleton() && containsSingleton(beanName)) {
// 如果是单例模式，需要保证全局唯一，且不必重复创建，使用缓存提高性能
synchronized (getSingletonMutex()) {
// 从缓存中获取，如果为空才创建
Object object = this.factoryBeanObjectCache.get(beanName);
if (object == null) {
// 真正去创建
object = doGetObjectFromFactoryBean(factory, beanName);
// Only post-process and store if not put there already during getObject() call above
// (e.g. because of circular reference processing triggered by custom getBean calls)
Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
if (alreadyThere != null) {
object = alreadyThere;
}
else {
if (shouldPostProcess) {
if (isSingletonCurrentlyInCreation(beanName)) {
// Temporarily return non-post-processed object, not storing it yet..
return object;
}
beforeSingletonCreation(beanName);
try {
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName,
"Post-processing of FactoryBean's singleton object failed", ex);
}
finally {
afterSingletonCreation(beanName);
}
}
if (containsSingleton(beanName)) {
this.factoryBeanObjectCache.put(beanName, object);
}
}
}
return object;
}
}
else {
// 如果不是单例模式，没有存在缓存，直接创建
Object object = doGetObjectFromFactoryBean(factory, beanName);
// 当不是用户自定义的，调用后置处理器处理逻辑
if (shouldPostProcess) {
try {
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
}
}
return object;
}
}
这个方法中主要是判断这个bean是不是单例的：
- 如果是单例的则需要保证全局唯一，不能重复创建，就可以使用缓存来存储；所以当这个bean没有在缓存中时才去创建，在创建完成之后如果需要的话处理post-process；
- 如果不是单例的话就直接去创建，在创建完成之后如果需要的话处理post-process；
这里的创建工作都委托给了 doGetObjectFromFactoryBean()方法：
private Object doGetObjectFromFactoryBean(FactoryBean<?> factory, String beanName) throws BeanCreationException {
Object object;
try {
// 权限验证
if (System.getSecurityManager() != null) {
AccessControlContext acc = getAccessControlContext();
try {
object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);
}
catch (PrivilegedActionException pae) {
throw pae.getException();
}
}
else {
// 调用FactoryBean的 getObject() 方法，返回真正的bean
object = factory.getObject();
}
}
catch (FactoryBeanNotInitializedException ex) {
throw new BeanCurrentlyInCreationException(beanName, ex.toString());
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
}
if (object == null) {
if (isSingletonCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(
beanName, "FactoryBean which is currently in creation returned null from getObject");
}
object = new NullBean();
}
return object;
}
在这个方法中，我们终于看见了我们想要看见的方法：object = factory.getObject(); 调用FactoryBean的getObject()方法返回FactoryBean中生成的bean，也就是我们最终需要的bean实例对象！
但是我们可以看到，再获取到需要的bean对象之后也没有直接返回，而是调用postProcessObjectFromFactoryBean()方法做了一些后置处理的操作：
object = postProcessObjectFromFactoryBean(object, beanName);
AbstractAutowireCapableBeanFactory.java
protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {
return applyBeanPostProcessorsAfterInitialization(object, beanName);
}
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
Object current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
这个后置处理器会在后面专门进行讲解；这里我们可以了解到 在Spring获取bean的规则中有这样一条：尽可能保证所有bean初始化后都会调用注册的 BeanPostProcessor的postProcessAfterInitialization()方法进行处理；在实际开发过程中可以针对这个特性设计自己的业务逻辑。
这里等于是先讲了当能从缓存中获取到sharedInstance的情况下，从bean实例中获取真正bean对象的步骤；当从缓存中获取不到sharedInstance时，需要先去从头开始bean实例的加载过程，然后再来执行 从bean实例中获取真正bean对象的步骤。
4. 从头开始bean实例的加载
4.1 原型模式的依赖检查
当没有从单列缓存中获取到bean实例时，就要开始去创建bean实例了；创建之前先判断这个beanName是否已经在被创建了（而且要是原型模式的正在创建），如果当前beanName已经作为一个原型模式的bean的name在被创建，直接抛出异常，因为Spring中只有单例模式才去解决循环依赖。
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
protected boolean isPrototypeCurrentlyInCreation(String beanName) {
Object curVal = this.prototypesCurrentlyInCreation.get();
return (curVal != null &&
(curVal.equals(beanName) || (curVal instanceof Set && ((Set<?>) curVal).contains(beanName))));
}
4.2 检测parentBeanFactory
判断原型模式没问题后，就开始创建了；创建之前先获取parentBeanFactory，当parentBeanFactory不为空时，再去判断当前加载的XML配置文件中是否有这个beanName对应的配置，如果没有则需要到parentBeanFactory去尝试加载bean了：
BeanFactory parentBeanFactory = getParentBeanFactory();
// parentBeanFactory存在，且containsBeanDefinition() 检测到当前加载的XML配置文件中不包含beanName所对应的配置
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
// 返回原始的bean名称
String nameToLookup = originalBeanName(name);
// 递归到 BeanFactory中寻找
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);
}
}
在上面我们是把name进行了一次转换，转换成了beanName的；在这里，我们需要获取原始的name，就得把beanName转换回来，如果name是以"&"开头的，需要在beanName上加上这个符号。
protected String originalBeanName(String name) {
String beanName = transformedBeanName(name);
if (name.startsWith(FACTORY_BEAN_PREFIX)) {
beanName = FACTORY_BEAN_PREFIX + beanName;
}
return beanName;
}
创建步骤：
- 如果parentBeanFactory是AbstractBeanFactory类型的，则直接使用传入的参数递归调用当前正在调用的doGetBean()方法即可；
- 当前传入的参数args不为null，则使用parentBeanFactory调用getBean()方法的重载方法：
Object getBean(String name, Object... args) throws BeansException; - 当前传入的参数requiredType不为null，则使用parentBeanFactory调用getBean()方法的重载方法：
<T> T getBean(String name, Class<T> requiredType) throws BeansException; - 如果参数都为null，则使用parentBeanFactory调用getBean()方法的重载方法：
Object getBean(String name) throws BeansException;
4.3 标记 alreadyCreated
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
protected void markBeanAsCreated(String beanName) {
if (!this.alreadyCreated.contains(beanName)) {
synchronized (this.mergedBeanDefinitions) {
if (!this.alreadyCreated.contains(beanName)) {
// Let the bean definition get re-merged now that we're actually creating
// the bean... just in case some of its metadata changed in the meantime.
clearMergedBeanDefinition(beanName);
this.alreadyCreated.add(beanName);
}
}
}
}
判断typeCheckOnly参数表明不仅仅是类型检查的时候，需要把当前的beanName放到alreadyCreated的map缓存中（缓存真多…）。
4.4 转换GenericBeanDefinition为RootBeanDefinition
因为从XML配置文件中读取到的bean信息在前面被我们存入了 GenericBeanDefinition中，但是后面对bean的处理都是针对于 RootBeanDefinition，所以在这里我们需要进行一个转换；转换的同时如果当前这个bean是子bean，且父bean不为空的情况下，需要合并父bean中的属性：
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
// Quick check on the concurrent map first, with minimal locking.
RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
if (mbd != null && !mbd.stale) {
return mbd;
}
return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
}
checkMergedBeanDefinition(mbd, beanName, args);
转换之后再进行一次RootBeanDefinition是否为abstract的检查，如果是，抛出异常。
4.5 寻找依赖
在Spring中，一个bean可能依赖于其他的bean；所以在bean初始化的时候，如果这个bean配置成了依赖其他的bean，就需要先加载依赖的bean：
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
// 如果存在依赖，需要先初始化依赖的bean
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 {
// 递归，先实例化依赖的bean
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
初始化依赖的bean之前，先使用isDependent()方法判断：当前bean需要依赖的bean，是否又依赖于当前bean，如果是的话抛出循环依赖的异常。（为什么这里又是直接抛出异常？？不去处理了…）
不存在循环依赖的情况下就把bean的依赖关系记录到 dependenciesForBeanMap缓存中，然后再递归调用 getBean()方法加载依赖的bean。
4.6 针对不同的scope进行bean的创建
在上面的各种检测工作，转换工作，依赖处理等都完成之后，就可以创建这个bean本身了。但是在Spring中存在不同的scope（singleton、prototype、request等），所以Spring需要根据不同的scope使用不同的策略创建bean。
4.6.1 singleton类型bean的创建
在上面讲过先从缓存中获取单列bean的过程，到这里的时候是从缓存中没有获取到单列bean了，就需要自己去创建。Spring中使用了getSingleton的重载方法实现bean的创建过程：
if (mbd.isSingleton()) {
// 如果是单例，使用 getSingleton的重载方法创建bean（函数式接口，getObject()方法的实现）
sharedInstance = getSingleton(beanName, () -> {
try {
// 创建bean的核心部分
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
destroySingleton(beanName);
throw ex;
}
});
// 检测当前bean是否是FactoryBean类型的bean，如果是则调用该bean对应的FactoryBean中的getObject()来真正获取bean
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
使用lambda表达式生成了一个ObjectFactory接口的实例作为参数传入，并且实现了这个接口的getObject()方法。
DefaultSingletonBeanRegistry.java
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 new BeanCreationNotAllowedException(beanName,
"Singleton bean creation not allowed while singletons of this factory are in destruction " +
"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
}
if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
// 加载单例前，记录正在加载的状态到缓存中 this.singletonsCurrentlyInCreation.add(beanName) （可以对循环依赖进行检测）
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
// 调用参数传入的 ObjectFactory的 getObject（）方法实例化bean
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
catch (IllegalStateException ex) {
// Has the singleton object implicitly appeared in the meantime ->
// if yes, proceed with it since the exception indicates that state.
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
}
catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
// 加载单例后，从缓存中移除正在加载的状态 this.singletonsCurrentlyInCreation.remove(beanName)
afterSingletonCreation(beanName);
}
if (newSingleton) {
// 将结果记录到缓存，并删除加载bean过程中所记录的各种辅助状态
addSingleton(beanName, singletonObject);
}
}
// 返回单例对象
return singletonObject;
}
这个方法主要实现了：
- 首先判断这个bean是否已经被加载过了，没有被加载过才会继续；
- 在bean创建之前，先把这个bean正在创建的状态记录到 singletonsCurrentlyInCreation缓存中；（可以对循环依赖进行检测）
- 通过调用传入的ObjectFactory接口的实例参数 的getObject()方法进行实例化bean；
- 在这个bean创建完成之后，从singletonsCurrentlyInCreation缓存中移除正在创建的状态；（对应步骤2）
- 将创建之后的bean根据对应的beanName记录到 singletonObjects缓存中，并移除 singletonFactories和 earlySingletonObjects缓存中的记录；
这个方法中主要还是对单例bean创建前后做一些准备及处理工作（单例bean才需要处理这些），真正创建的bean的过程是调用的是传入参数singletonFactory的getBean()方法实现的，这个方法的实现是我们在lambda表达式中定义的：return createBean(beanName, mbd, args);。
因为所有scope类型的bean的创建最终都是调用的createBean()方法，所以放到后面一起探究。
4.6.2 prototype类型bean的创建
else if (mbd.isPrototype()) {
// 如果是 proto type，使用new 创建
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
// 检测当前bean是否是FactoryBean类型的bean，如果是则调用该bean对应的FactoryBean中的getObject()来真正获取bean
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
实现内容及步骤：
- 创建前记录一下创建状态：
protected void beforePrototypeCreation(String beanName) {
Object curVal = this.prototypesCurrentlyInCreation.get();
if (curVal == null) {
this.prototypesCurrentlyInCreation.set(beanName);
}
else if (curVal instanceof String) {
Set<String> beanNameSet = new HashSet<>(2);
beanNameSet.add((String) curVal);
beanNameSet.add(beanName);
this.prototypesCurrentlyInCreation.set(beanNameSet);
}
else {
Set<String> beanNameSet = (Set<String>) curVal;
beanNameSet.add(beanName);
}
}
主要就是把这个正在创建的prototype类型的bean的beanName存到ThreadLocal类型的prototypesCurrentlyInCreation变量中去。
（其实这里我认为直接定义成ThreadLocal<Set>就行了，就不用再去对String和Set两种类型进行转换了…想实现的目的就是如果只有一个prototype类型的bean在创建就存成String类型的，如果有多个就存成Set类型的）
- 记录下创建状态之后，也是调用createBean()方法进行创建，所以同样放到后面一起探究。
- 在创建完成后，把前面记录的创建状态移除：
protected void afterPrototypeCreation(String beanName) {
Object curVal = this.prototypesCurrentlyInCreation.get();
if (curVal instanceof String) {
this.prototypesCurrentlyInCreation.remove();
}
else if (curVal instanceof Set) {
Set<String> beanNameSet = (Set<String>) curVal;
beanNameSet.remove(beanName);
if (beanNameSet.isEmpty()) {
this.prototypesCurrentlyInCreation.remove();
}
}
}
4.6.3 其他类型bean的创建
else {
// 指定的scope上实例化bean
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是否是FactoryBean类型的bean，如果是则调用该bean对应的FactoryBean中的getObject()来真正获取bean
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);
}
}
实现内容及步骤：
- 首先是获取指定的scope的名称，并且判断这个名称对应的scope有没有被注册；
- 调用Scope的get()方法，使用lambda表达式生成了一个ObjectFactory接口的实例作为参数传入，并且实现了这个接口的getObject()方法；在实现中：
- 调用了beforePrototypeCreation()方法；
- 定义了createBean()方法；
- 调用了afterPrototypeCreation()方法；
在这里也是调用了 记录和清除prototype类型bean的创建状态 的方法，bean的创建也是调用的createBean()方法。
到这里，不同的scope进行bean的创建的流程已经理清了，所以就来看看他们共同需要最终调用的createBean()方法。
4.7 准备创建bean（createBean）
BeanDefinition.java
protected abstract Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException;
AbstractAutowireCapableBeanFactory.java
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
if (logger.isTraceEnabled()) {
logger.trace("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
// Make sure bean class is actually resolved at this point, and
// clone the bean definition in case of a dynamically resolved Class
// which cannot be stored in the shared merged bean definition.
// 根据设置的class属性或者根据className 来解析Class
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
// 验证及准备覆盖的方法（对override属性进行标记及验证）
try {
mbdToUse.prepareMethodOverrides();
} catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
// 给 BeanPostProcessors一个机会来返回代理来替代真正的实例（在InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation()改变了bean，直接返回）
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
// 如果前置处理后返回的结果不为空，忽略后续的bean的创建，直接返回结果（AOP的功能就是基于这里判断的）
if (bean != null) {
return bean;
}
} catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
try {
// 没有改变bean，进程常规bean的创建
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("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);
}
}
在这个createBean()方法里，其实也没有直接去创建bean，而是做了一些创建bean的准备工作。
这个方法中主要实现了：
- 根据RootBeanDefinition中的beanClass属性或者根据beanName来解析要创建的bean的Class；
这里最终走到：
public Class<?> resolveBeanClass(@Nullable ClassLoader classLoader) throws ClassNotFoundException {
String className = getBeanClassName();
if (className == null) {
return null;
}
Class<?> resolvedClass = ClassUtils.forName(className, classLoader);
this.beanClass = resolvedClass;
return resolvedClass;
}
根据className和传入的类加载器classLoader，使用反射来创建出类对象Class；
2. 对override属性进行标记和验证（Spring配置中的lookup-method和replace-method属性的加载是存放到了BeanDefinition中的methodOverrides属性中了）；
3. 应用实例化前的后处理器，解析指定bean是否有实例化前的快捷方式；
4. 真正创建bean（doCreateBean(beanName, mbdToUse, args)；这里可以总结出一个规律，Spring中最后真正干活的代码，其实很多是以do开头的）；
4.7.1 处理override属性
AbstractBeanDefinition.java
public void prepareMethodOverrides() throws BeanDefinitionValidationException {
// Check that lookup methods exist and determine their overloaded status.
if (hasMethodOverrides()) {
getMethodOverrides().getOverrides().forEach(this::prepareMethodOverride);
}
}
protected void prepareMethodOverride(MethodOverride mo) throws BeanDefinitionValidationException {
// 获取对应类中对应方法名的个数
int count = ClassUtils.getMethodCountForName(getBeanClass(), mo.getMethodName());
if (count == 0) {
throw new BeanDefinitionValidationException(
"Invalid method override: no method with name '" + mo.getMethodName() +
"' on class [" + getBeanClassName() + "]");
}
else if (count == 1) {
// 标记MethodOverride 暂未被覆盖，避免参数类型检查的开销
// Mark override as not overloaded, to avoid the overhead of arg type checking.
mo.setOverloaded(false);
}
}
在这篇Spring——2. 默认标签的解析文章的 1.1.4和 1.1.5章节中，我们讲述了lookup-method和replace-method标签的使用和解析。
在解析过程中我们可以看到分别创建了 LookupOverride 和 ReplaceOverride 的实例，并且添加到了BeanDefinition的 methodOverride属性中，也就是将这个两个属性相关的配置统一存放在了methodOverride属性里。
这两个功能实现的原理是在bean实例化的时候，如果检测到存在methodOverride属性，会动态地为当前bean生成代理并使用拦截器为bean做增强处理（具体逻辑在bean实例化部分解析）。
如果一个类中存在若干个重载方法，那么在函数调用及增强的时候需要根据参数类型去进行匹配，来最终确认当前调用的是哪个方法。
所以prepareMethodOverrides()方法在这里的作用是：
根据方法名获取对应类中匹配的方法个数，如果方法不存在直接抛出异常；如果这个类中匹配的方法只有一个，那么就设置该方法没有被重载，在后续调用中也就可以不用匹配，直接找到使用的方法。
4.7.2 后处理器的应用
AbstractAutowireCapableBeanFactory.java
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
// 给 BeanPostProcessors一个机会来返回代理来替代真正的实例（在InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation()改变了bean，直接返回）
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
// 如果前置处理后返回的结果不为空，忽略后续的bean的创建，直接返回结果（AOP的功能就是基于这里判断的）
if (bean != null) {
return bean;
}
} catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
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 实例化前 调用后置处理器的方法进行处理
// 如果重写了 InstantiationAwareBeanPostProcessor中的 postProcessBeforeInstantiation()，
// 并在postProcessBeforeInstantiation中改变了bean，直接返回就可以了；
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
// bean 实例化后 调用后置处理器的方法进行处理
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
resolveBeforeInstantiation()方法中：
- 使用了beforeInstantiationResolved字段判断这个bean的实例化后处理器程序是否启动，如果没有启动则继续；
- 当这个bean的beanClass已经被解析了才继续；
- 分别调用两个方法；
4.7.2.1 实例化前的后处理器应用
bean实例化前的后处理器调用，也就是将 AbstractBeanDefinition转换为 BeanWrapper前的处理；给子类一个修改BeanDefinition的机会，当程序经过这个方法后，bean可能已经不是我们认为的bean了，而可能成为了一个经过处理的bean：可能是通过cglib生成的，也可能是通过其他技术生成的（后面会介绍）。
在这里我们只需要知道在bean的实例化前会调用后处理器方法进行处理：
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;
}
4.7.2.2 实例化后的后处理器应用
在上面我们了解到了 Spring中的bean在初始化后会尽可能将bean的后处理器postProcessAfterInitialization()方法应用到这个bean中。
在这里如果返回的bean不为null，则不会再经历bean的创建过程，所以只有在这里才能应用这个bean的后处理器postProcessAfterInitialization()方法：
if (bean != null) {
// bean 实例化后 调用后置处理器的方法进行处理
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
Object current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
4.8 真正创建bean（doCreateBean）
为了避免文章太长，所以把真正创建bean及后续的解析放到下一篇文章中。敬请期待~
133
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
