Sping @Autowired @Value @Resourece依赖注入原理

weixin_45849726

已于 2024-05-14 20:10:17 修改

阅读量826

点赞数 18

分类专栏： java基础 spring 文章标签： java spring

于 2024-05-12 22:52:07 首次发布

本文链接：https://blog.csdn.net/weixin_45849726/article/details/138767561

版权

java基础同时被 2 个专栏收录

12 篇文章 0 订阅

订阅专栏

spring

3 篇文章 0 订阅

订阅专栏

Spring 依赖注入发生在bean的实例化之后初始化之前的阶段，可以查看：bean的创建过程

@Autowired @Value

@Autowired和@Value由AutowiredAnnotationBeanPostProcessor实现依赖注入。

寻找注入点：

AutowiredAnnotationBeanPostProcessor实现了MergedBeanDefinitionPostProcessor接口
实现的MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition方法将会在bean实例化的时候被调用

public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
    InjectionMetadata metadata = this.findAutowiringMetadata(beanName, beanType, (PropertyValues)null); //构造注入点，封装到metadata 中
    metadata.checkConfigMembers(beanDefinition);
}

postProcessMergedBeanDefinition --> findAutowiringMetadata -->buildAutowiringMetadata
buildAutowiringMetadata解析bean对象和其所有父类的属性和方法，判断是否包含Autowired注解，并构建InjectionMetadata 对象然后将其缓存

 private InjectionMetadata buildAutowiringMetadata(Class<?> clazz) {
        if (!AnnotationUtils.isCandidateClass(clazz, this.autowiredAnnotationTypes)) {//判断bean的类型是否需要注入，如String类型，则不会进行依赖注入
            return InjectionMetadata.EMPTY;
        } else {
            List<InjectedElement> elements = new ArrayList();
            Class targetClass = clazz;

            do {
                List<InjectedElement> currElements = new ArrayList();
                ReflectionUtils.doWithLocalFields(targetClass, (field) -> { //遍历bean中的属性
                    MergedAnnotation<?> ann = this.findAutowiredAnnotation(field);//判断属性中是否有@Autowired、@Value、@Inject
                    if (ann != null) {
                        if (Modifier.isStatic(field.getModifiers())) {
                            if (this.logger.isInfoEnabled()) {
                                this.logger.info("Autowired annotation is not supported on static fields: " + field);
                            }

                            return;
                        }

                        boolean required = this.determineRequiredStatus(ann); //拿到@Autowired的required属性
                        currElements.add(new AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement(field, required));
                    }

                });
                ReflectionUtils.doWithLocalMethods(targetClass, (method) -> { //遍历bean中的方法
                    Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
                    if (BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
                        MergedAnnotation<?> ann = this.findAutowiredAnnotation(bridgedMethod);//判断方法中是否有@Autowired、@Value、@Inject
                        if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
                            if (Modifier.isStatic(method.getModifiers())) {
                                if (this.logger.isInfoEnabled()) {
                                    this.logger.info("Autowired annotation is not supported on static methods: " + method);
                                }

                                return;
                            }

                            if (method.getParameterCount() == 0 && this.logger.isInfoEnabled()) {
                                this.logger.info("Autowired annotation should only be used on methods with parameters: " + method);
                            }

                            boolean required = this.determineRequiredStatus(ann); //拿到@Autowired的required属性 
                            PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
                            currElements.add(new AutowiredAnnotationBeanPostProcessor.AutowiredMethodElement(method, required, pd));
                        }

                    }
                });
                elements.addAll(0, currElements);
                targetClass = targetClass.getSuperclass(); //通过循环遍历父类的属性和方法
            } while(targetClass != null && targetClass != Object.class);

            return InjectionMetadata.forElements(elements, clazz);
        }
    }

ReflectionUtils.doWithLocalMethods遍历bean的所有属性，findAutowiredAnnotation遍历autowiredAnnotationTypes(@Autowired、@Value、@Inject),如果匹配到其中一个则返回，将其放入currElements集合

