Spring源码分析之getBean

一.前言

spring作为JAVAEE最核心的框架,是每一个java开发者所必须掌握的,非常重要,本篇从一个简单例子入手,由浅入深的分析spring创建bean的全过程,目标在于彻底搞懂spring原理,方便以后整合其他框架

二.测试代码

 /**
 * * * @author <a href="mailto:2256222053@qq.com">zc</a>
 * @Date 2022/4/3 0003 14:45
 */
@Lazy
public class CreateBean {  

    private String name;  

 private int age;  

 public CreateBean() {
    }  

    public CreateBean(int age) {
        this.age = age;
 }  

    public CreateBean(String name) {
        this.name = name;
 }  

    public CreateBean(String name, int age) {
        this.name = name;
 this.age = age;
 }  

    public void setName(String name) {
        this.name = name;
 }  

    public void setAge(int age) {
        this.age = age;
 }  

    @Override
 public String toString() {
        return "CreateBean{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
 }
}

• 一个交给spring管理的bean,为了好debug,加了一个懒加载属性

@Test
void doCreateBean(){
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(CreateBean.class);
 Object bean = context.getBean("createBean", "chuan", 24);
 System.out.println(bean);
}

• 一个启动类,getBean是入口,开始创建bean

三. 开始获取bean:getBean()

@Override
public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
   assertBeanFactoryActive();
 return getBeanFactory().getBean(name, requiredType);
}

1. 判断容器的活动状态:assertBeanFactoryActive()

容器在启动的时候会设置这个状态值,具体在:AbstractApplicationContext#prepareRefresh()

2.获取beanFactory:getBeanFactory()

从beanFactory中获取bean,默认这个beanFactory是DefaultListableBeanFactory,因为AnnotationConfigApplicationContext继承了GenericApplicationContext,通过他的构造器可以发现

public GenericApplicationContext() {
   this.beanFactory = new DefaultListableBeanFactory();
}

3.getBean(name, requiredType)

通过bean的名称获取bean,第二个参数是bean的类型,如果传了后面会做类型转换,否则就是Object

@Override
public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
   return doGetBean(name, requiredType, null, false);
}

getBean:这个类有很多getBean方法,这是使用重载的表现,但是最终都会调用doGetBean,这个方法有四个参数,分别是bean的名称name,bean的类型,创建bean时构造参数的值

四.真正获取Bean的方法:doGetBean()

protected <T> T doGetBean(
      String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
      throws BeansException {  

   String beanName = transformedBeanName(name);
 Object beanInstance;  

 // Eagerly check singleton cache for manually registered singletons.
 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 + "'");
 }
      }
      beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
 }  

   else {
      // Fail if we're already creating this bean instance:
 // We're assumably within a circular reference. if (isPrototypeCurrentlyInCreation(beanName)) {
         throw new BeanCurrentlyInCreationException(beanName);
 }  

      // Check if bean definition exists in this factory.
 BeanFactory parentBeanFactory = getParentBeanFactory();
 if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
         // Not found -> check parent.
 String nameToLookup = originalBeanName(name);
 if (parentBeanFactory instanceof AbstractBeanFactory) {
            return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                  nameToLookup, requiredType, args, typeCheckOnly);
 }
         else if (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);
 }  

      StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
            .tag("beanName", name);
 try {
         if (requiredType != null) {
            beanCreation.tag("beanType", requiredType::toString);
 }
         RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
 checkMergedBeanDefinition(mbd, beanName, args);  

 // Guarantee initialization of beans that the current bean depends on.
 String[] dependsOn = mbd.getDependsOn();
 if (dependsOn != null) {
            for (String dep : dependsOn) {
               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);
 }
            }
         }  

         // Create bean instance.
 if (mbd.isSingleton()) {
            sharedInstance = getSingleton(beanName, () -> {
               try {
                  return createBean(beanName, mbd, args);
 }
               catch (BeansException ex) {
 throw ex;
 }
            });
 beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
 }  

         else if (mbd.isPrototype()) {
            // It's a prototype -> create a new instance.
 Object prototypeInstance = null;
 try {
               beforePrototypeCreation(beanName);
 prototypeInstance = createBean(beanName, mbd, args);
 }
            finally {
               afterPrototypeCreation(beanName);
 }
            beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
 }  

         else {
            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);
 }
               });
 beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
 }
            catch (IllegalStateException ex) {
               throw new ScopeNotActiveException(beanName, scopeName, ex);
 }
         }
      }
      catch (BeansException ex) {
         beanCreation.tag("exception", ex.getClass().toString());
 beanCreation.tag("message", String.valueOf(ex.getMessage()));
 cleanupAfterBeanCreationFailure(beanName);
 throw ex;
 }
      finally {
         beanCreation.end();
 }
   }  

   return adaptBeanInstance(name, beanInstance, requiredType);
}

这个方法很复杂,但是可以简要分为以下几个步骤

1. 获取bean名称

transformedBeanName()

因为可能会有前缀&,获取FactoryBean的情况,所以需要在这解析

2.尝试从缓存中获取bean

getSingleton()

3.判断这个bean是否在创建中

isPrototypeCurrentlyInCreation(beanName)

这一步目的是为了防止循环依赖

4.标记为正在创建中

markBeanAsCreated(beanName):将这个bean

5.合并Definition

getMergedLocalBeanDefinition(beanName)

通过parentName的值来判断是否有父definition,合并的目的在于保证definition的正确性,spring在每次要用definition的时候都会进行一次合并,因为有很多扩展点可以修改definition

6.检查合并后的Definition

checkMergedBeanDefinition(mbd, beanName, args);

7.获取依赖的Bean

mbd.getDependsOn();

如果不为空则会先创建依赖的bean

8.获取真正需要的Bean

getSingleton(beanName,()->{return createBean(beanName, mbd, args);})

获取一个注册好的bean,如果没有,会使用参数FactoryBean注册一个,非常重要,真正创建bean的入口,下面会详细会讲创建过程

