autowired的对象为null_@Autowired和@Value 在spring Bean 生命周期依赖注入过程

主要实现的 BeanPostProcessor 是 

AutowiredAnnotationBeanPostProcessor

演示例子

public class AnnotatedBeanDependencyAutoDemo {

    @Autowired
    private User user;

    @Bean
    public User user(){
        User user = new User();
        user.setId(189999L);
        user.setName("ddddd");
        return user;
    }

    public static void main(String[] args) {
        //主要看这个构造函数，进入禁进去
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        //也可以使用   applicationContext.register 进行注册
         applicationContext.register(AnnotatedBeanDependencyAutoDemo.class);

         applicationContext.refresh();
        AnnotatedBeanDependencyAutoDemo demo = applicationContext.getBean(AnnotatedBeanDependencyAutoDemo.class);
        User userAuto = demo.user;
        System.out.println(userAuto);

        //关闭上下文
        applicationContext.close();

    }
}

我们首先看看AutowiredAnnotationBeanPostProcessor

我们先来看看方法栈，看看他的调用链，

这是它的UML类图，然后我们再看看他的方法这个方法，

AutowiredAnnotationBeanPostProcessor 是一个实现了多重接口的 bean-post-processor，它处理 @Autowired 和 @Value 的依赖注入处理

这里我们主要看到的是

postProcessProperties这个方法，这个方法的来源是 InstantiationAwareBeanPostProcessor#postProcessProperties ，在Bean 生命周期中实例化之后，进行属性植入的时候，会进行调用

这里承接 Spring IOC 源码分析--第二篇 中创建Bean过程中的提到的针对于 @Autowired 和 @Value 的处理过程

我们直接查看调用的方法栈

我们首先看到一个方法

1. findAutowiringMetadata

InjectionMetadata ：内部类，用于管理注入元数据，就是一个用于管理注入元数据的一个类

我们进入到findAutowiringMetadata 看看 

    private InjectionMetadata findAutowiringMetadata(String beanName, Class> clazz, @Nullable PropertyValues pvs) {
        // Fall back to class name as cache key, for backwards compatibility with custom callers.
        String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
        // Quick check on the concurrent map first, with minimal locking.
        InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
        if (InjectionMetadata.needsRefresh(metadata, clazz)) {
            synchronized (this.injectionMetadataCache) {
                //查看缓存中有没有这个Bean，没有 就执行方法 buildAutowiringMetadata 去构建
                metadata = this.injectionMetadataCache.get(cacheKey);
                if (InjectionMetadata.needsRefresh(metadata, clazz)) {
                    if (metadata != null) {
                        metadata.clear(pvs);
                    }
                    //接着往下走
                    metadata = buildAutowiringMetadata(clazz);
                    this.injectionMetadataCache.put(cacheKey, metadata);
                }
            }
        }
        return metadata;
    }

这个方法中就是查询，如果查询不到就去创建一个InjectionMetadata

接着看

buildAutowiringMetadata

    private InjectionMetadata buildAutowiringMetadata(final Class> clazz) {
        if (!AnnotationUtils.isCandidateClass(clazz, this.autowiredAnnotationTypes)) {
            return InjectionMetadata.EMPTY;
        }

        List elements = new ArrayList<>();Class> targetClass = clazz;do {final List currElements = new ArrayList<>();
            ReflectionUtils.doWithLocalFields(targetClass, field -> {//找父类，以及父类的父类直至最终的Object类，看有没有被@Autowired修饰--为空进行merge
                MergedAnnotation> ann = findAutowiredAnnotation(field);if (ann != null) {//注解@Autowired修饰的字段是否为staticif (Modifier.isStatic(field.getModifiers())) {if (logger.isInfoEnabled()) {
                            logger.info("Autowired annotation is not supported on static fields: " + field);
                        }return;
                    }//判断 @Autowired required()是否为true
                    boolean required = determineRequiredStatus(ann);
                    currElements.add(new AutowiredFieldElement(field, required));
                }
            });
            ReflectionUtils.doWithLocalMethods(targetClass, method -> {
                Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {return;
                }
                MergedAnnotation> ann = findAutowiredAnnotation(bridgedMethod);if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {if (Modifier.isStatic(method.getModifiers())) {if (logger.isInfoEnabled()) {
                            logger.info("Autowired annotation is not supported on static methods: " + method);
                        }return;
                    }if (method.getParameterCount() == 0) {if (logger.isInfoEnabled()) {
                            logger.info("Autowired annotation should only be used on methods with parameters: " +
                                    method);
                        }
                    }
                    boolean required = determineRequiredStatus(ann);
                    PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
                    currElements.add(new AutowiredMethodElement(method, required, pd));
                }
            });
            elements.addAll(0, currElements);
            targetClass = targetClass.getSuperclass();
        }while (targetClass != null && targetClass != Object.class);return InjectionMetadata.forElements(elements, clazz);
    }

