详解@Resource解析过程

刺骨的言语ヽ痛彻心扉 2023-10-02 12:21 31阅读 0赞

### 一、Resource注解解析过程 ###

@Resource和@Autowired处理的逻辑基本相同，都是先查找注入点，然后再根据注入点进行属性注入，所不同的是@Resource的解析是由CommonAnnotationBeanPostProcessor来完成的，@Autowired解析由AutowiredAnnotationBeanPostProcessor完成，下面介绍@Resource解析的全过程

##### 1.1 寻找注入点 #####

寻找注入点的时机与@Autowired一致，都是在实例化后，调用所有实现了MergedBeanDefinitionPostProcessor接口的postProcessMergedBeanDefinition()方法，同样Resource注解的处理类CommonAnnotationBeanPostProcessor也实现了MergedBeanDefinitionPostProcessor接口，所以会调用该类的postProcessMergedBeanDefinition()方法来寻找注入点

方法的第一行代码会去调用InitDestroyAnnotationBeanPostProcessor的postProcessMergedBeanDefinition()来缓存和检查初始化方法和销毁方法

第二行代码去查找@Resource注解的元数据

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

根据beanName先去缓存中获取，如果缓存中没有或者InjectionMetadata中的目标class与当前beanType不符，则调用buildResourceMetadata来生成注解元数据

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

循环遍历当前类和父类的属性和方法，判断是否有@Resource注解，如果有，则生成ResourceElement对象，ResourceElement继承自InjectionMetadata.InjectedElement，将ResourceElement对象对象放入到InjectedElement对象结合中，然后生成InjectionMetadata对象返回

对于静态属性和静态方法，@Autowired不会进行处理，但@Resource则直接抛出异常

private InjectionMetadata buildResourceMetadata(final Class<?> clazz) {
        
        if (!AnnotationUtils.isCandidateClass(clazz, resourceAnnotationTypes)) {
        
            return InjectionMetadata.EMPTY;
        }
    
        List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
        Class<?> targetClass = clazz;
    
        do {
        
            final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();
    
            ReflectionUtils.doWithLocalFields(targetClass, field -> {
        
                ……
                else if (field.isAnnotationPresent(Resource.class)) {
        
                    if (Modifier.isStatic(field.getModifiers())) {
        
                        throw new IllegalStateException("@Resource annotation is not supported on static fields");
                    }
                    if (!this.ignoredResourceTypes.contains(field.getType().getName())) {
        
                        currElements.add(new ResourceElement(field, field, null));
                    }
                }
            });
    
            ReflectionUtils.doWithLocalMethods(targetClass, method -> {
        
                Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
                if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
        
                    return;
                }
                ……
                    else if (bridgedMethod.isAnnotationPresent(Resource.class)) {
        
                        if (Modifier.isStatic(method.getModifiers())) {
        
                            throw new IllegalStateException("@Resource annotation is not supported on static methods");
                        }
                        Class<?>[] paramTypes = method.getParameterTypes();
                        if (paramTypes.length != 1) {
        
                            throw new IllegalStateException("@Resource annotation requires a single-arg method: " + method);
                        }
                        if (!this.ignoredResourceTypes.contains(paramTypes[0].getName())) {
        
                            PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
                            currElements.add(new ResourceElement(method, bridgedMethod, pd));
                        }
                    }
                }
            });
    
            elements.addAll(0, currElements);
            targetClass = targetClass.getSuperclass();
        }
        while (targetClass != null && targetClass != Object.class);
    
        return InjectionMetadata.forElements(elements, clazz);
    }

ResourceElement的构造方法如下，@Resource注解可以通过name和type两个方法指定注入Bean的名字和类型，如果没有指定name，则使用默认的名称，使用参数名或set方法去掉set前缀当作name

如果指定了type属性，检查属性的类型或方法的第一个参数类型是否与指定的类型匹配，如果不匹配将抛出异常

public ResourceElement(Member member, AnnotatedElement ae, @Nullable PropertyDescriptor pd) {
        
        super(member, pd);
        Resource resource = ae.getAnnotation(Resource.class);
        String resourceName = resource.name();
        Class<?> resourceType = resource.type();
    
        // 使用@Resource时没有指定具体的name，那么则用field的name，或setXxx()中的xxx
        this.isDefaultName = !StringUtils.hasLength(resourceName);
        if (this.isDefaultName) {
        
            resourceName = this.member.getName();
            if (this.member instanceof Method && resourceName.startsWith("set") && resourceName.length() > 3) {
        
                resourceName = Introspector.decapitalize(resourceName.substring(3));
            }
        }
        // 使用@Resource时指定了具体的name，进行占位符填充
        else if (embeddedValueResolver != null) {
        
            resourceName = embeddedValueResolver.resolveStringValue(resourceName);
        }
    
        // @Resource除开可以指定bean，还可以指定type，type默认为Object
        if (Object.class != resourceType) {
        
            // 如果指定了type，则验证一下和field的类型或set方法的第一个参数类型，是否和所指定的resourceType匹配
            checkResourceType(resourceType);
        }
        else {
        
            // No resource type specified... check field/method.
            resourceType = getResourceType();
        }
        ……
    }

##### 1.2 属性注入 #####