getObjectForBeanInstance(sharedInstance, name, beanName, mbd);,如果name有前缀&,那么会返回FactoryBean的实例,如果注册的是一个FactoryBean,这里会调用getObject来返回真正的bean对象

adaptBeanInstance(name, beanInstance, requiredType);最后一步类型转换

五.获取Bean的过程: getSingleton()

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
  Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
     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 + "'");
}
        beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
           this.suppressedExceptions = new LinkedHashSet<>();
}
        try {
           singletonObject = singletonFactory.getObject();
newSingleton = true;
}
        catch (IllegalStateException ex) {
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;
}
           afterSingletonCreation(beanName);
}
        if (newSingleton) {
           addSingleton(beanName, singletonObject);
}
     }
     return singletonObject;
}
}

1.尝试从一级缓存中获取Bean

Object singletonObject = this.singletonObjects.get(beanName);

我们这里肯定是没有的,如果有则会直接返回

2.将这个Bean标记为创建中

beforeSingletonCreation(beanName);

里面主要操作就是将这个beanName添加进singletonsCurrentlyInCreation数组中,这个数组里面存的都是正在创建的Bean名称

3.创建Bean

singletonObject = singletonFactory.getObject();

singletonFactory是上面传过来的参数,所以这会去调用上面传过来的的createBean方法,这里使用了@FunctionalInterface函数接口,非常精髓,下面会详细分析createBean的过程

4.将这个Bean标记为已创建

afterSingletonCreation(beanName);

对应上面第二步,删除singletonsCurrentlyInCreation的这个beanName,标记他已经创建完成

5.注册Bean

addSingleton(beanName, singletonObject)

注册bean,把上面第三步创建出来的singletonObject添加进一级缓存singletonObjects和单例缓存registeredSingletons中,删除三级缓存singletonFactories和二级缓存earlySingletonObjects中key为beanName的值

六.开始创建Bean: createBean(beanName, mbd, args)

 protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
    if (this.logger.isTraceEnabled()) {
        this.logger.trace("Creating instance of bean '" + beanName + "'");
 }  

    RootBeanDefinition mbdToUse = mbd;
 Class<?> resolvedClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
 if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
        mbdToUse = new RootBeanDefinition(mbd);
 mbdToUse.setBeanClass(resolvedClass);
 }  

    try {
        mbdToUse.prepareMethodOverrides();
 } catch (BeanDefinitionValidationException var9) {
        throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", var9);
 }  

    Object beanInstance;
 try {
        beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
 if (beanInstance != null) {
            return beanInstance;
 }
    } catch (Throwable var10) {
        throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", var10);
 }  

    try {
        beanInstance = this.doCreateBean(beanName, mbdToUse, args);
 if (this.logger.isTraceEnabled()) {
            this.logger.trace("Finished creating instance of bean '" + beanName + "'");
 }  

        return beanInstance;
 } catch (ImplicitlyAppearedSingletonException | BeanCreationException var7) {
        throw var7;
 } catch (Throwable var8) {
        throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", var8);
 }
}

1.加载类

Class<?> resolvedClass = resolveBeanClass(mbd, beanName);

2.标记override的属性

mbdToUse.prepareMethodOverrides();

其实就是lookup-method和replace-method两个属性,如果没有重载会记录下来,后面就不会根据参数判断是哪一个具体的方法,减少了系统开销

3,实例化之前后置处理器

Object bean = resolveBeforeInstantiation(beanName, mbdToUse);

调用所有实现了InstantiationAwareBeanPostProcessor接口的类的postProcessBeforeInstantiation方法,如果返回不为null,会接着调用所有实现了BeanPostProcessor接口的类的postProcessAfterInitialization方法,然后返回,aop就是在此处实现的,我们这里所有实现了InstantiationAwareBeanPostProcessor接口的类都是默认的,返回的都是null,所以不会执行后置处理器的after方法,会返回一个null,下面是参考代码

@Nullable
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
    Object bean = null;
 if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
        if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
            Class<?> targetType = this.determineTargetType(beanName, mbd);
 if (targetType != null) {
                bean = this.applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
 if (bean != null) {
                    bean = this.applyBeanPostProcessorsAfterInitialization(bean, beanName);
 }
            }
        }  

        mbd.beforeInstantiationResolved = bean != null;
 }  

    return bean;
}

4.判断第三步返回的bean是否为空

Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
   return bean;
}

这一步比较重要,因为如果不为空会直接返回,这代表着不会执行spring创建bean的方法,比如后面的属性注入,aware接口回调,初始化前,初始化,初始化后都不会执行

5.创建Bean

Object beanInstance = doCreateBean(beanName, mbdToUse, args);

真正开始创建bean的方法,spring真正干活的方法都是以do开头的,我认为这是一种很好的方法命名规则

七.真正开始创建Bean: doCreateBean(beanName, mbdToUse, args)

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
    BeanWrapper instanceWrapper = null;
 if (mbd.isSingleton()) {
        instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
 }  

    if (instanceWrapper == null) {
        instanceWrapper = this.createBeanInstance(beanName, mbd, args);
 }  

    synchronized(mbd.postProcessingLock) {
        if (!mbd.postProcessed) {
            try {
                this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
 } catch (Throwable var17) {
 }  

            mbd.postProcessed = true;
 }
    }  

    boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
 if (earlySingletonExposure) {  

        this.addSingletonFactory(beanName, () -> {
            return this.getEarlyBeanReference(beanName, mbd, bean);
 });
 }  

    Object exposedObject = bean;  

        this.populateBean(beanName, mbd, instanceWrapper);
        exposedObject = this.initializeBean(beanName, exposedObject, mbd);  

    if (earlySingletonExposure) {
        Object earlySingletonReference = this.getSingleton(beanName, false);
 if (earlySingletonReference != null) {
            if (exposedObject == bean) {
                exposedObject = earlySingletonReference;
 } else if (!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {
                String[] dependentBeans = this.getDependentBeans(beanName);
 Set<String> actualDependentBeans = new LinkedHashSet(dependentBeans.length);
 String[] var12 = dependentBeans;
 int var13 = dependentBeans.length;  

 for(int var14 = 0; var14 < var13; ++var14) {
                    String dependentBean = var12[var14];
 if (!this.removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                        actualDependentBeans.add(dependentBean);
 }
                }
            }
        }
    }  

    try {
        this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
 return exposedObject;
 } catch (BeanDefinitionValidationException var16) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
 }
}

