一，Spring启动流程概述
Spring的IoC容器在实现控制反转和依赖注入的过程中，可以划分为两个阶段：
-
容器启动阶段
-
Bean实例化阶段
容器初始化
-
加载配置
-
分析配置信息
-
将Bean信息装配到BeanDefinition
-
将Bean信息注册到相应的BeanDefinitionRegistry
-
其他后续处理
容器实例化
-
根据策略实例化对象
-
装配依赖
-
Bean初始化前处理
-
对象初始化
-
对象其他处理
-
注册回调接口
二，Spring启动流程详解
注册后处理器
// 实例化并且注册所有BeanPostProcessors
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}
BeanPostProcessor
BeanPostProcessor是Spring的Bean工厂中一个非常重要的接口，允许Spring框架在新创建Bean实例时对其进行定制化修改。比如我们对Bean内容进行修改、创建代理对象等等。也就是说，Spring IoC容器实例化了一个Bean，而后BeanPostProcessor开始完成它们的工作。
BeanPostProcessor接口定义了回调方法，可以实现这些方法，以提供自己的实例化逻辑（或覆盖容器的默认值），依赖关系解析逻辑等。如果您想在Spring容器完成Bean的实例化、配置和初始化之后实现一些自定义逻辑，则可以插入一个或多个自定义BeanPostProcessor实现。
public interface BeanPostProcessor {
// Bean初始化之前调用
Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
// Bean初始化之后调用
Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
}
在实际使用中可以配置多个BeanPostProcessor实例，并且可以通过设置Order属性来控制这些BeanPostProcessor的执行顺序。只有当BeanPostProcessor实现Ordered接口时，才可以设置此属性。
InstantiationAwareBeanPostProcessor
InstantiationAwareBeanPostProcessor实际上继承了BeanPostProcessor接口，主要作用于实例化阶段的前后。
使用方式
public class CarBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName)
throws BeansException {
System.out.println("===> 1.调用postProcessBeforeInitialization()");
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName)
throws BeansException {
System.out.println("===> 1.调用postProcessAfterInitialization()");
return bean;
}
}
public class CarInstantiationBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName)
throws BeansException {
System.out.println("===> 2.调用postProcessBeforeInstantiation()");
return null;
}
@Override
public boolean postProcessAfterInstantiation(Object bean, String beanName)
throws BeansException {
System.out.println("===> 2.调用postProcessAfterInstantiation()");
return false;
}
@Override
public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)
throws BeansException {
System.out.println("===> 2.调用postProcessPropertyValues()");
return pvs;
}
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName)
throws BeansException {
System.out.println("===> 2.调用postProcessBeforeInitialization()");
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName)
throws BeansException {
System.out.println("===> 2.调用postProcessAfterInitialization()");
return bean;
}
}
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 http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="car" class="xxx.xxx.processor.Car">
<property name="name" value="benz"/>
</bean>
<bean id="testPostProcessor"
class="xxx.xxx.processor.CarBeanPostProcessor"/>
<bean id="testInstantiationBeanPostProcessor"
class="xxx.xxx.processor.CarInstantiationBeanPostProcessor"/>
</beans>源码解读
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
// 从BeanFactory中获取所有BeanPostProcessor的名字
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// 注册BeanPostProcessorChecker，以便在BeanPostProcessor实例化期间创建一个Bean时记录一条info消息
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// 对BeanPostProcessor按照实现的接口PriorityOrdered，Ordered进行分类并存储
// 保存实现PriorityOrdered接口的BeanPostProcessor
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();
// 保存实现Ordered接口的BeanPostProcessor
List<String> orderedPostProcessorNames = new ArrayList<String>();
// 保存没有实现PriorityOrdered和Ordered接口的BeanPostProcessor
List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
// 遍历postProcessorNames所有的BeanPostProcessor
for (String ppName : postProcessorNames) {
// 如果调用适配函数，发现该类实现了PriorityOrdered接口
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 从容器中取出BeanPostProcessor
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
// 保存到List集合中
priorityOrderedPostProcessors.add(pp);
// 如果这个类实现了MergedBeanDefinitionPostProcessor接口
if (pp instanceof MergedBeanDefinitionPostProcessor接口) {
internalPostProcessors.add(pp);
}
}
// 如果调用适配函数，发现该类实现了Ordered接口
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
// 既没有实现PriorityOrdered接口也没有实现Ordered接口
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// 首先，处理实现PriorityOrdered接口的BeanPostProcessor
// 对BeanPostProcessor进行排序
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 注册BeanPostProcessor
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// 其次，处理实现Ordered接口的BeanPostProcessor
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
for (String ppName : orderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
// 对BeanPostProcessor进行排序
sortPostProcessors(orderedPostProcessors, beanFactory);
// 注册BeanPostProcessor
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
// 处理其他普通的BeanPostProcessor
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
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);
// 注册BeanPostProcessor
registerBeanPostProcessors(beanFactory, internalPostProcessors);
// 重新注册后BeanPostProcessor，用于内部Bean检测为ApplicationListener，//将其移至处理器链的末尾（用于拾取代理等）
// Re-register post-processor for detecting inner beans as ApplicationListeners,
// moving it to the end of the processor chain (for picking up proxies etc).
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
Bean的类型
Spring中有两种类型的Bean：
-
普通Bean
-
工厂Bean（即：FactoryBean）
FactoryBean
普通Bean可以直接使用Xml进行配置，但如果你的Bean拥有复杂的初始化代码（如涉及到很多其他的Bean），使用XML配置方式比较困难，这时就可以使用FactoryBean，并在该类中编写复杂的初始化，然后将自定义FactoryBean插入容器。
FactoryBean接口提供了三种方法：
T getObject() throws Exception; // 返回此工厂创建的对象实例
Class<?> getObjectType(); // 返回的对象类型，如果对象类型未知则返回null
boolean isSingleton(); // 如果FactoryBean返回单例返回true，否则返回false。这个接口使你可以提供一个复杂的逻辑来生成Bean。它本质是一个Bean，但这个Bean不是用来注入到其它地方像Service、Dao一样使用的，它是用来生成其它Bean使用的。
Spring框架中的许多地方都使用了FactoryBean概念和接口，Spring附带了50多个FactoryBean接口实现。很多开源项目在集成Spring 时也都使用到FactoryBean，比如 MyBatis3 提供 mybatis-spring项目中的 org.mybatis.spring.SqlSessionFactoryBean。
FactoryBean使用示例：
PersonFactoryBean
public class PersonFactoryBean implements FactoryBean<Person> {
private String jsonInfo;
@Override
public Person getObject() throws Exception {
ObjectMapper om = new ObjectMapper();
return om.readValue(jsonInfo, Person.class);
}
@Override
public Class<?> getObjectType() {
return Person.class;
}
@Override
public boolean isSingleton() {
return false;
}
public String getJsonInfo() {
return jsonInfo;
}
public void setJsonInfo(String jsonInfo) {
this.jsonInfo = jsonInfo;
}
}
beans.xml
<bean id="person" class="ai.yunxi.PersonFactoryBean">
<property name="jsonInfo"
value="{ "id": 1,"name": "abc",
"age": 27, "salary": 5555.0,
"address": "beijing"}"/>
</bean>
Bean生命周期
Spring Bean的生命周期只有四个阶段：
-
实例化（Instantiation）：调用构造函数
-
属性赋值（Populate）：设置依赖注入
-
初始化（Initialization）：调用init方法
-
销毁（Destruction）：调用destory方法
生命周期也可以理解为四个等级。每个等级中都用有相应的接口，实现其中某个接口或者将实现类注入到Spring容器，容器就会在相应的时机调用其方法。
-
工厂级处理器接口
-
容器级生命周期接口
-
Bean级生命周期接口
-
Bean本身方法
| 接口 | 分类 | 描述 |
| BeanFactoryPostProcessor | 工厂后处理器接口 | 容器创建完毕，装配Bean源后立即调用 |
| InstantiationAwareBeanPostProcessor | 容器后处理器接口 | 分别在调用构造之前，注入属性之前，实例化完成时调用 |
| BeanPostProcessor | 容器后处理器接口 | 分别在Bean的初始化方法调用前后执行 |
| BeanNameAware | Bean级后置处理器接口 | 注入属性后调用 |
| BeanFactoryAware | Bean级后置处理器接口 | 注入属性后调用 |
| InitializingBean | Bean级后置处理器接口 | 在类本身的初始化方法之前调用其方法（本身也是初始化方法） |
| DisposableBean | Bean级后置处理器接口 | 在类本身的销毁方法执行之前调用其方法（本身也是销毁方法） |
| init方法 | Bean本身方法 | 在注入属性之后调用初始化方法 |
| destroy方法 | Bean本身方法 | 在关闭容器的时候进行销毁 |
Spring中Bean初始化/销毁的三种方法
-
通过实现 InitializingBean/DisposableBean 接口来定制初始化之后/销毁之前的操作方法；
-
在<bean> 元素上添加 init-method/destroy-method来指定初始化之后 /销毁之前调用的操作方法；
-
在方法上加上@PostConstruct 或@PreDestroy注解来指定该方法是在初始化之后还是销毁之前调用。
public class Person implements InitializingBean {
private int id;
private String name;
private int age;
private BigDecimal salary;
private String address;
public Person() {
System.out.println("Person构造函数");
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public BigDecimal getSalary() {
return salary;
}
public void setSalary(BigDecimal salary) {
this.salary = salary;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@PostConstruct
public void postConstruct(){
System.out.println("调用PostConstruct");
}
public void initMethod(){
System.out.println("调用initMethod");
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("调用afterPropertiesSet()");
}
}
Spring Bean的生命周期：
-
Spring对Bean进行实例化，调用Bean的构造参数
-
设置对象属性，调用Bean的set方法，将属性注入到bean的属性中
-
检查Bean是否实现BeanNameAware、BeanFactoryAware、ApplicationContextAware接口，如果实现了这几个接口Spring会分别调用其中实现的方法。
-
如果Bean是否实现BeanPostProcessor接口，Spring会在初始化方法的前后分别调用postProcessBeforeInitialization和postProcessAfterInitialization方法
-
如果Bean是否实现InitalizingBean接口，将调用afterPropertiesSet()方法
-
如果Bean声明初始化方法，也会被调用
-
使用Bean。Bean将会一直保留在应用的上下文中，直到该应用上下文被销毁。
-
检查Bean是否实现DisposableBean接口，Spring会调用它们的destory方法
-
如果Bean声明销毁方法，该方法也会被调用
Bean获取
org.springframework.beans.factory.support.AbstractBeanFactory
protected <T> T doGetBean(final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException {
// 将别名解析为规范Bean名称，如果是FactoryBean还需删除前缀
final String beanName = transformedBeanName(name);
Object bean;
// 检查缓存是否有对象
// 循环依赖解决的关键入口
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
if (logger.isDebugEnabled()) {
// 该Bean是否正在创建中
if (isSingletonCurrentlyInCreation(beanName)) {
// logger.debug(.....) 打印日志（略）
}
else {
// logger.debug(.....) 打印日志（略）
}
}
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// 如果已经创建了Bean实例则抛出异常，因为可能在循环引用中
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 检查工厂中是否存在Bean定义
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
String nameToLookup = originalBeanName(name);
if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
// 合并BeanDefinition。合并主要是因为BeanDefinition可能存在parent BeanDefinition
// 所以要依据合并后的BeanDefinition来实例化和初始化
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 检查合并后的BeanDefinition。主要是检查是否是abstract
checkMergedBeanDefinition(mbd, beanName, args);
// 获取依赖信息
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
// 确保当前Bean依赖的Bean初始化
for (String dep : dependsOn) {
if (isDependent(beanName, dep)) {
// throw异常（略）
}
try {
// 注册依赖Bean
registerDependentBean(dep, beanName);
// 获取依赖Bean
getBean(dep);
} catch (NoSuchBeanDefinitionException ex) {
// throw异常（略）
}
}
}
// 创建Bean实例
// 如果是单例对象
if (mbd.isSingleton()) {
// 使用匿名对象工厂来创建Bean
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
try {
// 创建Bean
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// 从单例缓存中显式删除实例。在创建过程可能将它提前引用缓存中，以方便循环引用解析。
// 还要删除所有对该Bean临时引用的Bean
destroySingleton(beanName);
throw ex;
}
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// 如果是Prototype对象
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
// 记录到当前创建的原型对象缓存
beforePrototypeCreation(beanName);
// 创建Bean
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
// 创建完毕，从当前创建的原型对象缓存移除
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
// 既不是Singleton也不是Prototype，可能是自定义scope的对象
else {
// 获取Scope名称
String scopeName = mbd.getScope();
// 根据名称解析出对应的Scope对象
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, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
// 记录到当前创建的原型对象缓存
beforePrototypeCreation(beanName);
try {
// 创建Bean
return createBean(beanName, mbd, args);
}
finally {
// 创建完毕，从当前创建的原型对象缓存移除
afterPrototypeCreation(beanName);
}
}
});
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
// throw异常（略）
}
}
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// 所需的类型与实际Bean实例类型进行匹配转换
if (requiredType != null && bean != null && !requiredType.isInstance(bean)) {
try {
// 转换成需要的类型
return getTypeConverter().convertIfNecessary(bean, requiredType);
}
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;
}org.springframework.beans.factory.support.DefaultSingletonBeanRegistry
// 根据Bean注册名称返回单例对象，检查已经实例化的单例，并允许提前曝光当前创建的单例对象（解析循环引用）
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
// 根据Bean注册名称返回单例对象。如果尚未注册，则创建并注册一个新的
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "'beanName' must not be null");
// 注意synchronized
synchronized (this.singletonObjects) {
// 根据Bean名称从单例缓存中获取实例
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
if (this.singletonsCurrentlyInDestruction) {
// 抛出异常。原因：工厂单例销毁时不允许创建Bean实例
// throw new BeanCreationNotAllowedException(.......);
}
if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
// 创建前检查，主要检查两项。如果不成功抛出异常
// 1. 正在创建缓存inCreationCheckExclusions中不包含该Bean
// 2. 待创建缓存singletonsCurrentlyInCreation中可以添加该Bean
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<Exception>();
}
try {
// 从工厂中获取单例对象
singletonObject = singletonFactory.getObject();
// 创建成功则为true
newSingleton = true;
}
catch (IllegalStateException ex) {
// 如果出现异常，则从单例缓存中获取
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;
}
// 创建后检查，仍然是两项检查：
// 1. 正在创建缓存inCreationCheckExclusions中不包含该Bean
// 2. 待创建缓存singletonsCurrentlyInCreation中可以移除该Bean
afterSingletonCreation(beanName);
}
// 创建成功同步几个重要的缓存
if (newSingleton) {
// 同步缓存：
// 1. singletonObjects中添加单例对象
// 2. singletonFactories移除该Bean
// 3. earlySingletonObjects移除该Bean
// 4. registeredSingletons添加该BeanName
addSingleton(beanName, singletonObject);
}
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
}
Bean创建
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory
// 创建实例，填充实例，应用后处理器
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
if (logger.isDebugEnabled()) {
logger.debug("Creating instance of bean '" + beanName + "'");
}
// 合并的BeanDefinition
RootBeanDefinition mbdToUse = mbd;
// 确保解析并加载Bean的Class
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
// 如果解析的类在合并的BeanDefinition不存在，则克隆Bean定义
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
// 设置Bean的Class
mbdToUse.setBeanClass(resolvedClass);
}
try {
// Spring将lookup-method和replace-method统称为override method，这里主要就是处理这2个函数
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// 该函数的作用是给 BeanPostProcessors 后置处理器返回一个代理对象的机会
// 这里是实现AOP处理的重要地方
// AOP是通过BeanPostProcessor机制实现的，而接口InstantiationAwareBeanPostProcessor是实现代理的重点
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);
}
// 如果后处理器返回的Bean为空，则调用doCreateBean执行创建Bean的过程
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
// 实际创建指定的Bean
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
throws BeanCreationException {
// BeanWrapper 是一个用于包装Bean实例的接口，通过这个接口可以设置/获取Bean实例的属性
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
// 从未完成的实例缓存中获取
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
// 如果缓存中不存在，则执行创建（三种方式）
if (instanceWrapper == null) {
// 创建 bean 实例，并将实例封装在BeanWrapper中返回。createBeanInstance中包含三种创建方式：
// 1.工厂方法创建Bean实例
// 2.通过构造方法自动注入（autowire by constructor）的方式创建
// 3.通过无参构造方法方法创建
// 如果Bean配置了lookup-method和replace-method，则使用CGLIB增强Bean实例
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// 获取包装的Bean实例
final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
// 获取包装的Class
Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
// 待解析的目标类型
mbd.resolvedTargetType = beanType;
// 允许BeanPostProcessor修改合并的BeanDefinition。这里主要是合并Bean的定义信息
// Autowired等注解就是在这一步完成预解析，并且将注解需要的信息放入缓存
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
// 应用MergedBeanDefinitionPostProcessor后处理器
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// earlySingletonExposure 是一个重要的变量，用于表示是否提前暴露单例Bean，用于解决循环依赖。
// earlySingletonExposure 由三个条件组成：是否是单例、是否允许循环引用、当前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初始化完成前添加ObjectFactory到singletonFactories缓存。
addSingletonFactory(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
// 此回调使后处理器有机会提前曝光Bean（即在目标Bean完全初始化之前）。通常是为了解决循环依赖
return getEarlyBeanReference(beanName, mbd, bean);
}
});
}
// 下面是初始化Bean的流程
Object exposedObject = bean;
try {
// 使用BeanDefinintion的属性值填充Bean实例
populateBean(beanName, mbd, instanceWrapper);
if (exposedObject != null) {
// 初始化Bean
// 如果Bean实现了BeanNameAware、BeanClassLoaderAware、BeanFactoryAware接口则设置
// 应用BeanPostProcessor后处理器
// 执行自定义init-method方法
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) {
// 从提前曝光的Bean缓存中查询，目的是验证是否存在循环依赖
// 如果存在循环依赖，在这里earlySingletonReference不为空
Object earlySingletonReference = getSingleton(beanName, false);
// 在检测到循环依赖的情况下，earlySingletonReference不会为null
if (earlySingletonReference != null) {
// 如果exposedObject没有在initializeBean初始化方法中被改变，说明没有被增强
// 初始化之后的Bean等于原始的bean说明不是proxy对象
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
// 确定是否已经给指定的beanName称注册了依赖
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
// Bean创建后其依赖的Bean一定也是已经创建的
// 如果actualDependentBeans不为空，则表示依赖的Bean并没有被创建完，即存在循环依赖
if (!actualDependentBeans.isEmpty()) {
// 抛出异常
// throw new BeanCurrentlyInCreationException(....)
}
}
} }
// Register bean as disposable.
// 如果Bean实现了Disposable，则注册该Bean为
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
// 创建Bean实例
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
// Make sure bean class is actually resolved at this point.
Class<?> beanClass = resolveBeanClass(mbd, beanName);
if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
// 抛出异常
// throw new BeanCreationException(.....);
}
// 如果工厂方法不为空
if (mbd.getFactoryMethodName() != null) {
// 使用工厂方法创建实例
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
// Shortcut when re-creating the same bean...
boolean resolved = false;
boolean autowireNecessary = false;
if (args == null) {
synchronized (mbd.constructorArgumentLock) {
if (mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
if (resolved) {
if (autowireNecessary) {
return autowireConstructor(beanName, mbd, null, null);
}
else {
return instantiateBean(beanName, mbd);
}
}
// Candidate constructors for autowiring?
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, ctors, args);
}
// 调用实例化策略接口来实例化Bean，这里使用无参构造
return instantiateBean(beanName, mbd);
}
// 实例化Bean
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
try {
Object beanInstance;
final BeanFactory parent = this;
if (System.getSecurityManager() != null) {
beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
return getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
}, getAccessControlContext());
}
else {
// InstantiationStrategy负责进行实例化
// SimpleInstantiationStrategy是一个简单的用于Bean实例化的类。如：由Bean类的默认构造函数、带参构造函数或者工厂方法等来实例化Bean。不支持方法注入。
// CglibSubclassingInstantiationStrategy如果方法需要被覆盖来实现“方法注入”，使用CGLIB动态生成子类
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
// 实例化后的Bean使用BeanWrapper包装。BeanWrapper可以设置以及访问被包装对象的属性值
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
// 初始化BeanWrapper包装包含了2个工作：设置ConversionService和CustomerEditor
initBeanWrapper(bw);
return bw;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
}
}
// 初始化Bean
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
invokeAwareMethods(beanName, bean);
return null;
}
}, getAccessControlContext());
}
else {
// 设置Aware
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 调用初始化前处理器
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
// 执行自定义初始化方法
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()) {
// 调用初始化后处理器
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
解决循环引用
// 注册名称返回单例对象，检查已经实例化的单例，并允许提前引用当前创建的单例对象（解析循环引用）
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 从单例缓存中根据Bean名字获取单例对象
Object singletonObject = this.singletonObjects.get(beanName);
// 如果单例对象为空，并且单例对象正在创建中
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
// 注意synchronized关键字
synchronized (this.singletonObjects) {
// 从earlySingletonObjects缓存中通过Bean名称获取对象
singletonObject = this.earlySingletonObjects.get(beanName);
// 如果单例对象仍然为空，并且允许提前引用为true
// allowEarlyReference参数含义：是否允许提前曝光
if (singletonObject == null && allowEarlyReference) {
// 从singletonFactories中根据Bean名称获取对应的单例工厂
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
// 通过工厂创建单例对象（此时还未进行依赖注入）
singletonObject = singletonFactory.getObject();
// 把创建的单例对象放到提前引用的缓存
this.earlySingletonObjects.put(beanName, singletonObject);
// 移除该单例对象的工厂
this.singletonFactories.remove(beanName);
}
}
}
}
}
代码中出现的缓存：
-
singletonObjects：初始化完成的单例对象缓存；
-
earlySingletonObjects：提前曝光的单例对象缓存；
-
singletonFactories：单例Bean的工厂函数对象缓存；
-
singletonsCurrentlyInCreation：即将创建的单例集合
扫一扫
421
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
