SpringBoot 注解 @Value 实现源码分析

• 前言
• 1. @Value 的源码处理流程
• 2. 源码分析
• • • 2.1 后置处理器 AutowiredAnnotationBeanPostProcessor 的注册
    • 2.2 属性处理器 PropertySourcesPropertyResolver 的注册
    • 2.3 @Value 标注字段的依赖处理

SpringBoot 提供了很多开箱即用的实用工具，比如我们可以使用 @Value 注解获取容器中的配置数据，自动完成属性的赋值，本文即从源码角度来解析 @Value 的实现机制

@Value 实现属性注入的源码流程如下图所示，笔者将其从组件的准备到组件的使用分为了三个部分：

1. @Value 后置处理器 AutowiredAnnotationBeanPostProcessor 的注册，这个后置处理器主要用于识别获取 @Value 中配置的属性字符串
2. @Value 属性值来源处理器 PropertySourcesPropertyResolver 的注册，该处理器负责从容器中取得指定的属性值
3. 创建 Bean 对象时，容器使用以上两个组件对 @Value 标注的属性进行依赖注入

1. 在 SpringBoot 注解 @import 的原理-ConfigurationClassPostProcessor 源码解析 中，笔者分析了 SpringBoot 的基础注解 @import 功能实现依赖的核心组件 ConfigurationClassPostProcessor 的注册，本文 @Value 依赖的组件 AutowiredAnnotationBeanPostProcessor 的注册流程与其基本一致，都是从 SpringApplication#prepareContext() 方法触发，一直调用到 AnnotationConfigUtils#registerAnnotationConfigProcessors() 方法

   AnnotationConfigUtils#registerAnnotationConfigProcessors() 负责解析注册比较重要的后置处理器，本文主要关注以下几个步骤：

   1. 新建 ContextAnnotationAutowireCandidateResolver 处理器，并通过beanFactory.setAutowireCandidateResolver() 调用 DefaultListableBeanFactory#setAutowireCandidateResolver() 方法将其缓存到容器内，后续将使用它来获取 @Value 注解中配置的字符串
   2. 将 AutowiredAnnotationBeanPostProcessor 包装为 BeanDefinition 并注册，这个 Bean 后置处理器将用于处理 Bean 的内部属性依赖

   public static Set 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 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));
    	}
   
    	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;
    }
   

2. DefaultListableBeanFactory#setAutowireCandidateResolver() 方的处理很简单，可以看到就是一个赋值操作，将新建的 AutowireCandidateResolver 子类 ContextAnnotationAutowireCandidateResolver 对象保存在内部

    public void setAutowireCandidateResolver(final AutowireCandidateResolver autowireCandidateResolver) {
    	Assert.notNull(autowireCandidateResolver, "AutowireCandidateResolver must not be null");
    	if (autowireCandidateResolver instanceof BeanFactoryAware) {
    		if (System.getSecurityManager() != null) {
    			AccessController.doPrivileged((PrivilegedAction