1.创建bean实例

createBeanInstance(beanName, mbd, args)

2.执行Definition的后置处理器

applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName)

spring在这一步实现了对元注解的解析

如果这个bean是单例的且正在创建中,则会加入三级缓存中,目的是暴露bean的引用,解决循环依赖:this.addSingletonFactory(beanName, () -> {

return this.getEarlyBeanReference(beanName, mbd, bean);

})

3.属性填充

populateBean(beanName, mbd, instanceWrapper);

4.初始化bean

initializeBean(beanName, exposedObject, mbd);

5.注册Bean的销毁方法

registerDisposableBeanIfNecessary(beanName, bean, mbd)

到这才真正开始进入创建bean的流程,流程中的每一步都非常复杂,建议还是很模糊的同学自重，避免走火入魔想对我人身攻击的。下面就每个方法重要的点一一解析，严格按照方法的执行先后顺序来说明

1.1 创建Bean实例

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable 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(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);
 }  

   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);
 }  

   // Preferred constructors for default construction?
 ctors = mbd.getPreferredConstructors();
 if (ctors != null) {
      return autowireConstructor(beanName, mbd, ctors, null);
 }  

   // No special handling: simply use no-arg constructor.
 return instantiateBean(beanName, mbd);
}

1. 通过Supplier接口创建Bean实例

Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
   return obtainFromSupplier(instanceSupplier, beanName);
}

我们这里没有使用这个方式,这种方式需要在注册的时候提供如下

public class C implements Supplier<C> {
    @Override
 public C get() {
        System.out.println("Supplier");
 return new C();
 }
}

/**
 * 自定义实例化方法{@link java.util.function.Supplier#get}
 * 源码调用{@link org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBeanInstance}
 */@Test
void supplier(){
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
 context.registerBean(C.class,new C());
 context.refresh();
 context.getBean("c");
}

2. 通过静态工厂或实例工厂创建Bean实例

if (mbd.getFactoryMethodName() != null) {
   return instantiateUsingFactoryMethod(beanName, mbd, args);
}

我们这没有使用工厂的方式,这两种使用方式如下:

实例工厂:

public class FactoryBeanService {
    private static Bean bean = new Bean();
 private FactoryBeanService() {}  

    public Bean createInstance() {
        System.out.println("实例工厂方法实例化bean");
 return bean;
 }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">  

 <bean id="serviceLocator"
 class="com.youlai.laboratory.spring.create.FactoryBeanService"
 />  

 <bean id="factoryBeanService"
 factory-bean="serviceLocator"
 factory-method="createInstance"
 />  

</beans>

@Test
void factoryBean(){
    ClassPathXmlApplicationContext xmlApplicationContext = new ClassPathXmlApplicationContext("classpath:spring/create/FactoryBean.xml");
}

静态工厂:

public class FactoryClassService {
    private static Bean bean = new Bean();
 private FactoryClassService() {}
    public static Bean createInstance() {
        System.out.println("静态工厂方法实例化bean");
 return bean;
 }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">  

