【原始碼】“@Value 注入不成功”引發的一系列騷操作

eaglelihh發表於2021-08-03

背景

專案裡想用@Value注入一個欄位，可沒想到怎麼都注入不成功，但換另一種方式就可以，於是就想了解一下@Value註解不成功的原因。

本文的程式碼是基於Spring的5.3.8版本

模擬`@Value`成功的場景

首先為了搞清楚@Value註解不成功的原理，我們先用最簡單的程式碼模擬一下它注入成功的例子：

在resources資料夾下定義了application.yml，內容如下：
my:
  value: hello

定義一個配置類：
@Configuration
@Data
public class Config {
    @Value("${my.value}")
    private String myValue;
}

定義一個測試類：
public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
        Config config = context.getBean(Config.class);
        System.out.println(config);
    }
}

輸出：
Config(myValue=${my.value})

上面的程式碼做了幾件事情：

在resources/application.yml檔案中定義了my.value=hello
定義了一個Config類，利用@value註解將hello注入到欄位myValue中
定義了一個Main類測試效果

測試類做了幾件事情：

使用AnnotationConfigApplicationContext這個容器載入配置類
獲取配置類Config
輸出注入的欄位myValue

從結果來看，並沒有注入成功，我的第一感覺就是沒有把我們的application.yml檔案裡的內容載入到environment裡面，那我們就來看看environment裡面都有什麼內容，如下程式碼：

public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
        ConfigurableEnvironment environment = context.getEnvironment();
        System.out.println(environment);
    }
}

從結果來看：

environment並沒有包含我們application.yml檔案裡的內容
但它包含了其他兩個東西，分別是systemProperties和systemEnvironment

那我們就需要把application.yml檔案裡的內容載入到environment，需要考慮以下兩個問題：

怎麼解析yml檔案的內容
怎麼把解析的內容放到environment中

針對問題一：可以利用spring自帶的YamlPropertySourceLoader這個類的load()方法，它會返回一個List<PropertySource<?>>

針對問題二：我們可以先來看一下預設的內容是怎麼放進去的，看一下getEnvironment()的原始碼：

public abstract class AbstractApplicationContext extends DefaultResourceLoader
		implements ConfigurableApplicationContext {
	public ConfigurableEnvironment getEnvironment() {
		if (this.environment == null) {
			this.environment = createEnvironment();
		}
		return this.environment;
	}
	protected ConfigurableEnvironment createEnvironment() {
		return new StandardEnvironment();
	}
}

從上面可以看出預設建立的是一個StandardEnvironment，我們再來看一下它的初始化：

public class StandardEnvironment extends AbstractEnvironment {
	public static final String SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME = "systemEnvironment";

	public static final String SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME = "systemProperties";

	@Override
	protected void customizePropertySources(MutablePropertySources propertySources) {
		propertySources.addLast(
				new PropertiesPropertySource(SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME, getSystemProperties()));
		propertySources.addLast(
				new SystemEnvironmentPropertySource(SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME, getSystemEnvironment()));
	}
}

public abstract class AbstractEnvironment implements ConfigurableEnvironment {
	public AbstractEnvironment() {
		this(new MutablePropertySources());
	}

	protected AbstractEnvironment(MutablePropertySources propertySources) {
		this.propertySources = propertySources;
		this.propertyResolver = createPropertyResolver(propertySources);
		customizePropertySources(propertySources);
	}
}

從上面程式碼可以看出，在StandardEnvironment.customizePropertySources()的方法中，是通過propertySources.addLast()方法新增進去的，那我們可以照葫蘆畫瓢，如下：

public class Main {
    public static void main(String[] args) throws IOException {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
        ConfigurableEnvironment environment = context.getEnvironment();
        System.out.println(environment);
        YamlPropertySourceLoader loader = new YamlPropertySourceLoader();
        List<PropertySource<?>> propertySources = loader.load("my-properties",
                new FileSystemResource("/Users/tiger/spring-boot-study/src/main/resources/application.yml"));
        environment.getPropertySources().addLast(propertySources.get(0));
        System.out.println(environment);
    }
}

從上面結果可以看出，我們已經成功把我們的application.yml檔案內容放到environment中了