@Nullable
private MergedAnnotation<?> findAutowiredAnnotation(AccessibleObject ao) {
    MergedAnnotations annotations = MergedAnnotations.from(ao);
    Iterator var3 = this.autowiredAnnotationTypes.iterator();

    MergedAnnotation annotation;
    do {
        if (!var3.hasNext()) {
            return null;
        }

        Class<? extends Annotation> type = (Class)var3.next();
        annotation = annotations.get(type);
    } while(!annotation.isPresent());

    return annotation;
}

protected boolean determineRequiredStatus(MergedAnnotation<?> ann) {
    return this.determineRequiredStatus((AnnotationAttributes)ann.asMap((mergedAnnotation) -> {
        return new AnnotationAttributes(mergedAnnotation.getType());
    }, new Adapt[0]));
}

autowiredAnnotationTypes在AutowiredAnnotationBeanPostProcessor实例化时被赋值

public AutowiredAnnotationBeanPostProcessor() {
        this.autowiredAnnotationTypes.add(Autowired.class);
        this.autowiredAnnotationTypes.add(Value.class);

        try {
            this.autowiredAnnotationTypes.add(ClassUtils.forName("javax.inject.Inject", AutowiredAnnotationBeanPostProcessor.class.getClassLoader()));
            this.logger.trace("JSR-330 'javax.inject.Inject' annotation found and supported for autowiring");
        } catch (ClassNotFoundException var2) {
        }

    }

ReflectionUtils.doWithLocalMethods遍历bean的所有方法，进行和属性类似的逻辑

进行依赖注入：

AutowiredAnnotationBeanPostProcessor实现了SmartInstantiationAwareBeanPostProcessor接口
实现的SmartInstantiationAwareBeanPostProcessor.postProcessProperties方法将会在bean进行依赖注入的时候被调用
从缓存中拿到metadata

public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
    InjectionMetadata metadata = this.findAutowiringMetadata(beanName, bean.getClass(), pvs); //从缓存中拿到metadata 

    try {
        metadata.inject(bean, beanName, pvs);
        return pvs;
    } catch (BeanCreationException var6) {
        throw var6;
    } catch (Throwable var7) {
        throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", var7);
    }
}

然后调用AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement.inject对属性进行依赖注入，在resolveFieldValue方法获取值后，通过反射进行赋值

protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
    Field field = (Field)this.member;
    Object value;
    if (this.cached) {
        try {
            value = AutowiredAnnotationBeanPostProcessor.this.resolvedCachedArgument(beanName, this.cachedFieldValue);//获取需要进行注入的bean对象
        } catch (NoSuchBeanDefinitionException var7) {
            value = this.resolveFieldValue(field, bean, beanName);
        }
    } else {
        value = this.resolveFieldValue(field, bean, beanName);
    }

    if (value != null) {
        ReflectionUtils.makeAccessible(field);//通过反射对bean赋值
        field.set(bean, value);
    }

}

调用resolveFieldValue方法，根据filed从BeanFactory中查到对应的Bean对象。