 <bean id="factoryClassService"
 class="com.youlai.laboratory.spring.create.FactoryClassService"
 factory-method="createInstance"/>  

</beans>

@Test
void factoryMethod(){
    ClassPathXmlApplicationContext xmlApplicationContext = new ClassPathXmlApplicationContext("classpath:spring/create/FactoryClass.xml");
}

3. 推断可用的构造器

Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName)

这一步比较重要,下面会详细分析

@Override
@Nullable
public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, final String beanName)
      throws BeanCreationException {

   // Let's check for lookup methods here...
   if (!this.lookupMethodsChecked.contains(beanName)) {
      if (AnnotationUtils.isCandidateClass(beanClass, Lookup.class)) {
         try {
            Class<?> targetClass = beanClass;
            do {
               ReflectionUtils.doWithLocalMethods(targetClass, method -> {
                  Lookup lookup = method.getAnnotation(Lookup.class);
                  if (lookup != null) {
                     Assert.state(this.beanFactory != null, "No BeanFactory available");
                     LookupOverride override = new LookupOverride(method, lookup.value());
                     try {
                        RootBeanDefinition mbd = (RootBeanDefinition)
                              this.beanFactory.getMergedBeanDefinition(beanName);
                        mbd.getMethodOverrides().addOverride(override);
                     }
                     catch (NoSuchBeanDefinitionException ex) {
                        throw new BeanCreationException(beanName,
                              "Cannot apply @Lookup to beans without corresponding bean definition");
                     }
                  }
               });
               targetClass = targetClass.getSuperclass();
            }
            while (targetClass != null && targetClass != Object.class);

         }
         catch (IllegalStateException ex) {
            throw new BeanCreationException(beanName, "Lookup method resolution failed", ex);
         }
      }
      this.lookupMethodsChecked.add(beanName);
   }

   // Quick check on the concurrent map first, with minimal locking.
   Constructor<?>[] candidateConstructors = this.candidateConstructorsCache.get(beanClass);
   if (candidateConstructors == null) {
      // Fully synchronized resolution now...
      synchronized (this.candidateConstructorsCache) {
         candidateConstructors = this.candidateConstructorsCache.get(beanClass);
         if (candidateConstructors == null) {
            Constructor<?>[] rawCandidates;
            try {
               rawCandidates = beanClass.getDeclaredConstructors();
            }
            catch (Throwable ex) {
               throw new BeanCreationException(beanName,
                     "Resolution of declared constructors on bean Class [" + beanClass.getName() +
                     "] from ClassLoader [" + beanClass.getClassLoader() + "] failed", ex);
            }
            List<Constructor<?>> candidates = new ArrayList<>(rawCandidates.length);
            Constructor<?> requiredConstructor = null;
            Constructor<?> defaultConstructor = null;
            Constructor<?> primaryConstructor = BeanUtils.findPrimaryConstructor(beanClass);
            int nonSyntheticConstructors = 0;
            for (Constructor<?> candidate : rawCandidates) {
               if (!candidate.isSynthetic()) {
                  nonSyntheticConstructors++;
               }
               else if (primaryConstructor != null) {
                  continue;
               }
               MergedAnnotation<?> ann = findAutowiredAnnotation(candidate);
               if (ann == null) {
                  Class<?> userClass = ClassUtils.getUserClass(beanClass);
                  if (userClass != beanClass) {
                     try {
                        Constructor<?> superCtor =
                              userClass.getDeclaredConstructor(candidate.getParameterTypes());
                        ann = findAutowiredAnnotation(superCtor);
                     }
                     catch (NoSuchMethodException ex) {
                        // Simply proceed, no equivalent superclass constructor found...
                     }
                  }
               }
               if (ann != null) {
                  if (requiredConstructor != null) {
                     throw new BeanCreationException(beanName,
                           "Invalid autowire-marked constructor: " + candidate +
                           ". Found constructor with 'required' Autowired annotation already: " +
                           requiredConstructor);
                  }
                  boolean required = determineRequiredStatus(ann);
                  if (required) {
                     if (!candidates.isEmpty()) {
                        throw new BeanCreationException(beanName,
                              "Invalid autowire-marked constructors: " + candidates +
                              ". Found constructor with 'required' Autowired annotation: " +
                              candidate);
                     }
                     requiredConstructor = candidate;
                  }
                  candidates.add(candidate);
               }
               else if (candidate.getParameterCount() == 0) {
                  defaultConstructor = candidate;
               }
            }
            if (!candidates.isEmpty()) {
               // Add default constructor to list of optional constructors, as fallback.
               if (requiredConstructor == null) {
                  if (defaultConstructor != null) {
                     candidates.add(defaultConstructor);
                  }
                  else if (candidates.size() == 1 && logger.isInfoEnabled()) {
                     logger.info("Inconsistent constructor declaration on bean with name '" + beanName +
                           "': single autowire-marked constructor flagged as optional - " +
                           "this constructor is effectively required since there is no " +
                           "default constructor to fall back to: " + candidates.get(0));
                  }
               }
               candidateConstructors = candidates.toArray(new Constructor<?>[0]);
            }
            else if (rawCandidates.length == 1 && rawCandidates[0].getParameterCount() > 0) {
               candidateConstructors = new Constructor<?>[] {rawCandidates[0]};
            }
            else if (nonSyntheticConstructors == 2 && primaryConstructor != null &&
                  defaultConstructor != null && !primaryConstructor.equals(defaultConstructor)) {
               candidateConstructors = new Constructor<?>[] {primaryConstructor, defaultConstructor};
            }
            else if (nonSyntheticConstructors == 1 && primaryConstructor != null) {
               candidateConstructors = new Constructor<?>[] {primaryConstructor};
            }
            else {
               candidateConstructors = new Constructor<?>[0];
            }
            this.candidateConstructorsCache.put(beanClass, candidateConstructors);
         }
      }
   }
   return (candidateConstructors.length > 0 ? candidateConstructors : null);
}

1.处理@Lookup注解的方法

// Let's check for lookup methods here...
if (!this.lookupMethodsChecked.contains(beanName)) {
   if (AnnotationUtils.isCandidateClass(beanClass, Lookup.class)) {
      try {
         Class<?> targetClass = beanClass;
         do {
            ReflectionUtils.doWithLocalMethods(targetClass, method -> {
               Lookup lookup = method.getAnnotation(Lookup.class);
               if (lookup != null) {
                  Assert.state(this.beanFactory != null, "No BeanFactory available");
                  LookupOverride override = new LookupOverride(method, lookup.value());
                  try {
                     RootBeanDefinition mbd = (RootBeanDefinition)
                           this.beanFactory.getMergedBeanDefinition(beanName);
                     mbd.getMethodOverrides().addOverride(override);
                  }
                  catch (NoSuchBeanDefinitionException ex) {
                     throw new BeanCreationException(beanName,
                           "Cannot apply @Lookup to beans without corresponding bean definition");
                  }
               }
            });
            targetClass = targetClass.getSuperclass();
         }
         while (targetClass != null && targetClass != Object.class);

      }
      catch (IllegalStateException ex) {
         throw new BeanCreationException(beanName, "Lookup method resolution failed", ex);
      }
   }
   this.lookupMethodsChecked.add(beanName);
}

@Lookup注解主要是为了解决在单例依赖原型时,依赖的原型bean会被修改为单例bean

2. 尝试从缓存中获取可用构造器数组

Constructor<?>[] candidateConstructors = this.candidateConstructorsCache.get(beanClass);

我们这一步获取为空,如果不为空则会跳过下面的3,4,5步骤,执行第六步返回

3. 获取所有构造器

Constructor<?>[] candidateConstructors = this.candidateConstructorsCache.get(beanClass);

4. 效验是否有可用的构造器,生成可用的构造器数组

循环第二步得到的构造器数组,先判断他是否有@Autowire注解,如果没有@Autowire注解,则通过类名是否含有$$字符判断这个类是否是CJLAB的子类,如果不是则跳过,是子类则获取他带有@Autowire注解的构造器,如果这个构造器有@Autowire注解,先获取required属性的值,如果为false则把构造器加入可用的构造器数组中,如果为true,则判断可用的构造器数组是否为空,不为空则代表着这个类有多个@Autowire标注的构造器并且参数都为必传,这种情况就抛出异常,为空就把这个构造器标注为最终使用的构造器,并且加入可用的构造器数组中

5. 生成可用构造器集合并添加到缓存中

