Spring源码 --- AbstractBeanFactory结构及其通过beanName获取bean的过程

以下是详细描叙，简化版的各个接口方法运行的时机，可以看这一篇。

一：首先看下AbstractBeanFactory结构：

1、AliasRegistry、SimpleAliasRegistry

这两个是关于一个BeanDefinition的别名的，在进行别名映射的实时会进行循环别名检查，即看有没有相同的别名。

2、SingletonBeanRegistry

这个看名称就知道是关于单例注册的接口

Spring源码 --- AbstractBeanFactory结构及其通过beanName获取bean的过程

3、BeanFactory

是定义一些关于Bean获取的接口：

Spring源码 --- AbstractBeanFactory结构及其通过beanName获取bean的过程

4、HierarchicalBeanFactory

这个是用于管理BeanFactory的层级结构，一个BeanFactory可以有其父的BeanFactory

public interface HierarchicalBeanFactory extends BeanFactory {

   @Nullable
   BeanFactory getParentBeanFactory();

   boolean containsLocalBean(String name);
}

这里的containsLocalBean方法就是用于判断这个bean有没有在当前这层。

5、DefaultSingletonBeanRegistry

这个就是关于单例Bean的获取时状态管理的主要类

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

   /** Cache of singleton objects: bean name --> bean instance */
   private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

   /** Cache of singleton factories: bean name --> ObjectFactory */
   private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

   /** Cache of early singleton objects: bean name --> bean instance */
   private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

   /** Set of registered singletons, containing the bean names in registration order */
   private final Set<String> registeredSingletons = new LinkedHashSet<>(256);

   /** Names of beans that are currently in creation */
   private final Set<String> singletonsCurrentlyInCreation =
         Collections.newSetFromMap(new ConcurrentHashMap<>(16));

   /** Names of beans currently excluded from in creation checks */
   private final Set<String> inCreationCheckExclusions =
         Collections.newSetFromMap(new ConcurrentHashMap<>(16));

   /** List of suppressed Exceptions, available for associating related causes */
   
   /** Flag that indicates whether we're currently within destroySingletons */
   private boolean singletonsCurrentlyInDestruction = false;
    ...................
}

可以看到这里有很多Map，Spring就是用最Map及一些状态值去控制Bean的获取的。

6、ConfigurableBeanFactory

这个类，可配置BeanFactory,就是定义一些在获取Bean的过程中，还需要进行一些别样的处理，例如我们可以自定义BeanPostProcessor类、以及进行类型转换的内容等：

public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {
   String SCOPE_SINGLETON = "singleton";

   String SCOPE_PROTOTYPE = "prototype";
    ..............
   void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar);

   void registerCustomEditor(Class<?> requiredType, Class<? extends PropertyEditor> propertyEditorClass);
   .............

   void setTypeConverter(TypeConverter typeConverter);

   TypeConverter getTypeConverter();

   void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);

   boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException
   ..........

}

7、FactoryBeanRegistrySupport

这个他自己的方法，是用于一些通过实现FactoryBean接口的Bean的获取时的一些需要的操作：

@Nullable
protected Class<?> getTypeForFactoryBean(final FactoryBean<?> factoryBean) {
       ............
         return factoryBean.getObjectType();
     .............
}

private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)
      throws BeanCreationException {

        Object object;
       ........
         object = factory.getObject();
       ...........
        return object;
}

public interface FactoryBean<T> {
   @Nullable
   T getObject() throws Exception;

   @Nullable
   Class<?> getObjectType();

   default boolean isSingleton() {
      return true;
   }
}

二、使用AbstractBeanFactroy获取bean的过程

我们通过一个demo来分析：

@Test
public void testFactoryBeanObtain() throws Exception {
   DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
   new XmlBeanDefinitionReader(factory).loadBeanDefinitions(RETURNS_NULL_CONTEXT);
   School schoolBean = (School)factory.getBean("schoolBean");
}
public class School {
   private String name;
   private Student student;
   .........
}
public class Student {
   private String name;
}
<beans>
   <bean id="schoolBean" class="fev.test.School">
      <property name = "name" value="schoolFev"/>
      <property name = "student"  ref="studentBean"/>
   </bean>

   <bean id="studentBean" class="fev.test.Student">
      <property name="name" value="studentFev"/>
   </bean>
</beans>

，然后就会调用在AbstractFactory类的geetBean方法：

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) {
      .............
      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) {
            return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                  nameToLookup, requiredType, args, typeCheckOnly);
         }
         else if (args != null) {
            return (T) parentBeanFactory.getBean(nameToLookup, args);
         }
         else {
            return parentBeanFactory.getBean(nameToLookup, requiredType);
         }
      }

      if (!typeCheckOnly) {
         markBeanAsCreated(beanName);
      }

      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);
               getBean(dep);
            }
         }
         if (mbd.isSingleton()) {
            sharedInstance = getSingleton(beanName, () -> {
               try {
                  return createBean(beanName, mbd, args);
               }
              ...............
            });
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
         }

         else if (mbd.isPrototype()) {
            Object prototypeInstance = null;
            try {
               beforePrototypeCreation(beanName);
               prototypeInstance = createBean(beanName, mbd, args);
            }
            finally {
               afterPrototypeCreation(beanName);
            }
            bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
         }

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

   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) {
         throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
      }
   }
   return (T) bean;
}

过通过Bean名称获取Bean的逻辑就是在这个AbstractFactory类的doGetBean方法。

1、获取标准名称(transformedBeanName()方法调用)

protected String transformedBeanName(String name) {
   return canonicalName(BeanFactoryUtils.transformedBeanName(name));
}
String FACTORY_BEAN_PREFIX = "&";
public static String transformedBeanName(String name) {
   String beanName = name;
   while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
      beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
   }
   return beanName;
}

这里首先是去掉&，这个&是与FactoryBean相关的内容。通过简单的例子来说明：

Spring源码 --- AbstractBeanFactory结构及其通过beanName获取bean的过程

也就是说，当是由FactoryBean去产生对象，如果名称前没有加&其获取的就是产生的对象，如果加了&其获取的就是FactoryBean的实现类本身，所以在这里会去掉这个符号（在对应的描叙BeanDefinition中会有相应的描叙是获取本身还是工厂）。

canonicalName方法就是获取标准规范的bean名称，因为我们可以还有用到别名，所以在这里就通过别名获取标准名：

public String canonicalName(String name) {
   String canonicalName = name;
   String resolvedName;
   do {
      resolvedName = this.aliasMap.get(canonicalName);
      if (resolvedName != null) {
         canonicalName = resolvedName;
      }
   }
   while (resolvedName != null);
   return canonicalName;
}

2、getSingleton(beanName)

public Object getSingleton(String beanName) {
   return getSingleton(beanName, true);
}

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
   Object singletonObject = this.singletonObjects.get(beanName);
   if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
      synchronized (this.singletonObjects) {
         singletonObject = this.earlySingletonObjects.get(beanName);
         if (singletonObject == null && allowEarlyReference) {
            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
            if (singletonFactory != null) {
               singletonObject = singletonFactory.getObject();
               this.earlySingletonObjects.put(beanName, singletonObject);
               this.singletonFactories.remove(beanName);
            }
         }
      }
   }
   return singletonObject;
}

这就是从Spring的三层缓存中去取。其中入参allowEarlyReference就是看如果第二层earlySingletonObjects没有取到，去不去第三层ObjectFactory中去取。然后isSingletonCurrentlyInCreation(beanName)方法：

Spring源码 --- AbstractBeanFactory结构及其通过beanName获取bean的过程

其是一个set集合，这个集合就是放当前正在创建的BeanName的(到后面流程看是什么时候put的)。这里的三层缓存结构，实现最底层的是singletonFactories，这一层是放的ObjectFactory，这个ObjectFactory可以用lamda：

@FunctionalInterface
public interface ObjectFactory<T> {

   /**
    * Return an instance (possibly shared or independent)
    * of the object managed by this factory.
    * @return the resulting instance
    * @throws BeansException in case of creation errors
    */
   T getObject() throws BeansException;

}

初始对象的逻辑是放在方法getObject()中的。如果调到第三层的实时，就运行此方法，然后将这个方法返回的对象放到第二层earlySingletonObjects，这个时候，这个对象只是产生了，但里面的一些属性值，还没有设置。然后将第二层的对象设置属性值后就放到第三层。这里的三层结构就将结果循环依赖问题（如果是用到构造方法注入还是会循环依赖保存，两个对象通过构造方法互相需要，都无法创建）。就是先将对象分配空间产生对象，不用将里面的属性值都设置完，只是先将自己的地址设置到对象属性中。

可以看到此这里是传的allowEarlyReference为true，就会调用到最底层。

3、没有取到 isPrototypeCurrentlyInCreation(beanName)方法的调用

Spring源码 --- AbstractBeanFactory结构及其通过beanName获取bean的过程

这个prototypesCurrentlyInCreation是与线程绑定的prototypesCurrentlyInCreation，表示当前这个beanName是不是正在创建(到后面看其是在什么时候set的)，如果在就返回true并报BeanCurrentlyInCreationException异常：

public BeanCurrentlyInCreationException(String beanName) {
   super(beanName,
         "Requested bean is currently in creation: Is there an unresolvable circular reference?");
}

