谈谈Spring中的对象跟Bean，你知道Spring怎么创建对象的吗？

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
   // 初始化一个ConversionService用于类型转换，这个ConversionService会在实例化对象的时候用到
   if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
         beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
      beanFactory.setConversionService(
            beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
   }

  // 添加一个StringValueResolver，用于处理占位符，可以看到，默认情况下就是使用环境中的属性值来替代占位符中的属性
   if (!beanFactory.hasEmbeddedValueResolver()) {
      beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
   }

   // 创建所有的LoadTimeWeaverAware
   String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
   for (String weaverAwareName : weaverAwareNames) {
      getBean(weaverAwareName);
   }

   // 静态织入完成后将临时的类加载器设置为null,所以除了创建LoadTimeWeaverAware时可能会用到临时类加载器，其余情况下都为空
   beanFactory.setTempClassLoader(null);

   // 将所有的配置信息冻结
   beanFactory.freezeConfiguration();

   // 开始进行真正的创建
   beanFactory.preInstantiateSingletons();
}

public void  preInstantiateSingletons() throws BeansException {
     // 所有bd的名称 
  List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
     // 遍历所有bd，一个个进行创建 
  for (String beanName : beanNames) {
            // 获取到指定名称对应的bd
   RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
            // 对不是延迟加载的单例的Bean进行创建
   if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                // 判断是否是一个FactoryBean
    if (isFactoryBean(beanName)) {
                    // 如果是一个factoryBean的话，先创建这个factoryBean，创建factoryBean时，需要在beanName前面拼接一个&符号
     Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
     if (bean instanceof FactoryBean) {
      final FactoryBean<?> factory = (FactoryBean<?>) bean;
      boolean isEagerInit;
      if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
       isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
           ((SmartFactoryBean<?>) factory)::isEagerInit,
         getAccessControlContext());
      }
      else {
                            // 判断是否是一个SmartFactoryBean，并且不是懒加载的，就意味着，在创建了这个factoryBean之后要立马调用它的getObject方法创建另外一个Bean
       isEagerInit = (factory instanceof SmartFactoryBean &&
         ((SmartFactoryBean<?>) factory).isEagerInit());
      }
      if (isEagerInit) {
       getBean(beanName);
      }
     }
    }
    else {
                    // 不是factoryBean的话，我们直接创建就行了
     getBean(beanName);
    }
   }
  }
  // 在创建了所有的Bean之后，遍历
  for (String beanName : beanNames) {
            // 这一步其实是从缓存中获取对应的创建的Bean，这里获取到的必定是单例的 
   Object singletonInstance = getSingleton(beanName);
            // 判断是否是一个SmartInitializingSingleton，最典型的就是我们之前分析过的EventListenerMethodProcessor，在这一步完成了对已经创建好的Bean的解析，会判断其方法上是否有 @EventListener注解，会将这个注解标注的方法通过EventListenerFactory转换成一个事件监听器并添加到监听器的集合中
   if (singletonInstance instanceof SmartInitializingSingleton) {
    final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
    if (System.getSecurityManager() != null) {
     AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
      smartSingleton.afterSingletonsInstantiated();
      return null;
     }, getAccessControlContext());
    }
    else {
     smartSingleton.afterSingletonsInstantiated();
    }
   }
  }
 }

 protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
   @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
  // 前面我们说过了，传入的name可能时& + beanName这种形式，这里做的就是去除掉&，得到beanName
  final String beanName = transformedBeanName(name);
  Object bean;
  // 这个方法就很牛逼了，通过它解决了循环依赖的问题，不过目前我们只需要知道它是从单例池中获取已经创建的Bean即可，循环依赖后面我单独写一篇文章
        // 方法作用：已经创建的Bean会被放到单例池中，这里就是从单例池中获取
  Object sharedInstance = getSingleton(beanName);
        
  if (sharedInstance != null && args == null) {
            // 如果直接从单例池中获取到了这个bean(sharedInstance),我们能直接返回吗？
            // 当然不能，因为获取到的Bean可能是一个factoryBean,如果我们传入的name是 & + beanName 这种形式的话，那是可以返回的，但是我们传入的更可能是一个beanName，那么这个时候Spring就还需要调用这个sharedInstance的getObject方法来创建真正被需要的Bean
   bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
  }
  else {
            // 在缓存中获取不到这个Bean
            // 原型下的循环依赖直接报错
   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 if (requiredType != null) {
     return parentBeanFactory.getBean(nameToLookup, requiredType);
    }
    else {
     return (T) parentBeanFactory.getBean(nameToLookup);
    }
   }
            
            // 如果不仅仅是为了类型推断，也就是代表我们要对进行实例化
            // 那么就将bean标记为正在创建中，其实就是将这个beanName放入到alreadyCreated这个set集合中
   if (!typeCheckOnly) {
    markBeanAsCreated(beanName);
   }
   try {
                
    final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                
                // 检查合并后的bd是否是abstract,这个检查现在已经没有作用了，必定会通过
    checkMergedBeanDefinition(mbd, beanName, args);

    // @DependsOn注解标注的当前这个Bean所依赖的bean名称的集合，就是说在创建当前这个Bean前，必须要先将其依赖的Bean先完成创建
    String[] dependsOn = mbd.getDependsOn();
    if (dependsOn != null) {
                    // 遍历所有申明的依赖
     for (String dep : dependsOn) {
                        // 如果这个bean所依赖的bean又依赖了当前这个bean,出现了循环依赖，直接报错
      if (isDependent(beanName, dep)) {
       throw new BeanCreationException(mbd.getResourceDescription(), beanName,
         "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
      }
                        // 注册bean跟其依赖的依赖关系，key为依赖，value为依赖所从属的bean
      registerDependentBean(dep, beanName);
      try {
                            // 先创建其依赖的Bean
       getBean(dep);
      }
      catch (NoSuchBeanDefinitionException ex) {
       throw new BeanCreationException(mbd.getResourceDescription(), beanName,
         "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
      }
     }
    }
    // 我们目前只分析单例的创建，单例看懂了，原型自然就懂了
    if (mbd.isSingleton()) {
                    // 这里再次调用了getSingleton方法，这里跟方法开头调用的getSingleton的区别在于，这个方法多传入了一个ObjectFactory类型的参数，这个ObjectFactory会返回一个Bean
     sharedInstance = getSingleton(beanName, () -> {
      try {
       return createBean(beanName, mbd, args);
      }
      catch (BeansException ex) {
       destroySingleton(beanName);
       throw ex;
      }
     });
     bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
    }
  // 省略原型跟域对象的相关代码
  return (T) bean;
 }

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) {
          // 工厂已经在销毁阶段了，这个时候还在创建Bean的话，就直接抛出异常
         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!)");
         }
         // 在单例创建前，记录一下正在创建的单例的名称，就是把beanName放入到singletonsCurrentlyInCreation这个set集合中去
         beforeSingletonCreation(beanName);
         boolean newSingleton = false;
         boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
         if (recordSuppressedExceptions) {
            this.suppressedExceptions = new LinkedHashSet<>();
         }
         try {
             // 这里调用了singletonFactory的getObject方法，对应的实现就是在doGetBean中的那一段lambda表达式
            singletonObject = singletonFactory.getObject();
            newSingleton = true;
         }
        // 省略异常处理
         finally {
            if (recordSuppressedExceptions) {
               this.suppressedExceptions = null;
            }
             // 在单例完成创建后，将beanName从singletonsCurrentlyInCreation中移除
             // 标志着这个单例已经完成了创建
            afterSingletonCreation(beanName);
         }
         if (newSingleton) {
             // 添加到单例池中
            addSingleton(beanName, singletonObject);
         }
      }
      return singletonObject;
   }
}

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

   RootBeanDefinition mbdToUse = mbd;
    
    // 解析得到beanClass，为什么需要解析呢？如果是从XML中解析出来的标签属性肯定是个字符串嘛
    // 所以这里需要加载类，得到Class对象
   Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
   if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
      mbdToUse = new RootBeanDefinition(mbd);
      mbdToUse.setBeanClass(resolvedClass);
   }
   // 对XML标签中定义的lookUp属性进行预处理，如果只能根据名字找到一个就标记为非重载的，这样在后续就不需要去推断到底是哪个方法了，对于@LookUp注解标注的方法是不需要在这里处理的，AutowiredAnnotationBeanPostProcessor会处理这个注解
   try {
      mbdToUse.prepareMethodOverrides();
   }
   // 省略异常处理...
   try {
       // 在实例化对象前，会经过后置处理器处理
       // 这个后置处理器的提供了一个短路机制，就是可以提前结束整个Bean的生命周期，直接从这里返回一个Bean
       // 不过我们一般不会这么做，它的另外一个作用就是对AOP提供了支持，在这里会将一些不需要被代理的Bean进行标记，就本文而言，你可以暂时理解它没有起到任何作用
      Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
      if (bean != null) {
         return bean;
      }
   }
    // 省略异常处理...
   try {
       // doXXX方法，真正干活的方法，doCreateBean，真正创建Bean的方法
      Object beanInstance = doCreateBean(beanName, mbdToUse, args);
      if (logger.isDebugEnabled()) {
         logger.debug("Finished creating instance of bean '" + beanName + "'");
      }
      return beanInstance;
   }
  // 省略异常处理...
}