if (!candidates.isEmpty()) {
   // Add default constructor to list of optional constructors, as fallback.
   if (requiredConstructor == null) {
      if (defaultConstructor != null) {
         candidates.add(defaultConstructor);
      }
      else if (candidates.size() == 1 && logger.isInfoEnabled()) {
         logger.info("Inconsistent constructor declaration on bean with name '" + beanName +
               "': single autowire-marked constructor flagged as optional - " +
               "this constructor is effectively required since there is no " +
               "default constructor to fall back to: " + candidates.get(0));
      }
   }
   candidateConstructors = candidates.toArray(new Constructor<?>[0]);
}
else if (rawCandidates.length == 1 && rawCandidates[0].getParameterCount() > 0) {
   candidateConstructors = new Constructor<?>[] {rawCandidates[0]};
}
else if (nonSyntheticConstructors == 2 && primaryConstructor != null &&
      defaultConstructor != null && !primaryConstructor.equals(defaultConstructor)) {
   candidateConstructors = new Constructor<?>[] {primaryConstructor, defaultConstructor};
}
else if (nonSyntheticConstructors == 1 && primaryConstructor != null) {
   candidateConstructors = new Constructor<?>[] {primaryConstructor};
}
else {
   candidateConstructors = new Constructor<?>[0];
}
//添加进缓存中
this.candidateConstructorsCache.put(beanClass, candidateConstructors);

6. 根据可用构造器集合的数量返回

(candidateConstructors.length > 0 ? candidateConstructors : null);

如果构建器集合数量大于0,则返回这个集合,否则返回null

4. 通过候选构造器集合创建Bean实例

autowireConstructor(beanName, mbd, ctors, null);

这一步里面非常复杂,选择性看

	public BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd,
			@Nullable Constructor<?>[] chosenCtors, @Nullable Object[] explicitArgs) {

		BeanWrapperImpl bw = new BeanWrapperImpl();
		this.beanFactory.initBeanWrapper(bw);

		Constructor<?> constructorToUse = null;
		ArgumentsHolder argsHolderToUse = null;
		Object[] argsToUse = null;

		if (explicitArgs != null) {
			argsToUse = explicitArgs;
		}
		else {
			Object[] argsToResolve = null;
			synchronized (mbd.constructorArgumentLock) {
				constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod;
				if (constructorToUse != null && mbd.constructorArgumentsResolved) {
					// Found a cached constructor...
					argsToUse = mbd.resolvedConstructorArguments;
					if (argsToUse == null) {
						argsToResolve = mbd.preparedConstructorArguments;
					}
				}
			}
			if (argsToResolve != null) {
				argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve);
			}
		}

		if (constructorToUse == null || argsToUse == null) {
			// Take specified constructors, if any.
			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);
				}
			}

			if (candidates.length == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
				Constructor<?> uniqueCandidate = candidates[0];
				if (uniqueCandidate.getParameterCount() == 0) {
					synchronized (mbd.constructorArgumentLock) {
						mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
						mbd.constructorArgumentsResolved = true;
						mbd.resolvedConstructorArguments = EMPTY_ARGS;
					}
					bw.setBeanInstance(instantiate(beanName, mbd, uniqueCandidate, EMPTY_ARGS));
					return bw;
				}
			}

			// Need to resolve the constructor.
			boolean autowiring = (chosenCtors != null ||
					mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
			ConstructorArgumentValues resolvedValues = null;

			int minNrOfArgs;
			if (explicitArgs != null) {
				minNrOfArgs = explicitArgs.length;
			}
			else {
				ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
				resolvedValues = new ConstructorArgumentValues();
				minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
			}

			AutowireUtils.sortConstructors(candidates);
			int minTypeDiffWeight = Integer.MAX_VALUE;
			Set<Constructor<?>> ambiguousConstructors = null;
			Deque<UnsatisfiedDependencyException> causes = null;

			for (Constructor<?> candidate : candidates) {
				int parameterCount = candidate.getParameterCount();

				if (constructorToUse != null && argsToUse != null && argsToUse.length > parameterCount) {
					// Already found greedy constructor that can be satisfied ->
					// do not look any further, there are only less greedy constructors left.
					break;
				}
				if (parameterCount < minNrOfArgs) {
					continue;
				}

				ArgumentsHolder argsHolder;
				Class<?>[] paramTypes = candidate.getParameterTypes();
				if (resolvedValues != null) {
					try {
						String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate, parameterCount);
						if (paramNames == null) {
							ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
							if (pnd != null) {
								paramNames = pnd.getParameterNames(candidate);
							}
						}
						argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw, paramTypes, paramNames,
								getUserDeclaredConstructor(candidate), autowiring, candidates.length == 1);
					}
					catch (UnsatisfiedDependencyException ex) {
						if (logger.isTraceEnabled()) {
							logger.trace("Ignoring constructor [" + candidate + "] of bean '" + beanName + "': " + ex);
						}
						// Swallow and try next constructor.
						if (causes == null) {
							causes = new ArrayDeque<>(1);
						}
						causes.add(ex);
						continue;
					}
				}
				else {
					// Explicit arguments given -> arguments length must match exactly.
					if (parameterCount != explicitArgs.length) {
						continue;
					}
					argsHolder = new ArgumentsHolder(explicitArgs);
				}

				int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
						argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
				// Choose this constructor if it represents the closest match.
				if (typeDiffWeight < minTypeDiffWeight) {
					constructorToUse = candidate;
					argsHolderToUse = argsHolder;
					argsToUse = argsHolder.arguments;
					minTypeDiffWeight = typeDiffWeight;
					ambiguousConstructors = null;
				}
				else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) {
					if (ambiguousConstructors == null) {
						ambiguousConstructors = new LinkedHashSet<>();
						ambiguousConstructors.add(constructorToUse);
					}
					ambiguousConstructors.add(candidate);
				}
			}

			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 on bean class [" + mbd.getBeanClassName() + "] " +
						"(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities)");
			}
			else if (ambiguousConstructors != null && !mbd.isLenientConstructorResolution()) {
				throw new BeanCreationException(mbd.getResourceDescription(), beanName,
						"Ambiguous constructor matches found on bean class [" + mbd.getBeanClassName() + "] " +
						"(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
						ambiguousConstructors);
			}

			if (explicitArgs == null && argsHolderToUse != null) {
				argsHolderToUse.storeCache(mbd, constructorToUse);
			}
		}

		Assert.state(argsToUse != null, "Unresolved constructor arguments");
		bw.setBeanInstance(instantiate(beanName, mbd, constructorToUse, argsToUse));
		return bw;
	}

