【源碼】「@Value 注入不成功」引發的一系列騷操作

2021 年 8 月 3 日
筆記
spring

背景
模擬@Value成功的場景
模擬注入不成功的場景
看看為什麼沒有注入成功
為什麼加static和不加static的載入順序是不一樣的呢
我們不加static，能不能也讓它注入成功呢？
總結

背景

項目里想用@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呢？同樣會載入不成功嗎？又是因為什麼原因呢？其實也可以用同樣的方法來測試，和本文講的如出一轍，小夥伴們可自行探究一下。

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

Tags: spring