// 这个方法真正创建了Bean,创建一个Bean会经过 创建对象 > 依赖注入 > 初始化 这三个过程，在这个过程中，BeanPostPorcessor会穿插执行，本文主要探讨的是创建对象的过程，所以关于依赖注入及初始化我们暂时省略，在后续的文章中再继续研究
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
      throws BeanCreationException {

   // Instantiate the bean.
   BeanWrapper instanceWrapper = null;
   if (mbd.isSingleton()) {
       // 这行代码看起来就跟factoryBean相关，这是什么意思呢？
       // 在下文我会通过例子介绍下，你可以暂时理解为，这个地方返回的就是个null
      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
   }
   if (instanceWrapper == null) {
       // 这里真正的创建了对象
      instanceWrapper = createBeanInstance(beanName, mbd, args);
   }
   // 省略依赖注入，初始化
}

public class Main {
 public static void main(String[] args) {
  AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(Config.class);
 }
}

// 没有做什么特殊的配置，就是扫描了需要的组件，测试时换成你自己的包名
@ComponentScan("com.dmz.source.instantiation")
@Configuration
public class Config {
}

// 这里申明了一个FactoryBean,并且通过@DependsOn注解申明了这个FactoryBean的创建要在orderService之后，主要目的是为了在DmzFactoryBean创建前让容器发生一次属性注入
@Component
@DependsOn("orderService")
public class DmzFactoryBean implements FactoryBean<DmzService> {
 @Override
 public DmzService getObject() throws Exception {
  return new DmzService();
 }

 @Override
 public Class<?> getObjectType() {
  return DmzService.class;
 }
}

// 没有通过注解的方式将它放到容器中，而是通过上面的DmzFactoryBean来管理对应的Bean
public class DmzService {
}

// OrderService中需要注入dmzService
@Component
public class OrderService {
 @Autowired
 DmzService dmzService;
}

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
   
   Class<?> beanClass = resolveBeanClass(mbd, beanName);
   // 省略异常
    
    // 通过bd中提供的instanceSupplier来获取一个对象
    // 正常bd中都不会有这个instanceSupplier属性，这里也是Spring提供的一个扩展点，但实际上不常用
   Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
   if (instanceSupplier != null) {
      return obtainFromSupplier(instanceSupplier, beanName);
   }

   // bd中提供了factoryMethodName属性，那么要使用工厂方法的方式来创建对象，工厂方法又会区分静态工厂方法跟实例工厂方法
   if (mbd.getFactoryMethodName() != null) {
      return instantiateUsingFactoryMethod(beanName, mbd, args);
   }

   // 在原型模式下，如果已经创建过一次这个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);
      }
   }

   // 推断构造函数
   Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
   if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
         mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
      return autowireConstructor(beanName, mbd, ctors, args);
   }

   // 调用无参构造函数创建对象
   return instantiateBean(beanName, mbd);
}

public static void main(String[] args) {
  AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext();
    // 直接注册一个Bean,并且指定它的supplier就是Service::new
  ac.registerBean("service", Service.class,Service::new，zhe'sh);
  ac.refresh();
  System.out.println(ac.getBean("service"));
}

protected BeanWrapper instantiateUsingFactoryMethod(
    String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
    return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);
}

<bean id="dmzServiceGetFromStaticMethod"
      factory-bean="factoryBean"
      factory-method="getObject">
    <constructor-arg type="java.lang.String" value="hello" name="s"/>
    <constructor-arg type="com.dmz.source.instantiation.service.DmzFactory" ref="factoryBean"/>
</bean>

<!--测试静态工厂方法创建对象-->
<bean id="service"
      class="com.dmz.official.service.MyFactoryBean"
      factory-method="staticGet">
    <constructor-arg type="java.lang.String" value="hello"/>
</bean>

<bean id="dmzService" class="com.dmz.source.instantiation.service.DmzService">
    <constructor-arg name="s" value="hello"/>
</bean>

public BeanWrapper instantiateUsingFactoryMethod(
    String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
    // 第一段代码：创建并初始话一个BeanWrapperImpl
    BeanWrapperImpl bw = new BeanWrapperImpl();
    this.beanFactory.initBeanWrapper(bw);
    // ......
}

// 第一步：调用空参构造
public BeanWrapperImpl() {
    // 调用另外一个构造函数，表示要注册默认的属性编辑器
    this(true);
}

// 这个构造函数表明是否要注册默认编辑器，上面传入的值为true,表示需要注册
public BeanWrapperImpl(boolean registerDefaultEditors) {
    super(registerDefaultEditors);
}

// 调用到父类的构造函数，确定要使用默认的属性编辑器
protected AbstractNestablePropertyAccessor(boolean registerDefaultEditors) {
    if (registerDefaultEditors) {
        registerDefaultEditors();
    }
    // 对typeConverterDelegate进行初始化
    this.typeConverterDelegate = new TypeConverterDelegate(this);
}

