spring5.1.x源码解析之十三(spring自动注入)

今天药忘吃喽~ 2023-05-21 07:16 10阅读 0赞

### 文章目录 ###

*  Demo
 *   *  解析成beanDefinitions
     *  加载对象
 *  注入@Auto
 *   *  赋值

# Demo #

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:aop="http://www.springframework.org/schema/aop"
           xsi:schemaLocation="
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd
             http://www.springframework.org/schema/aop
             http://www.springframework.org/schema/aop/spring-aop.xsd">
    
        <context:component-scan base-package="org.example.context" ></context:component-scan>
    
    </beans>

package org.example.context;
    
    import org.springframework.beans.factory.BeanFactory;
    import org.springframework.beans.factory.xml.XmlBeanFactory;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.springframework.core.io.ClassPathResource;
    
    public class App {
        
        public static void main(String[] args) {
        
            ApplicationContext bf = new ClassPathXmlApplicationContext("context.xml");
            //BeanFactory bf = new XmlBeanFactory(new ClassPathResource("context.xml"));
            MyService autoTest = (MyService) bf.getBean("myService");
            autoTest.sayHello();
        }
    }

package org.example.context;
    
    import lombok.Data;
    import org.springframework.stereotype.Repository;
    
    
    @Repository
    @Data
    public class Dao {
        
        private String name="heh";
        private String age="15";
    
    }

package org.example.context;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    
    
    @Service
    public class MyService {
        
        @Autowired
        private Dao dao;
    
        public void sayHello() {
        
            System.out.println(dao.toString());
        }
    }

## 解析成beanDefinitions ##

public class ComponentScanBeanDefinitionParser implements BeanDefinitionParser {
        
    
    	//扫描的基本包路径
    	private static final String BASE_PACKAGE_ATTRIBUTE = "base-package";
    
    	//对资源进行筛选的正则表达式，这边是个大的范畴，具体细分在include-filter与exclude-filter中进行 -->
    	private static final String RESOURCE_PATTERN_ATTRIBUTE = "resource-pattern";
    
    	// 是否使用默认的过滤器，默认值true
    	private static final String USE_DEFAULT_FILTERS_ATTRIBUTE = "use-default-filters";
    
    	//是否激活属性注入注解
    	private static final String ANNOTATION_CONFIG_ATTRIBUTE = "annotation-config";
    
    	// Bean的ID策略生成器
    	private static final String NAME_GENERATOR_ATTRIBUTE = "name-generator";
    
    	//scope解析器 ，与scoped-proxy只能同时配置一个.将@Scope(value="",proxyMode=ScopedProxyMode.NO,scopeName="")的配置解析成为一个ScopeMetadata对象,
    	private static final String SCOPE_RESOLVER_ATTRIBUTE = "scope-resolver";
    
    	//scope代理，与scope-resolver只能同时配置一个.scope代理，有三个值选项，no(默认值)，interfaces(接口代理)，targetClass（类代理）
    	private static final String SCOPED_PROXY_ATTRIBUTE = "scoped-proxy";
    
    	private static final String EXCLUDE_FILTER_ELEMENT = "exclude-filter";
    
    	private static final String INCLUDE_FILTER_ELEMENT = "include-filter";
    
    	private static final String FILTER_TYPE_ATTRIBUTE = "type";
    
    	//用来告知哪些类需要注册成Spring Bean,使用type和expression属性一起协作来定义组件扫描策略。
    	private static final String FILTER_EXPRESSION_ATTRIBUTE = "expression";}

/*
    	解析扫描包路径
    	生成扫描器,对注解和xml属性设置
    	扫描生成BeanDefinitionHolder
    	注册
    	 */
    	public BeanDefinition parse(Element element, ParserContext parserContext) {
        
    		//获取扫描包路径base-package
    		String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);
    		//环境变量解析
    		basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);
    				//分隔
    		String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,
    				ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
    
    		// Actually scan for bean definitions and register them.
    		//生成扫描器,对注解和xml属性设置
    		ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
    		//真正扫描在这儿
    		Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
    		//注册
    		registerComponents(parserContext.getReaderContext(), beanDefinitions, element);
    
    		return null;
    	}

