【原始碼】“@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})

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

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

測試類做了幾件事情:

  1. 使用AnnotationConfigApplicationContext這個容器載入配置類
  2. 獲取配置類Config
  3. 輸出注入的欄位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);
    }
}

從結果來看:

  1. environment並沒有包含我們application.yml檔案裡的內容
  2. 但它包含了其他兩個東西,分別是systemPropertiessystemEnvironment

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

  1. 怎麼解析yml檔案的內容
  2. 怎麼把解析的內容放到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呢?同樣會載入不成功嗎?又是因為什麼原因呢?其實也可以用同樣的方法來測試,和本文講的如出一轍,小夥伴們可自行探究一下。

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

相關文章