// 初始化BeanWrapper，主要就是将容器中配置的conversionService赋值到当前这个BeanWrapper上
// 同时注册定制的属性编辑器
protected void initBeanWrapper(BeanWrapper bw) {
    bw.setConversionService(getConversionService());
    registerCustomEditors(bw);
}

// 传入的参数就是我们的BeanWrapper，它同时也是一个属性编辑器注册表
protected void registerCustomEditors(PropertyEditorRegistry registry) {
    PropertyEditorRegistrySupport registrySupport =
        (registry instanceof PropertyEditorRegistrySupport ? (PropertyEditorRegistrySupport) registry : null);
    if (registrySupport != null) {
        // 这个配置的作用就是在注册默认的属性编辑器时，可以增加对数组到字符串的转换功能
        // 默认就是通过","来切割字符串转换成数组，对应的属性编辑器就是StringArrayPropertyEditor
        registrySupport.useConfigValueEditors();
    }
    // 将容器中的属性编辑器注册到当前的这个BeanWrapper
    if (!this.propertyEditorRegistrars.isEmpty()) {
        for (PropertyEditorRegistrar registrar : this.propertyEditorRegistrars) {
            registrar.registerCustomEditors(registry);
            // 省略异常处理~
        }
    }
    // 这里我们没有添加任何的自定义的属性编辑器，所以肯定为空
    if (!this.customEditors.isEmpty()) {
        this.customEditors.forEach((requiredType, editorClass) ->
                                   registry.registerCustomEditor(requiredType, BeanUtils.instantiateClass(editorClass)));
    }
}

public BeanWrapper instantiateUsingFactoryMethod(
    String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {

    // 省略已经分析的第一段代码，到这里已经得到了一个具有类型转换功能的BeanWrapper
 
    // 实例化这个Bean的工厂Bean
    Object factoryBean;
    // 工厂Bean的Class
    Class<?> factoryClass;
    // 静态工厂方法或者是实例化工厂方法
    boolean isStatic;
 
    /*下面这段代码就是为上面申明的这三个属性赋值*/ 
    String factoryBeanName = mbd.getFactoryBeanName();
    // 如果创建这个Bean的工厂就是这个Bean本身的话，那么直接抛出异常
    if (factoryBeanName != null) {
        if (factoryBeanName.equals(beanName)) {
            throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
                                                   "factory-bean reference points back to the same bean definition");
        }
        // 得到创建这个Bean的工厂Bean
        factoryBean = this.beanFactory.getBean(factoryBeanName);
        if (mbd.isSingleton() && this.beanFactory.containsSingleton(beanName)) {
            throw new ImplicitlyAppearedSingletonException();
        }
        factoryClass = factoryBean.getClass();
        isStatic = false;
    }
    else {
        // factoryBeanName为null,说明是通过静态工厂方法来实例化Bean的
        // 静态工厂进行实例化Bean，beanClass属性必须要是工厂的class,如果为空，直接报错
        if (!mbd.hasBeanClass()) {
            throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
                                                   "bean definition declares neither a bean class nor a factory-bean reference");
        }
        factoryBean = null;
        factoryClass = mbd.getBeanClass();
        isStatic = true;
    }
    // 省略后续代码
}

public BeanWrapper instantiateUsingFactoryMethod(
    String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
    
    // 省略第一段，第二段代码
    
    // 到这里已经得到了一个BeanWrapper,明确了实例化当前这个Bean到底是静态工厂还是实例工厂
    // 并且已经确定了工厂Bean
    
    // 最终确定的要用来创建对象的方法
    Method factoryMethodToUse = null;
    ArgumentsHolder argsHolderToUse = null;
    Object[] argsToUse = null;
 
    // 参数分析时已经说过，explicitArgs就是null
    if (explicitArgs != null) {
        argsToUse = explicitArgs;
    }
    else {
        // 下面这段代码是什么意思呢？
        // 在原型模式下，我们会多次创建一个Bean,所以Spring对参数以及所使用的方法做了缓存
        // 在第二次创建原型对象的时候会进入这段缓存的逻辑
        // 但是这里有个问题，为什么Spring对参数有两个缓存呢？
        // 一：resolvedConstructorArguments
        // 二：preparedConstructorArguments
        // 这里主要是因为，直接使用解析好的构造的参数，因为这样会导致创建出来的所有Bean都引用同一个属性
        Object[] argsToResolve = null;
        synchronized (mbd.constructorArgumentLock) {
            factoryMethodToUse = (Method) mbd.resolvedConstructorOrFactoryMethod;
            // 缓存已经解析过的工厂方法或者构造方法
            if (factoryMethodToUse != null && mbd.constructorArgumentsResolved) {
                // resolvedConstructorArguments跟preparedConstructorArguments都是对参数的缓存
                argsToUse = mbd.resolvedConstructorArguments;
                if (argsToUse == null) {
                    argsToResolve = mbd.preparedConstructorArguments;
                }
            }
        }
        if (argsToResolve != null) {
            // preparedConstructorArguments需要再次进行解析
            argsToUse = resolvePreparedArguments(beanName, mbd, bw, factoryMethodToUse, argsToResolve);
        }
    }
    // 省略后续代码
}

<?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"
    default-autowire="constructor"><!--这里开启自动注入，并且是通过构造函数进行自动注入-->

 <!--factoryObject 提供了创建对象的方法-->
 <bean id="factoryObject" class="com.dmz.spring.first.instantiation.service.FactoryObject"/>

 <!--提供一个用于测试自动注入的对象-->
 <bean class="com.dmz.spring.first.instantiation.service.OrderService" id="orderService"/>
 
    <!--主要测试这个对象的实例化过程-->
 <bean id="dmzService" factory-bean="factoryObject" factory-method="getDmz" scope="prototype">
  <constructor-arg name="name" value="dmz"/>
  <constructor-arg name="age" value="18"/>
  <constructor-arg name="birthDay" value="2020-05-23"/>
 </bean>
 
    <!--测试静态方法实例化对象的过程-->
 <bean id="indexService" class="com.dmz.spring.first.instantiation.service.FactoryObject"
    factory-method="staticGetIndex"/>
 
    <!--提供这个转换器,用于转换dmzService中的birthDay属性,从字符串转换成日期对象-->
 <bean class="org.springframework.context.support.ConversionServiceFactoryBean" id="conversionService">
  <property name="converters">
   <set>
    <bean class="com.dmz.spring.first.instantiation.service.ConverterStr2Date"/>
   </set>
  </property>
 </bean>
</beans>

public class FactoryObject {

 public DmzService getDmz(String name, int age, Date birthDay, OrderService orderService) {
  System.out.println("getDmz with "+"name,age,birthDay and orderService");
  return new DmzService();
 }

 public DmzService getDmz(String name, int age, Date birthDay) {
  System.out.println("getDmz with "+"name,age,birthDay");
  return new DmzService();
 }

 public DmzService getDmz(String name, int age) {
  System.out.println("getDmz with "+"name,age");
  return new DmzService();
 }