那我們把測試程式碼改成：

public class Main {
    public static void main(String[] args) throws IOException {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
        YamlPropertySourceLoader loader = new YamlPropertySourceLoader();
        List<PropertySource<?>> propertySources = loader.load("my-properties",
                new FileSystemResource("/Users/tiger/spring-boot-study/src/main/resources/application.yml"));
        context.getEnvironment().getPropertySources().addLast(propertySources.get(0));
        Config config = context.getBean(Config.class);
        System.out.println(config);
    }
}

輸出：
Config(myValue=${my.value})

從上面的結果可以看出，還是沒有得到我們想要的結果，這是因為conig類會提前初始化，是在refresh()方法中的finishBeanFactoryInitialization()方法進行的，所以我們要在這一步之前把我們的內容放到environment中

翻了一翻refresh()這個方法，發現在prepareRefresh()這個方法裡有一個initPropertySources()的方法，註釋寫著初始化一系列的資源，所以我們可以在這個方法裡面載入我們的配置檔案，於是變成：

public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class) {
            @SneakyThrows
            @Override
            public void initPropertySources() {
                YamlPropertySourceLoader loader = new YamlPropertySourceLoader();
                List<PropertySource<?>> propertySources = loader.load("my-properties",
                        new FileSystemResource("/Users/tiger/spring-boot-study/src/main/resources/application.yml"));
                getEnvironment().getPropertySources().addLast(propertySources.get(0));
            }
        };
        Config config = context.getBean(Config.class);
        System.out.println(config);
    }
}

輸出：
Config(myValue=hello)

到目前為止，我們模擬了@Value注入成功的場景，專案裡面應該不會出現這種資源沒有載入的問題，因為這些事情spring boot都幫我們做好了

所以直接在@Configuration類下直接用@Value是沒有問題的

模擬注入不成功的場景

現在我們就來模擬一下注入不成功的場景，配置類改成如下：

@Configuration
@Data
public class Config {
    @Value("${my.value}")
    private String myValue;

    @Bean
    public MyBeanFactoryPostProcessor myBeanFactoryPostProcessor() {
        return new MyBeanFactoryPostProcessor();
    }

    public static class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        }
    }
}

輸出結果：

Config(myValue=null)

這就是我專案上遇到的問題，在配置類中再生成一個BeanFactoryPostProcessor後，@Value就注入不成功了

但只要把這個方法寫成static就可以了，如下：

@Configuration
@Data
public class Config {
    @Value("${my.value}")
    private String myValue;

    @Bean
    public static MyBeanFactoryPostProcessor myBeanFactoryPostProcessor() {
        return new MyBeanFactoryPostProcessor();
    }

    public static class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        }
    }
}

輸出結果：

Config(myValue=hello)

看看為什麼沒有注入成功

@Value是由AutowiredAnnotationBeanPostProcessor.postProcessProperties()處理的，所以我們就以這裡為入口進行除錯。

我們先把static去掉：

發現沒有執行到上述方法，那我們再把static加上，看一下成功的情況：

可以看到，是可以到這個方法的，而且知道這個方法是被AbstractAutowireCapableBeanFactory.populateBean()呼叫的，我們再看一下這裡的情況：

從上圖可以看出，getBeanPostProcessorCache().instantiationAware是有AutowiredAnnotationBeanPostProcessor這個例項的

那我們再來看一下不加static這裡的情況：

果然，沒有注入成功的原因是在建立config例項的時候，還沒有建立AutowiredAnnotationBeanPostProcessor例項

我們來看一下這個getBeanPostProcessorCache().instantiationAware是什麼東西，又是如何生成的