2. metadata.inject方法

进入inject 方法，再次进入到 InjectedElement 的inject 在这个方法中通过代理进行实现方法

    public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
        Collection checkedElements = this.checkedElements;
        Collection elementsToIterate =
                (checkedElements != null ? checkedElements : this.injectedElements);if (!elementsToIterate.isEmpty()) {for (InjectedElement element : elementsToIterate) {if (logger.isTraceEnabled()) {
                    logger.trace("Processing injected element of bean '" + beanName + "': " + element);
                }//inject方法中 通过代理机进行调用
                element.inject(target, beanName, pvs);
            }
        }
    }protected void inject(Object target, @Nullable String requestingBeanName, @Nullable PropertyValues pvs)
                throws Throwable {if (this.isField) {
                Field field = (Field) this.member;
                ReflectionUtils.makeAccessible(field);
                field.set(target, getResourceToInject(target, requestingBeanName));
            }else {if (checkPropertySkipping(pvs)) {return;
                }try {
                    Method method = (Method) this.member;
                    ReflectionUtils.makeAccessible(method);//看这里
                    method.invoke(target, getResourceToInject(target, requestingBeanName));
                }catch (InvocationTargetException ex) {throw ex.getTargetException();
                }
            }
        }

重点来了 。。。。。

这里直接会跳转到 DefaultListableBeanFactory#resolveDependency这个方法中进行依赖的注入

resolveDependency方法

    public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
            @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
//        参数解释：
//        1. DependencyDescriptor: 对依赖的描述，其中这个类中的字段是Bean的一些相关设置的值
//        2. requestingBeanName: 声明给定依赖项的bean的名称，需要获取的外围Bean的名称
        /*如   public class AnnotationDependencyResolutionDemo{
             @Autowired
             private User user;
             }*/
//        requestingBeanName 指的是 AnnotationDependencyResolutionDemo 这个外围bean 而不是 User
//        3. autowiredBeanNames: 所有自动连接bean(用于解析给定依赖项)的所有名称都应添加到其中的集合
//        4. TypeConverter:  类型转换器
        descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
        if (Optional.class == descriptor.getDependencyType()) {
            // 内部调用方式是也是调用这个方法doResolveDependency(...)
            return createOptionalDependency(descriptor, requestingBeanName);
        }
        else if (ObjectFactory.class == descriptor.getDependencyType() ||
                ObjectProvider.class == descriptor.getDependencyType()) {
            return new DependencyObjectProvider(descriptor, requestingBeanName);
        }
        else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
            return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName);
        }
        else {
            //判断是否是延迟加载,@Lazy 为true,或者在 xml配置了这个属性
            Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
                    descriptor, requestingBeanName);
            if (result == null) {
                // 如果 result 为 null，我们看
                result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
            }
            return result;
        }
    }