 public DmzService getDmz() {
  System.out.println("getDmz with empty arg");
  return new DmzService();
 }

 public static IndexService staticGetIndex() {
  return new IndexService();
 }
}

public class DmzService {
}

public class IndexService {
}

public class OrderService {
}

public class ConverterStr2Date implements Converter<String, Date> {
 @Override
 public Date convert(String source) {
  try {
   return new SimpleDateFormat("yyyy-MM-dd").parse(source);
  } catch (ParseException e) {
   return null;
  }
 }
}

/**
 * @author 程序员DMZ
 * @Date Create in 23:14 2020/5/21
 * @Blog https://daimingzhi.blog.csdn.net/
 */
public class Main {
 public static void main(String[] args) {
  ClassPathXmlApplicationContext cc = new ClassPathXmlApplicationContext();
  cc.setConfigLocation("application.xml");
  cc.refresh();
  cc.getBean("dmzService");
        // 两次调用，用于测试缓存的方法及参数
//  cc.getBean("dmzService");

 }
}

public BeanWrapper instantiateUsingFactoryMethod(
    String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
//  第一段代码：到这里已经得到了一个BeanWrapper，并对这个BeanWrapper做了初始化
//  第二段代码：明确了实例化当前这个Bean到底是静态工厂还是实例工厂
// 第三段代码：以及从缓存中取过了对应了方法以及参数

// 进入第四段代码分析，执行到这段代码说明是第一次实例化这个对象
if (factoryMethodToUse == null || argsToUse == null) {
   // 如果被cglib代理的话，获取父类的class
   factoryClass = ClassUtils.getUserClass(factoryClass);
   // 获取到工厂类中的所有方法，接下来要一步步从这些方法中筛选出来符合要求的方法
   Method[] rawCandidates = getCandidateMethods(factoryClass, mbd);
   List<Method> candidateList = new ArrayList<>();
      // 第一步筛选：之前 在第二段代码中已经推断了方法是静态或者非静态的
      // 所以这里第一个要求就是要满足静态/非静态这个条件
      // 第二个要求就是必须符合bd中定义的factoryMethodName的名称
      // 其中第二个要求请注意，如果bd是一个configurationClassBeanDefinition,也就是说是通过扫描@Bean注解产生的，那么在判断时还会添加是否标注了@Bean注解
   for (Method candidate : rawCandidates) {
    if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate)) {
     candidateList.add(candidate);
    }
   }
      // 将之前得到的方法集合转换成数组
      // 到这一步得到的其实就是某一个方法的所有重载方法
       // 比如dmz(),dmz(String name),dmz(String name,int age)
   Method[] candidates = candidateList.toArray(new Method[0]);
    
      // 排序，public跟参数多的优先级越高
   AutowireUtils.sortFactoryMethods(candidates);
   
      // 用来保存从配置文件中解析出来的参数
   ConstructorArgumentValues resolvedValues = null;
            // 是否使用了自动注入，本段代码中没有使用到这个属性，但是在后面用到了
   boolean autowiring = (mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
   int minTypeDiffWeight = Integer.MAX_VALUE;
      // 可能出现多个符合要求的方法，用这个集合保存，实际上如果这个集合有值，就会抛出异常了
   Set<Method> ambiguousFactoryMethods = null;

   int minNrOfArgs;
      // 必定为null,不考虑了
   if (explicitArgs != null) {
    minNrOfArgs = explicitArgs.length;
   }
   else {
                // 就是说配置文件中指定了要使用的参数，那么需要对其进行解析，解析后的值就存储在resolvedValues这个集合中
    if (mbd.hasConstructorArgumentValues()) {
                    // 通过解析constructor-arg标签，将参数封装成了ConstructorArgumentValues
                    // ConstructorArgumentValues这个类在下文我们专门分析
     ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
     resolvedValues = new ConstructorArgumentValues();
                    // 解析标签中的属性，类似进行类型转换，后文进行详细分析
     minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
    }
    else {
                    // 配置文件中没有指定要使用的参数，所以执行方法的最小参数个数就是0
     minNrOfArgs = 0;
    }
   }
 // 省略后续代码....
}

public class ConstructorArgumentValues {
 // 通过下标方式指定的参数
 private final Map<Integer, ValueHolder> indexedArgumentValues = new LinkedHashMap<>();
 // 没有指定下标
 private final List<ValueHolder> genericArgumentValues = new ArrayList<>();
 // 省略无关代码.....
}

<bean id="dmzService" factory-bean="factoryObject" factory-method="getDmz" scope="prototype">
    <constructor-arg name="name" value="dmz"/>
    <constructor-arg name="age" value="18"/>
    <constructor-arg index="2"  value="2020-05-23"/>
    <!--  <constructor-arg name="birthDay" value="2020-05-23"/>-->
</bean>

// 方法目的：解析配置文件中指定的方法参数
// beanName：bean名称
// mbd：beanName对应的beanDefinition
// bw：通过它进行类型转换
// ConstructorArgumentValues cargs：解析标签得到的属性，还没有经过解析（类型转换）
// ConstructorArgumentValues resolvedValues：已经经过解析的参数
// 返回值：返回方法需要的最小参数个数
private int resolveConstructorArguments(String beanName, RootBeanDefinition mbd, BeanWrapper bw,
                                        ConstructorArgumentValues cargs, ConstructorArgumentValues resolvedValues) {
 
    // 是否有定制的类型转换器，没有的话直接使用BeanWrapper进行类型转换
    TypeConverter customConverter = this.beanFactory.getCustomTypeConverter();
    TypeConverter converter = (customConverter != null ? customConverter : bw);
    
    // 构造一个BeanDefinitionValueResolver，专门用于解析constructor-arg中的value属性，实际上还包括ref属性，内嵌bean标签等等
    BeanDefinitionValueResolver valueResolver =
        new BeanDefinitionValueResolver(this.beanFactory, beanName, mbd, converter);
 
    // minNrOfArgs 记录执行方法要求的最小参数个数，一般情况下就是等于constructor-arg标签指定的参数数量
    int minNrOfArgs = cargs.getArgumentCount();

    for (Map.Entry<Integer, ConstructorArgumentValues.ValueHolder> entry : cargs.getIndexedArgumentValues().entrySet()) {
        int index = entry.getKey();
        if (index < 0) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                            "Invalid constructor argument index: " + index);
        }
        // 这是啥意思呢？
        // 这个代码我认为是有问题的，并且我给Spring官方已经提了一个issue，官方将会在5.2.7版本中修复
        // 暂且你先这样理解
        // 假设A方法直接在配置文件中指定了index=3上要使用的参数，那么这个时候A方法至少需要4个参数
        // 但是其余的3个参数可能不是通过constructor-arg标签指定的，而是直接自动注入进来的，那么在配置文件中我们就只配置了index=3上的参数，也就是说 int minNrOfArgs = cargs.getArgumentCount()=1，这个时候 index=3,minNrOfArgs=1, 所以 minNrOfArgs = 3+1
        if (index > minNrOfArgs) {
            minNrOfArgs = index + 1;
        }
        ConstructorArgumentValues.ValueHolder valueHolder = entry.getValue();
        // 如果已经转换过了，直接添加到resolvedValues集合中
        if (valueHolder.isConverted()) {
            resolvedValues.addIndexedArgumentValue(index, valueHolder);
        }
        else {
            // 解析value/ref/内嵌bean标签等
            Object resolvedValue =
                valueResolver.resolveValueIfNecessary("constructor argument", valueHolder.getValue());
            // 将解析后的resolvedValue封装成一个新的ValueHolder，并将其source设置为解析constructor-arg得到的那个ValueHolder，后期会用到这个属性进行判断
            ConstructorArgumentValues.ValueHolder resolvedValueHolder =
                new ConstructorArgumentValues.ValueHolder(resolvedValue, valueHolder.getType(), valueHolder.getName());
            resolvedValueHolder.setSource(valueHolder);
            resolvedValues.addIndexedArgumentValue(index, resolvedValueHolder);
        }
    }
   // 对getGenericArgumentValues进行解析，代码基本一样，不再赘述
    return minNrOfArgs;
}