4、接下来就看当前BeanFactory有没有父级BeanFactory，同时看这个beanName对应的BeanDefinition有没有在当前这个BeanFactory中，有父级并且没有在当前BeanFactory中就先去父级中取：

// Check if bean definition exists in this factory.
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
   ..............

private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

public boolean containsBeanDefinition(String beanName) {
   Assert.notNull(beanName, "Bean name must not be null");
   return this.beanDefinitionMap.containsKey(beanName);
}

5、如果没有父容器，看入参传的typeCheckOnly的值(当前是false)

if (!typeCheckOnly) {
   markBeanAsCreated(beanName);   （标记当前bean正在创建）
}

protected void markBeanAsCreated(String beanName) {
   if (!this.alreadyCreated.contains(beanName)) {
      synchronized (this.mergedBeanDefinitions) {
         if (!this.alreadyCreated.contains(beanName)) {
            // Let the bean definition get re-merged now that we're actually creating
            // the bean... just in case some of its metadata changed in the meantime.
            clearMergedBeanDefinition(beanName);
            this.alreadyCreated.add(beanName);
         }
      }
   }
}

protected void clearMergedBeanDefinition(String beanName) {
   this.mergedBeanDefinitions.remove(beanName);
}

将其从mergedBeanDefinitions中remove（什么时候put的），放到alreadyCreated中。注意这里用了一个双重锁检查（你判断没有，然后等待锁，进入再判断一次。为了解决，你判断没有，等待锁，锁当前的使用者创建对象，释放锁，你抢到锁，如果不先进行检查，就会再创建一次）。

6、checkMergedBeanDefinitionmbd, beanName, args)，看其是不是abstract的

protected void checkMergedBeanDefinition(RootBeanDefinition mbd, String beanName, @Nullable Object[] args)
      throws BeanDefinitionStoreException {

   if (mbd.isAbstract()) {
      throw new BeanIsAbstractException(beanName);
   }
}

7、检查其有没有需要依赖(@DependOn)的Bean

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);
      getBean(dep);
   }
}

本Bean通过@DependOn加的bean，简单理解就是@DependOn中的Bean要比本Bean先加载。通过isDependent判断，同时这里也有一个循环引用错误。

private boolean isDependent(String beanName, String dependentBeanName, @Nullable Set<String> alreadySeen) {
   if (alreadySeen != null && alreadySeen.contains(beanName)) {
      return false;
   }
   String canonicalName = canonicalName(beanName);
   Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
   if (dependentBeans == null) {
      return false;
   }
   if (dependentBeans.contains(dependentBeanName)) {
      return true;
   }
   .........
}

通过dependentBeanMap判断，然后这个dependentBeanMap的put就是在下面的registerDependentBean方法：

/** Map between dependent bean names: bean name --> Set of dependent bean names */
private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);

/** Map between depending bean names: bean name --> Set of bean names for the bean's dependencies */
private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64);

public void registerDependentBean(String beanName, String dependentBeanName) {
   // A quick check for an existing entry upfront, avoiding synchronization...
   String canonicalName = canonicalName(beanName);
   Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
   if (dependentBeans != null && dependentBeans.contains(dependentBeanName)) {
      return;
   }
   // No entry yet -> fully synchronized manipulation of the dependentBeans Set
   synchronized (this.dependentBeanMap) {
      dependentBeans = this.dependentBeanMap.get(canonicalName);
      if (dependentBeans == null) {
         dependentBeans = new LinkedHashSet<>(8);
         this.dependentBeanMap.put(canonicalName, dependentBeans);
      }
      dependentBeans.add(dependentBeanName);
   }
   synchronized (this.dependenciesForBeanMap) {
      Set<String> dependenciesForBean = this.dependenciesForBeanMap.get(dependentBeanName);
      if (dependenciesForBean == null) {
         dependenciesForBean = new LinkedHashSet<>(8);
         this.dependenciesForBeanMap.put(dependentBeanName, dependenciesForBean);
      }
      dependenciesForBean.add(canonicalName);
   }
}

这里有两个map dependenciesForBeanMap、dependentBeanMap，这里我们先主要关注dependentBeanMap，这个就是用来判断是不是已经放到dependentBeanMap中了，相当一个缓存以及判断循环引用的作用。

注册之后再通过getBean(dep)方法，去先获取依赖的bean（也证明了前面说的DependOn中的Bean要比本Bean先加载）。

8、dependOn如果没有或者处理完了之后，就开始Bean的获取了。如果是单例Bean：

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

这里的getSingleton方法入参用了lamda表达是，所以先将() ->{}这部分先别看成要运行的代码，因为其只是getSingleton的入参，是先运行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!)");
         }
         beforeSingletonCreation(beanName);
         boolean newSingleton = false;
         boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
        .............
         try {
            singletonObject = singletonFactory.getObject();
            newSingleton = true;
         }
         catch (IllegalStateException ex) {
            singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject == null) {
               throw ex;
            }
         }
         catch (BeanCreationException ex) {
           ................
            throw ex;
         }
         finally {
           ..............
            afterSingletonCreation(beanName);
         }
         if (newSingleton) {
            addSingleton(beanName, singletonObject);
         }
      }
      return singletonObject;
   }
}

先从获取单例的第一层singletonObjects中获取，如果为空，再通过看BeanFactory容器有没有正在销毁(默认为false)：

public void destroySingletons() {
   synchronized (this.singletonObjects) {
      this.singletonsCurrentlyInDestruction = true;
   }
...........
   this.containedBeanMap.clear();
   this.dependentBeanMap.clear();
   this.dependenciesForBeanMap.clear();
   ..........
}

如果为false调用beforeSingletonCreation方法：

protected void beforeSingletonCreation(String beanName) {
   if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
      throw new BeanCurrentlyInCreationException(beanName);
   }
}

这里主要是两个全局变量：singletonsCurrentlyInCreation，这个就是用来表示这个单例bean正在创建，这是一个set集合，所以如果添加失败，就表示正在创建。同时其如果没有包含在inCreationCheckExclusions（单例创建检查避免），也就是说，即使发生了循环依赖，你如果不想检测出来，就可以放到inCreationCheckExclusions中。这里会抛一个循环依赖的异常：

public BeanCurrentlyInCreationException(String beanName) {
   super(beanName,
         "Requested bean is currently in creation: Is there an unresolvable circular reference?");
}

现在就调我们以lamda形式的入参了：

singletonObject = singletonFactory.getObject();

@FunctionalInterface
public interface ObjectFactory<T> {
   T getObject() throws BeansException;
}

这个接口的@FunctionalInterface标志就表示其可以用lamda表达式。然后就是前面lamda表达式的createBean(beanName, mbd, args)方法，这个方法是创建一个bean的主要逻辑：

@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
      throws BeanCreationException {
   RootBeanDefinition mbdToUse = mbd;
   Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
   if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
      mbdToUse = new RootBeanDefinition(mbd);
      mbdToUse.setBeanClass(resolvedClass);
   }

   // Prepare method overrides.
   try {
      mbdToUse.prepareMethodOverrides();
   }
    ........
   try {
      // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
      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 {
      Object beanInstance = doCreateBean(beanName, mbdToUse, args);
      return beanInstance;
   }
   ............
}

1、Class<?> resolvedClass = resolveBeanClass(mbd, beanName)方法，这个就是获取这个bean的Class

protected Class<?> resolveBeanClass(final RootBeanDefinition mbd, String beanName, final Class<?>... typesToMatch)
      throws CannotLoadBeanClassException {
   try {
      if (mbd.hasBeanClass()) {
         return mbd.getBeanClass();
      }
      if (System.getSecurityManager() != null) {
         return AccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>) () ->
            doResolveBeanClass(mbd, typesToMatch), getAccessControlContext());
      }
      else {
         return doResolveBeanClass(mbd, typesToMatch);
      }
      .........
}

可以看到在BeanDefintion里面如果有设置就直接返回、如果没有就再去解析，解析过程就不展开了。

Spring源码 --- AbstractBeanFactory结构及其通过beanName获取bean的过程

2、检查有没有方法需要重写：mbdToUse.prepareMethodOverrides()，这里主要是<lookup-method/>标签逻辑判断，

看其的用法。这里我们用一个简单的demo来说下这个方法：

<beans>
   <bean id="cat" class="fev.test.Cat"/>
   <bean id="abstractPet" class="fev.test.AbstractPet">
      <lookup-method name="getPet"  bean="cat"/>
   </bean>
</beans>

public class Pet {
   private int age;
}
public class Cat extends Pet {
   private String name;
}
public abstract class AbstractPet  {
   public abstract Pet getPet();
}
factory.getBean("abstractPet");

public void prepareMethodOverrides() throws BeanDefinitionValidationException {
   // Check that lookup methods exists.
   if (hasMethodOverrides()) {
      Set<MethodOverride> overrides = getMethodOverrides().getOverrides();
      synchronized (overrides) {
         for (MethodOverride mo : overrides) {
            prepareMethodOverride(mo);
         }
      }
   }
}

首先是hasMethodOverrides方法，这个方法就是看其有没有需要重写的方法，这里会有，然后就循环遍历：