大家有兴趣的去看看   DependencyDescriptor  它是依赖描述器，简单说下

 伪代码 public class AnnotationDependencyResolutionDemo {  @Autowired//实施注入 + 通过类型User.class查找 + 字段名称是 "user"  private User user;  /*   * 依赖处理过程:   * DependencyDescriptor(依赖描述) --- >   * declaringClass --- AnnotationDependencyProcessingDemo 描述的对象类的类型，这里是当前类   * getDependencyType() 依赖字段类型---  User.class   * required 为 true ,这个required 是指的@Autowired中的required值   * eager 对应的  @Lazy对应,  实时加载 为 true,   * fieldName -- user : 字段名称   */

getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary 我们这里就不讲解了，就是查看是否标注了 @Lazy这个属性，即是否为懒加载，

然后进入到

doResolveDependency

    public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
            @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
        //处理嵌套多次注入的时候一个保护点，null就是没有保护点
        InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
        try {
            //快捷方式
            Object shortcut = descriptor.resolveShortcut(this);
            if (shortcut != null) {
                return shortcut;
            }
            //当前类的class type 这里这个被标注的类
             /*如   public class AnnotationDependencyResolutionDemo{
             @Autowired
             private User user;
             }*/
            // 这个例子中是指的是 User 这个被 @Autowired 标注的类
            Class> type = descriptor.getDependencyType();
            Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
            if (value != null) {
                if (value instanceof String) {
                    String strVal = resolveEmbeddedValue((String) value);
                    BeanDefinition bd = (beanName != null && containsBean(beanName) ?
                            getMergedBeanDefinition(beanName) : null);
                    value = evaluateBeanDefinitionString(strVal, bd);
                }
                TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
                try {
                    return converter.convertIfNecessary(value, type, descriptor.getTypeDescriptor());
                }
                catch (UnsupportedOperationException ex) {
                    // A custom TypeConverter which does not support TypeDescriptor resolution...
                    return (descriptor.getField() != null ?
                            converter.convertIfNecessary(value, type, descriptor.getField()) :
                            converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
                }
            }
            //descriptor.getDependencyType()是否是集合类型
            Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
            if (multipleBeans != null) {
                return multipleBeans;
            }
            //查询beanName外围Bean 下面管理的 类型为 这个 type(descriptor.getDependencyType()) 的 Bean--真正被  @Autowired 标注的类
            Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
            if (matchingBeans.isEmpty()) {
                if (isRequired(descriptor)) {
                    raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
                }
                return null;
            }

            String autowiredBeanName;
            Object instanceCandidate;

            if (matchingBeans.size() > 1) {
                //查找Primary =true 或者 @Priority 的Bean ---  Looks for {@code @Primary} and {@code @Priority} (in that order) 的Bean
                autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
                if (autowiredBeanName == null) {
                    if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
                        // 抛出异常不是唯一的Bean
                        return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);
                    }
                    else {
                        // In case of an optional Collection/Map, silently ignore a non-unique case:
                        // possibly it was meant to be an empty collection of multiple regular beans
                        // (before 4.3 in particular when we didn't even look for collection beans).
                        return null;
                    }
                }
                //通过autowiredBeanName(标注Primary =true 或者 @Priority的Bean)名称获取 Bean
                instanceCandidate = matchingBeans.get(autowiredBeanName);
            }
            else {
                // We have exactly one match.
                Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
                autowiredBeanName = entry.getKey();
                instanceCandidate = entry.getValue();
            }

            if (autowiredBeanNames != null) {
                autowiredBeanNames.add(autowiredBeanName);
            }
            if (instanceCandidate instanceof Class) {
                //beanFactory.getBean(beanName)，获取这个Bean了
                instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
            }
            Object result = instanceCandidate;
            if (result instanceof NullBean) {
                if (isRequired(descriptor)) {
                    raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
                }
                result = null;
            }
            if (!ClassUtils.isAssignableValue(type, result)) {
                throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass());
            } // 返回被@Autowired 标注的 Bean
            return result;
        }
        finally {
            ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
        }
    }

这里我们再看看 resolveMultipleBeans，这个代表我们的类型是否是结合类型

如 下面的伪代码 ， 这里就会判断 autowiredUserSet是否是集合类型