/*
    	对xml配置属性设置
    	 */
    	protected ClassPathBeanDefinitionScanner configureScanner(ParserContext parserContext, Element element) {
        
    		boolean useDefaultFilters = true;
    		//用默认过滤器使用默认的 Filter 进行包扫描，而默认的 Filter 对标有 @Service,@Controller和@Repository 的注解的类进行扫描，
    		if (element.hasAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE)) {
        
    			useDefaultFilters = Boolean.valueOf(element.getAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE));
    		}
    
    		// Delegate bean definition registration to scanner class.
    		//内部有对java注解和spring注解支持
    		ClassPathBeanDefinitionScanner scanner = createScanner(parserContext.getReaderContext(), useDefaultFilters);
    		//设置检测到bean的默认值
    		scanner.setBeanDefinitionDefaults(parserContext.getDelegate().getBeanDefinitionDefaults());
    		//设置名称匹配模式
    		scanner.setAutowireCandidatePatterns(parserContext.getDelegate().getAutowireCandidatePatterns());
    
    		//过滤出特定的类
    		if (element.hasAttribute(RESOURCE_PATTERN_ATTRIBUTE)) {
        
    			scanner.setResourcePattern(element.getAttribute(RESOURCE_PATTERN_ATTRIBUTE));
    		}
    
    		try {
        
    			//设置默认名称构造器
    			parseBeanNameGenerator(element, scanner);
    		} catch (Exception ex) {
        
    			parserContext.getReaderContext().error(ex.getMessage(), parserContext.extractSource(element), ex.getCause());
    		}
    
    		try {
        
    			parseScope(element, scanner);
    		} catch (Exception ex) {
        
    			parserContext.getReaderContext().error(ex.getMessage(), parserContext.extractSource(element), ex.getCause());
    		}
    
    		parseTypeFilters(element, scanner, parserContext);
    
    		return scanner;
    	}

protected ClassPathBeanDefinitionScanner createScanner(XmlReaderContext readerContext, boolean useDefaultFilters) {
        
    		return new ClassPathBeanDefinitionScanner(readerContext.getRegistry(), useDefaultFilters,
    				readerContext.getEnvironment(), readerContext.getResourceLoader());
    	}

public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
    			Environment environment, @Nullable ResourceLoader resourceLoader) {
        
    
    		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    		this.registry = registry;
    
    		if (useDefaultFilters) {
        
    			registerDefaultFilters();
    		}
    		setEnvironment(environment);
    		setResourceLoader(resourceLoader);
    	}