Spring源码 --- AbstractBeanFactory结构及其通过beanName获取bean的过程

这里的信息就是配置文件写的<lookup-method name="getPet" bean="cat"/>

protected void prepareMethodOverride(MethodOverride mo) throws BeanDefinitionValidationException {
   int count = ClassUtils.getMethodCountForName(getBeanClass(), mo.getMethodName());
   if (count == 0) {
      throw new BeanDefinitionValidationException(
            "Invalid method override: no method with name '" + mo.getMethodName() +
            "' on class [" + getBeanClassName() + "]");
   }
   else if (count == 1) {
      // Mark override as not overloaded, to avoid the overhead of arg type checking.
      mo.setOverloaded(false);
   }
}
public static int getMethodCountForName(Class<?> clazz, String methodName) {
   int count = 0;
   Method[] declaredMethods = clazz.getDeclaredMethods();
   for (Method method : declaredMethods) {
      if (methodName.equals(method.getName())) {
         count++;
      }
   }
   Class<?>[] ifcs = clazz.getInterfaces();
   for (Class<?> ifc : ifcs) {
      count += getMethodCountForName(ifc, methodName);
   }
   if (clazz.getSuperclass() != null) {
      count += getMethodCountForName(clazz.getSuperclass(), methodName);
   }
   return count;
}

然后在这里就会获取到匹配的方法数量

Spring源码 --- AbstractBeanFactory结构及其通过beanName获取bean的过程

这里设置为false，我们看其在LookupOverride类的使用：

@Override
public boolean matches(Method method) {
   if (this.method != null) {
      return method.equals(this.method);
   }
   else {
      return (method.getName().equals(getMethodName()) && (!isOverloaded() ||
            Modifier.isAbstract(method.getModifiers()) || method.getParameterCount() == 0));
   }
}

这里就是判断是否匹配，如果匹配然后就会再Cglib中进行复写的处理，这里先不展开了。

3、resolveBeforeInstantiation(beanName, mbdToUse)方法的调用

@Nullable
volatile Boolean beforeInstantiationResolved;
@Nullable
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
   Object bean = null;
   if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
      // Make sure bean class is actually resolved at this point.
      if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
         Class<?> targetType = determineTargetType(beanName, mbd);
         if (targetType != null) {
            bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
            if (bean != null) {
               bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
            }
         }
      }
     ..............
   }
   return bean;
}

这个hasInstantiationAwareBeanPostProcessors就判断目前有没有实现InstantiationAwareBeanPostProcessor接口的类：

InstantiationAwareBeanPostProcessor（继承BeanPostProcessor 接口）

public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {
   @Nullable
   default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
      return null;
   }
   default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
      return true;
   }
         ..........
}

4、applyBeanPostProcessorsBeforeInstantiation方法

protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
   for (BeanPostProcessor bp : getBeanPostProcessors()) {
      if (bp instanceof InstantiationAwareBeanPostProcessor) {
         InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
         Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
         if (result != null) {
            return result;
         }
      }
   }
   return null;
}

这里结合InstantiationAwareBeanPostProcessor接口的postProcessBeforeInstantiation方法的入参，这个方法的入参是Class描叙，以及这个Bean的名称。然后返回是一个Object对象，所以这里实际是如果你有实现InstantiationAwareBeanPostProcessor的类，就可以这个时候你主动去创建这个Bean对象，不用spring容器帮你创建。

5、当你如果通过InstantiationAwareBeanPostProcessor接口创建，返回一个对象，调用applyBeanPostProcessorsAfterInitialization方法

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
      throws BeansException {

   Object result = existingBean;
   for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
      Object current = beanProcessor.postProcessAfterInitialization(result, beanName);
      if (current == null) {
         return result;
      }
      result = current;
   }
   return result;
}

BeanPostProcessor

循环调用容器中实现了BeanPostProcessor接口的类，调用其的postProcessAfterInitialization方法。如果其中一个类返回null，就结束循环。

6、这个resolveBeforeInstantiation(beanName, mbdToUse)方法调用完成后，我们回到createBean方法：

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

这个是如果自己通过InstantiationAwareBeanPostProcessor接口完成了Bean的创建就直接return了。

7、如果自己没有通过InstantiationAwareBeanPostProcessor接口创建，我们往下走

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

这个就是Spring去创建Bean的具体逻辑了。

8、doCreateBean方法

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
      throws BeanCreationException {

   BeanWrapper instanceWrapper = null;
   if (mbd.isSingleton()) {
      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
   }
   if (instanceWrapper == null) {
      instanceWrapper = createBeanInstance(beanName, mbd, args);
   }
   final Object bean = instanceWrapper.getWrappedInstance();
   Class<?> beanType = instanceWrapper.getWrappedClass();
   if (beanType != NullBean.class) {
      mbd.resolvedTargetType = beanType;
   }
   synchronized (mbd.postProcessingLock) {
      if (!mbd.postProcessed) {
         try {
            applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
         }
         .............
         mbd.postProcessed = true;
      }
   }
   boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
         isSingletonCurrentlyInCreation(beanName));
   if (earlySingletonExposure) {
      addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
   }
   Object exposedObject = bean;
   try {
      populateBean(beanName, mbd, instanceWrapper);
      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()) {
              .............
            }
         }
      }
   }

   // Register bean as disposable.
   try {
      registerDisposableBeanIfNecessary(beanName, bean, mbd);
   }
      ...............
   return exposedObject;
}

9、

private final Map<String, BeanWrapper> factoryBeanInstanceCache = new ConcurrentHashMap<>(16);

if (mbd.isSingleton()) {
   instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}

这个factoryBeanInstanceCache是放继承FactoryBean接口的Bean。其put操作是通过类型判断对应Bean的时候放的（我们是通过name获取，所以现在没有调用put方法）

10、createBeanInstance方法去创建这个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);
   ...............
   Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
   if (instanceSupplier != null) {
      return obtainFromSupplier(instanceSupplier, beanName);
   }

   if (mbd.getFactoryMethodName() != null)  {
      return instantiateUsingFactoryMethod(beanName, mbd, args);
   }
     /
   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);
      }
   }

   // Need to determine the constructor...
   Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
   if (ctors != null ||
         mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
         mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
      return autowireConstructor(beanName, mbd, ctors, args);
   }
   return instantiateBean(beanName, mbd);
}

这里分为两部分，实现是根据Supplier（JDK的内容），如果没有在通过getFactoryMethodName创建实例（就是factory-method标签的作用通过自定义工厂类去参加）。

然后时候下面的部分：

if (resolved) {
   if (autowireNecessary) {
      return autowireConstructor(beanName, mbd, null, null);
   }
   else {
      return instantiateBean(beanName, mbd);
   }
}

以及下面的部分

Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null ||
      mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
      mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
   return autowireConstructor(beanName, mbd, ctors, args);
}

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

这里上面其实算是下面的缓存，通过resolvedConstructorOrFactoryMethod，下面确认是那种方式，然后会将构造函数设置到resolvedConstructorOrFactoryMethod，下次就能直接再上面调用。不用走下面的逻辑。这里我们看下面的逻辑：

determineConstructorsFromBeanPostProcessors方法：

protected Constructor<?>[] determineConstructorsFromBeanPostProcessors(@Nullable Class<?> beanClass, String beanName)
      throws BeansException {

   if (beanClass != null && hasInstantiationAwareBeanPostProcessors()) {
      for (BeanPostProcessor bp : getBeanPostProcessors()) {
         if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
            SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
            Constructor<?>[] ctors = ibp.determineCandidateConstructors(beanClass, beanName);
            if (ctors != null) {
               return ctors;
            }
         }
      }
   }
   return null;
}

SmartInstantiationAwareBeanPostProcessor

可以看到这里是判断看又没有SmartInstantiationAwareBeanPostProcessor 接口实现。如果有，就通过满足条件的SmartInstantiationAwareBeanPostProcessor 实现类去获取Bean的构造函数，像上面InstantiationAwareBeanPostProcessor 接口直接创建Bean类似逻辑。

然后逻辑判断：

if (ctors != null ||
      mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
      mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))

这里是或，如果能获取到构造函数或自动设置Bean注入方式为AUTOWIRE_CONSTRUCTOR或有ConstructorArgumentValues构造参数，也可以：

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

   return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
}

然后这个autowireConstructor方法，会进行构造函数参数、以及确认构造函数，这里我们跳过一些细节，因为最终是拿到构造函数去初始化：

public BeanWrapper autowireConstructor(final String beanName, final RootBeanDefinition mbd,
      @Nullable Constructor<?>[] chosenCtors, @Nullable final Object[] explicitArgs) {
   BeanWrapperImpl bw = new BeanWrapperImpl();
   this.beanFactory.initBeanWrapper(bw);
    .............
   try {
      final InstantiationStrategy strategy = beanFactory.getInstantiationStrategy();
      Object beanInstance;
       ................
         beanInstance = strategy.instantiate(mbd, beanName, this.beanFactory, constructorToUse, argsToUse);
      }
      bw.setBeanInstance(beanInstance);
      return bw;
   }
   catch (Throwable ex) {
      throw new BeanCreationException(mbd.getResourceDescription(), beanName,
            "Bean instantiation via constructor failed", ex);
   }
}