1. 创建一个BeanWrapperImpl并初始化

BeanWrapperImpl bw = new BeanWrapperImpl();
this.beanFactory.initBeanWrapper(bw);

BeanWrapperImpl是用来承载bean实例的,里面封装了

2.对候选的构造器集合排序

AutowireUtils.sortConstructors(candidates);

排序会把修饰符为publi排在前面,其余的修饰符的排在后面,先根据修饰符,然后根据参数的数量排序,参数数量越多的排在越前面,参数越少的排在越后面

3. 创建参数对象

argsHolder = new ArgumentsHolder(explicitArgs);

new ArgumentsHolder(explicitArgs);创建一个保存参数的对象

4. 开始实例化Bean

instantiate(beanName, mbd, constructorToUse, argsToUse)

这里面实例化的方式分为两种

@Override
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
      final Constructor<?> ctor, Object... args) {

   if (!bd.hasMethodOverrides()) {
      if (System.getSecurityManager() != null) {
         // use own privileged to change accessibility (when security is on)
         AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
            ReflectionUtils.makeAccessible(ctor);
            return null;
         });
      }
      return BeanUtils.instantiateClass(ctor, args);
   }
   else {
      return instantiateWithMethodInjection(bd, beanName, owner, ctor, args);
   }
}

通过判断是否有覆盖方法来选择实例化方式,这里覆盖的方法指的是标题六的第二步

[六.开始创建Bean: createBean(beanName, mbd, args)]:

1. 通过CJLAB来实例化

public Object instantiate(@Nullable Constructor<?> ctor, Object... args) {
   Class<?> subclass = createEnhancedSubclass(this.beanDefinition);
   Object instance;
   if (ctor == null) {
      instance = BeanUtils.instantiateClass(subclass);
   }
   else {
      try {
         Constructor<?> enhancedSubclassConstructor = subclass.getConstructor(ctor.getParameterTypes());
         instance = enhancedSubclassConstructor.newInstance(args);
      }
      catch (Exception ex) {
         throw new BeanInstantiationException(this.beanDefinition.getBeanClass(),
               "Failed to invoke constructor for CGLIB enhanced subclass [" + subclass.getName() + "]", ex);
      }
   }
   // SPR-10785: set callbacks directly on the instance instead of in the
   // enhanced class (via the Enhancer) in order to avoid memory leaks.
   Factory factory = (Factory) instance;
   factory.setCallbacks(new Callback[] {NoOp.INSTANCE,
         new LookupOverrideMethodInterceptor(this.beanDefinition, this.owner),
         new ReplaceOverrideMethodInterceptor(this.beanDefinition, this.owner)});
   return instance;
}

如果包含覆盖方法,就会使用上面这种方式实例化Bean,其中加了两个拦截器,来实现方法替换

2. 通过构造器实例化Bean

public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
   Assert.notNull(ctor, "Constructor must not be null");
   try {
      ReflectionUtils.makeAccessible(ctor);
      if (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(ctor.getDeclaringClass())) {
         return KotlinDelegate.instantiateClass(ctor, args);
      }
      else {
         Class<?>[] parameterTypes = ctor.getParameterTypes();
         Assert.isTrue(args.length <= parameterTypes.length, "Can't specify more arguments than constructor parameters");
         Object[] argsWithDefaultValues = new Object[args.length];
         for (int i = 0 ; i < args.length; i++) {
            if (args[i] == null) {
               Class<?> parameterType = parameterTypes[i];
               argsWithDefaultValues[i] = (parameterType.isPrimitive() ? DEFAULT_TYPE_VALUES.get(parameterType) : null);
            }
            else {
               argsWithDefaultValues[i] = args[i];
            }
         }
         return ctor.newInstance(argsWithDefaultValues);
      }
   }
   catch (InstantiationException ex) {
      throw new BeanInstantiationException(ctor, "Is it an abstract class?", ex);
   }
   catch (IllegalAccessException ex) {
      throw new BeanInstantiationException(ctor, "Is the constructor accessible?", ex);
   }
   catch (IllegalArgumentException ex) {
      throw new BeanInstantiationException(ctor, "Illegal arguments for constructor", ex);
   }
   catch (InvocationTargetException ex) {
      throw new BeanInstantiationException(ctor, "Constructor threw exception", ex.getTargetException());
   }
}

到这终于完成了实例化,真正执行实例化的是通过newInstance(argsWithDefaultValues),newInstance是JAVA提供的一种创建Bean实例的方式,下面回到创建Bean的第二步,也就是创建bean实例的下一步,执行Definition的后置处理器

2.1 执行Definition的后置处理器

applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);

protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
   for (MergedBeanDefinitionPostProcessor processor : getBeanPostProcessorCache().mergedDefinition) {
      processor.postProcessMergedBeanDefinition(mbd, beanType, beanName);
   }
}

调用MergedBeanDefinitionPostProcessor接口的postProcessMergedBeanDefinition方法,这里获取MergedBeanDefinitionPostProcessor接口默认有三个

• CommonAnnotationBeanPostProcessor : 解析@PostConstruct，@PreDestroy，@Resource注解
• AutowiredAnnotationBeanPostProcessor: 解析@Autowired ,@Value注解
• ApplicationListenerDetector:

2.1.1 解析@PostConstruct，@PreDestroy