發現只有在AbstractBeanFactory.getBeanPostProcessorCache()這個方法會將InstantiationAwareBeanPostProcessor新增到instantiationAware，如下：

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
	BeanPostProcessorCache getBeanPostProcessorCache() {
		BeanPostProcessorCache bpCache = this.beanPostProcessorCache;
		if (bpCache == null) {
			bpCache = new BeanPostProcessorCache();
			for (BeanPostProcessor bp : this.beanPostProcessors) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					bpCache.instantiationAware.add((InstantiationAwareBeanPostProcessor) bp);
					if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
						bpCache.smartInstantiationAware.add((SmartInstantiationAwareBeanPostProcessor) bp);
					}
				}
				if (bp instanceof DestructionAwareBeanPostProcessor) {
					bpCache.destructionAware.add((DestructionAwareBeanPostProcessor) bp);
				}
				if (bp instanceof MergedBeanDefinitionPostProcessor) {
					bpCache.mergedDefinition.add((MergedBeanDefinitionPostProcessor) bp);
				}
			}
			this.beanPostProcessorCache = bpCache;
		}
		return bpCache;
	}
}

從上面的程式碼看出，本質還是從this.beanPostProcessors獲取的，我們來看一下什麼時候會把AutowiredAnnotationBeanPostProcessor新增到容器中，如下：

從上圖可知：AutowiredAnnotationBeanPostProcessor是在refresh()方法中的registerBeanPostProcessors()方法注入的

我們再來看一下加static方法的config類是什麼時候載入的：

再來看一下不加static方法的config類是什麼時候載入的

我們來總結一下提到的方法在refresh()方法中的順序：

invokeBeanFactoryPostProcessors(); ——> 不加static的時候，在這一步載入config類

registerBeanPostProcessors();  ——> 註冊AutowiredAnnotationBeanPostProcessor

finishBeanFactoryInitialization(); 加static的時候，在這一步載入config類

所以我們就知道原因了：當不加static欄位時候，載入config類的時候，我們的AutowiredAnnotationBeanPostProcessor還沒有註冊，所以就會不成功，而當加上static後，我們載入config類的時候，我們的AutowiredAnnotationBeanPostProcessor已經註冊好了。

為什麼加`static`和不加`static`的載入順序是不一樣的呢

spring容器會在invokeBeanFactoryPostProcessors()這一步會載入所有的BeanFactoryPostProcessor，如果用static修飾的話，則不會載入config類，反之會載入。原因如下：

上圖已經給出了原因，如果生成bean的工廠方法是static方法就不會載入，反之會載入。

我們不加`static`，能不能也讓它注入成功呢？

那無非就是在載入config類之前，把AutowiredAnnotationBeanPostProcessor提前載入到容器就可以了，那我們來看一下原始碼是怎麼載入這個例項的：

我們同樣可以依葫蘆畫瓢，看看在哪裡提前載入比較合適，發現postProcessBeanFactory()這個方法比較合適，於是改成：

public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class) {
            @SneakyThrows
            @Override
            public void initPropertySources() {
                YamlPropertySourceLoader loader = new YamlPropertySourceLoader();
                List<PropertySource<?>> propertySources = loader.load("my-properties",
                        new FileSystemResource("/Users/tiger/spring-boot-study/src/main/resources/application.yml"));
                getEnvironment().getPropertySources().addLast(propertySources.get(0));
            }

            @Override
            protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
                String ppName = "org.springframework.context.annotation.internalAutowiredAnnotationProcessor";
                beanFactory.addBeanPostProcessor(getBean(ppName, BeanPostProcessor.class));
            }
        };
        Config config = context.getBean(Config.class);
        System.out.println(config);
    }
}

輸出：
Config(myValue=${my.value})

從結果來看，還是沒注入成功啊，經過一番除錯，發現是在下面步驟中出了問題：

我們來看一下載入成功的情況：

embeddedValueResolver是在下面步驟中被新增進去的：

可以看出是在refresh()中的finishBeanFactoryInitialization()這個方法裡面新增進去的，所以我們也要提前搞一下：

public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class) {
            @SneakyThrows
            @Override
            public void initPropertySources() {
                YamlPropertySourceLoader loader = new YamlPropertySourceLoader();
                List<PropertySource<?>> propertySources = loader.load("my-properties",
                        new FileSystemResource("/Users/tiger/spring-boot-study/src/main/resources/application.yml"));
                getEnvironment().getPropertySources().addLast(propertySources.get(0));
            }

            @Override
            protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
                String ppName = "org.springframework.context.annotation.internalAutowiredAnnotationProcessor";
                beanFactory.addBeanPostProcessor(getBean(ppName, BeanPostProcessor.class));
                beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
            }
        };
        Config config = context.getBean(Config.class);
        System.out.println(config);
    }
}