创建对象就是在strategy.instantiate方法：

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

   if (!bd.hasMethodOverrides()) {
       ............
      return (args != null ? BeanUtils.instantiateClass(ctor, args) : BeanUtils.instantiateClass(ctor));
   }
   else {
      return instantiateWithMethodInjection(bd, beanName, owner, ctor, args);
   }

可以看到这里有两个分支，一个就是前面说的有没有方法重写，去创建，如果没有是直接通过Spring的工具类BeanUtils.instantiateClass创建对象：

public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
   try {
      ReflectionUtils.makeAccessible(ctor);
      return (KotlinDetector.isKotlinType(ctor.getDeclaringClass()) ?
            KotlinDelegate.instantiateClass(ctor, args) : ctor.newInstance(args));
   }
  ...........
}

如果需要重写：

Spring源码 --- AbstractBeanFactory结构及其通过beanName获取bean的过程

可以看到这里就有使用与Cglib去创建对象了。另一个实现类SimpleIns.....并有没有实现整个创建逻辑：

protected Object instantiateWithMethodInjection(RootBeanDefinition bd, @Nullable String beanName,
      BeanFactory owner, @Nullable Constructor<?> ctor, @Nullable Object... args) {

   throw new UnsupportedOperationException("Method Injection not supported in SimpleInstantiationStrategy");
}

创建好对象后就设置到BeanWrapperImpl中bw.setBeanInstance(beanInstance);

public void setBeanInstance(Object object) {
   this.wrappedObject = object;
   this.rootObject = object;
   this.typeConverterDelegate = new TypeConverterDelegate(this, this.wrappedObject);
   setIntrospectionClass(object.getClass());
}

如果不满足上面分支，我们再回到前面的createBeanInstance方法走下面分支：

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

protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
   try {
      Object beanInstance;
      final BeanFactory parent = this;
        ..........
         beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
      }
      BeanWrapper bw = new BeanWrapperImpl(beanInstance);
      initBeanWrapper(bw);
      return bw;
   }
   ..............
}

@Override
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
   if (!bd.hasMethodOverrides()) {
      Constructor<?> constructorToUse;
      synchronized (bd.constructorArgumentLock) {
         constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
         if (constructorToUse == null) {
            final Class<?> clazz = bd.getBeanClass();
                ...........
                  constructorToUse = clazz.getDeclaredConstructor();
               }
               bd.resolvedConstructorOrFactoryMethod = constructorToUse;
            }
            catch (Throwable ex) {
               throw new BeanInstantiationException(clazz, "No default constructor found", ex);
            }
         }
      }
      return BeanUtils.instantiateClass(constructorToUse);
   }
   else {
      // Must generate CGLIB subclass.
      return instantiateWithMethodInjection(bd, beanName, owner);
   }
}

可以看到这个如果有重写，也会像前面能获取到构造函数一样，调用instantiateWithMethodInjection方法去创建对象，如果没有，就会constructorToUse = clazz.getDeclaredConstructor();主动获取构造函数，然后放到前面有提到的resolvedConstructorOrFactoryMethod中，形成类似缓存，然后通过BeanUtils.instantiateClass创建对象。

现在Bean对象创建后，还没有属性赋值，下面我们再回到前面的doCreateBean方法。

Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
   mbd.resolvedTargetType = beanType;
}

public Class<?> getTargetType() {
   if (this.resolvedTargetType != null) {
      return this.resolvedTargetType;
   }
   ResolvableType targetType = this.targetType;
   return (targetType != null ? targetType.resolve() : null);
}

这里等于获取这个Bean对应的Class（这里等于就是将Bean的calss描叙解析出来），然后设置到BeanDefintion的resolvedTargetType属性中，这个属性是在通过类型获取中有其作用，可以先不关注。

final Object postProcessingLock = new Object();
boolean postProcessed = false;

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

postProcessed 默认为false，进入applyMergedBeanDefinitionPostProcessors方法：

protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
   for (BeanPostProcessor bp : getBeanPostProcessors()) {
      if (bp instanceof MergedBeanDefinitionPostProcessor) {
         MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
         bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
      }
   }
}

MergedBeanDefinitionPostProcessor

可以看到这里有一个新的继承PostProcessor的接口

public interface MergedBeanDefinitionPostProcessor extends BeanPostProcessor {
   void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName);
}

这个方法的入参有RootBeanDefinition、beanType、beanName，然后返回为void，所以这里一般如果不实现一些诸如Aware类型的接口的话。通过这些入参可以知道这个接口应该是让你能处理RootBeanDefinition的内容。同时这里还有一个时机的问题，就是这个还没有通过RootBeanDefinition的propertyValues设置对象的值。

运行这个之后再回到前面mbd.postProcessed = true;将其设置为true，下次就不再运行这里了。

之后是一个判断：

private boolean allowCircularReferences = true;

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

public boolean isSingletonCurrentlyInCreation(String beanName) {
   return this.singletonsCurrentlyInCreation.contains(beanName);
}

allowCircularReferences 是否允许循环引用，默认为true。然后是singletonsCurrentlyInCreation判断含不含有这个beanName。

满足调用addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean))方法：

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
   Assert.notNull(singletonFactory, "Singleton factory must not be null");
   synchronized (this.singletonObjects) {
      if (!this.singletonObjects.containsKey(beanName)) {
         this.singletonFactories.put(beanName, singletonFactory);
         this.earlySingletonObjects.remove(beanName);
         this.registeredSingletons.add(beanName);
      }
   }
}

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
   Object exposedObject = bean;
   if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
      for (BeanPostProcessor bp : getBeanPostProcessors()) {
         if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
            SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
            exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
         }
      }
   }
   return exposedObject;
}

前面的 () -> getEarlyBeanReference(beanName, mbd, bean) lamda表达式就是表示ObjectFactory对象。可以看到这里就是将这个ObjectFactory放到了Bean三层结果的第三层singletonFactories中，同时放到单例集合registeredSingletons中。（这个时候并没有去获取这个Bea，所以其不会调用这个ObjectFactory的get方法去获取这个Bean，还没与提到第二层）

对于getEarlyBeanReference方法。这个方法再次调用了前面提到的SmartInstantiationAwareBeanPostProcessor接口的另一个方法getEarlyBeanReference，通过入参可以看到，我们可以通过这个接口去操作原始的还没有赋值的对象，然后将其返回。

现在运行populateBean(beanName, mbd, instanceWrapper)方法去填充这个Bean对象的属性值了

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
   if (bw == null) {
      if (mbd.hasPropertyValues()) {
         throw new BeanCreationException(
               mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
      }
      else {
         return;
      }
   }
   // Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
   // state of the bean before properties are set. This can be used, for example,
   // to support styles of field injection.
   boolean continueWithPropertyPopulation = true;
   if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
      for (BeanPostProcessor bp : getBeanPostProcessors()) {
         if (bp instanceof InstantiationAwareBeanPostProcessor) {
            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
            if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
               continueWithPropertyPopulation = false;
               break;
            }
         }
      }
   }
   if (!continueWithPropertyPopulation) {
      return;
   }
   PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

   if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
         mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
      MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
      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) {
      if (pvs == null) {
         pvs = mbd.getPropertyValues();
      }
      PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
      if (hasInstAwareBpps) {
         for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
               InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
               pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
               if (pvs == null) {
                  return;
               }
            }
         }
      }
      if (needsDepCheck) {
         checkDependencies(beanName, mbd, filteredPds, pvs);
      }
   }
   if (pvs != null) {
      applyPropertyValues(beanName, mbd, bw, pvs);
   }
}

1、首先进行判断看实例是否为null

if (bw == null) {
   if (mbd.hasPropertyValues()) {
      throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
   }
   else {
      // Skip property population phase for null instance.
      return;
   }
}

2、

boolean continueWithPropertyPopulation = true;

if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
   for (BeanPostProcessor bp : getBeanPostProcessors()) {
      if (bp instanceof InstantiationAwareBeanPostProcessor) {
         InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
         if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
            continueWithPropertyPopulation = false;
            break;
         }
      }
   }
}
if (!continueWithPropertyPopulation) {
   return;
}

这里的hasInstantiationAwareBeanPostProcessors是用来判断有没有添加在前面提到的InstantiationAwareBeanPostProcessor类型的PostProcessor。

public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
  .............
   if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
      this.hasInstantiationAwareBeanPostProcessors = true;
   }
   ...............
}

然后有就运行这个接口的bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)方法：

default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
   return true;
}

这个方法是布尔类型，所以可以这个通过这个布尔类型在通过下面的代码：，可以知道可以通过这个方法来控制，让整个Bean是否还需要运行下面的代码来接着填充Bean的属性。

if (!continueWithPropertyPopulation) {
   return;
}

接下来是PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null)。获取BeanDefintion的PropertyValues。我们前面的Bean XML的描叙为：

<bean id="schoolBean" class="fev.test.School">
   <property name = "name" value="schoolFev"/>
   <property name = "student"  ref="studentBean"/>
</bean>

Spring源码 --- AbstractBeanFactory结构及其通过beanName获取bean的过程