@Override
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
   super.postProcessMergedBeanDefinition(beanDefinition, beanType, beanName);
   InjectionMetadata metadata = findResourceMetadata(beanName, beanType, null);
   metadata.checkConfigMembers(beanDefinition);
}

• 调用父类,扫描@PostConstruct,@PreDestroy注解的类
• findResourceMetadata:扫描@Resource注解的类

private LifecycleMetadata findLifecycleMetadata(Class<?> clazz) {
   if (this.lifecycleMetadataCache == null) {
      // Happens after deserialization, during destruction...
      return buildLifecycleMetadata(clazz);
   }
   // Quick check on the concurrent map first, with minimal locking.
   LifecycleMetadata metadata = this.lifecycleMetadataCache.get(clazz);
   if (metadata == null) {
      synchronized (this.lifecycleMetadataCache) {
         metadata = this.lifecycleMetadataCache.get(clazz);
         if (metadata == null) {
            metadata = buildLifecycleMetadata(clazz);
            this.lifecycleMetadataCache.put(clazz, metadata);
         }
         return metadata;
      }
   }
   return metadata;
}

• 先从缓存里面获取,如果为空再获取一遍,双重效验

• buildLifecycleMetadata:构建元数据

• 添加进缓存lifecycleMetadataCache中

  buildLifecycleMetadata

  private LifecycleMetadata buildLifecycleMetadata(final Class<?> clazz) {
     do {
        final List<LifecycleElement> currInitMethods = new ArrayList<>();
        final List<LifecycleElement> currDestroyMethods = new ArrayList<>();
  
        ReflectionUtils.doWithLocalMethods(targetClass, method -> {
            //
           if (this.initAnnotationType != null && method.isAnnotationPresent(this.initAnnotationType)) {
              LifecycleElement element = new LifecycleElement(method);
              currInitMethods.add(element);
              if (logger.isTraceEnabled()) {
                 logger.trace("Found init method on class [" + clazz.getName() + "]: " + method);
              }
           }
           if (this.destroyAnnotationType != null && method.isAnnotationPresent(this.destroyAnnotationType)) {
              currDestroyMethods.add(new LifecycleElement(method));
              if (logger.isTraceEnabled()) {
                 logger.trace("Found destroy method on class [" + clazz.getName() + "]: " + method);
              }
           }
        });
        initMethods.addAll(0, currInitMethods);
        destroyMethods.addAll(currDestroyMethods);
        targetClass = targetClass.getSuperclass();
     }
     while (targetClass != null && targetClass != Object.class);
  
     return (initMethods.isEmpty() && destroyMethods.isEmpty() ? this.emptyLifecycleMetadata :
           new LifecycleMetadata(clazz, initMethods, destroyMethods));
  }
  

• 查找标注了PostConstruct和PreDestroy注解的方法,通过isAnnotationPresent来判断,分别加入到currInitMethods和currDestroyMethods数组,最后再封装到

LifecycleMetadata类里面

2.1.2 解析@Resource

private InjectionMetadata findResourceMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
   // Fall back to class name as cache key, for backwards compatibility with custom callers.
   String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
   // Quick check on the concurrent map first, with minimal locking.
   InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
   if (InjectionMetadata.needsRefresh(metadata, clazz)) {
      synchronized (this.injectionMetadataCache) {
         metadata = this.injectionMetadataCache.get(cacheKey);
         if (InjectionMetadata.needsRefresh(metadata, clazz)) {
            if (metadata != null) {
               metadata.clear(pvs);
            }
            metadata = buildResourceMetadata(clazz);
            this.injectionMetadataCache.put(cacheKey, metadata);
         }
      }
   }
   return metadata;
}

这一步和上面一样,先使用双重效验检查缓存,如果有则直接返回,没有则创建

buildResourceMetadata(clazz)

private InjectionMetadata buildResourceMetadata(Class<?> clazz) {

      ReflectionUtils.doWithLocalFields(targetClass, field -> {
          if (field.isAnnotationPresent(Resource.class)) {
            if (Modifier.isStatic(field.getModifiers())) {
               throw new IllegalStateException("@Resource annotation is not supported on static fields");
            }
            if (!this.ignoredResourceTypes.contains(field.getType().getName())) {
               currElements.add(new ResourceElement(field, field, null));
            }
         }
      });

      ReflectionUtils.doWithLocalMethods(targetClass, method -> {

       if (bridgedMethod.isAnnotationPresent(Resource.class)) {
               if (Modifier.isStatic(method.getModifiers())) {
                  throw new IllegalStateException("@Resource annotation is not supported on static methods");
               }
               Class<?>[] paramTypes = method.getParameterTypes();
               if (paramTypes.length != 1) {
                  throw new IllegalStateException("@Resource annotation requires a single-arg method: " + method);
               }
               if (!this.ignoredResourceTypes.contains(paramTypes[0].getName())) {
                  PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
                  currElements.add(new ResourceElement(method, bridgedMethod, pd));
               }
      });

      elements.addAll(0, currElements);
      targetClass = targetClass.getSuperclass();
   }
   while (targetClass != null && targetClass != Object.class);

   return InjectionMetadata.forElements(elements, clazz);
}

先扫描字段,再扫描方法,判断是否有static修饰符,如果有则报错,注意这里还检查了参数,只有一个参数的时候才会添加到elements数组中,最后封装到InjectionMetadata对象里

2.1.3解析@Autowired,@Value

AutowiredAnnotationBeanPostProcessor#findAutowiringMetadata

private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
   // Fall back to class name as cache key, for backwards compatibility with custom callers.
   String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
   // Quick check on the concurrent map first, with minimal locking.
   InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
   if (InjectionMetadata.needsRefresh(metadata, clazz)) {
      synchronized (this.injectionMetadataCache) {
         metadata = this.injectionMetadataCache.get(cacheKey);
         if (InjectionMetadata.needsRefresh(metadata, clazz)) {
            if (metadata != null) {
               metadata.clear(pvs);
            }
            metadata = buildAutowiringMetadata(clazz);
            this.injectionMetadataCache.put(cacheKey, metadata);
         }
      }
   }
   return metadata;
}