protected void registerDefaultFilters() {
        
    		//这里有对所有的Service,@response,@Controller等注解的支持
    		this.includeFilters.add(new AnnotationTypeFilter(Component.class));
    		ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
    		//对JSR250 330支持
    		try {
        
    			this.includeFilters.add(new AnnotationTypeFilter(
    					((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
    			logger.trace("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");
    		}
    		catch (ClassNotFoundException ex) {
        
    			// JSR-250 1.1 API (as included in Java EE 6) not available - simply skip.
    		}
    		try {
        
    			this.includeFilters.add(new AnnotationTypeFilter(
    					((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));
    			logger.trace("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
    		}
    		catch (ClassNotFoundException ex) {
        
    			// JSR-330 API not available - simply skip.
    		}
    	}

/*
    	扫描包,生成BeanDefinition
    	对注解bean的处理
    	注册bean
    	 */
    	protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
        
    		Assert.notEmpty(basePackages, "At least one base package must be specified");
    		Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
    		for (String basePackage : basePackages) {
        
    			//扫描包下basePackage路径下java文件
    			Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
    			for (BeanDefinition candidate : candidates) {
        
    				//解析scope
    				ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
    				candidate.setScope(scopeMetadata.getScopeName());
    				//构造名字,通常类名首字母小写
    				String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
    				if (candidate instanceof AbstractBeanDefinition) {
        
    					postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
    				}
    				//如果是AnnotatedBeanDefinition类型的Bean
    				if (candidate instanceof AnnotatedBeanDefinition) {
        
    					// 检测常用注解，如primary,Lazy,DependsOn,Role等
    					AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
    				}
    				//检测当前bean是否注册
    				if (checkCandidate(beanName, candidate)) {
        
    					BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
    					//如果当前bean使用来生成代理的bean,进行下一步处理
    					definitionHolder =
    							AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
    					beanDefinitions.add(definitionHolder);
    					//注册BeanDefinition,以及别名
    					registerBeanDefinition(definitionHolder, this.registry);
    				}
    			}
    		}
    		return beanDefinitions;
    	}

protected void registerComponents(
    			XmlReaderContext readerContext, Set<BeanDefinitionHolder> beanDefinitions, Element element) {
        
    
    		Object source = readerContext.extractSource(element);
    		CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), source);
    
    		for (BeanDefinitionHolder beanDefHolder : beanDefinitions) {
        
    			compositeDef.addNestedComponent(new BeanComponentDefinition(beanDefHolder));
    		}
    
    		// Register annotation config processors, if necessary.
    		boolean annotationConfig = true;
    		if (element.hasAttribute(ANNOTATION_CONFIG_ATTRIBUTE)) {
        
    			annotationConfig = Boolean.valueOf(element.getAttribute(ANNOTATION_CONFIG_ATTRIBUTE));
    		}
    
    		// Register annotation config processors, if necessary.
    		if (annotationConfig) {
        
    		//如果配置了includeAnnotationConfig,则注册对应注解的处理器以保证注解功能的正常使用
    			Set<BeanDefinitionHolder> processorDefinitions =
    					AnnotationConfigUtils.registerAnnotationConfigProcessors(readerContext.getRegistry(), source);
    			for (BeanDefinitionHolder processorDefinition : processorDefinitions) {
        
    				compositeDef.addNestedComponent(new BeanComponentDefinition(processorDefinition));
    			}
    		}
    
    		readerContext.fireComponentRegistered(compositeDef);
    	}

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
    			BeanDefinitionRegistry registry, @Nullable Object source) {
        
    
    		DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
    		if (beanFactory != null) {
        
    			if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
        
    					beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
    			}
    			if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
        
    				beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
    			}
    		}
    
    		Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
    
    		if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        
    			RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
    			def.setSource(source);
    			beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
    		}
    
    		//@Autowired自动装配注解器处理
    		if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        
    			RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
    			def.setSource(source);
    			beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
    		}
    
    		// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
    		if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        
    			RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
    			def.setSource(source);
    			beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
    		}
    
    		// Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
    		if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        
    			RootBeanDefinition def = new RootBeanDefinition();
    			try {
        
    				def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
    						AnnotationConfigUtils.class.getClassLoader()));
    			}
    			catch (ClassNotFoundException ex) {
        
    				throw new IllegalStateException(
    						"Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
    			}
    			def.setSource(source);
    			beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
    		}
    
    		if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
        
    			RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
    			def.setSource(source);
    			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
    		}
    
    		if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
        
    			RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
    			def.setSource(source);
    			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
    		}
    
    		return beanDefs;
    	}

## 加载对象 ##

注意XmlBeanFactory解析的时候不会注入@Autowired标记对象,访问才加载对象.  
因为虽然注册@Autowired解析的处理器,但没有加载,所以无法解析属性,而且没有对非懒加载对象的处理.  
org.springframework.context.support.AbstractApplicationContext\#refresh