輸出：
Config(myValue=hello)

好了，大功告成！

總結

看到這裡，相信大家都知道@Value為什麼載入不成功了吧，主要就是因為載入順序的關係，可以看出最簡單的方法就是在方法上加一個static，後面的探究主要是地對Spring容器載入順序的理解

本文探究的是在配置類裡存在BeanFactoryPostProcessor，如果換成BeanPostProcessor呢？同樣會載入不成功嗎？又是因為什麼原因呢？其實也可以用同樣的方法來測試，和本文講的如出一轍，小夥伴們可自行探究一下。

有什麼問題歡迎一起探討~~~

「從原始碼中學習」Vue原始碼中的JS騷操作
2019-02-25
原始碼VueJS
EventSource 引發的一系列事件
2023-04-29
事件
每日 30 秒 ⏱ 函式引數騷操作
2019-03-26
函式
make:migration 的騷操作
2019-03-23
&引用上的騷操作
2020-10-19
Feign 400錯誤引發的一系列問題
2021-10-02
opacity騷操作
2019-05-12
mysql騷操作
2024-08-13
MySql
@Value DI注入的幾種使用方法
2020-12-18
Fragment跳轉的騷操作
2019-01-18
Fragment
markdown的騷氣操作（一）
2021-09-12
聊聊那些年的騷操作！！！
2021-02-01
論減少程式碼中return語句的騷操作
2020-10-17
Redis 資料結構之字串的那些騷操作 -- 像讀小說一樣讀原始碼
2020-11-16
Redis資料結構字串原始碼
@AllArgsConstructor與@Value共同使用引發的報錯問題
2020-03-06
Struct
Python - 解包的各種騷操作
2021-08-04
Python
JavaScript騷操作之操作符
2018-12-16
JavaScript
React 原始碼中的依賴注入方法
2021-09-09
React原始碼依賴注入
Java原始碼閱讀-String中的private final char value[];
2024-04-24
Java原始碼
Java中內部類的騷操作
2019-07-30
Java
Android 截圖的各種騷操作
2019-05-22
Android
[譯] GitHub 上的 12 個騷操作
2019-03-03
Github
使用解構的幾個騷操作
2018-12-28
JS中Function.apply() 的騷操作
2020-12-21
JSFunctionAPP
Spring原始碼解析——依賴注入(二)
2020-10-22
Spring原始碼依賴注入
C++ DLL注入工具完整原始碼
2022-01-29
C++原始碼
死磕Spring原始碼-依賴注入
2021-09-09
Spring原始碼依賴注入
Spring 原始碼分析之 bean 依賴注入原理(注入屬性)
2019-04-07
Spring原始碼Bean依賴注入
Python裡的17個“騷操作”好玩有趣
2019-08-13
Python
《關於MySQL的一些騷操作》
2019-11-18
MySql
JetCache埋點的騷操作,不服不行啊
2020-08-17
關於JS更新input元素的value屬性引發的狗血討論
2019-04-17
JS
Guava中這些Map的騷操作，讓我的程式碼量減少了50%
2022-12-08
Guava
Feign踩坑原始碼分析--@FeignClient注入容器
2023-05-10
原始碼client
Python 資料庫騷操作 — Redis
2019-02-16
Python資料庫Redis
Python 資料庫騷操作 -- Redis
2018-11-12
Python資料庫Redis
Python 資料庫騷操作 -- MongoDB
2018-11-07
Python資料庫MongoDB
Python資料庫MongoDB騷操作
2018-11-07
Python資料庫MongoDB

【原始碼】“@Value 注入不成功”引發的一系列騷操作

背景

模擬@Value成功的場景

模擬注入不成功的場景

看看為什麼沒有注入成功

為什麼加static和不加static的載入順序是不一樣的呢

我們不加static，能不能也讓它注入成功呢？

總結

相關文章

模擬`@Value`成功的場景

為什麼加`static`和不加`static`的載入順序是不一樣的呢

我們不加`static`，能不能也讓它注入成功呢？