// 这个方法的目的就是将解析constructor-arg标签得到的value值进行一次解析
// 在解析标签时ref属性会被封装为RuntimeBeanReference，那么在这里进行解析时就会去调用getBean
// 在解析value属性会会被封装为TypedStringValue，那么这里会尝试去进行一个转换
// 关于标签的解析大家有兴趣的话可以去看看org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parsePropertyValue
// 这里不再赘述了
public Object resolveValueIfNecessary(Object argName, @Nullable Object value) {
 
    // 解析constructor-arg标签中的ref属性，实际就是调用了getBean
    if (value instanceof RuntimeBeanReference) {
        RuntimeBeanReference ref = (RuntimeBeanReference) value;
        return resolveReference(argName, ref);
    }
    
    // ......
    
       /**  
   * <constructor-arg>
   *    <set value-type="java.lang.String">
   *     <value>1</value>
   *    </set>
   * </constructor-arg>
   * 通过上面set标签中的value-type属性对value进行类型转换,
   * 如果value-type属性为空,那么这里不会进行类型转换
   */
   else if (value instanceof TypedStringValue) {
   TypedStringValue typedStringValue = (TypedStringValue) value;
   Object valueObject = evaluate(typedStringValue);
   try {
    Class<?> resolvedTargetType = resolveTargetType(typedStringValue);
    if (resolvedTargetType != null) {
     return this.typeConverter.convertIfNecessary(valueObject, resolvedTargetType);
    }
    else {
     return valueObject;
    }
   }
   catch (Throwable ex) {
    // Improve the message by showing the context.
    throw new BeanCreationException(
      this.beanDefinition.getResourceDescription(), this.beanName,
      "Error converting typed String value for " + argName, ex);
   }
  }
    // 省略后续代码....
}