public class AnnotationDependencyQualifierInjectionDemo{@Autowiredprivate Set autowiredUserSet;}

    private Object resolveMultipleBeans(DependencyDescriptor descriptor, @Nullable String beanName,
            @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) {
        // 被@Autowired 标注的类，可能是map，list也可能是一个单体类
        Class> type = descriptor.getDependencyType();

        if (descriptor instanceof StreamDependencyDescriptor) {
            Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
            if (autowiredBeanNames != null) {
                autowiredBeanNames.addAll(matchingBeans.keySet());
            }
            Stream<Object> stream = matchingBeans.keySet().stream()
                    .map(name -> descriptor.resolveCandidate(name, type, this))
                    .filter(bean -> !(bean instanceof NullBean));
            if (((StreamDependencyDescriptor) descriptor).isOrdered()) {
                stream = stream.sorted(adaptOrderComparator(matchingBeans));
            }
            return stream;
        }//是否是数组
        else if (type.isArray()) {
            Class> componentType = type.getComponentType();
            ResolvableType resolvableType = descriptor.getResolvableType();
            Class> resolvedArrayType = resolvableType.resolve(type);
            if (resolvedArrayType != type) {
                componentType = resolvableType.getComponentType().resolve();
            }
            if (componentType == null) {
                return null;
            }
            Map<String, Object> matchingBeans = findAutowireCandidates(beanName, componentType,
                    new MultiElementDescriptor(descriptor));
            if (matchingBeans.isEmpty()) {
                return null;
            }
            if (autowiredBeanNames != null) {
                autowiredBeanNames.addAll(matchingBeans.keySet());
            }
            TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
            Object result = converter.convertIfNecessary(matchingBeans.values(), resolvedArrayType);
            if (result instanceof Object[]) {
                Comparator<Object> comparator = adaptDependencyComparator(matchingBeans);
                if (comparator != null) {
                    Arrays.sort((Object[]) result, comparator);
                }
            }
            return result;
        }//是否是被标注的类 是否是接口，是否是type实现了 Collection
        else if (Collection.class.isAssignableFrom(type) && type.isInterface()) {
            Class> elementType = descriptor.getResolvableType().asCollection().resolveGeneric();
            if (elementType == null) {
                return null;
            }
            Map<String, Object> matchingBeans = findAutowireCandidates(beanName, elementType,
                    new MultiElementDescriptor(descriptor));
            if (matchingBeans.isEmpty()) {
                return null;
            }
            if (autowiredBeanNames != null) {
                autowiredBeanNames.addAll(matchingBeans.keySet());
            }
            TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
            Object result = converter.convertIfNecessary(matchingBeans.values(), type);
            if (result instanceof List) {
                if (((List>) result).size() > 1) {
                    Comparator<Object> comparator = adaptDependencyComparator(matchingBeans);
                    if (comparator != null) {
                        ((List>) result).sort(comparator);
                    }
                }
            }
            return result;
        }
        else if (Map.class == type) {
            //获取其元信息
            ResolvableType mapType = descriptor.getResolvableType().asMap();
            //获取Bean类型是Map,中 key的ClassType
            Class> keyType = mapType.resolveGeneric(0);
            if (String.class != keyType) {
                return null;
            }
            //获取Bean类型是Map,中 value 的ClassType
            Class> valueType = mapType.resolveGeneric(1);
            if (valueType == null) {
                return null;
            }
            //查询beanName 下面管理的 类型为 这个 type(descriptor.getDependencyType()) 的 Bean
            Map<String, Object> matchingBeans = findAutowireCandidates(beanName, valueType,
                    new MultiElementDescriptor(descriptor));
            if (matchingBeans.isEmpty()) {
                return null;
            }
            if (autowiredBeanNames != null) {
                autowiredBeanNames.addAll(matchingBeans.keySet());
            }
            return matchingBeans;
        }
        else {
            return null;
        }
    }

findAutowireCandidates

findAutowireCandidates方法查询然后封装到map中。如果大家有兴趣的可以看看

然后我们再回到resolveDependency方法中，然后返回Bean

到这里我们，最后返回Bean

    public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
            @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
//        参数解释：
//        1. DependencyDescriptor: 对依赖的描述，其中这个类中的字段是Bean的一些相关设置的值
//        2. requestingBeanName: 声明给定依赖项的bean的名称，需要获取的外围Bean的名称
        /*如   public class AnnotationDependencyResolutionDemo{
             @Autowired
             private User user;
             }*/
//        requestingBeanName 指的是 AnnotationDependencyResolutionDemo 这个外围bean 而不是 User
//        3. autowiredBeanNames: 所有自动连接bean(用于解析给定依赖项)的所有名称都应添加到其中的集合
//        4. TypeConverter:  类型转换器
        descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
        if (Optional.class == descriptor.getDependencyType()) {
            // 内部调用方式是也是调用这个方法doResolveDependency(...)
            return createOptionalDependency(descriptor, requestingBeanName);
        }
        else if (ObjectFactory.class == descriptor.getDependencyType() ||
                ObjectProvider.class == descriptor.getDependencyType()) {
            return new DependencyObjectProvider(descriptor, requestingBeanName);
        }
        else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
            return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName);
        }
        else {
            //判断是否是延迟加载,@Lazy 为true,或者在 xml配置了这个属性
            Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
                    descriptor, requestingBeanName);
            if (result == null) {
                // 如果 result 为 null，我们看
                result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
            }
            return result;
        }
    }

到这里，我们就执行完了AutowiredAnnotationBeanPostProcessor的postProcessProperties方法.