spring 源码之 @Autowired 加在构造器上 autowireConstructor解析

spring @Autowired

@autowired可以写在变量和构造器上，注入bean，但是有的时候写在变量上会报空指针异常NPE，然后通过写在构造器上就解决了此问题，如下所示：
这种方式会报错

public class Test{
   
    @Autowired
    private A a;

    private final String prefix = a.getExcelPrefix();

........
}

正确、不报错

public class Test{
   
    private final String prefix;

    @Autowired
    public Test(A a) {
   
        this.prefix= a.getExcelPrefix();
    }

........
}

• 其实这两种方式都可以使用，但报错的原因是加载顺序的问题，@autowired写在变量上的注入要等到类完全加载完，才会将相应的bean注入，而变量是在加载类的时候按照相应顺序加载的，所以变量的加载要早于@autowired变量的加载，那么给变量prefix 赋值的时候所使用的a，其实还没有被注入，所以报空指针，而使用构造器就在加载类的时候将a加载了，这样在内部使用a给prefix 赋值就完全没有问题。

• 不使用用构造器，那么也可以不给prefix 赋值，而是在接下来的代码使用的地方，通过a.getExcelPrefix()进行赋值，这时的对a的使用是在类完全加载之后，即a被注入了，所以也是可以的。

• @Autowired一定要等本类构造完成后，才能从外部引用设置进来。所以@Autowired的注入时间一定会晚于构造函数的执行时间。但在初始化变量的时候就使用了还没注入的bean，所以导致了NPE。如果在初始化其它变量时不使用这个要注入的bean，而是在以后的方法调用的时候去赋值，是可以使用这个bean的，因为那时类已初始化好，即已注入好了。

解析下@Autowired加在构造器上的原理。

在创建实例里的代码里会对构造器进行判断，是否需要对构造器中的参数进行解析注入。
以下是org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBeanInstance
方法代码片段

autowireConstructor方法在AbstractAutowireCapableBeanFactory类中调用，这个方法作用是获取被包装后的bean，包装后的对象是BeanWrapper对象，这个对象的实现类是BeanWrapperImpl。其中包含被封装后待处理的bean，和设置bean属性的属性编辑器。
 现在对这个方法进行分析：

  //AbstractAutowireCapableBeanFactory类中
    protected BeanWrapper autowireConstructor(
            String beanName, RootBeanDefinition mbd, Constructor<?>[] ctors, Object[] explicitArgs) {
   
  //此处的this就是AbstractAutowireCapableBeanFactory
        return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
    }

ConstructorResolver类中的autowireConstructor方法

 public BeanWrapper autowireConstructor(
            final String beanName, final RootBeanDefinition mbd, Constructor<?>[] chosenCtors, final Object[] explicitArgs) {
   
        //先实例化一个BeanWrapperImpl类对象
        BeanWrapperImpl bw = new BeanWrapperImpl();
       /*
		这里的beanFactory是初始化ConstructorResolver构造器的时候在
		AbstractAutowireCapableBeanFactory类的autowireConstructor
		方法中传进来的就是AbstractAutowireCapableBeanFactory
		 */
        //--------------------------------------------------------1--------------------------------------------//
        this.beanFactory.initBeanWrapper(bw);
        //--------------------------------------------------------1--------------------------------------------//

        Constructor<?> constructorToUse = null;
        ArgumentsHolder argsHolderToUse = null;
        Object[] argsToUse = null;
        //如果构造参数不为空就直接使用
        if (explicitArgs != null) {
   
            argsToUse = explicitArgs;
        }
        else {
   
            Object[] argsToResolve = null;
            synchronized (mbd.constructorArgumentLock) {
   
                //获取已缓存解析的构造函数或工厂方法
				// （resolvedConstructorOrFactoryMethod----用于缓存已解析的构造函数或工厂方法）
                constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod;
                //如果缓存不为空，并且构造参数已经解析缓存了，
                //(constructorArgumentsResolved为包可见，用于表示构造参数状态是否已经解析)
                if (constructorToUse != null && mbd.constructorArgumentsResolved) {
   
                    // Found a cached constructor...
                    //获取缓存的构造函数（resolvedConstructorArguments
                    //---用于缓存完全解析的构造函数参数的包可见字段）
                    argsToUse = mbd.resolvedConstructorArguments;
                    if (argsToUse == null) {
   
                        //如果获取到的缓存的构造参数是空，
                        //就获取缓存的部分准备的构造函数参数（preparedConstructorArguments
                        //---用于缓存部分准备的构造函数参数的包可见字段）
                        argsToResolve = mbd.preparedConstructorArguments;
                    }
                }
            }
            //如果缓存的参数不是空，就进行解析，解析时会对
            //argsToResolve中的每个的类型进行转化，也是一个复杂的逻辑