@Nullable
private Object resolveFieldValue(Field field, Object bean, @Nullable String beanName) {
    DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
    desc.setContainingClass(bean.getClass());
    Set<String> autowiredBeanNames = new LinkedHashSet(1);
    Assert.state(AutowiredAnnotationBeanPostProcessor.this.beanFactory != null, "No BeanFactory available");
    TypeConverter typeConverter = AutowiredAnnotationBeanPostProcessor.this.beanFactory.getTypeConverter();

    Object value;
    try {
        value = AutowiredAnnotationBeanPostProcessor.this.beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
    } catch (BeansException var12) {
        throw new UnsatisfiedDependencyException((String)null, beanName, new InjectionPoint(field), var12);
    }

    synchronized(this) {
        if (!this.cached) {
            Object cachedFieldValue = null;
            if (value != null || this.required) {
                cachedFieldValue = desc;
                AutowiredAnnotationBeanPostProcessor.this.registerDependentBeans(beanName, autowiredBeanNames);
                if (autowiredBeanNames.size() == 1) {
                    String autowiredBeanName = (String)autowiredBeanNames.iterator().next();
                    if (AutowiredAnnotationBeanPostProcessor.this.beanFactory.containsBean(autowiredBeanName) && AutowiredAnnotationBeanPostProcessor.this.beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {
                        cachedFieldValue = new AutowiredAnnotationBeanPostProcessor.ShortcutDependencyDescriptor(desc, autowiredBeanName, field.getType());
                    }
                }
            }

            this.cachedFieldValue = cachedFieldValue;
            this.cached = true;
        }

        return value;
    }
}

同第4步，调用进行AutowiredAnnotationBeanPostProcessor.AutowiredMethodElement.inject对属性进行依赖注入，在resolveMethodArguments方法获取值后，通过反射进行赋值

protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
    if (!this.checkPropertySkipping(pvs)) {
        Method method = (Method)this.member;
        Object[] arguments;
        if (this.cached) {
            try {
                arguments = this.resolveCachedArguments(beanName);
            } catch (NoSuchBeanDefinitionException var8) {
                arguments = this.resolveMethodArguments(method, bean, beanName);
            }
        } else {
            arguments = this.resolveMethodArguments(method, bean, beanName);
        }

        if (arguments != null) {
            try {
                ReflectionUtils.makeAccessible(method);
                method.invoke(bean, arguments);//反射调用方法进行依赖注入
            } catch (InvocationTargetException var7) {
                throw var7.getTargetException();
            }
        }

    }
}

同第5步，调用resolveMethodArguments方法，根据method从BeanFactory中查到对应的Bean对象。

@Nullable
        private Object[] resolveMethodArguments(Method method, Object bean, @Nullable String beanName) {
            int argumentCount = method.getParameterCount();
            Object[] arguments = new Object[argumentCount];
            DependencyDescriptor[] descriptors = new DependencyDescriptor[argumentCount];
            Set<String> autowiredBeans = new LinkedHashSet(argumentCount);
            Assert.state(AutowiredAnnotationBeanPostProcessor.this.beanFactory != null, "No BeanFactory available");
            TypeConverter typeConverter = AutowiredAnnotationBeanPostProcessor.this.beanFactory.getTypeConverter();

            for(int ix = 0; ix < arguments.length; ++ix) {
                MethodParameter methodParam = new MethodParameter(method, ix);
                DependencyDescriptor currDesc = new DependencyDescriptor(methodParam, this.required);
                currDesc.setContainingClass(bean.getClass());
                descriptors[ix] = currDesc;

                try {
                    Object arg = AutowiredAnnotationBeanPostProcessor.this.beanFactory.resolveDependency(currDesc, beanName, autowiredBeans, typeConverter);
                    if (arg == null && !this.required) {
                        arguments = null;
                        break;
                    }

                    arguments[ix] = arg;
                } catch (BeansException var17) {
                    throw new UnsatisfiedDependencyException((String)null, beanName, new InjectionPoint(methodParam), var17);
                }
            }

            synchronized(this) {
                if (!this.cached) {
                    if (arguments == null) {
                        this.cachedMethodArguments = null;
                    } else {
                        DependencyDescriptor[] cachedMethodArguments = (DependencyDescriptor[])Arrays.copyOf(descriptors, arguments.length);
                        AutowiredAnnotationBeanPostProcessor.this.registerDependentBeans(beanName, autowiredBeans);
                        if (autowiredBeans.size() == argumentCount) {
                            Iterator<String> it = autowiredBeans.iterator();
                            Class<?>[] paramTypes = method.getParameterTypes();

                            for(int i = 0; i < paramTypes.length; ++i) {
                                String autowiredBeanName = (String)it.next();
                                if (AutowiredAnnotationBeanPostProcessor.this.beanFactory.containsBean(autowiredBeanName) && AutowiredAnnotationBeanPostProcessor.this.beanFactory.isTypeMatch(autowiredBeanName, paramTypes[i])) {
                                    cachedMethodArguments[i] = new AutowiredAnnotationBeanPostProcessor.ShortcutDependencyDescriptor(descriptors[i], autowiredBeanName, paramTypes[i]);
                                }
                            }
                        }

                        this.cachedMethodArguments = cachedMethodArguments;
                    }

                    this.cached = true;
                }

                return arguments;
            }
        }