public void refresh() throws BeansException, IllegalStateException {
        
    	...
    				//激活各种BeanFactory处理器
    				//AutowiredAnnotationBeanPostProcessor在这儿激活的
    	invokeBeanFactoryPostProcessors(beanFactory);
    		
    		//初始化剩下的非延迟初始化单实例,一般在这里初始化注解的对象,以及处理@Autowired
    				finishBeanFactoryInitialization(beanFactory);
    ...
    }

# 注入@Auto #

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory\#doCreateBean

org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor\#findAutowiringMetadata

缓存InjectionMetadata

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) {
        
    				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;
    	}

private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) {
        
    		List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
    		Class<?> targetClass = clazz;
    
    		do {
        
    			final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();
    
    			ReflectionUtils.doWithLocalFields(targetClass, field -> {
        
    				//获取Autowired对象
    				AnnotationAttributes ann = findAutowiredAnnotation(field);
    				if (ann != null) {
        
    					if (Modifier.isStatic(field.getModifiers())) {
        
    						if (logger.isInfoEnabled()) {
        
    							logger.info("Autowired annotation is not supported on static fields: " + field);
    						}
    						return;
    					}
    					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;
    				}
    				AnnotationAttributes 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 new InjectionMetadata(clazz, elements);
    	}

## 赋值 ##

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
        
    	...
    	PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
    	...
    	}

@Override
    	protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
        
    	...
    	//对属性获取完毕前对属性再次处理
    			for (BeanPostProcessor bp : getBeanPostProcessors()) {
        
    				if (bp instanceof InstantiationAwareBeanPostProcessor) {
        
    					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
    					//对所有需要依赖检查的属性进行后处理,其中包括对每个属性的校验RequiredAnnotationBeanPostProcessor
    					PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
    					if (pvsToUse == null) {
        
    						if (filteredPds == null) {
        
    							filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
    						}
    						pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
    						if (pvsToUse == null) {
        
    							return;
    						}
    					}
    					pvs = pvsToUse;
    				}
    			}
    }
    ...

org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor\#postProcessProperties

@Override
    	public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
        
    		InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
    		try {
        
    			metadata.inject(bean, beanName, pvs);
    		}
    		catch (BeanCreationException ex) {
        
    			throw ex;
    		}
    		catch (Throwable ex) {
        
    			throw new BeanCreationException(beanName, "Injection of autowired 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) {
        
    				if (logger.isTraceEnabled()) {
        
    					logger.trace("Processing injected element of bean '" + beanName + "': " + element);
    				}
    				element.inject(target, beanName, pvs);
    			}
    		}
    	}

@Override
    		protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
        
    			Field field = (Field) this.member;
    			Object value;
    			if (this.cached) {
        
    				value = resolvedCachedArgument(beanName, this.cachedFieldValue);
    			}
    			else {
        
    				DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
    				desc.setContainingClass(bean.getClass());
    				Set<String> autowiredBeanNames = new LinkedHashSet<>(1);
    				Assert.state(beanFactory != null, "No BeanFactory available");
    				TypeConverter typeConverter = beanFactory.getTypeConverter();
    				try {
        
    					value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);//转换@Auto为对象
    				}
    				catch (BeansException ex) {
        
    					throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);
    				}
    				synchronized (this) {
        
    					if (!this.cached) {
        
    						if (value != null || this.required) {
        
    							this.cachedFieldValue = desc;
    							registerDependentBeans(beanName, autowiredBeanNames);
    							if (autowiredBeanNames.size() == 1) {
        
    								String autowiredBeanName = autowiredBeanNames.iterator().next();
    								if (beanFactory.containsBean(autowiredBeanName) &&
    										beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {
        
    									this.cachedFieldValue = new ShortcutDependencyDescriptor(
    											desc, autowiredBeanName, field.getType());
    								}
    							}
    						}
    						else {
        
    							this.cachedFieldValue = null;
    						}
    						this.cached = true;
    					}
    				}
    			}
    			if (value != null) {
        //设置@Auto对象
    				ReflectionUtils.makeAccessible(field);
    				field.set(bean, value);
    			}
    		}
    	}