通过这个图片以及Bean XML描叙可以知道，如果是简单的属性描叙ProertyValue的value为TypedStringValue类型，而如果有用的另一个Bean的话就是RuntimeVeanReference类型。

然后下面是判断是那种装配方式就是我们在标签中写的例如：

if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
      mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
   MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
   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;
}

protected void autowireByName(
      String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
   String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
   for (String propertyName : propertyNames) {
      if (containsBean(propertyName)) {
         Object bean = getBean(propertyName);
         pvs.add(propertyName, bean);
         registerDependentBean(propertyName, beanName);
         ...........
      }
   }
}

如果没有设置这个属性，就跳过这里直接到下面。可以看到这里是根据propertyName直接去获取Bean。然后添加到pvs中。（跳过unsatisfiedNonSimpleProperties方法会将简单类型去掉，例如我们前面讲的schoolBean中，假设设置这个为byName，会将其中的name属性去掉，只返回student属性, !BeanUtils.isSimpleProperty(pd.getPropertyType())）：

if (pd.getWriteMethod() != null && !isExcludedFromDependencyCheck(pd) && !pvs.contains(pd.getName()) &&
      !BeanUtils.isSimpleProperty(pd.getPropertyType())) {

这里如果没有设置这两种类型就到下面两个判断：

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

第一个看名称就知道是判断有没有InstantiationAwareBeanPostProcessor接口实现类。这个类如果不开其继承的BeanPostProcessor的方法有三个方法，前面已经运行两个了，一个是初始构造函数，一个是用于控制是否继续往下设置Bean的属性。现在是要运行其的第三个方法。

第二个是检查DependencyCheck，关于DependencyCheck可以看这篇文章:

public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
      implements BeanDefinition, Cloneable {
        ...............
public static final int DEPENDENCY_CHECK_NONE = 0;
/**
 * Constant that indicates dependency checking for object references.
 * @see #setDependencyCheck
 */
public static final int DEPENDENCY_CHECK_OBJECTS = 1;
/**
 * Constant that indicates dependency checking for "simple" properties.
 * @see #setDependencyCheck
 * @see org.springframework.beans.BeanUtils#isSimpleProperty
 */
public static final int DEPENDENCY_CHECK_SIMPLE = 2;
/**
 * Constant that indicates dependency checking for all properties
 * (object references as well as "simple" properties).
 * @see #setDependencyCheck
 */
public static final int DEPENDENCY_CHECK_ALL = 3;
    .............
}

简答来说，就是通过不同的检查级别来检查Bean的属性有没有设置，例如不检查、只检查简单类型，同时也检查引用类型等。

现在我们玩下看这两个的使用：

private final ConcurrentMap<Class<?>, PropertyDescriptor[]> filteredPropertyDescriptorsCache =
      new ConcurrentHashMap<>(256);

if (hasInstAwareBpps || needsDepCheck) {
   if (pvs == null) {
      pvs = mbd.getPropertyValues();
   }
   PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
   if (hasInstAwareBpps) {
      for (BeanPostProcessor bp : getBeanPostProcessors()) {
         if (bp instanceof InstantiationAwareBeanPostProcessor) {
            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
            pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
            if (pvs == null) {
               return;
            }
         }
      }
   }
   if (needsDepCheck) {
      checkDependencies(beanName, mbd, filteredPds, pvs);
   }
}

首先获取filteredPds这个是与下面checkDependencies方法相关的,获取filteredPropertyDescriptorsCache 里面的值(工厂类的成员变量)。

然后运行InstantiationAwareBeanPostProcessor实现类的postProcessPropertyValues方法。通过返回结果，这个方法应该是让你能自定义处理pvs。

然后是checkDependencies方法：

protected void checkDependencies(
      String beanName, AbstractBeanDefinition mbd, PropertyDescriptor[] pds, PropertyValues pvs)
      throws UnsatisfiedDependencyException {
   int dependencyCheck = mbd.getDependencyCheck();
   for (PropertyDescriptor pd : pds) {
      if (pd.getWriteMethod() != null && !pvs.contains(pd.getName())) {
         boolean isSimple = BeanUtils.isSimpleProperty(pd.getPropertyType());
         boolean unsatisfied = (dependencyCheck == RootBeanDefinition.DEPENDENCY_CHECK_ALL) ||
               (isSimple && dependencyCheck == RootBeanDefinition.DEPENDENCY_CHECK_SIMPLE) ||
               (!isSimple && dependencyCheck == RootBeanDefinition.DEPENDENCY_CHECK_OBJECTS);
         if (unsatisfied) {
            throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, pd.getName(),
                  "Set this property value or disable dependency checking for this bean.");
         }
      }
   }
}

这里可以看到，假如是DEPENDENCY_CHECK_SIMPLE，看目前在配置XML的时候填写的PropertyValues 属性，如果在PropertyDescriptor中中，没有就代表没有设置这个值，然后看当前的检查基本是哪种，然后通过isSimpleProperty方法，判断其是不是简单类型，如果是满足这一条，就报UnsatisfiedDependencyException异常。

这里我们通过一个demo来说明：

public class Student
{
    private String name;
    private int age;
    private Book book;
}
public class Book
{
    private String color;
}
<bean id="student" class="......Student" dependency-check="simple">
    <property name="name" value="Fev"/>
    <property name="book" ref="book"/>
</bean>
<bean id="book" class=".........Book">
    <property name="color" value="red"/>
</bean>

Spring源码 --- AbstractBeanFactory结构及其通过beanName获取bean的过程

可以看到在IDEA中直接就给出提示了。

我们忽略这个，进入源码：

Spring源码 --- AbstractBeanFactory结构及其通过beanName获取bean的过程

可以看到这里现在已经获取了需要拦截检查的属性（通过BeanDefintion的Class获取）

Spring源码 --- AbstractBeanFactory结构及其通过beanName获取bean的过程

可以看到在检查age的时候，这里为true，就会报下面的UnsatisfiedDependencyException异常（这个地方的内容换了环境后面补充的，所以与前面的源码格式不同）。

这里都处理完了之后就通过applyPropertyValues(beanName, mbd, bw, pvs)方法，将属性填充到Bean对象中。

protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
    ..............
   MutablePropertyValues mpvs = null;
   List<PropertyValue> original;
         ..........
   if (pvs instanceof MutablePropertyValues) {
      mpvs = (MutablePropertyValues) pvs;
      if (mpvs.isConverted()) {
         // Shortcut: use the pre-converted values as-is.
         try {
            bw.setPropertyValues(mpvs);
            return;
         }
       ............
      }
      original = mpvs.getPropertyValueList();
   }
   else {
      original = Arrays.asList(pvs.getPropertyValues());
   }
   TypeConverter converter = getCustomTypeConverter();
   if (converter == null) {
      converter = bw;
   }
   BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
   // Create a deep copy, resolving any references for values.
   List<PropertyValue> deepCopy = new ArrayList<>(original.size());
   boolean resolveNecessary = false;
   for (PropertyValue pv : original) {
      if (pv.isConverted()) {
         deepCopy.add(pv);
      }
      else {
         String propertyName = pv.getName();
         Object originalValue = pv.getValue();
         Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
         Object convertedValue = resolvedValue;
         boolean convertible = bw.isWritableProperty(propertyName) &&
               !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
         if (convertible) {
            convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
         }
         if (resolvedValue == originalValue) {
            if (convertible) {
               pv.setConvertedValue(convertedValue);
            }
            deepCopy.add(pv);
         }
         else if (convertible && originalValue instanceof TypedStringValue &&
               !((TypedStringValue) originalValue).isDynamic() &&
               !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
            pv.setConvertedValue(convertedValue);
            deepCopy.add(pv);
         }
         else {
            resolveNecessary = true;
            deepCopy.add(new PropertyValue(pv, convertedValue));
         }
      }
   }
   if (mpvs != null && !resolveNecessary) {
      mpvs.setConverted();
   }
   try {
      //设置实例化对象的值
      bw.setPropertyValues(new MutablePropertyValues(deepCopy));
   }
       ................
}

这一大长串我们分成小段来分析：

1、我们目前这个pvs就是MutablePropertyValues类型：

mpvs = (MutablePropertyValues) pvs;
if (mpvs.isConverted()) {
   // Shortcut: use the pre-converted values as-is.
   try {
      bw.setPropertyValues(mpvs);
      return;
   }
   .........
}
original = mpvs.getPropertyValueList();

public boolean isConverted() {
   return this.converted;
}

converted默认为false，现在还不会在这里运行（所以这里应该也相当一个缓存的方法）

TypeConverter converter = getCustomTypeConverter();
if (converter == null) {
   converter = bw;
}

获取类型转换器，这个前面章节有讲过

BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
public BeanDefinitionValueResolver(
      AbstractBeanFactory beanFactory, String beanName, BeanDefinition beanDefinition, TypeConverter typeConverter) {

   this.beanFactory = beanFactory;
   this.beanName = beanName;
   this.beanDefinition = beanDefinition;
   this.typeConverter = typeConverter;
}

构建BeanDefinitionValueResolver对象。

然后是遍历original，实现是

if (pv.isConverted()) {
   deepCopy.add(pv);
}

目前为false，走的是下面，我们到下面看这个converted(看注释，这个应该是表示这个值不需要再进行转换)与deepCopy是干嘛的