依赖注入具体实现：

@Value注解如果存在占位符，会在Evironment对象中进行匹配。Spring会将vm options启动参数和被@PropertySourece(“*.properties”)的内容封装到Evironment中
@Autowired注解会先通过类型进行匹配bean，然后会进行过滤(如@Qualifier)，在之后通过@primary->@priority->beanName的方式获取bean

AbstractBeanFactory.createBean()–>AbstractAutowireCapableBeanFactory.createBean()–>AbstractAutoWireCapableBeanFactory.doCreateBean()–>populateBean()–>AutowiredAnnotationBeanPostProcessor.postProcessProperties()->AutowiredFieldElement.inject()/AutowiredMethodElement.inject()–>resolveFieldValue()/resolveMethodArguments()–>DefaultListableBeanFactory.resolveDependency()

@Nullable
public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName, @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
    descriptor.initParameterNameDiscovery(this.getParameterNameDiscoverer());
    if (Optional.class == descriptor.getDependencyType()) {
        return this.createOptionalDependency(descriptor, requestingBeanName);
    } else if (ObjectFactory.class != descriptor.getDependencyType() && ObjectProvider.class != descriptor.getDependencyType()) {
        if (javaxInjectProviderClass == descriptor.getDependencyType()) {
            return (new DefaultListableBeanFactory.Jsr330Factory()).createDependencyProvider(descriptor, requestingBeanName);
        } else {
            Object result = this.getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(descriptor, requestingBeanName);//判断是否有@Lazy注解，如果有则返回代理对象
            if (result == null) {
                result = this.doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);//否则进行依赖注入
            }

            return result;
        }
    } else {
        return new DefaultListableBeanFactory.DependencyObjectProvider(descriptor, requestingBeanName);
    }
}

进行依赖注入的核心方法doResolveDependency：

@Nullable
public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName, @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
    InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);

    Object var11;
    try {
        Object shortcut = descriptor.resolveShortcut(this);
        if (shortcut != null) {
            Object var20 = shortcut;
            return var20;
        }

		//获取注入参数的类型
        Class<?> type = descriptor.getDependencyType();
        //获取@value 中的值
        Object value = this.getAutowireCandidateResolver().getSuggestedValue(descriptor);
        Object var23;
        if (value == null) {
        	//如果存在多个匹配到的bean，并且被@Autowired注解标注的是list或者map(map的key必须为String，会用来存储bean的名字)，则会将所有类型匹配的bean封装进去，并进行依赖注入
            Object multipleBeans = this.resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
            if (multipleBeans != null) {
                var23 = multipleBeans;
                return var23;
            }
			//通过bean的类型找到所有的bean，key是beanName，value可能是bean对象，可能是beanClass
            Map<String, Object> matchingBeans = this.findAutowireCandidates(beanName, type, descriptor);
            //没有找到bean
            if (matchingBeans.isEmpty()) {
            	//且@Autowired的required = true，则抛出异常
                if (this.isRequired(descriptor)) {
                    this.raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
                }
				//且@Autowired的required = false，则注入null
                var11 = null;
                return var11;
            }

            Object instanceCandidate;
            Object result;
            String autowiredBeanName;
            if (matchingBeans.size() > 1) {
            	//如果找到多个bean，进一步筛选出某一个，@Primary-->优先级最高-->name
                autowiredBeanName = this.determineAutowireCandidate(matchingBeans, descriptor);
                if (autowiredBeanName == null) {
                    if (!this.isRequired(descriptor) && this.indicatesMultipleBeans(type)) {
                        result = null;
                        return result;
                    }

                    result = descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);
                    return result;
                }

                instanceCandidate = matchingBeans.get(autowiredBeanName);
            } else {
            	//如果只找到一个bean
                Entry<String, Object> entry = (Entry)matchingBeans.entrySet().iterator().next();
                autowiredBeanName = (String)entry.getKey();
                instanceCandidate = entry.getValue();
            }
			//记录匹配过的beanName
            if (autowiredBeanNames != null) {
                autowiredBeanNames.add(autowiredBeanName);
            }
			//判断是否是class，如果是则创建对应的bean，调用getBean
            if (instanceCandidate instanceof Class) {
                instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
            }
			
            result = instanceCandidate;
            //如果注册bean的时候定义的null，则在spring中是NullBean
            if (instanceCandidate instanceof NullBean) {
            	//如果required则抛出异常
                if (this.isRequired(descriptor)) {
                    this.raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
                }
				//否则返回null
                result = null;
            }

            if (!ClassUtils.isAssignableValue(type, result)) {
                throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass());
            }

            Object var14 = result;
            return var14;
        }

		//处理@Value注解
        if (value instanceof String) {
            String strVal = this.resolveEmbeddedValue((String)value);//占位符填充(${})，会在Evironment对象中进行匹配。Spring会将vm options启动参数和被@PropertySourece("*.properties")的内容封装到Evironment中
            BeanDefinition bd = beanName != null && this.containsBean(beanName) ? this.getMergedBeanDefinition(beanName) : null;
            //spring 表达式(#{})
            value = this.evaluateBeanDefinitionString(strVal, bd);
        }

        TypeConverter converter = typeConverter != null ? typeConverter : this.getTypeConverter();

        try {
            var23 = converter.convertIfNecessary(value, type, descriptor.getTypeDescriptor());
            return var23;
        } catch (UnsupportedOperationException var18) {
            var11 = descriptor.getField() != null ? converter.convertIfNecessary(value, type, descriptor.getField()) : converter.convertIfNecessary(value, type, descriptor.getMethodParameter());
        }
    } finally {
        ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
    }

    return var11;
}