属性注入是在属性填充的时候过程中完成，调用InstantiationAwareBeanPostProcessor实现类的postProcessProperties()，@Resource注解的属性注入是在CommonAnnotationBeanPostProcessor的postProcessProperties()中完成

*  ###### 开始注入 ######
    
    获取已经缓存的注入点，然后调用InjectedElement的inject()，这个地方不同于@Autowired，Autowired注解的属性注入分别会调用AutowiredFieldElement和AutowiredMethodElement的inject()
    
        public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
              
            InjectionMetadata metadata = findResourceMetadata(beanName, bean.getClass(), pvs);
            try {
              
                metadata.inject(bean, beanName, pvs);
            }
            catch (Throwable ex) {
              
                throw new BeanCreationException(beanName, "Injection of resource dependencies failed", ex);
            }
            return pvs;
        }
    
        public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
              
           Collection<InjectedElement> checkedElements = this.checkedElements;
           Collection<InjectedElement> elementsToIterate =
                 (checkedElements != null ? checkedElements : this.injectedElements);
           if (!elementsToIterate.isEmpty()) {
              
              // 遍历每个注入点进行依赖注入
              for (InjectedElement element : elementsToIterate) {
              
                 element.inject(target, beanName, pvs);
              }
           }
        }
 *  ###### 获取注入值 ######
    
    InjectedElement的inject()源码如下，直接调用getResourceToInject()获取依赖值进行注入
    
        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();
              }
           }
        }
    
    如果属性或方法标注了@Lazy注解，则生成一个代理对象，否则调用getResource()获取注入对象
    
        protected Object getResourceToInject(Object target, @Nullable String requestingBeanName) {
              
           return (this.lazyLookup ? buildLazyResourceProxy(this, requestingBeanName) :
                 getResource(this, requestingBeanName));
        }
    
    getResource()源码如下，调用核心的autowireResource()获取bean对象
    
        protected Object getResource(LookupElement element, @Nullable String requestingBeanName)
              throws NoSuchBeanDefinitionException {
              
        	……
           // 根据LookupElement从BeanFactory找到适合的bean对象
           return autowireResource(this.resourceFactory, element, requestingBeanName);
        }
    
    如果当前的beanFactory属于AutowireCapableBeanFactory，如果根据名称找不到bean对象时，还可以调用resolveDependency()根据type获取或生成bean对象
    
    @Resource注解查找bean对象时，先判断是否使用默认名，如果用默认名，则先根据默认名判断BeanFactory是否有，如果有的话直接调用getBean()获取bean对象，如果没有，再调用resolveDependency()根据类型去查找或生成bean对象，resolveDependency()是@Autowired解析的核心方法
    
    如果指定了名称，则直接调用getBean()方法去查找bean对象
    
    如果找到了bean对象，则将它的name缓存在autowiredBeanNames中，最后调用beanFactory.registerDependentBean()缓存beanName之间的依赖关系，当前注入的bean对象的被哪些bean依赖，缓存的是beanNaem，而不是bean对象
    
        protected Object autowireResource(BeanFactory factory, LookupElement element, @Nullable String requestingBeanName)
              throws NoSuchBeanDefinitionException {
              
        
           Object resource;
           Set<String> autowiredBeanNames;
           String name = element.name;
        
           if (factory instanceof AutowireCapableBeanFactory) {
              
              AutowireCapableBeanFactory beanFactory = (AutowireCapableBeanFactory) factory;
              DependencyDescriptor descriptor = element.getDependencyDescriptor();
        
              // 假设@Resource中没有指定name，并且field的name或setXxx()的xxx不存在对应的bean，那么则根据field类型或方法参数类型从BeanFactory去找
              if (this.fallbackToDefaultTypeMatch && element.isDefaultName && !factory.containsBean(name)) {
              
                 autowiredBeanNames = new LinkedHashSet<>();
                 resource = beanFactory.resolveDependency(descriptor, requestingBeanName, autowiredBeanNames, null);
                 if (resource == null) {
              
                    throw new NoSuchBeanDefinitionException(element.getLookupType(), "No resolvable resource object");
                 }
              }
              else {
              
                 resource = beanFactory.resolveBeanByName(name, descriptor);
                 autowiredBeanNames = Collections.singleton(name);
              }
           }
           else {
              
              resource = factory.getBean(name, element.lookupType);
              autowiredBeanNames = Collections.singleton(name);
           }
        
           if (factory instanceof ConfigurableBeanFactory) {
              
              ConfigurableBeanFactory beanFactory = (ConfigurableBeanFactory) factory;
              for (String autowiredBeanName : autowiredBeanNames) {
              
                 if (requestingBeanName != null && beanFactory.containsBean(autowiredBeanName)) {
              
                    beanFactory.registerDependentBean(autowiredBeanName, requestingBeanName);
                 }
              }
           }
        
           return resource;
        }

##### 1.3 与@Autowired区别 #####

1、性能上两者没有任何区别，@Resource是Jdk提供了注解，Spring对其进行了具体实现，在获取依赖注入值的过程中，@Autowired先根据类型来查找，然后进行Qualifier筛选等层层筛选，而@Resource先根据名城查找，如果使用的是默认名，并且beanFactory根据名称找不到的时候，才会调用与@Autowired一样的逻辑根据类型来找

2、如果@Resource指定了名称，则只会根据名称来查找bean对象，找不到直接抛异常