String propertyName = pv.getName();
Object originalValue = pv.getValue();
Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
Object convertedValue = resolvedValue;
boolean convertible = bw.isWritableProperty(propertyName) &&
      !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
if (convertible) {
   convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
}
// Possibly store converted value in merged bean definition,
// in order to avoid re-conversion for every created bean instance.
if (resolvedValue == originalValue) {
   if (convertible) {
      pv.setConvertedValue(convertedValue);
   }
   deepCopy.add(pv);
}
else if (convertible && originalValue instanceof TypedStringValue &&
      !((TypedStringValue) originalValue).isDynamic() &&
      !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
   pv.setConvertedValue(convertedValue);
   deepCopy.add(pv);
}
else {
   resolveNecessary = true;
   deepCopy.add(new PropertyValue(pv, convertedValue));
}

valueResolver.resolveValueIfNecessary(pv, originalValue)方法，这个方法就是获取我们的目的属性3值，例如我们的引用类型student，这个方法就会获取到这个student 所对应的Bean。

public Object resolveValueIfNecessary(Object argName, @Nullable Object value) {
   if (value instanceof RuntimeBeanReference) {
      RuntimeBeanReference ref = (RuntimeBeanReference) value;
      return resolveReference(argName, ref);
   }
   else if (value instanceof RuntimeBeanNameReference) {
      ...............
   }
   else if (value instanceof BeanDefinitionHolder) {
     ..............
   }
   else if (value instanceof BeanDefinition) {
      .............
   }
   else if (value instanceof ManagedArray) {
        .............
   }
   else if (value instanceof ManagedList) {
      // May need to resolve contained runtime references.
      return resolveManagedList(argName, (List<?>) value);
   }
   else if (value instanceof ManagedSet) {
      // May need to resolve contained runtime references.
      return resolveManagedSet(argName, (Set<?>) value);
   }
   else if (value instanceof ManagedMap) {
      // May need to resolve contained runtime references.
      return resolveManagedMap(argName, (Map<?, ?>) value);
   }
   else if (value instanceof ManagedProperties) {
        ..............
   }
   else if (value instanceof TypedStringValue) {
                ..............
            return this.typeConverter.convertIfNecessary(valueObject, resolvedTargetType);
         }
         else {
            return valueObject;
         }
        .............
   else {
      return evaluate(value);  
   }
}

我们可以看到这个方法有各种类型对应的获取方法，就是前面讲的属性的对应的value表示其是什么类型。我们前面讲到对应TypedStringValue(简单的名称)与RuntimeBeanReference(引用到了其他的Bean)简单的String类型并不需要什么转换。我们看如果是RuntimeBeanReference类型：

private Object resolveReference(Object argName, RuntimeBeanReference ref) {
   try {
      Object bean;
      String refName = ref.getBeanName();
      refName = String.valueOf(doEvaluate(refName));
      if (ref.isToParent()) {
           ..........
         bean = this.beanFactory.getParentBeanFactory().getBean(refName);
      }
      else {
         bean = this.beanFactory.getBean(refName);
         this.beanFactory.registerDependentBean(refName, this.beanName);
      }
      if (bean instanceof NullBean) {
         bean = null;
      }
      return bean;
   }
   ...........
}

可以看到在这里就又会与去beanFactory.getBean(refName);获取bean了。然后走前面的流程。

获取到需要的value后，我们往下：

boolean convertible = bw.isWritableProperty(propertyName) &&
      !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
if (convertible) {
   convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
}

这里就是可转换的，这个属性是可写的，isNestedOrIndexedProperty方法具体作用在前面讲类型转换的章节讲过,简单说下其逻辑。如果这个propertyName含有'.'、"["这样的前缀符号，就返回true。现在我们是标准名称，不含，所以convertible为true，然后就调用convertForProperty方法去进行类型转换，类型转获取就不在这里再描叙了。

转换后

if (resolvedValue == originalValue) {
   if (convertible) {
      pv.setConvertedValue(convertedValue);
   }
   deepCopy.add(pv);
}
else if (convertible && originalValue instanceof TypedStringValue &&
      !((TypedStringValue) originalValue).isDynamic() &&
      !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
   pv.setConvertedValue(convertedValue);
   deepCopy.add(pv);
}
else {
   resolveNecessary = true;
   deepCopy.add(new PropertyValue(pv, convertedValue));
}

resolvedValue == originalValue是Property转换后的value与原来的value相同走的分支，直接这个看大概是设置集合这种类型。

我们如果用引用其他bean，就走的是下面分支。

resolveNecessary = true;

deepCopy.add(new PropertyValue(pv, convertedValue));

public PropertyValue(PropertyValue original, @Nullable Object newValue) {
   Assert.notNull(original, "Original must not be null");
   this.name = original.getName();
   this.value = newValue;
   this.optional = original.isOptional();
   this.conversionNecessary = original.conversionNecessary;
   this.resolvedTokens = original.resolvedTokens;
   setSource(original);
   copyAttributesFrom(original);
}

resolveNecessary (需要解析)，设置为true，再将PropertyValue以及解析获取所的的value(将convertedValue覆盖原来的value)添加到deepCopy。

if (mpvs != null && !resolveNecessary) {
   mpvs.setConverted();
}
public void setConverted() {
   this.converted = true;
}

如果我们是例如引用其他bean的类型，这里的resolveNecessary(需要进行解析)已经被我们设置为true了，所以这里整个converted还是默认值false，如果是上面那两个分支，没有设置resolveNecessary为true，然后这里就会将converted设置为true。如果为true，我们回到上面的

if (pvs instanceof MutablePropertyValues) {
   mpvs = (MutablePropertyValues) pvs;
   if (mpvs.isConverted()) {
      // Shortcut: use the pre-converted values as-is.
      try {
         bw.setPropertyValues(mpvs);
         return;
      }
}

就不会运行下面这些了。

然后我们再到下面的bw.setPropertyValues(new MutablePropertyValues(deepCopy))方法，这里可以看到前面的deepCopy就是搜集转换后的PropertyValue。将其设置到Bean对象中(这个setPropertyValue前面类型转换器有分析)

AbstractNestablePropertyAccessor类

public void setPropertyValue(PropertyValue pv) throws BeansException {
   PropertyTokenHolder tokens = (PropertyTokenHolder) pv.resolvedTokens;
   if (tokens == null) {
      String propertyName = pv.getName();
      AbstractNestablePropertyAccessor nestedPa;
      try {
         nestedPa = getPropertyAccessorForPropertyPath(propertyName);
      ...........
      tokens = getPropertyNameTokens(getFinalPath(nestedPa, propertyName));
      if (nestedPa == this) {
         pv.getOriginalPropertyValue().resolvedTokens = tokens;
      }
      nestedPa.setPropertyValue(tokens, pv);
   }
   else {
      setPropertyValue(tokens, pv);
   }
}

这里最终会调用到：

public void setValue(final @Nullable Object value) throws Exception {
      final Method writeMethod = (this.pd instanceof GenericTypeAwarePropertyDescriptor ?
            ((GenericTypeAwarePropertyDescriptor) this.pd).getWriteMethodForActualAccess() :
            this.pd.getWriteMethod());
         ..............
         ReflectionUtils.makeAccessible(writeMethod);
         writeMethod.invoke(getWrappedInstance(), value);
      }
   }
}

现在已经通过populateBean方法属性设置了，我们再回到前面的doCreateBean方法，现在是运行exposedObject = initializeBean(beanName, exposedObject, mbd)方法

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

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
     ............
      invokeAwareMethods(beanName, bean);
   }

   Object wrappedBean = bean;
   if (mbd == null || !mbd.isSynthetic()) {
      wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
   }
   try {
      invokeInitMethods(beanName, wrappedBean, mbd);
   }
   ................
   if (mbd == null || !mbd.isSynthetic()) {
      wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
   }
   return wrappedBean;
}

可以看到这个方法开始是运行invokeAwareMethods方法

private void invokeAwareMethods(final String beanName, final Object bean) {
   if (bean instanceof Aware) {
      if (bean instanceof BeanNameAware) {
         ((BeanNameAware) bean).setBeanName(beanName);
      }
      if (bean instanceof BeanClassLoaderAware) {
         ClassLoader bcl = getBeanClassLoader();
         if (bcl != null) {
            ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
         }
      }
      if (bean instanceof BeanFactoryAware) {
         ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
      }
   }
}

可以看到这里是运行Aware类型的接口

BeanNameAware、BeanClassLoaderAware、BeanFactoryAware

这三个可以看到分别是对创建的对象进行beanName设置、类加载器设置、BeanFactory设置。

然后是

if (mbd == null || !mbd.isSynthetic()) {
   wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}

public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
      throws BeansException {

   Object result = existingBean;
   for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
      Object current = beanProcessor.postProcessBeforeInitialization(result, beanName);
      if (current == null) {
         return result;
      }
      result = current;
   }
   return result;
}

BeanPostProcessor

可以看到这里是运行BeanPostProcessor接口的postProcessBeforeInitialization方法。从返回可以看到，你可以去操作修改这个Bean对象。