findAutowireCandidates，通过类型使用BeanFactoryUtils查找所有的bean，然后有过滤bean的逻辑(@Qualifier)

BeanFactoryUtils.beanNamesForTypeIncludingAncestors()–>beanNamesForTypeIncludingAncestors()–>DefaultListableBeanFactory.getBeanNamesForType()
beanNamesForTypeIncludingAncestors()中会进行递归调用，并合并父子BeanFactory得到的bean集合

//includeNonSingletons true表示所有bean,false表示单例baen 
public static String[] beanNamesForTypeIncludingAncestors(ListableBeanFactory lbf, Class<?> type, boolean includeNonSingletons, boolean allowEagerInit) {
    Assert.notNull(lbf, "ListableBeanFactory must not be null");
    String[] result = lbf.getBeanNamesForType(type, includeNonSingletons, allowEagerInit);
    if (lbf instanceof HierarchicalBeanFactory) {
        HierarchicalBeanFactory hbf = (HierarchicalBeanFactory)lbf;
        if (hbf.getParentBeanFactory() instanceof ListableBeanFactory) {
            String[] parentResult = beanNamesForTypeIncludingAncestors((ListableBeanFactory)hbf.getParentBeanFactory(), type, includeNonSingletons, allowEagerInit);
            result = mergeNamesWithParent(result, parentResult, hbf);
        }
    }

    return result;
}

DefaultListableBeanFactory.getBeanNamesForType()–>doGetBeanNamesForType–>AbstractBeanFactory.isTypeMatch
doGetBeanNamesForType会遍历缓存中所有的beanDefinition拿到bean
如果isTypeMatch会从通过beanName从单例池获取，如果单例池没有会通过bean的类型判断是否是FactoryBean

//includeNonSingletons true表示所有bean,false表示单例baen 
public String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit) {
    if (this.isConfigurationFrozen() && type != null && allowEagerInit) {
    	//allBeanNamesByType 所有bean的集合，singletonBeanNamesByType单例bean的集合
        Map<Class<?>, String[]> cache = includeNonSingletons ? this.allBeanNamesByType : this.singletonBeanNamesByType;
        String[] resolvedBeanNames = (String[])cache.get(type);
        if (resolvedBeanNames != null) {
            return resolvedBeanNames;
        } else {
            resolvedBeanNames = this.doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, true);
            if (ClassUtils.isCacheSafe(type, this.getBeanClassLoader())) {
                cache.put(type, resolvedBeanNames);
            }

            return resolvedBeanNames;
        }
    } else {
        return this.doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, allowEagerInit);
    }
}