public BeanWrapper instantiateUsingFactoryMethod(
    String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
    //  第一段代码：到这里已经得到了一个BeanWrapper，并对这个BeanWrapper做了初始化
    //  第二段代码：明确了实例化当前这个Bean到底是静态工厂还是实例工厂
    // 第三段代码：以及从缓存中取过了对应了方法以及参数
    //  第四段代码：明确了方法需要的最小的参数数量并对配置文件中的标签属性进行了一次解析

    // 进入第五段代码分析
    
    // 保存在创建方法参数数组过程中发生的异常，如果最终没有找到合适的方法，那么将这个异常信息封装后抛出
    LinkedList<UnsatisfiedDependencyException> causes = null;
    
    // 开始遍历所有在第四段代码中查询到的符合要求的方法
    for (Method candidate : candidates) {
        // 方法的参数类型
        Class<?>[] paramTypes = candidate.getParameterTypes();
        // 候选的方法的参数必须要大于在第四段这推断出来的最小参数个数
        if (paramTypes.length >= minNrOfArgs) {
            ArgumentsHolder argsHolder;
            // 必定为null,不考虑
            if (explicitArgs != null) {
                // Explicit arguments given -> arguments length must match exactly.
                if (paramTypes.length != explicitArgs.length) {
                    continue;
                }
                argsHolder = new ArgumentsHolder(explicitArgs);
            }
            else {
                // Resolved constructor arguments: type conversion and/or autowiring necessary.
                try {
                    // 获取参数的具体名称
                    String[] paramNames = null;
                    ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
                    if (pnd != null) {
                        paramNames = pnd.getParameterNames(candidate);
                    }
                    // 根据方法的参数名称以及配置文件中配置的参数创建一个参数数组用于执行工厂方法
                    argsHolder = createArgumentArray(
                        beanName, mbd, resolvedValues, bw, paramTypes, paramNames, candidate, autowiring);
                }
                // 在创建参数数组的时候可能发生异常，这个时候的异常不能直接抛出，要确保所有的候选方法遍历完成，只要有一个方法符合要求即可，但是如果遍历完所有方法还是没找到合适的构造器，那么直接抛出这些异常
                catch (UnsatisfiedDependencyException ex) {
                    if (logger.isTraceEnabled()) {
                        logger.trace("Ignoring factory method [" + candidate + "] of bean '" + beanName + "': " + ex);
                    }
                    // Swallow and try next overloaded factory method.
                    if (causes == null) {
                        causes = new LinkedList<>();
                    }
                    causes.add(ex);
                    continue;
                }
                // 计算类型差异
                // 首先判断bd中是宽松模式还是严格模式，目前看来只有@Bean标注的方法解析得到的Bean会使用严格模式来计算类型差异，其余都是使用宽松模式
                // 严格模式下，
                int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
                                      argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
                // 选择一个类型差异最小的方法
                if (typeDiffWeight < minTypeDiffWeight) {
                    factoryMethodToUse = candidate;
                    argsHolderToUse = argsHolder;
                    argsToUse = argsHolder.arguments;
                    minTypeDiffWeight = typeDiffWeight;
                    ambiguousFactoryMethods = null;
                }
    // 省略后续代码.......
    }

/* beanName：要实例化的Bean的名称
 * mbd：对应Bean的BeanDefinition
 * resolvedValues：从配置文件中解析出来的并尝试过类型转换的参数
 * bw：在这里主要就是用作类型转换器
 * paramTypes：当前遍历到的候选的方法的参数类型数组
 * paramNames：当前遍历到的候选的方法的参数名称
 * executable：当前遍历到的候选的方法
 * autowiring：是否时自动注入
 */
private ArgumentsHolder createArgumentArray(
    String beanName, RootBeanDefinition mbd, @Nullable ConstructorArgumentValues resolvedValues,
   BeanWrapper bw, Class<?>[] paramTypes, @Nullable String[] paramNames, Executable executable,
   boolean autowiring) throws UnsatisfiedDependencyException {

  TypeConverter customConverter = this.beanFactory.getCustomTypeConverter();
  TypeConverter converter = (customConverter != null ? customConverter : bw);

  ArgumentsHolder args = new ArgumentsHolder(paramTypes.length);
  Set<ConstructorArgumentValues.ValueHolder> usedValueHolders = new HashSet<>(paramTypes.length);
  Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
  // 遍历候选方法的参数，跟据方法实际需要的类型到resolvedValues中去匹配
  for (int paramIndex = 0; paramIndex < paramTypes.length; paramIndex++) {
   Class<?> paramType = paramTypes[paramIndex];
   String paramName = (paramNames != null ? paramNames[paramIndex] : "");
   
   ConstructorArgumentValues.ValueHolder valueHolder = null;
   if (resolvedValues != null) {
                // 首先，根据方法参数的下标到resolvedValues中找对应的下标的属性
                // 如果没找到再根据方法的参数名/类型去resolvedValues查找
    valueHolder = resolvedValues.getArgumentValue(paramIndex, paramType, paramName, usedValueHolders);
    // 如果都没找到
                // 1.是自动注入并且方法的参数长度正好跟配置中的参数数量相等
                // 2.不是自动注入
                // 那么按照顺序一次选取
    if (valueHolder == null && (!autowiring || paramTypes.length == resolvedValues.getArgumentCount())) {
     valueHolder = resolvedValues.getGenericArgumentValue(null, null, usedValueHolders);
    }
   }
   // 也就是说在配置的参数中找到了合适的值可以应用于这个方法上
   if (valueHolder != null) {
    // 防止同一个参数被应用了多次
    usedValueHolders.add(valueHolder);
    Object originalValue = valueHolder.getValue();
    Object convertedValue;
                // 已经进行过类型转换就不会需要再次进行类型转换
    if (valueHolder.isConverted()) {
     convertedValue = valueHolder.getConvertedValue();
     args.preparedArguments[paramIndex] = convertedValue;
    }
    else {
     // 尝试将配置的值转换成方法参数需要的类型
     MethodParameter methodParam = MethodParameter.forExecutable(executable, paramIndex);
     try {
                        // 进行类型转换
      convertedValue = converter.convertIfNecessary(originalValue, paramType, methodParam);
     }
     catch (TypeMismatchException ex) {
      // 抛出UnsatisfiedDependencyException，在调用该方法处会被捕获
     }
     Object sourceHolder = valueHolder.getSource();
                    // 只要是valueHolder存在，到这里这个判断必定成立
     if (sourceHolder instanceof ConstructorArgumentValues.ValueHolder) {
      Object sourceValue = ((ConstructorArgumentValues.ValueHolder) sourceHolder).getValue();
      args.resolveNecessary = true;
      args.preparedArguments[paramIndex] = sourceValue;
     }
    }

    args.arguments[paramIndex] = convertedValue;
    args.rawArguments[paramIndex] = originalValue;
   }
   else {
                // 方法执行需要参数，但是resolvedValues中没有提供这个参数，也就是说这个参数是要自动注入到Bean中的
    MethodParameter methodParam = MethodParameter.forExecutable(executable, paramIndex);
    // 不是自动注入，直接抛出异常
    if (!autowiring) {
     // 抛出UnsatisfiedDependencyException，在调用该方法处会被捕获
    }
    try {
                    // 自动注入的情况下，调用getBean获取需要注入的Bean
     Object autowiredArgument =
       resolveAutowiredArgument(methodParam, beanName, autowiredBeanNames, converter);
                    // 把getBean返回的Bean封装到本次方法执行时需要的参数数组中去
     args.rawArguments[paramIndex] = autowiredArgument;
     args.arguments[paramIndex] = autowiredArgument;
                    // 标志这个参数是自动注入的
     args.preparedArguments[paramIndex] = new AutowiredArgumentMarker();
                    // 自动注入的情况下，在第二次调用时，需要重新处理，不能直接缓存
     args.resolveNecessary = true;
    }
    catch (BeansException ex) {
     // 抛出UnsatisfiedDependencyException，在调用该方法处会被捕获
    }
   }
  }
  
     // 注册Bean之间的依赖关系
  for (String autowiredBeanName : autowiredBeanNames) {
   this.beanFactory.registerDependentBean(autowiredBeanName, beanName);
   if (logger.isDebugEnabled()) {
    logger.debug("Autowiring by type from bean name '" + beanName +
      "' via " + (executable instanceof Constructor ? "constructor" : "factory method") +
      " to bean named '" + autowiredBeanName + "'");
   }
  }

  return args;
 }

public BeanWrapper instantiateUsingFactoryMethod(
    String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
    //  第一段代码：到这里已经得到了一个BeanWrapper，并对这个BeanWrapper做了初始化
    //  第二段代码：明确了实例化当前这个Bean到底是静态工厂还是实例工厂
    // 第三段代码：以及从缓存中取过了对应了方法以及参数
    //  第四段代码：明确了方法需要的最小的参数数量并对配置文件中的标签属性进行了一次解析
    //  第五段代码：到这里已经确定了可以使用来实例化Bean的方法是哪个
    
 // 省略抛出异常的代码，就是在对推断出来的方法做验证
    // 1.推断出来的方法不能为null
    // 2.推断出来的方法返回值不能为void
    // 3.推断出来的方法不能有多个
  
    // 对参数进行缓存
      if (explicitArgs == null && argsHolderToUse != null) {
         argsHolderToUse.storeCache(mbd, factoryMethodToUse);
      }
   }

   try {
      Object beanInstance;

      if (System.getSecurityManager() != null) {
         final Object fb = factoryBean;
         final Method factoryMethod = factoryMethodToUse;
         final Object[] args = argsToUse;
         beanInstance = AccessController.doPrivileged((PrivilegedAction<Object>) () ->
               beanFactory.getInstantiationStrategy().instantiate(mbd, beanName, beanFactory, fb, factoryMethod, args),
               beanFactory.getAccessControlContext());
      }
      else {
          // 反射调用对应方法进行实例化
          // 1.获取InstantiationStrategy，主要就是SimpleInstantiationStrategy跟CglibSubclassingInstantiationStrategy，其中CglibSubclassingInstantiationStrategy主要是用来处理beanDefinition中的lookupMethod跟replaceMethod。通常来说我们使用的就是SimpleInstantiationStrateg
          // 2.SimpleInstantiationStrateg就是单纯的通过反射调用方法
         beanInstance = this.beanFactory.getInstantiationStrategy().instantiate(
               mbd, beanName, this.beanFactory, factoryBean, factoryMethodToUse, argsToUse);
      }
  // beanWrapper在这里对Bean进行了包装
      bw.setBeanInstance(beanInstance);
      return bw;
   }
   catch (Throwable ex) {
      throw new BeanCreationException(mbd.getResourceDescription(), beanName,
            "Bean instantiation via factory method failed", ex);
   }
}

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    // 上面的代码已经分析过了
    // 1.使用supplier来得到一个对象
    // 2.通过factotryMethod方法实例化一个对象
 
    // 看起来是不是有点熟悉，在使用factotryMethod创建对象时也有差不多这样的一段代码，看起来就是使用缓存好的方法直接创建一个对象
    boolean resolved = false;
    boolean autowireNecessary = false;
    
    // 不对这个参数进行讨论，就认为一直为null
    if (args == null) {
        synchronized (mbd.constructorArgumentLock) {
            // bd中的resolvedConstructorOrFactoryMethod不为空，说明已经解析过构造方法了
            if (mbd.resolvedConstructorOrFactoryMethod != null) {
                // resolved标志是否解析过构造方法
                resolved = true;
                autowireNecessary = mbd.constructorArgumentsResolved;
            }
        }
    }
    if (resolved) {
        // 构造函数已经解析过了，并且这个构造函数在调用时需要自动注入参数
        if (autowireNecessary) {
            // 此时部分解析好的参数已经存在了beanDefinition中，并且构造函数也在bd中
            // 那么在这里只会从缓存中去取构造函数以及参数然后反射调用
            return autowireConstructor(beanName, mbd, null, null);
        }
        else {
            // 这里就是直接反射调用空参构造
            return instantiateBean(beanName, mbd);
        }
    }
 // 推断出能够使用的需要参数的构造函数
    Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    // 在推断出来的构造函数中选取一个合适的方法来进行Bean的实例化
    // ctors不为null：说明存在1个或多个@Autowired标注的方法
    // mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR：说明是自动注入
    // mbd.hasConstructorArgumentValues()：配置文件中配置了构造函数要使用的参数
    // !ObjectUtils.isEmpty(args)：外部传入的参数，必定为null,不多考虑
    // 上面的条件只要满足一个就会进入到autowireConstructor方法
    // 第一个条件满足，那么通过autowireConstructor在推断出来的构造函数中再进一步选择一个差异值最小的，参数最长的构造函数
    // 第二个条件满足，说明没有@Autowired标注的方法，但是需要进行自动注入，那么通过autowireConstructor会去遍历类中申明的所有构造函数，并查找一个差异值最小的，参数最长的构造函数
    // 第三个条件满足，说明不是自动注入，那么要通过配置中的参数去类中申明的所有构造函数中匹配
    // 第四个必定为null,不考虑
    if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
        mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
        return autowireConstructor(beanName, mbd, ctors, args);
    }
 
    // 反射调用空参构造
    return instantiateBean(beanName, mbd);
}