同时我们将这个BeanPostProcessor接口及其子接口与Aware接口使用比较。可以知道这两者的区别。一个是需要进行instanceof判断的所以Aware接口是实现的要注入的Bean对象上的，而BeanPostProcessor接口是能作用在整个Bean工厂所有的Bean创建创建过程。

InitializingBean

protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
      throws Throwable {

   boolean isInitializingBean = (bean instanceof InitializingBean);
   if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
              ...................
         ((InitializingBean) bean).afterPropertiesSet();
   }

   if (mbd != null && bean.getClass() != NullBean.class) {
      String initMethodName = mbd.getInitMethodName();
      if (StringUtils.hasLength(initMethodName) &&
            !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
            !mbd.isExternallyManagedInitMethod(initMethodName)) {
         invokeCustomInitMethod(beanName, bean, mbd);
      }
   }
}

protected void invokeCustomInitMethod(String beanName, final Object bean, RootBeanDefinition mbd)
      throws Throwable {

   String initMethodName = mbd.getInitMethodName();
           ...............
         ReflectionUtils.makeAccessible(initMethod);
         initMethod.invoke(bean);
    ............
   }
}

可以看到这里是有两部分的

前一部分InitializingBean接口afterPropertiesSet方法的执行，同样InitializingBean也是作用在Bean级别。

第二部分是initMethod方法的执行。

public class School {
   private String name;
   private Student student;
   public void initStart()
   {
      System.out.println("initMethod");
   }
}
<bean id="schoolBean" class="fev.test.School" init-method="initStart">
   <property name = "name" value="schoolFev"/>
   <property name = "student"  ref="studentBean"/>
</bean>

所以这个initMethod方法就是你在Bean配置的时候指定的一个Bean中的方法，让其在这个时候执行（需要注意这些的BeanPostProcessor接口及Aware接口执行的作用及其执行的时机）

这个initializeBean方法执行之后

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

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
   Object singletonObject = this.singletonObjects.get(beanName);
   if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
      synchronized (this.singletonObjects) {
         singletonObject = this.earlySingletonObjects.get(beanName);
         if (singletonObject == null && allowEarlyReference) {
            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
            if (singletonFactory != null) {
               singletonObject = singletonFactory.getObject();
               this.earlySingletonObjects.put(beanName, singletonObject);
               this.singletonFactories.remove(beanName);
            }
         }
      }
   }
   return singletonObject;
}

这个earlySingletonExposure在前面的设置的，看是否设置为能循环引用，以及是否是单例创建，这里为true。然后是getSingleton(beanName, false);方法执行。这个方法就是去三级缓存中取。如果入参allowEarlyReference为false就表示不会去第三层去，表示不会掉第三层ObjectFactory的get方法（后面会再调用一次传入true，将其提到第二层）。所以这里是不能取到的，直接不运行下面的部分。假如这里能取到，然后是allowRawInjectionDespiteWrapping （默认为false，且spring并没有主动再设置这个值），并且有依赖其他的Bean(dependentOn)。

for (String dependentBean : dependentBeans) {
   if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
      actualDependentBeans.add(dependentBean);
   }
}
if (!actualDependentBeans.isEmpty()) {
   throw new BeanCurrentlyInCreationException(beanName,
      ...............
}
protected boolean removeSingletonIfCreatedForTypeCheckOnly(String beanName) {
   if (!this.alreadyCreated.contains(beanName)) {
      removeSingleton(beanName);
      return true;
   }
   else {
      return false;
   }
}

可以看到这里，通过alreadyCreated，如果没有包含就返回true(表示依赖的Bean并没有创建)，然后就添加到actualDependentBeans中，如果actualDependentBeans不为空，就报BeanCurrentlyInCreationException错误。

这里运行之后

// Register bean as disposable.
try {
   registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
   if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
      if (mbd.isSingleton()) {
           ...........
         registerDisposableBean(beanName,
               new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
      }
      else {
         // A bean with a custom scope...
         Scope scope = this.scopes.get(mbd.getScope());
         if (scope == null) {
            throw new IllegalStateException("No Scope registered for scope name '" + mbd.getScope() + "'");
         }
         scope.registerDestructionCallback(beanName,
               new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
      }
   }
}
protected boolean requiresDestruction(Object bean, RootBeanDefinition mbd) {
   return (bean.getClass() != NullBean.class &&
         (DisposableBeanAdapter.hasDestroyMethod(bean, mbd) || (hasDestructionAwareBeanPostProcessors() &&
               DisposableBeanAdapter.hasApplicableProcessors(bean, getBeanPostProcessors()))));
}
public static boolean hasApplicableProcessors(Object bean, List<BeanPostProcessor> postProcessors) {
   if (!CollectionUtils.isEmpty(postProcessors)) {
      for (BeanPostProcessor processor : postProcessors) {
         if (processor instanceof DestructionAwareBeanPostProcessor) {
            DestructionAwareBeanPostProcessor dabpp = (DestructionAwareBeanPostProcessor) processor;
            if (dabpp.requiresDestruction(bean)) {
               return true;
            }
         }
      }
   }
   return false;
}
public void registerDisposableBean(String beanName, DisposableBean bean) {
   synchronized (this.disposableBeans) {
      this.disposableBeans.put(beanName, bean);
   }
}

注册为一次性Bean，这里有两个地方。

DestructionAwareBeanPostProcessor

一判断、如果不是多例，并且在容器中有DestructionAwareBeanPostProcessor接口的实现类。

registerDisposableBean(beanName, new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));

public interface DestructionAwareBeanPostProcessor extends BeanPostProcessor {

   void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException;
    
   default boolean requiresDestruction(Object bean) {
      return true;
   }
}

class DisposableBeanAdapter implements DisposableBean, Runnable, Serializable { 
      public DisposableBeanAdapter(Object bean, String beanName, RootBeanDefinition beanDefinition,
         List<BeanPostProcessor> postProcessors, @Nullable AccessControlContext acc) {

      Assert.notNull(bean, "Disposable bean must not be null");
      this.bean = bean;
      this.beanName = beanName;
      ...............
      this.beanPostProcessors = filterPostProcessors(postProcessors, bean);
    }
}

private List<DestructionAwareBeanPostProcessor> filterPostProcessors(List<BeanPostProcessor> processors, Object bean) {
      ................
      for (BeanPostProcessor processor : processors) {
         if (processor instanceof DestructionAwareBeanPostProcessor) {
            DestructionAwareBeanPostProcessor dabpp = (DestructionAwareBeanPostProcessor) processor;
            if (dabpp.requiresDestruction(bean)) {
               filteredPostProcessors.add(dabpp);
            }
   }
   return filteredPostProcessors;
}

通过这个DestructionAwareBeanPostProcessor接口的requiresDestruction方法，将其添加到DisposableBeanAdapter中，然后在销毁这个一次性Bean的时候，在运行DestructionAwareBeanPostProcessor的postProcessBeforeDestruction方法。后面一开始是运行 Bean容器本身的destroy方法，再是在Bean标签配置的destroy-method方法，与前面的inti-method一样

@Override
public void destroy() {
   if (!CollectionUtils.isEmpty(this.beanPostProcessors)) {
      for (DestructionAwareBeanPostProcessor processor : this.beanPostProcessors) {
         processor.postProcessBeforeDestruction(this.bean, this.beanName);
      }
   }

   if (this.invokeDisposableBean) {
           ..........
            ((DisposableBean) bean).destroy();
         }
      }
     ........
   }

   if (this.destroyMethod != null) {
      invokeCustomDestroyMethod(this.destroyMethod);
   }
   else if (this.destroyMethodName != null) {
      Method methodToCall = determineDestroyMethod(this.destroyMethodName);
      if (methodToCall != null) {
         invokeCustomDestroyMethod(methodToCall);
      }
   }
}

二如果是单例就注册到disposableBeans中，表示是一次性的Bean。如果是Scope，这个Scope前面有提到过，例如Session这种，只需要在一次创建中产生。这里就是调用这个scope的registerDestructionCallback方法。这个scope就先不再展开了。

最后到这里整个Bean的创建就完成了。

让我们再回到前面的getSinglet方法：

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
          ...........
         beforeSingletonCreation(beanName);
            ...............
            singletonObject = singletonFactory.getObject();
            newSingleton = true;
              ............
         finally {
             .........
            afterSingletonCreation(beanName);
         }
         if (newSingleton) {
            addSingleton(beanName, singletonObject);
         }
      }
      return singletonObject;
   }
}

我们前面则一到部分就是讲singletonObject = singletonFactory.getObject()。现在运行finally代码块中的afterSingletonCreation方法

protected void afterSingletonCreation(String beanName) {
   if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
      throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
   }
}

这个其实就是一个检测作用，判断这个Bean是否正在创建。同时通过singletonsCurrentlyInCreation，将其从singletonsCurrentlyInCreation，单例创建状态移除，put是在前面的beforeSingletonCreation(beanName)方法。

然后如果是新创建的Bean;

protected void addSingleton(String beanName, Object singletonObject) {
   synchronized (this.singletonObjects) {
      this.singletonObjects.put(beanName, singletonObject);
      this.singletonFactories.remove(beanName);
      this.earlySingletonObjects.remove(beanName);
      this.registeredSingletons.add(beanName);
   }
}