如果通过类型匹配到多个bean，则调用determineAutowireCandidate获取bean，先通过@primary获取，如果没有该注解则判断优先级，否则通过beanName获取bean:

@Nullable
protected String determineAutowireCandidate(Map<String, Object> candidates, DependencyDescriptor descriptor) {
    Class<?> requiredType = descriptor.getDependencyType();
    //判断是否有@primary(该注解会设置Bean的BeanDefinition的isPrimary)
    String primaryCandidate = this.determinePrimaryCandidate(candidates, requiredType);
    if (primaryCandidate != null) {
        return primaryCandidate;
    } else {
    	//获取优先级最高的bean @priority(只能注解到类上，且数字越小越优先)
        String priorityCandidate = this.determineHighestPriorityCandidate(candidates, requiredType);
        if (priorityCandidate != null) {
            return priorityCandidate;
        } else {
            Iterator var6 = candidates.entrySet().iterator();

            String candidateName;
            Object beanInstance;
            do {
                if (!var6.hasNext()) {
                    return null;
                }

                Entry<String, Object> entry = (Entry)var6.next();
                //获取被配到的bean名字
                candidateName = (String)entry.getKey();
                //获取匹配到的bean对象
                beanInstance = entry.getValue();
                //this.matchesBeanName(candidateName, descriptor.getDependencyName()) 如果beanName匹配到，则返回
            } while((beanInstance == null || !this.resolvableDependencies.containsValue(beanInstance)) && !this.matchesBeanName(candidateName, descriptor.getDependencyName()));

            return candidateName;
        }
    }
}

this.getAutowireCandidateResolver().getSuggestedValue(descriptor); 获取@Value的值
QualifierAnnotationAutowireCandidateResolver.getSuggestedValue

@Nullable
public Object getSuggestedValue(DependencyDescriptor descriptor) {
    Object value = this.findValue(descriptor.getAnnotations());//查询并获取@Value注解的值
    if (value == null) {
        MethodParameter methodParam = descriptor.getMethodParameter();//获取方法参数列表
        if (methodParam != null) {
            value = this.findValue(methodParam.getMethodAnnotations());//判断方法参数前是否有@Value注解，返回值
        }
    }

    return value;
}

@Resourece

@Resourece由CommonAnnotationBeanPostProcessor实现依赖注入

同@Autowired，postProcessMergedBeanDefinition方法寻找注入点，postProcessProperties方法进行依赖注入。

找注入点方法同样 postProcessMergedBeanDefinition()–>postProcessMergedBeanDefinition()–>buildResourceMetadata(),
在buildResourceMetadata方法中遍历field和method，判断是否被@Resource注解，构造出CommonAnnotationBeanPostProcessor.ResourceElement和CommonAnnotationBeanPostProcessor.ResourceElement对象，将其存入缓存

进行依赖注入时：postProcessProperties()–>findResourceMetadata() 寻找依赖注入的bean
会先根据名字匹配beean，在根据类型匹配，和@Autowired不同
进行依赖注入：postProcessProperties()–>inject()–>InjectionMetadata.inject()–>InjectedElement.inject–>ResourceElement.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, this.getResourceToInject(target, requestingBeanName));
    } else {
        if (this.checkPropertySkipping(pvs)) {
            return;
        }

        try {
            Method method = (Method)this.member;
            ReflectionUtils.makeAccessible(method);
            method.invoke(target, this.getResourceToInject(target, requestingBeanName));
        } catch (InvocationTargetException var5) {
            throw var5.getTargetException();
        }
    }

}

weixin_45849726

关注

18
点赞
踩
26

收藏

觉得还不错? 一键收藏
2
评论
Sping @Autowired @Value @Resourece依赖注入原理

AnnotationUtils.isCandidateClass(clazz, this.autowiredAnnotationTypes)) {//判断bean的类型是否需要注入，如String类型，则不会进行依赖注入。然后调用AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement.inject对属性进行依赖注入，在resolveFieldValue方法获取值后，通过反射进行赋值。//从缓存中拿到metadata。
复制链接

扫一扫