这里和上面一样,先使用双重效验检查缓存,如果有则直接返回,没有则创建

AutowiredAnnotationBeanPostProcessor#buildAutowiringMetadata

private InjectionMetadata buildAutowiringMetadata(Class<?> clazz) {

   do {
      final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();

      ReflectionUtils.doWithLocalFields(targetClass, field -> {
         MergedAnnotation<?> ann = findAutowiredAnnotation(field);
         if (ann != null) {
            if (Modifier.isStatic(field.getModifiers())) {
               if (logger.isInfoEnabled()) {
                  logger.info("Autowired annotation is not supported on static fields: " + field);
               }
               return;
            }
            boolean required = determineRequiredStatus(ann);
            currElements.add(new AutowiredFieldElement(field, required));
         }
      });

      ReflectionUtils.doWithLocalMethods(targetClass, method -> {

         MergedAnnotation<?> ann = findAutowiredAnnotation(bridgedMethod);
         if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
            if (Modifier.isStatic(method.getModifiers())) {
               if (logger.isInfoEnabled()) {
                  logger.info("Autowired annotation is not supported on static methods: " + method);
               }
               return;
            }
            if (method.getParameterCount() == 0) {
               if (logger.isInfoEnabled()) {
                  logger.info("Autowired annotation should only be used on methods with parameters: " +
                        method);
               }
            }
            boolean required = determineRequiredStatus(ann);
            PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
            currElements.add(new AutowiredMethodElement(method, required, pd));
         }
      });

      elements.addAll(0, currElements);
      targetClass = targetClass.getSuperclass();
   }
   while (targetClass != null && targetClass != Object.class);

   return InjectionMetadata.forElements(elements, clazz);
}

通过findAutowiredAnnotation查找带有@Autowired,@Value的属性和方法

@Nullable
private MergedAnnotation<?> findAutowiredAnnotation(AccessibleObject ao) {
   MergedAnnotations annotations = MergedAnnotations.from(ao);
   for (Class<? extends Annotation> type : this.autowiredAnnotationTypes) {
      MergedAnnotation<?> annotation = annotations.get(type);
      if (annotation.isPresent()) {
         return annotation;
      }
   }
   return null;
}

this.autowiredAnnotationTypes在构造方法时添加

public AutowiredAnnotationBeanPostProcessor() {
   this.autowiredAnnotationTypes.add(Autowired.class);
   this.autowiredAnnotationTypes.add(Value.class);
}

到此类的元数据就解析完了,最后还有一个ApplicationListenerDetector

public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
   if (ApplicationListener.class.isAssignableFrom(beanType)) {
      this.singletonNames.put(beanName, beanDefinition.isSingleton());
   }
}

这里就是记录一下这个bean是否是单例

3.1 属性填充

下面分析这个方法内部是怎么实现属性填充的

populateBean(beanName, mbd, instanceWrapper);

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {

   if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
      for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
         if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
            return;
         }
      }
   }

   PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

   int resolvedAutowireMode = mbd.getResolvedAutowireMode();
   if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
      MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
      // Add property values based on autowire by name if applicable.
      if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
         autowireByName(beanName, mbd, bw, newPvs);
      }
      // Add property values based on autowire by type if applicable.
      if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
         autowireByType(beanName, mbd, bw, newPvs);
      }
      pvs = newPvs;
   }

   boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
   boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

   PropertyDescriptor[] filteredPds = null;
   if (hasInstAwareBpps) {
      if (pvs == null) {
         pvs = mbd.getPropertyValues();
      }
      for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
         PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
         if (pvsToUse == null) {
            if (filteredPds == null) {
               filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
            }
            pvsToUse = bp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
            if (pvsToUse == null) {
               return;
            }
         }
         pvs = pvsToUse;
      }
   }
   if (needsDepCheck) {
      if (filteredPds == null) {
         filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
      }
      checkDependencies(beanName, mbd, filteredPds, pvs);
   }

   if (pvs != null) {
      applyPropertyValues(beanName, mbd, bw, pvs);
   }
}

3.1.1 调用实现了InstantiationAwareBeanPostProcessor接口的postProcessAfterInstantiation方法,如果返回false则中断下面的属性填充,目的是为了让用户可以自定义属性注入

3.1.2 获取注入方式,根据注入方式解析属性到PropertyValues类里

3.1.3 对标注@AutoWired的属性进行依赖注入

3.1.4 依赖检查: checkDependencies(beanName, mbd, filteredPds, pvs)

3.1.5 applyPropertyValues,将解析的值用BeanWrapper进行包装

4.1 初始化bean

initializeBean(beanName, exposedObject, mbd)

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
   if (System.getSecurityManager() != null) {
      AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
         invokeAwareMethods(beanName, bean);
         return null;
      }, getAccessControlContext());
   }
   else {
      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;
}

4.1.1调用各种aware接口:invokeAwareMethods

4.1.2:执行初始化前置操作:applyBeanPostProcessorsBeforeInitialization

4.1.3:初始化:InitializingBean

4.1.4:调用method-init初始化方法

4.1.5:执行初始化后置操作:applyBeanPostProcessorsAfterInitialization

5 .1注册bean的销毁方法

5.1.1 检查是否实现DisposableBean 接口以及指定的销毁方法和注册的 DestructionAwareBeanPostProcessors

protected boolean requiresDestruction(Object bean, RootBeanDefinition mbd) {
   return (bean.getClass() != NullBean.class && (DisposableBeanAdapter.hasDestroyMethod(bean, mbd) ||
         (hasDestructionAwareBeanPostProcessors() && DisposableBeanAdapter.hasApplicableProcessors(
               bean, getBeanPostProcessorCache().destructionAware))));
}

5.1.2 将bean的添加到注册表,完成注册

public void registerDisposableBean(String beanName, DisposableBean bean) {
   synchronized (this.disposableBeans) {
      this.disposableBeans.put(beanName, bean);
   }
}