// 实际调用的就是AutowiredAnnotationBeanPostProcessor中的determineCandidateConstructors方法
// 这个方法看起来很长，但实际确很简单，就是通过@Autowired注解确定哪些构造方法可以作为候选方法，其实在使用factoryMethod来实例化对象的时候也有这种逻辑在其中，后续在总结的时候我们对比一下
public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, final String beanName)
   throws BeanCreationException {

  // 这里做的事情很简单，就是将@Lookup注解标注的方法封装成LookupOverride添加到BeanDefinition中的methodOverrides属性中，如果这个属性不为空，在实例化对象的时候不能选用SimpleInstantiationStrateg,而要使用CglibSubclassingInstantiationStrategy，通过cglib代理给方法加一层拦截了逻辑
     // 避免重复检查
  if (!this.lookupMethodsChecked.contains(beanName)) {
   try {
    ReflectionUtils.doWithMethods(beanClass, method -> {
     Lookup lookup = method.getAnnotation(Lookup.class);
     if (lookup != null) {
      Assert.state(this.beanFactory != null, "No BeanFactory available");    // 将@Lookup注解标注的方法封装成LookupOverride
      LookupOverride override = new LookupOverride(method, lookup.value());
      try {
                            // 添加到BeanDefinition中的methodOverrides属性中
       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");
      }
     }
    });
   }
   catch (IllegalStateException ex) {
    throw new BeanCreationException(beanName, "Lookup method resolution failed", ex);
   }
   this.lookupMethodsChecked.add(beanName);
  }
  
    // 接下来要开始确定到底哪些构造函数能被作为候选者
  
    // 先尝试从缓存中获取
  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) {
      // 省略异常信息
     }
     List<Constructor<?>> candidates = new ArrayList<>(rawCandidates.length);
                    // 保存添加了Autowired注解并且required属性为true的构造方法
     Constructor<?> requiredConstructor = null;
                    // 空参构造
     Constructor<?> defaultConstructor = null;
                    // 看方法注释上说明的，这里除非是kotlin的类，否则必定为null,不做过多考虑，我们就将其当作null
     Constructor<?> primaryConstructor = BeanUtils.findPrimaryConstructor(beanClass);
     int nonSyntheticConstructors = 0;
                    // 对类中的所有构造方法进行遍历
     for (Constructor<?> candidate : rawCandidates) {
                        // 非合成方法
      if (!candidate.isSynthetic()) {
       nonSyntheticConstructors++;
      }
      else if (primaryConstructor != null) {
       continue;
      }
                        // 查询方法上是否有Autowired注解
      AnnotationAttributes ann = findAutowiredAnnotation(candidate);
      if (ann == null) {
                            // userClass != beanClass说明这个类进行了cglib代理
       Class<?> userClass = ClassUtils.getUserClass(beanClass);
       if (userClass != beanClass) {
        try {
                                    // 如果进行了cglib代理，那么在父类上再次查找Autowired注解
         Constructor<?> superCtor =
           userClass.getDeclaredConstructor(candidate.getParameterTypes());
         ann = findAutowiredAnnotation(superCtor);
        }
        catch (NoSuchMethodException ex) {
         // Simply proceed, no equivalent superclass constructor found...
        }
       }
      }
                        // 说明当前的这个构造函数上有Autowired注解
      if (ann != null) {
       if (requiredConstructor != null) {
        // 省略异常抛出
       }
                            // 获取Autowired注解中的required属性
       boolean required = determineRequiredStatus(ann);
       if (required) {
                                // 类中存在多个@Autowired标注的方法，并且某个方法的@Autowired注解上被申明了required属性要为true,那么直接报错
        if (!candidates.isEmpty()) {
        // 省略异常抛出
        }
        requiredConstructor = candidate;
       }
                            // 添加到集合中，这个集合存储的都是被@Autowired注解标注的方法
       candidates.add(candidate);
      }
                        // 空参构造函数
      else if (candidate.getParameterCount() == 0) {
       defaultConstructor = candidate;
      }
     }
     if (!candidates.isEmpty()) {
      // 存在多个被@Autowired标注的方法
                        // 并且所有的required属性被设置成了false (默认为true)
      if (requiredConstructor == null) {
                            // 存在空参构造函数，注意，空参构造函数可以不被@Autowired注解标注
       if (defaultConstructor != null) {
                                // 将空参构造函数也加入到候选的方法中去
        candidates.add(defaultConstructor);
       }
       // 省略日志打印
      }
                        
      candidateConstructors = candidates.toArray(new Constructor<?>[0]);
     }
                    // 也就是说，类中只提供了一个构造函数，并且这个构造函数不是空参构造函数
     else if (rawCandidates.length == 1 && rawCandidates[0].getParameterCount() > 0) {
      candidateConstructors = new Constructor<?>[] {rawCandidates[0]};
     }
                    // 省略中间两个判断，primaryConstructor必定为null，不考虑
     // .....
     }
     else {
                        // 说明无法推断出来
      candidateConstructors = new Constructor<?>[0];
     }
     this.candidateConstructorsCache.put(beanClass, candidateConstructors);
    }
   }
  }
  return (candidateConstructors.length > 0 ? candidateConstructors : null);
 }