现在整个getBean的过程完成了：

if (mbd.isSingleton()) {
   sharedInstance = getSingleton(beanName, () -> {
      try {
         return createBean(beanName, mbd, args);
      }
     .........
   });
   bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}

运行getObjectForBeanInstance方法，这个是进行单例获取的，如果是单例。就会直接返回

protected Object getObjectForBeanInstance(
      Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {

   if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
      return beanInstance;
   }

   Object object = null;
   if (mbd == null) {
      object = getCachedObjectForFactoryBean(beanName);
   }
   if (object == null) {
     
      FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
      // Caches object obtained from FactoryBean if it is a singleton.
      if (mbd == null && containsBeanDefinition(beanName)) {
         mbd = getMergedLocalBeanDefinition(beanName);
      }
      boolean synthetic = (mbd != null && mbd.isSynthetic());
      object = getObjectFromFactoryBean(factory, beanName, !synthetic);
   }
   return object;
}

if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
   return beanInstance;
}
String FACTORY_BEAN_PREFIX = "&";
public static boolean isFactoryDereference(@Nullable String name) {
   return (name != null && name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));
}

这里就是如果不是FactoryBean或者在BeanName中加了&(前面讲过,加了&表示直接获取FactoryBean对象本身)

Object object = null;
if (mbd == null) {
   object = getCachedObjectForFactoryBean(beanName);
}
if (object == null) {
   FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
   if (mbd == null && containsBeanDefinition(beanName)) {
      mbd = getMergedLocalBeanDefinition(beanName);
   }
   boolean synthetic = (mbd != null && mbd.isSynthetic());
   object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
protected Object getCachedObjectForFactoryBean(String beanName) {
   return this.factoryBeanObjectCache.get(beanName);
}

mbd 为空从factoryBeanObjectCache缓存中取，不为空，直接下面逻辑。

getMergedLocalBeanDefinition方法前面讲过，这个mbd正常一般不会为null，

protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
   if (factory.isSingleton() && containsSingleton(beanName)) {
      synchronized (getSingletonMutex()) {
         Object object = this.factoryBeanObjectCache.get(beanName);
         if (object == null) {
            object = doGetObjectFromFactoryBean(factory, beanName);
            Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
            if (alreadyThere != null) {
               object = alreadyThere;
            }
            else {
               if (shouldPostProcess) {
                  try {
                     object = postProcessObjectFromFactoryBean(object, beanName);
                  }
                  catch (Throwable ex) {
                     throw new BeanCreationException(beanName,
                           "Post-processing of FactoryBean's singleton object failed", ex);
                  }
               }
               this.factoryBeanObjectCache.put(beanName, object);
            }
         }
         return object;
      }
   }
   else {
      Object object = doGetObjectFromFactoryBean(factory, beanName);
      if (shouldPostProcess) {
         try {
            object = postProcessObjectFromFactoryBean(object, beanName);
         }
         catch (Throwable ex) {
            throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
         }
      }
      return object;
   }
}
public boolean containsSingleton(String beanName) {
   return this.singletonObjects.containsKey(beanName);
}

这里一开始containsSingleton应该并不还有beanName，展示FactoryBean的BeanName。所以运行下面的else分支（其实上面的与下面的逻辑本质并不大）

shouldPostProcess为true， object = postProcessObjectFromFactoryBean(object, beanName);

protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {
   return applyBeanPostProcessorsAfterInitialization(object, beanName);
}

private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)
      throws BeanCreationException {

   Object object;
       ............
         object = factory.getObject();
      ...........
   return object;
}

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
      throws BeansException {

   Object result = existingBean;
   for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
      Object current = beanProcessor.postProcessAfterInitialization(result, beanName);
      if (current == null) {
         return result;
      }
      result = current;
   }
   return result;
}

可以看到下面的这部分，本质就是调用FactoryBean的getObject方法，获取真正的Bean，然后运行BeanPostProcessor接口的postProcessAfterInitialization方法。

现在这里定义单例Bean的获取就整体完成了。下面是多例Ban的内容

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

关于多例bean，首先是beforePrototypeCreation(beanName)方法，前面单例是beforeSingletonCreation(beanName)方法，将其放在singletonsCurrentlyInCreation Map中。现在多例

private final ThreadLocal<Object> prototypesCurrentlyInCreation =
      new NamedThreadLocal<>("Prototype beans currently in creation");

protected void beforePrototypeCreation(String beanName) {
   Object curVal = this.prototypesCurrentlyInCreation.get();
   if (curVal == null) {
      this.prototypesCurrentlyInCreation.set(beanName);
   }
   else if (curVal instanceof String) {
      Set<String> beanNameSet = new HashSet<>(2);
      beanNameSet.add((String) curVal);
      beanNameSet.add(beanName);
      this.prototypesCurrentlyInCreation.set(beanNameSet);
   }
   else {
      Set<String> beanNameSet = (Set<String>) curVal;
      beanNameSet.add(beanName);
   }
}

可以看到多例的prototypesCurrentlyInCreation相当于缓存是ThreadLocal，与对应线程进行绑定的。

然后是createBean(beanName, mbd, args)，去创建Bean，方法与单例调用是一样。

然后再调用afterPrototypeCreation犯方法，从创建状态中移除。

protected void afterPrototypeCreation(String beanName) {
   Object curVal = this.prototypesCurrentlyInCreation.get();
   if (curVal instanceof String) {
      this.prototypesCurrentlyInCreation.remove();
   }
   else if (curVal instanceof Set) {
      Set<String> beanNameSet = (Set<String>) curVal;
      beanNameSet.remove(beanName);
      if (beanNameSet.isEmpty()) {
         this.prototypesCurrentlyInCreation.remove();
      }
   }
}

之后与单例一样，调用bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd)方法，获取FactoryBean相关的内容。

多例之后，是另一中情况，例如为request，session这种应用范围

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

可以看到其整体与多例类似beforePrototypeCreation方法、afterPrototypeCreation方法、getObjectForBeanInstance方法与多例的方法是一样的，不同的是有一个获取对应Scope的内容，然后调用的是cope.get()方法去获取bean

Spring源码 --- AbstractBeanFactory结构及其通过beanName获取bean的过程

进入SessionScope

Override
public Object get(String name, ObjectFactory<?> objectFactory) {
   Object mutex = RequestContextHolder.currentRequestAttributes().getSessionMutex();
   synchronized (mutex) {
      return super.get(name, objectFactory);
   }
}

public Object get(String name, ObjectFactory<?> objectFactory) {
   RequestAttributes attributes = RequestContextHolder.currentRequestAttributes();
   Object scopedObject = attributes.getAttribute(name, getScope());
   if (scopedObject == null) {
      scopedObject = objectFactory.getObject();
      attributes.setAttribute(name, scopedObject, getScope());
      Object retrievedObject = attributes.getAttribute(name, getScope());
      if (retrievedObject != null) {
         scopedObject = retrievedObject;
      }
   }
   return scopedObject;
}

可以看到这里会将这个对象设置到RequestAttributes中 attributes.setAttribute(name, scopedObject, getScope())。

RequestAttributes attributes = RequestContextHolder.currentRequestAttributes();

去对象从RequestAttributes去就可以了。

现在整个三种情况的获取。

下面就是类型转换。

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;
   }
   ..........
}
return (T) bean;

然后有指明获取的类型requiredType，并且当前的bean不满足，就进行类型转换

getTypeConverter().convertIfNecessary(bean, requiredType);

至此，整个通过beanName获取对应Bean的过程就已经梳理完成。

Spring源码 --- AbstractBeanFactory结构及其通过beanName获取bean的过程

一：首先看下AbstractBeanFactory结构：

二、使用AbstractBeanFactroy获取bean的过程

InstantiationAwareBeanPostProcessor（继承BeanPostProcessor 接口）

BeanPostProcessor

SmartInstantiationAwareBeanPostProcessor

MergedBeanDefinitionPostProcessor

BeanNameAware、BeanClassLoaderAware、BeanFactoryAware

BeanPostProcessor

InitializingBean

DestructionAwareBeanPostProcessor

继续阅读

关于Gradle配置的小结

Java小案例——随机数猜测随机数猜测

nginx location中斜线的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的简单使用

neo4j之cypher使用文档

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？

spark/scala关于【资源文件】加载方法概述外部文件加载方案测试资源文件打包入jar包中小结

mybatis_入门程序Mybatis入门

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

Effective Java 8:通用程序设计

OOM三种类型

工厂模式-三种类型

【递归】高效率求2的n次幂

win10本地scala和spark安装安装scala安装spark

scala (3) Function 和 Method

Spring源码 --- AbstractBeanFactory结构及其通过beanName获取bean的过程

一： 首先看下AbstractBeanFactory结构：

二、使用AbstractBeanFactroy获取bean的过程

InstantiationAwareBeanPostProcessor（继承BeanPostProcessor 接口）

BeanPostProcessor

SmartInstantiationAwareBeanPostProcessor

MergedBeanDefinitionPostProcessor

BeanNameAware、BeanClassLoaderAware、BeanFactoryAware

BeanPostProcessor

InitializingBean

DestructionAwareBeanPostProcessor

继续阅读

一：首先看下AbstractBeanFactory结构：