Spring源码浅析——bean创建流程
上一篇文章大致总结了一下容器刷新的过程，对于容器初始化的提炼出了12个关键的函数，但归根结底在讲容器已经准备好了的事，本文着重讲如何在容器中创建及注入bean。本文共分四部分。第一部分下拆关键概念区分和Bean生命周期概括两部分，这部分区分BeanFactory和FactoryBean可以重点关注下。第二部分结合Bean全流程让你对BeanDefinition有一个宏观的概念。第三部分进入源码分析，如果只想看宏观概念，可以不读代码块，只看外部说明。还要说明一下，写bean生命周期的文章很多，但是就比较吓人的是，动不动就把源码一大推拉出来，一痛把人家源码作者的英文注解翻译成中文，再有细心的作者甚至会不惜笔墨，看到主流程中有些函数内部再次调用的外部方法功能也蛮核心的，所以笔不歇力继续奋笔疾书，把这些主流程的调用，调用里的调用，通通拿出源码注释来翻译一遍。我没有觉得这种方式不好，只是觉得诺大个bean生命周期涉及到的代码行数成千上万，单纯把代码提出来讲一讲，如果没有深入的理解和科学的复习，我觉得过目之后莞尔也成过眼烟云，没有太大意义。今天本文试图从另一个视角来讲解这个bean的生命周期。当然贴大段代码是知其然知其所以然所必须的，所以我也贴，看不看随你，哈哈~
第一部分、Bean的生命周期
1、关键概念区分
要说Bean的生命周期，首先得清楚的给下面一个问题答案？为什么要Bean，而不是其他的什么？
要说bean就得追根溯源，为什么要处理Bean这么个东西，我们知道它出现在Ioc Container容器创建完毕之后，你系统依赖的扩展组件，用户自定义的扩展组件，这些东西的装配得需要一个媒介，谁能来当这个媒介，你可以给它取名Aean，Cean…等等，但是最终Spring Boot的开发者给它取名为Bean。Bean既然不是单一功能的组件嵌入到Ioc Container架构出的系统内，那必然还需要有个对它进行统一管理的模块存在，BeanFactory应运而生，但它完全不同于FactoryBean，要注意区分。BeanFactory是比ApplicationContext还要底层的支撑bean实现逻辑的核心，如果我们把BeanFactory比做我们人体骨骼架构的话，那么ApplicationContext就可以看成是填充进来的肉身，包括五脏六腹、五官大脑。通常会把BeanFactory划分到底层容器一类，因为它更抽象。而ApplicationContext会被划分成高级容器一类，因为它实际是干活的，帮你实现了切实可用的各种类及函数，如果拿程序框架和CMS系统来做比的话，BeanFactory就是程序框架，ApplicationContext就是CMS系统，通常CMS系统可以达到开箱既用的程度，你几乎不需要做什么事情，系统就正常跑起来了，而BeanFactory有更好的灵活性，当然使用起来的学习曲线也更陡。
再说另一个概念FactoryBean。
为什么要用Factory Bean?因为简单，甚至你都不需要写任何自定义的Factory Beans，因为它们是框架专属的，同时也注定了它们无法在Spring IoC Container之外被使用。
举几个例子：
- 当从
JDNI中查找对象时(比如说data source)，你可以直接用JndiObjectFactoryBean - 当使用经典
Spring AOP为bean创建代理时，你可以直接使用ProxyFactoryBean - 当在
IoC Container中创建Hibernate session factory时，你可以直接使用LocalSessionFactoryBean
Factory Bean是什么？它是在Ioc Container内部作为工厂，服务于创建其他bean的bean。概念上来说，它与工厂方法是极其相似的，不同点在于在bean初始化过程中，它是一个Spring专属的Bean，能够被Spring IoC Container识别，同时容器也能用来初始化其他的bean。
如何使用FactoryBean来创建其他bean？ 这里有两种方式：
1.用你创建的bean class去implement FactoryBean Interface
2.直接扩展AbstractFactoryBean类
EmployeeFactoryBean.java
public class EmployeeFactoryBean extends AbstractFactoryBean<object>{
@Override
protected Object createInstance() throws Exception{
//代码
}
@Override
public Class<EmployeeDTO> getObjectType(){
return EmployeeDTO.class;
}
}
这种方式，要注意覆写createInstance()方法创建目标实例和要在getObjectType()方法中指定返回目标的bean类型这两个要点，缺一不可。
FactorBean 举例
下面的例子中，我将创建一个factory bean用于初始化不同的Employee对象，例如manager,director等等，带有一些预先填充好的属性。
定义的EmployeeDTO类如下：
EmployeeDTO.java
package com.howtodoinjava.demo.model;
public class EmployeeDTO{
private Integer id;
private String firstName;
private String lastName;
private String designation;
//Setters and Getters此处被隐藏掉
@Override
public String toString(){
return "Employee [id=" + id + ", firstName=" + firstName + ", lastName=" + lastName + ", type=" + designation + "]";
}
}
EmployeeFactoryBean上面我们已经示范了简单的demo,此处我们让该类扩展AbstractFactoryBean类，同时实现它的createInstance()方法和getObjectType()方法。
EmployeeFactoryBean.java
import org.springframework.beans.factory.config.AbstractFactoryBean;
import com.howtodoinjava.demo.model.EmployeeDTO;
public class EmployeeFactoryBean extends AbstractFactoryBean<Object>{
private String designation;
public String getDesignation(){
return designation;
}
@Override
protected Object createInstance() throws Exception{
EmployeeDTO employee = new EmployeeDTO();
employee.setId(-1);
employee.setFirstName("dummy);
employee.setLastName("dummy);
employee.setDesignation(designation);
return emloyee;
}
//必须声明此就去，否则autowiring无法生效
@Override
public Class<EmloyeeDTO> getObjectType(){
return EmployeeDTO.class;
}
}
你可以在bean的上下文xml文件中定义不同类型的Employee。
applicationContext.xml
<bean id="manager" class="com.howtodoinjava.demo.factory.EmployeeFactoryBean">
<property name="designation" value="Manager" />
</bean>
<bean id="director" class="com.howtodoinjava.demo.factory.EmployeeFactoryBean">
<property name="designation" value="Director" />
</bean>
用下面的代码对以上beans进行校验：
TestSpringContext.java
public class TestSpringContext{
@SuppressWarning("resource")
public static void main(String[] args){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml);
EmployeeDTO manager = (EmployeeDTO) context.getBean("manager");
EmployeeDTO director = (EmployeeDTO) context.getBean("director);
System.out.println(director);
}
}
输出:
Employee [id=-1, firstName=dummy, lastName=dummy, type=Manager]
Employee [id=-1, firstName=dummy, lastName=dummy, type=Director]
可见EmployeeFactoryBean用一个相同的工厂方法创建了两个不同的employee object。
获取FactoryBean instance本身
可以通过在bean名称前面加"&"方式：
EmployeeFactoryBean factory = (EmployeeFactoryBean) context.getBean("&director);
System.out.println(factory.getDesignation());
System.out.println(factory.getObjectType());
System.out.println(factory.getObject());
输出:
Employee [id=-1, firstName=dummy, lastName=dummy, type=Manager]
Employee [id=-1, firstName=dummy, lastName=dummy, type=Director]
再对两个概念区别做下总结
我最开始时候也以为这两个是一个东西，后来慢慢才发现它们的差异。BeanFactory着重在factory这个单词上面，也就是说它是一个产生Bean的工厂，而FactoryBean是工厂Bean，直观点解释就是工厂类型的Bean，水平扩展，可能还有监控类型的Bean，有国际化类型的Bean。前者是spring在初始化过程中生成Bean对象底层接口定义，无论在spring初始化过程中使用BeanPostFactoryProcessor，或者BeanPostProcessor在spring初始化完成做bean的初始化，它都起着最终生成BeanDefinition的重要作用。而FactoryBean可以让你轻松的基于它定制符合自己需求的工厂类的Bean，所以这两个概念一定不能弄混。
2、Bean生命周期概括
Bean生命周期总流程
- 根据配置情况调用Bean构造方法或者工厂方法实例化
Bean - 设置属性值，使用的方式就是我们一直谈到的
Ioc思想中的DI - 如果
Bean实现了BeanNameAware接口，spring则会调用Bean的setBeanName方法传入当前Bean的id - 如果
Bean实现了BeanFactoryAware接口，spring则会调用setBeanFactory方法传入当前实例的引用。 - 如果
Bean实现了ApplicationContextAware接口，则spring调用setApplicationContext方法传入当前ApplicationContext实例的引用 BeanPostProcessor和Bean如果关联，则spring会调用该接口的预处理方法postProcessBeforeInitialization(Object bean, String beanName)对Bean进行加工操作，由于spring的AOC就在此处实现，切面上覆写逻辑或者夹带私货都依靠此处支持，可以把它看成是流程中的重中之重- 检查
bean对象是否实现了InitializingBean接口，如果实现，则调用afterPropertiesSet方法。或者检查配置文件中是否配置了init-method属性，如果配置了，则去调用init-method属性配置的方法。 - 调用
BeanPostProcessor后置处理方法，即postProcessAfterInitialization(Object bean, String beanName)。我们所熟知的 AOP 就是在这里将Advice逻辑织入到bean中的。 - 如果
BeanPostProcessor和Bean关联，则Spring将调用该接口初始化方法postProcessorAfterIntialization()。至此，bean已经可以被应用系统使用了。 bean对象处于就绪状态，可以使用了。- 应用上下文被销毁，调用注册的
Destruction相关方法。如果bean实现了DispostbleBean接口，Spring容器会调用destroy方法。如果在配置文件中配置了destroy属性，Spring容器则会调用destroy属性对应的方法。
第二部分、宏观上来理解Bean生命周期中BeanDefinition的意义
bean的配置文件是以几种方式存在的，它可以是xml文件，也可以是相应的properties文件，还可以是注解方式引入的对于bean属性的扩展，但是这些在bean初始化过程中，在内存中都是BeanDefinition的方式存在，但是BeanDefinition也要有一个读取的东西，就是BeanDefinitionReader。同时进入真正的bean初始化的环节，这些BeanDefinition散落在内存中的各种，如何知道去哪里进行取用呢？就涉及到了BeanDefinitionRegistry，它形成一个键值对的Map告诉你这些Definition去哪里找，还有DefinitionWrapper，还有Autowire注解，Annotation,BeanPostProcessor和BeanProcessor之间的区别是前者是在IoC Container初始化过程中已经开始预处理一些Bean相关的，而后者则是在IoC Container初始化完成以后，Bean流程初始化过程中发挥作用的。
public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {
String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;
String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;
int ROLE_APPLICATION = 0;
int ROLE_SUPPORT = 1;
int ROLE_INFRASTRUCTURE = 2;
void setParentName(String parentName);
String getParentName();
void setBeanClassName(String beanClassName);
String getBeanClassName();
void setScope(String scope);
String getScope();
void setLazyInit(boolean lazyInit);
boolean isLazyInit();
void setDependsOn(String... dependsOn);
String[] getDependsOn();
void setAutowireCandidate(boolean autowireCandidate);
boolean isAutowireCandidate();
void setPrimary(boolean primary);
boolean isPrimary();
void setFactoryBeanName(String factoryBeanName);
String getFactoryBeanName();
void setFactoryMethodName(String factoryMethodName);
String getFactoryMethodName();
ConstructorArgumentValues getConstructorArgumentValues();
MutablePropertyValues getPropertyValues();
boolean isSingleton();
boolean isPrototype();
boolean isAbstract();
int getRole();
String getDescription();
String getResourceDescription();
BeanDefinition getOriginatingBeanDefinition();
}
第三部分、源码分析
public interface BeanDefinition extends AttributeAccessor,BeanMetadataElement{
String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;
String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;
//比较不重要，直接跳过吧
int ROLE_APPLICATION=0;
int ROLE_SUPPORT=1;
int ROLE_INFRASTRUCTURE=2;
//设置父bean，这里涉及到bean继承，不是java继承。一句话就是：继承父bean的配置信息
void setParentName(String parentName);
String getParentName;
//设置bean的类名称，将来是要通过反射来生成实例类的
void setBeanClassName(String beanClassName);
String getParentName();
//设置bean的scope
void setScope(String scope);
String getScope();
//设置是否懒加载
void setLazyInit(boolean lazyInit);
boolean isLazyInit();
//设置bean依赖的所有bean，注意，这里的依赖不是指属性依赖，(如@Autowire标记的)，
//是depends-on=""属性设置的值。一句话就是：不直接依赖于其它bean，但是希望其它bean先初始化
void setDependsoN(String... dependsOn);
String[] getDependsOn();
//设置
}
Spring Framework Runtime运行结构
针对于Singleton Bean的理解，我们可以借助于spring底层构成中的另一个重要元素来帮忙，就是CGLIB，我们知道CGLIB往上再推一层是ASM，就是说CGLIB就是继承自ASM来实现自己功能方法的，而CGLIB的组成按大模块来说有：proxy、core、transform。而我们要看的元素就是存在于proxy中的class Enhancer，它的作用是什么呢？它就是不自己实际创建相关的使用类，而是用来创建代理类。这里不要理解错了，注意它既不创建直接供使用的类，也不是“白手套”，它是来创建“白手套”的，也就是它是用来创建代理类的，相应调用方再拿着这些代理类去搞事。在依赖注入的概念中，很多类的实例化并不是自己一个个声明，完成最终初始化，而是交给服务注册器等外部模块，就类似“呼叫中心“的东西，Enhancer就是做这个的，可见实力着实是牛逼了。那Enhancer有啥特点呢？它不是线程安全的，在调用表态方法create的时候内部会创建一个Enhancer实例，会指挥如何生成代理类。而singleton scope范围内singleton类的创建思路其实有点类似，它不会直接调用createBean方法创建bean实例，而是通过getSingleton(String,ObjectFactory)方法获取bean实例，在其内部继续调用ObjectFactory的getObject()方法创建bean，并在创建完成后将bean放入缓存中，全程与需要实例出的singleton调用方没有任何直接接触，可谓是白手套“本白”了。
//AbstractBeanFactory中的getBean方法
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
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;
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 + "'");
}
}
//这个部分要注意，此处就涉及我上面费力说的那个BeanFactory和FactoryBean之间的区别了，如果普通的bean就直接返回sharedInstance，但是如果是FactoryBean，名字再怎么像工厂方法，它还是个bean对象，所以就返回它创建的那个对象
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
String nameToLookup = originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
// Delegation to parent with explicit args.
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);
}
}
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
//此处说明一下，对于singleton类型的bean我们还没有创建，所以要创建，对于prototype类型的bean，它一直没有，所以就是要创建
try {
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
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);
}
}
}
// 如果是 singleton scope 的，创建 singleton 的实例
if (mbd.isSingleton()) {
//上面说的那一大段，就是在解释这里，让你理解这个“白手套”
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()) {
// prototype型的bean 一直没 建就完了
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
// 如果不是singleton、prototype类型bean的话，需要委托给相应的实现类来处理
else {
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;
}
}
// 类型检查，对返回，不对抛异常
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;
}
执行到这里，接近核心了，就是要实际创建bean实例了，所以createBean方法出场了，但是它也并不是最终创建bean实例的方法，而是doCreateBean。
//AbstractAutowireCapableBeanFactory
@Override
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;
//文章开始时候，缕总流程的时候已经说过，实际bean实例化的过程就是获取一个一个BeanDefinition，然后放到beanDefinitionRegister中使用方调用，这里就涉及到BeanDefinition能够产出，它内部也要做各种事情的，这就是其中的一个环节，确保BeanDefinition中的class被加载，很容易理解，如果BeanDefinition只是返回，里面啥与系统交互的东西都没有，你拿到这些BeanDefinition没有任何意义
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
//此处涉及到一个概念叫做方法覆写，前面说了调用getBean方法生成bean实例，singleton和prototype都是获取方法，区别只在于前者怎么调都返回最初那一个，而prototype每次都生成一个新bean实例。但有一种情况出来了，假如singleton类型bean中有一个prototype类型的成员变量，此时你该如何处理呢？按上面说的，singleton每次返回同一个，而prototype每次需要一个新的bean实例对象，岂不是套娃了，如何解决？答案就是标注@Lookup注解，此时Spring会采用CGLIB生成字节码的方式来生成一个子类，这个子类每次都会返回一个新的实例对象
``````````````````````````
``````````````````````````
``````````````````````````
@Component
public class NewsProvider {
@Autowired
News news; // prototype bean
@Lookup
public News getNews() {
return news;
}
}
``````````````````````````
``````````````````````````
``````````````````````````
//或者使用replace-method，也是基于CGLIB实现的，定义一个bean，再定义一个方法覆写类，让它继承自MethodReplacer接口：
``````````````````````````
``````````````````````````
``````````````````````````
public class Cow {
public void run() {
System.out.print("execute...");
}
}
public class CowReplacer implements MethodReplacer {
@Override
public Object reimplement(Object obj, Method method, Object[] args) throws Throwable {
System.out.print("execute replacer...");
return null;
}
}
``````````````````````````
``````````````````````````
``````````````````````````
配置文件中如下搞：
``````````````````````````
``````````````````````````
``````````````````````````
<bean id="cow" class="com.guruyu.demo.Cow" >
<replaced-method name="run" replacer="cowReplacer"/>
</bean>
<bean id="cowReplacer" class="com.guruyu.demo.CowReplacer" />
``````````````````````````
``````````````````````````
``````````````````````````
//这样调用Cow实例的run方法的时候打印”execute replacer“而不是”execute“
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
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.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}
我们看createBean中做了哪些事，实际是对是调用doCreateBean前的一些预处理，保证BeanDefinition中涉及的相关类都被正确引入，注释中说明的singleton和prototype只返回单一对象或每次需要返回新实例都依照既定规则正确被加载。该进入真正创建bean对象的doCreateBean方法了。
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// BeanWrapper是基础接口，用来包裹Bean实例，方便访问其属性
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
// 从缓存中取BeanWrapper并清除缓存记录
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// 创建bean实例，放到BeanWrapper中包裹返回
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// 野生bean 啥属性没有
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// BeanDefinition不只是一个，需要对它们进行合并处理实际走的就是applyMergedBeanDefinitionPostProcessor(mdb,beanType,beanName)，其内部主要通过MergedBeanDefinitionPostProcessor的postProcessorMergedBeanDefinition方法。更多可以参考AutowireAnnotationBeanPostProcessor相关逻辑
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;
}
}
// earlySingletonExposure 用于解决循环引用，earlySingletonExposure它的判断逻辑是先判是否单例，再判断是否循环依赖，再判断是否处在创建状态中
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
// 添加工厂对象到 singletonFactories 缓存中
addSingletonFactory(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
// 获取早期bean引用，如果有方法被AOP切面方法匹配到了，切面逻辑就会在该处执行，有点类似于很多程序中的hook，钩子
return getEarlyBeanReference(beanName, mbd, bean);
}
});
}
Object exposedObject = bean;
try {
// 填充，前面说了，野生时候啥属性没有，此处开始往里填充属性
populateBean(beanName, mbd, instanceWrapper);
// bean初始化剩余部分的工作
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.");
}
}
}
}
// 注销
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
这部分是bean实例创建的核心方法，注释部分已经做了说明。为了方便理解，扩展一下，还是文章中我最开始宏观说明的部分，BeanDefinition存在于内存中，而且伴随着程序的运行，肯定不只一个BeanDefinition，它要被读取，所以有了BeanDefinitionReader，散落在不同位置的BeanDefinition要能够高效找到，所以引入了BeanDefinitionRegistry。可见所有工作都围着生成出BeanDefinition团团转，而此处在解决的问题就是如何“持续输出BeanDefinition”？我们知道很多人喜欢讲“这里调用方很多，不如抽出个通用类”，这句话的含义描述了一个通用性高的类具备以下的特点：
- 调用频次高、调用点位多
- 有规律性的执行顺序，所以可以向上抽象
- 方便调用
而方便调用这里实际上是有隐性所指的，早期的程序文件，单一文件执行逻辑特别多，代码冗长，所以，为了更高效的编程，才会出现重构这一动作。假如一个程序由三个模块组成，有的模块完成网络通信，有的模块完成ORM。此时，拆的太细或者抽象度都太高，都对高效复用性有影响，所以开发者开始按照约定的维度来做这种抽象的工作。而这里BeanDefinition创建后没有直接返回，而是放进BeanWrapper中包裹之后再进行返回，明显也是一种高效和清晰开发原则的折衷。
而doCreateBean内部又涉及到哪些流程呢？总结如下：
1.如果是单例先要清除缓存，然后开始创建，防止并发情况下的同时创建
2.调用createBeanInstance方法实例化Bean，将BeanDefinition转化为BeanWrapper
3.调用applyMergedBeanDefinitionPostProcessors方法来做实例化Bean，之后利用AutowiredAnnotationBeanPostProcessor类型的后置处理器解析@Autowired注解
4.信赖处理
5.populate属性填充
6.initializeBean初始化
7.循环依赖检查
8.注册DisposableBean
创建实例
spring中应用了哪些设计模式
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// 确保已经加载了此 class
Class<?> beanClass = resolveBeanClass(mbd, beanName);
// 校验一下这个类的访问权限
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());
}
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return obtainFromSupplier(instanceSupplier, beanName);
}
// 如果工厂方法不为空，则通过工厂方法构建 bean 对象。工厂方式可以见附录
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
// 如果不是第一次创建，比如第二次创建 prototype bean。这种情况下，我们可以从第一次创建知道，
// 采用无参构造函数，还是构造函数依赖注入来完成实例化。
// 这里的 resolved 和 mbd.constructorArgumentsResolved 将会在 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) {
// 通过有参构造器构造 bean 对象
return autowireConstructor(beanName, mbd, null, null);
}
else {
// 通过无参构造器构造 bean 对象
return instantiateBean(beanName, mbd);
}
}
// 判断是否采用有参构造函数
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
// 通过有参构造器构造 bean 对象
return autowireConstructor(beanName, mbd, ctors, args);
}
// 通过无参构造器构造 bean 对象
return instantiateBean(beanName, mbd);
}
执行流程总结
- 检测类访问权限，没权限就抛异常
- 若工厂方法不为空，则通过工厂方法创建bean对象
- 看构造方法是否已经解析过，解析过直接调用instantiateBean快捷返回，就比如前面强调的prototype类型的bean，默认就是新建，啥也不用判断，直接走方法返回实例即可
- 判断属于哪种方式，有参无参的方式
- 如果无参就走instantiateBean方法，有参就走autowireConstructor方法
有参、无参构造器方式的实例创建
1.有参构造器方式
protected BeanWrapper autowireConstructor(
String beanName, RootBeanDefinition mbd, Constructor<?>[] ctors, Object[] explicitArgs) {
// 创建 ConstructorResolver 对象，并调用其 autowireConstructor 方法
return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
}
public BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd,
@Nullable Constructor<?>[] chosenCtors, @Nullable Object[] explicitArgs) {
// 创建 BeanWrapperImpl 对象
BeanWrapperImpl bw = new BeanWrapperImpl();
this.beanFactory.initBeanWrapper(bw);
Constructor<?> constructorToUse = null;
ArgumentsHolder argsHolderToUse = null;
Object[] argsToUse = null;
// 确定参数值列表（argsToUse）
if (explicitArgs != null) {
argsToUse = explicitArgs;
}
else {
Object[] argsToResolve = null;
synchronized (mbd.constructorArgumentLock) {
// 获取已解析的构造方法
constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod;
if (constructorToUse != null && mbd.constructorArgumentsResolved) {
// 获取已解析的构造方法参数列表
argsToUse = mbd.resolvedConstructorArguments;
if (argsToUse == null) {
// 若 argsToUse 为空，则获取未解析的构造方法参数列表
argsToResolve = mbd.preparedConstructorArguments;
}
}
}
if (argsToResolve != null) {
// 解析参数列表
argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve);
}
}
if (constructorToUse == null) {
boolean autowiring = (chosenCtors != null ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR);
ConstructorArgumentValues resolvedValues = null;
int minNrOfArgs;
if (explicitArgs != null) {
minNrOfArgs = explicitArgs.length;
}
else {
ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
resolvedValues = new ConstructorArgumentValues();
/*
* 确定构造方法参数数量，比如下面的配置：
* <bean id="persion" class="com.guruyu.demo.Person">
* <constructor-arg index="0" value="xiaoming"/>
* <constructor-arg index="1" value="1"/>
* <constructor-arg index="2" value="man"/>
* </bean>
*
* 此时 minNrOfArgs = maxIndex + 1 = 2 + 1 = 3，除了计算 minNrOfArgs，
* 下面的方法还会将 cargs 中的参数数据转存到 resolvedValues 中
*/
minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
}
// 获取构造方法列表
Constructor<?>[] candidates = chosenCtors;
if (candidates == null) {
Class<?> beanClass = mbd.getBeanClass();
try {
candidates = (mbd.isNonPublicAccessAllowed() ?
beanClass.getDeclaredConstructors() : beanClass.getConstructors());
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Resolution of declared constructors on bean Class [" + beanClass.getName() +
"] from ClassLoader [" + beanClass.getClassLoader() + "] failed", ex);
}
}
// 按照构造方法的访问权限级别和参数数量进行排序
AutowireUtils.sortConstructors(candidates);
int minTypeDiffWeight = Integer.MAX_VALUE;
Set<Constructor<?>> ambiguousConstructors = null;
LinkedList<UnsatisfiedDependencyException> causes = null;
for (Constructor<?> candidate : candidates) {
Class<?>[] paramTypes = candidate.getParameterTypes();
/*
* 下面的 if 分支的用途是：若匹配到到合适的构造方法了，提前结束 for 循环
* constructorToUse != null 这个条件比较好理解，下面分析一下条件 argsToUse.length > paramTypes.length：
* 前面说到 AutowireUtils.sortConstructors(candidates) 用于对构造方法进行排序，排序规则如下：
* 1. 具有 public 访问权限的构造方法排在非 public 构造方法前
* 2. 参数数量多的构造方法排在前面
*
* 假设现在有一组构造方法按照上面的排序规则进行排序，排序结果如下（省略参数名称）：
*
* 1. public Hello(Object, Object, Object)
* 2. public Hello(Object, Object)
* 3. public Hello(Object)
* 4. protected Hello(Integer, Object, Object, Object)
* 5. protected Hello(Integer, Object, Object)
* 6. protected Hello(Integer, Object)
*
* argsToUse = [num1, obj2]，可以匹配上的构造方法2和构造方法6。由于构造方法2有更高的访问权限，
* 所以没理由不选他（尽管后者在参数类型上更加匹配）。 由于构造方法3参数数量 < argsToUse.length，
* 参数数量上不匹配，也不应该选。所以 argsToUse.length > paramTypes.length 这个条件用途是：
* 在当前找到候选构造器的情况下，如果接下来的构造器参数个数小于传入的参数个数，就没必要继续找下去了。
*/
if (constructorToUse != null && argsToUse.length > paramTypes.length) {
break;
}
// 构造方法参数数量低于配置的参数数量，则忽略当前构造方法。
if (paramTypes.length < minNrOfArgs) {
continue;
}
ArgumentsHolder argsHolder;
if (resolvedValues != null) {
try {
/*
* 判断否则方法是否有 ConstructorProperties 注解，若有，则取注解中的值。比如下面的代码：
*
* public class Persion {
* private String name;
* private Integer age;
*
* @ConstructorProperties(value = {"huzb", "20"})
* public Persion(String name, Integer age) {
* this.name = name;
* this.age = age;
* }
* }
*/
String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate, paramTypes.length);
if (paramNames == null) {
ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
if (pnd != null) {
/*
* 获取构造方法参数名称列表，比如有这样一个构造方法:
* public Person(String name, int age, String sex)
*
* 调用 getParameterNames 方法返回 paramNames = [name, age, sex]
* 这里要注意 Java 的反射是无法获取参数名的，获取到的是 arg0,arg1...
* Spring 使用 ASM 字节码操作框架来获取方法参数的名称。
*/
paramNames = pnd.getParameterNames(candidate);
}
}
/*
* 创建参数值列表，返回 argsHolder 会包含进行类型转换后的参数值，比如下面的配置:
*
* <bean id="persion" class="com.guruyu.demo.Person">
* <constructor-arg name="name" value="xiaoming"/>
* <constructor-arg name="age" value="1"/>
* <constructor-arg name="sex" value="man"/>
* </bean>
*
* Person 的成员变量 age 是 Integer 类型的，但由于在 Spring 配置中只能配成 String 类型，所以这里要进行类型转换。
* 注解方式下，这里会自动注入按类型匹配的参数
*/
argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw, paramTypes, paramNames,
getUserDeclaredConstructor(candidate), autowiring);
}
catch (UnsatisfiedDependencyException ex) {
if (this.beanFactory.logger.isTraceEnabled()) {
this.beanFactory.logger.trace(
"Ignoring constructor [" + candidate + "] of bean '" + beanName + "': " + ex);
}
if (causes == null) {
causes = new LinkedList<UnsatisfiedDependencyException>();
}
causes.add(ex);
continue;
}
}
else {
if (paramTypes.length != explicitArgs.length) {
continue;
}
argsHolder = new ArgumentsHolder(explicitArgs);
}
/*
* 计算参数值（argsHolder.arguments）每个参数类型与构造方法参数列表（paramTypes）中参数的类型差异量，
* 差异量越大表明参数类型差异越大。参数类型差异越大，表明当前构造方法并不是一个最合适的候选项。
* 引入差异量（typeDiffWeight）变量目的：是将候选构造方法的参数列表类型与参数值列表类型的差异进行量化，通过量化
* 后的数值筛选出最合适的构造方法。
*/
int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
if (typeDiffWeight < minTypeDiffWeight) {
constructorToUse = candidate;
argsHolderToUse = argsHolder;
argsToUse = argsHolder.arguments;
minTypeDiffWeight = typeDiffWeight;
ambiguousConstructors = null;
}
/*
* 如果两个构造方法与参数值类型列表之间的差异量一致，那么这两个方法都可以作为候选项，这个时候就出现歧义了，
* 这里先把有歧义的构造方法放入 ambiguousConstructors 集合中
*/
else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) {
if (ambiguousConstructors == null) {
ambiguousConstructors = new LinkedHashSet<Constructor<?>>();
ambiguousConstructors.add(constructorToUse);
}
ambiguousConstructors.add(candidate);
}
}
// 若上面未能筛选出合适的构造方法，这里将抛出 BeanCreationException 异常
if (constructorToUse == null) {
if (causes != null) {
UnsatisfiedDependencyException ex = causes.removeLast();
for (Exception cause : causes) {
this.beanFactory.onSuppressedException(cause);
}
throw ex;
}
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Could not resolve matching constructor " +
"(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities)");
}
/*
* 如果 constructorToUse != null，且 ambiguousConstructors 也不为空，表明解析出了多个的合适的构造方法，
* 此时就出现歧义了。Spring 不会擅自决定使用哪个构造方法，所以抛出异常。
*/
else if (ambiguousConstructors != null && !mbd.isLenientConstructorResolution()) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Ambiguous constructor matches found in bean '" + beanName + "' " +
"(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
ambiguousConstructors);
}
if (explicitArgs == null) {
/*
* 缓存相关信息，比如：
* 1. 已解析出的构造方法对象 resolvedConstructorOrFactoryMethod
* 2. 构造方法参数列表是否已解析标志 constructorArgumentsResolved
* 3. 参数值列表 resolvedConstructorArguments 或 preparedConstructorArguments
*
* 这些信息可用在其他地方，用于进行快捷判断
*/
argsHolderToUse.storeCache(mbd, constructorToUse);
}
}
try {
Object beanInstance;
if (System.getSecurityManager() != null) {
final Constructor<?> ctorToUse = constructorToUse;
final Object[] argumentsToUse = argsToUse;
beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
return beanFactory.getInstantiationStrategy().instantiate(
mbd, beanName, beanFactory, ctorToUse, argumentsToUse);
}
}, beanFactory.getAccessControlContext());
}
else {
// 调用实例化策略创建实例，默认情况下使用反射创建实例。
// 如果 bean 的配置信息中，包含 lookup-method 和 replace-method，则通过 CGLIB 增强 bean 实例
beanInstance = this.beanFactory.getInstantiationStrategy().instantiate(
mbd, beanName, this.beanFactory, constructorToUse, argsToUse);
}
// 设置 beanInstance 到 BeanWrapperImpl 对象中
bw.setBeanInstance(beanInstance);
return bw;
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Bean instantiation via constructor failed", ex);
}
}
有参数构造器方式总结
1.创建BeanWrapperImpl对象，看到后缀就知道它是一个具体的实现类 2.解析构造方法参数，算出minNrOfArgs 3.获取构造方法列表并排序 4.判断是否有注解形式参数参与流程，有则取其值与入参共同来用做bean实例的初始化 5.构造方法按约定规则遴选，依据是参数类型与参数列表中参数类型数据差异量的比值，比值越大越说明越不适合选该构造方法做初始化 6.缓存相关信息，整体bean实例也要放到BeanWrapper中的，缓存信息和放到BeanWrapper中的实例配套着用，缓存的就是那些费了好大劲判断，谁作为了构造函数以及实际使用哪些参数，下次直接缓存中取 7.bean实例放到BeanWrapper中，返回
2.无参构造器方式
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
try {
Object beanInstance;
final BeanFactory parent = this;
// if 条件分支里的一大坨是 Java 安全相关的代码，可以忽略，直接看 else 分支
if (System.getSecurityManager() != null) {
beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
return getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
}, getAccessControlContext());
}
else {
/**
* 调用实例化策略创建实例，默认情况下使用反射创建对象。如果 bean 的配置信息中
* 包含 lookup-method 和 replace-method，则通过 CGLIB 创建 bean 对象
*/
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
// 创建 BeanWrapperImpl 对象
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
initBeanWrapper(bw);
return bw;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
}
}
public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {
// 检测 bean 配置中是否配置了 lookup-method 或 replace-method，若配置了，则需使用 CGLIB 构建 bean 对象
if (bd.getMethodOverrides().isEmpty()) {
Constructor<?> constructorToUse;
synchronized (bd.constructorArgumentLock) {
constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
if (constructorToUse == null) {
final Class<?> clazz = bd.getBeanClass();
if (clazz.isInterface()) {
throw new BeanInstantiationException(clazz, "Specified class is an interface");
}
try {
if (System.getSecurityManager() != null) {
constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor<?>>() {
@Override
public Constructor<?> run() throws Exception {
return clazz.getDeclaredConstructor((Class[]) null);
}
});
}
else {
// 获取默认构造方法
constructorToUse = clazz.getDeclaredConstructor((Class[]) null);
}
// 设置 resolvedConstructorOrFactoryMethod
bd.resolvedConstructorOrFactoryMethod = constructorToUse;
}
catch (Throwable ex) {
throw new BeanInstantiationException(clazz, "No default constructor found", ex);
}
}
}
// 通过无参构造方法创建 bean 对象
return BeanUtils.instantiateClass(constructorToUse);
}
else {
// 使用 CGLIB 创建 bean 对象
return instantiateWithMethodInjection(bd, beanName, owner);
}
}
无参构造器方式总结
1.判断安全策略不达标直接异常 2.使用反射方式创建对象，如果有singleton和prototype方式出现嵌套，则通过CGLIB方式来创建，上面注释中有分析过 3.创建bean对象
属性注入方式的实例创建
- 常规方式
protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
// bean 实例的所有属性都在这里了
PropertyValues pvs = mbd.getPropertyValues();
if (bw == null) {
if (!pvs.isEmpty()) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
}
else {
return;
}
}
// 到这步的时候，bean 实例化完成（通过工厂方法或构造方法），但是还没开始属性设值，
// InstantiationAwareBeanPostProcessor 的实现类可以在这里对 bean 进行状态设置，比如忽略属性值的设置
boolean continueWithPropertyPopulation = true;
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// 如果返回 false，代表不需要进行后续的属性设值，也不需要再经过其他的 BeanPostProcessor 的处理
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
continueWithPropertyPopulation = false;
break;
}
}
}
}
if (!continueWithPropertyPopulation) {
return;
}
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// 通过名字找到所有属性值，如果是 bean 依赖，先初始化依赖的 bean。记录依赖关系
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// 通过类型装配。复杂一些
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
if (hasInstAwareBpps || needsDepCheck) {
PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
if (hasInstAwareBpps) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// 这里有个非常有用的 BeanPostProcessor 进到这里: AutowiredAnnotationBeanPostProcessor
// 对采用 @Autowired、@Value 注解的依赖进行设值
pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvs == null) {
return;
}
}
}
}
if (needsDepCheck) {
checkDependencies(beanName, mbd, filteredPds, pvs);
}
}
// 设置 bean 实例的属性值
applyPropertyValues(beanName, mbd, bw, pvs);
}
常规方式总结
1.获取属性列表pvs 2.在属性未注入之前，使用后置处理器进行状态设置 3.根据名称或类型解析相关依赖 4.再次应用后置处理，用于实现基于注解的属性注入 5.将属性应用到bean对象中
- 基于注解的属性注入
spring常用注解
@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
// 找到要以注解形式注入的属性信息
InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
try {
// 开始注入
metadata.inject(bean, beanName, pvs);
}
catch (BeanCreationException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
}
return pvs;
}
public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
Collection<InjectedElement> checkedElements = this.checkedElements;
Collection<InjectedElement> elementsToIterate =
(checkedElements != null ? checkedElements : this.injectedElements);
if (!elementsToIterate.isEmpty()) {
for (InjectedElement element : elementsToIterate) {
if (logger.isTraceEnabled()) {
logger.trace("Processing injected element of bean '" + beanName + "': " + element);
}
// 对每个属性依次注入
element.inject(target, beanName, pvs);
}
}
}
@Override
protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
// 要注入的字段
Field field = (Field) this.member;
Object value;
// 会把注入过的属性缓存起来
if (this.cached) {
value = resolvedCachedArgument(beanName, this.cachedFieldValue);
}
else {
// 字段的描述，包括字段名、是否必需、所属类、注解信息等
DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
desc.setContainingClass(bean.getClass());
Set<String> autowiredBeanNames = new LinkedHashSet<>(1);
Assert.state(beanFactory != null, "No BeanFactory available");
// 类型转换器，用于将 String 类型转换成其它类型
TypeConverter typeConverter = beanFactory.getTypeConverter();
try {
// 核心，实际解析属性的地方，返回的是依赖的实例
value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
}
catch (BeansException ex) {
throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);
}
synchronized (this) {
if (!this.cached) {
if (value != null || this.required) {
this.cachedFieldValue = desc;
registerDependentBeans(beanName, autowiredBeanNames);
if (autowiredBeanNames.size() == 1) {
String autowiredBeanName = autowiredBeanNames.iterator().next();
if (beanFactory.containsBean(autowiredBeanName) &&
beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {
this.cachedFieldValue = new ShortcutDependencyDescriptor(
desc, autowiredBeanName, field.getType());
}
}
}
else {
this.cachedFieldValue = null;
}
this.cached = true;
}
}
}
if (value != null) {
ReflectionUtils.makeAccessible(field);
// 通过反射注入
field.set(bean, value);
}
}
public Object resolveDependency(DependencyDescriptor descriptor, String requestingBeanName,
Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException {
descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
if (javaUtilOptionalClass == descriptor.getDependencyType()) {
return new OptionalDependencyFactory().createOptionalDependency(descriptor, requestingBeanName);
}
else if (ObjectFactory.class == descriptor.getDependencyType() ||
ObjectProvider.class == descriptor.getDependencyType()) {
return new DependencyObjectProvider(descriptor, requestingBeanName);
}
else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
return new Jsr330ProviderFactory().createDependencyProvider(descriptor, requestingBeanName);
}
else {
Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
descriptor, requestingBeanName);
if (result == null) {
// 核心，解析依赖
result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
}
return result;
}
}
public Object doResolveDependency(DependencyDescriptor descriptor, String beanName,
Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException {
InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
try {
// 该方法最终调用了 beanFactory.getBean(String, Class)，从容器中获取依赖
Object shortcut = descriptor.resolveShortcut(this);
// 如果容器中存在所需依赖，这里进行断路操作，提前结束依赖解析逻辑
if (shortcut != null) {
return shortcut;
}
Class<?> type = descriptor.getDependencyType();
// 处理 @value 注解
Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
if (value != null) {
if (value instanceof String) {
String strVal = resolveEmbeddedValue((String) value);
BeanDefinition bd = (beanName != null && containsBean(beanName) ? getMergedBeanDefinition(beanName) : null);
value = evaluateBeanDefinitionString(strVal, bd);
}
TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
return (descriptor.getField() != null ?
converter.convertIfNecessary(value, type, descriptor.getField()) :
converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
}
// 解析数组、list、map 等类型的依赖
Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
if (multipleBeans != null) {
return multipleBeans;
}
/*
* findAutowireCandidates 这个方法逻辑比较复杂，它返回的是一个<名称，类型/实例>的候选列表。比如下面的配置：
*
* <bean name="mongoDao" class="com.guruyu.demo.MongoDao" primary="true"/>
* <bean name="service" class="com.guruyu.demo.Service" autowire="byType"/>
* <bean name="mysqlDao" class="com.guruyu.demo.MySqlDao"/>
*
* 我们假设这个属性的类型是 Dao，而 mongoDao 和 mysqlDao 都继承了 Dao 接口，mongoDao 已被实例化，mysqlDao
* 尚未实例化，那么返回的候选列表就是：
*
* matchingBeans = [ <"mongoDao", Object@MongoDao>, <"mysqlDao", Class@MySqlDao> ]
*
* 方法内部的工作流程如下：
* 1. 方法开始时有一个 type 记录需要的属性的类型信息。
* 2. 类型如果是容器对象（我们在容器准备时放进 resolvableDependencies 的），那直接从容器中拿到，加入候选列表。
* 3. 根据类型信息从 BeanFactory 中获取某种类型 bean 的名称列表，比如按上面配置拿到的就是["mongoDao","mysqlDao"]
* 4. 遍历上一步得到的名称列表，并判断 bean 名称对应的 bean 是否是合适的候选项，若是合适，则把实例对象（已实例化）
* 或类型（未实例化）加入候选列表
* 5. 返回候选列表
*/
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
if (matchingBeans.isEmpty()) {
if (isRequired(descriptor)) {
// 抛出 NoSuchBeanDefinitionException 异常
raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
}
return null;
}
String autowiredBeanName;
Object instanceCandidate;
if (matchingBeans.size() > 1) {
/*
* matchingBeans.size() > 1，则表明存在多个可注入的候选项，这里判断使用哪一个候选项。
* 候选项的判定规则是：
* 1）声明了 primary 的优先级最高
* 2）实现了排序接口，如 Ordered 的优先级比没实现排序接口的高；同样实现了排序接口的会通过比较器比较
* 3）还没有得到结果的话，则按字段名进行匹配
*/
autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
if (autowiredBeanName == null) {
if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
// 抛出 NoUniqueBeanDefinitionException 异常
return descriptor.resolveNotUnique(type, matchingBeans);
}
else {
return null;
}
}
// 根据解析出的 autowiredBeanName，获取相应的候选项
instanceCandidate = matchingBeans.get(autowiredBeanName);
}
else { // 只有一个候选项，直接取出来即可
Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
autowiredBeanName = entry.getKey();
instanceCandidate = entry.getValue();
}
if (autowiredBeanNames != null) {
autowiredBeanNames.add(autowiredBeanName);
}
// 返回候选项实例，如果实例是 Class 类型，则调用 beanFactory.getBean(String, Class) 获取相应的 bean。否则直接返回即可
return (instanceCandidate instanceof Class ?
descriptor.resolveCandidate(autowiredBeanName, type, this) : instanceCandidate);
}
finally {
ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
}
}
基于注解属性注入的总结
- 找到需要基于注解方式注入的属性信息
- 依次对每个字段进行操作
- 构造字段描述，包括字段名、是否必需、所属类、注解信息等
- 获取属性值
- @Value设置的值，将String转成对应类型后返回
- 依赖的类型是个数组或集合，会将符合条件的bean全部放在数组或集合中返回
- 普通类型返回一个候选列表，然后根据判定规则选出优先级最高的一个
- 如果得到的属性是个Class对象，则调用getBean生成实例
- 通过反射注入
Spring中常用注解
各种回调的处理
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 {
// 如果 bean 实现了 BeanNameAware、BeanClassLoaderAware 或 BeanFactoryAware 接口，回调
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// BeanPostProcessor 的 postProcessBeforeInitialization 回调
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
// 处理 bean 中定义的 init-method，
// 或者如果 bean 实现了 InitializingBean 接口，调用 afterPropertiesSet() 方法
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()) {
// BeanPostProcessor 的 postProcessAfterInitialization 回调
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
各种回调部分总结
代码比较简单，看看应该就懂了。
最后，要强调一下Bean的生命周期是完全针对singleton类型来说的，至于说是prototype类型，它是把生命周期管理的权力交给了调用者，spring不管该种bean。你可以通过继承Bean相关类来更多定制化生命周期的流程，但是这样可能会导致定制部分与Spring的聚合过于紧密，可能会引发未知问题。