int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
                      argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));

if (typeDiffWeight < minTypeDiffWeight) {
    factoryMethodToUse = candidate;
    argsHolderToUse = argsHolder;
    argsToUse = argsHolder.arguments;
    minTypeDiffWeight = typeDiffWeight;
    ambiguousFactoryMethods = null;
}

public int getTypeDifferenceWeight(Class<?>[] paramTypes) {
    // 计算实际使用的参数跟方法申明的参数的差异值
   int typeDiffWeight = MethodInvoker.getTypeDifferenceWeight(paramTypes, this.arguments);
    // 计算没有经过类型转换的参数跟方法申明的参数的差异值
   int rawTypeDiffWeight = MethodInvoker.getTypeDifferenceWeight(paramTypes, this.rawArguments) - 1024;
   return (rawTypeDiffWeight < typeDiffWeight ? rawTypeDiffWeight : typeDiffWeight);
  }

public static int getTypeDifferenceWeight(Class<?>[] paramTypes, Object[] args) {
    int result = 0;
    for (int i = 0; i < paramTypes.length; i++) {
        // 在出现类型转换时，下面这个判断才会成立，也就是在比较rawArguments跟paramTypes的差异时才可能满足这个条件
        if (!ClassUtils.isAssignableValue(paramTypes[i], args[i])) {
            return Integer.MAX_VALUE;
        }
        if (args[i] != null) {
            Class<?> paramType = paramTypes[i];
            Class<?> superClass = args[i].getClass().getSuperclass();
            while (superClass != null) {
                // 如果我们传入的值是方法上申明的参数的子类，那么每多一层继承关系，差异值加2
                if (paramType.equals(superClass)) {
                    result = result + 2;
                    superClass = null;
                }
                else if (ClassUtils.isAssignable(paramType, superClass)) {
                    result = result + 2;
                    superClass = superClass.getSuperclass();
                }
                else {
                    superClass = null;
                }
            }
            // 判断方法的参数是不是一个接口，如果是，那么差异值加1
            if (paramType.isInterface()) {
                result = result + 1;
            }
        }
    }
    return result;
}

public int getAssignabilityWeight(Class<?>[] paramTypes) {
    // 严格模式下，只有三种返回值
    // 1.Integer.MAX_VALUE，经过类型转换后还是不符合要求，返回最大的类型差异
    // 因为解析后的参数可能返回一个NullBean（创建对象的方法返回了null,Spring会将其包装成一个NullBean）,不过一般不会出现这种情况，所以我们可以当这种情况不存在
   for (int i = 0; i < paramTypes.length; i++) {
    if (!ClassUtils.isAssignableValue(paramTypes[i], this.arguments[i])) {
     return Integer.MAX_VALUE;
    }
   }
    // 2.Integer.MAX_VALUE - 512，进行过了类型转换才符合要求
   for (int i = 0; i < paramTypes.length; i++) {
    if (!ClassUtils.isAssignableValue(paramTypes[i], this.rawArguments[i])) {
     return Integer.MAX_VALUE - 512;
    }
   }
    // 3.Integer.MAX_VALUE - 1024，没有经过类型转换就已经符合要求了，返回最小的类型差异
   return Integer.MAX_VALUE - 1024;
  }

public class FactoryObject {

 public DmzService getDmz() {
  System.out.println(0);
  return new DmzService();
 }

 public DmzService getDmz(OrderService indexService) {
  System.out.println(1);
  return new DmzService();
 }

 public DmzService getDmz(OrderService orderService, IndexService indexService) {
  System.out.println(2);
  return new DmzService();
 }

    public DmzService getDmz(OrderService orderService, IndexService indexService,IA ia) {
        System.out.println(3);
        return new DmzService();
    }
}

public class ServiceImpl implements IService {
}

public class IAImpl implements IA {
}

<?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"
default-autowire="constructor"><!--必须要开启自动注入，并且是通过构造函数进行自动注入，否则选用无参构造-->

 <!--factoryObject 提供了创建对象的方法-->
 <bean id="factoryObject" class="com.dmz.spring.instantiation.service.FactoryObject"/>

 <bean class="com.dmz.spring.instantiation.service.OrderService" id="orderService"/>

 <bean id="dmzService" factory-bean="factoryObject" factory-method="getDmz" />

 <bean class="com.dmz.spring.instantiation.service.ServiceImpl" id="iService"/>

 <bean class="com.dmz.spring.instantiation.service.IndexService" id="indexService"/>

</beans>

/**
 * @author 程序员DMZ
 * @Date Create in 23:59 2020/6/1
 * @Blog https://daimingzhi.blog.csdn.net/
 */
public class XMLMain {
 public static void main(String[] args) {
  ClassPathXmlApplicationContext cc =
    new ClassPathXmlApplicationContext("application.xml");
 }
}

/**
 * @author 程序员DMZ
 * @Date Create in 6:28 2020/6/1
 * @Blog https://daimingzhi.blog.csdn.net/
 */
@ComponentScan("com.dmz.spring.instantiation")
@Configuration
public class Config {

 @Bean
 public DmzService dmzService() {
  System.out.println(0);
  return new DmzService();
 }
 @Bean
 public DmzService dmzService(OrderService indexService) {
  System.out.println(1);
  return new DmzService();
 }
 @Bean
 public DmzService dmzService(OrderService orderService, IndexService indexService) {
  System.out.println(2);
  return new DmzService();
 }
 @Bean
 public DmzService dmzService(OrderService orderService, IndexService indexService, IA ia) {
  System.out.println("config " +3);
  return new DmzService();
 }

 @Bean
 public DmzService dmzService(OrderService orderService, IndexService indexService, IA ia, IService iService) {
  System.out.println("config " +4);
  return new DmzService();
 }
}

/**
 * @author 程序员DMZ
 * @Date Create in 6:29 2020/6/1
 * @Blog https://daimingzhi.blog.csdn.net/
 */
public class Main {
 public static void main(String[] args) {
  AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext();
  ac.register(Config.class);
  ac.refresh();
 }
}

@Component
public class DmzService {
 
    // 没有添加@Autowired注解，也会被当作候选方法
 public DmzService(){
  System.out.println(0);
 }

 @Autowired(required = false)
 public DmzService(OrderService orderService) {
  System.out.println(1);
 }

 @Autowired(required = false)
 public DmzService(OrderService orderService, IService iService) {
  System.out.println(2);
 }

 @Autowired(required = false)
 public DmzService(OrderService orderService, IndexService indexService, IService iService,IA ia) {
  System.out.println("DmzService "+3);
 }
}

/**
 * @author 程序员DMZ
 * @Date Create in 6:29 2020/6/1
 * @Blog https://daimingzhi.blog.csdn.net/
 */
public class Main {
 public static void main(String[] args) {
  AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext();
  ac.register(Config.class);
  ac.refresh();
 }
}