What are the methods for SpringBoot to read Yml configuration files?

1. Basic usage, use the annotation @Autowired to inject the Environment class

This method is more common, just like injecting service or dao, declare an Environment class variable and add the @Autowire annotation. As follows:

import org.springframework.core.env.Environment;
 
@Autowired
private Environment environment;

The method of use is to read the information in the configuration file through the getProperty(key) method. The code is as follows:

1). Configuration in Yml

heycloud:
  jobInfo: http://www.baidu.com

2 ).Get configuration

//获取url(注意:key一定要写完整，有几层就写几层，每层的名字用点分隔。)
String resultUrl = environment.getProperty("heycloud.jobInfo");

Note: This method of reading configuration information has certain limitations, including the following:

Limitation 1:

If you want to read in a static method To obtain configuration information, you cannot simply define Environment as static. Due to the injection mechanism, injecting a static bean will only result in an empty bean, that is, the value of the variable is null. Once the bean object is used, a null pointer exception will be reported. .

Incorrect way of writing:

@Autowired
    private static Environment environment;//这是错误写法，environment只会是null
    public void test(){
        //获取url
        String resultUrl = environment.getProperty("heycloud.jobInfo");//一旦使用environment变量就会报空指针异常    
    }

Correct way of writing:

1. Define Environment as static;

2. Add environment getter/setter methods;

3. Add the @Autowire annotation to the set method.

This can be effectively injected. It is worth noting that only the get method needs to be static, and the set method does not need to be static, otherwise the environment obtained will still be null.

The correct code is as follows:

    private static Environment environment;
 
    @Autowired
    public void setEnvironment(Environment environment) {
        this.environment = environment;
    }
 
    public static Environment getEnvironment() {
        return environment;
    }

Limitation 2:

Environment cannot directly read the customized Yml configuration file. You need to add a configuration class to the customized Yml The file is exposed to the spring environment.

Solution:

Define a configuration class and load the customized Yml file content into Environment. The code is as follows:

import org.springframework.beans.factory.config.YamlPropertiesFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
import org.springframework.core.io.ClassPathResource;
import org.springframework.stereotype.Component;
 
/**
 * 配置类
 * @Description 读取自定义Yml格式配置文件
 * @Date 2021/3/15 10:40
 * @Created by LSH
 */
@Component
public class SqlConfig {
    @Bean
    public PropertySourcesPlaceholderConfigurer getSqlConfigurer() {
        PropertySourcesPlaceholderConfigurer configurer = new PropertySourcesPlaceholderConfigurer();
        YamlPropertiesFactoryBean sqlConfigBean = new YamlPropertiesFactoryBean();
        sqlConfigBean.setResources(new ClassPathResource("sql-properties.yml"));
        configurer.setProperties(sqlConfigBean.getObject());
        return configurer;
    }
}

Once the configuration class is set, you can Use the @Autowired annotation to inject the Environment class to obtain custom configuration information. In short, if you encounter the problem of limitation 2, you just need to write one more configuration class.

Limitation 3:

Due to the loading order, the method of using annotations is not suitable for reading configurations in static code blocks (static{}), even if the solution to limitation 1 is used Nope, I haven't found a solution yet. Any advice from passing experts is welcome.

In fact, you can also manually load the class in the static block and load the configuration by reading the path of the Yml file, but this is not concise enough. If multiple classes have this requirement, each one will have to write a bunch of loads. category, so I didn’t go into details. However, there is more than one way to read the configuration file, and there is no need to identify a specific tree.

2. Basic usage, use @Value annotation to directly inject configuration information

The usage method is very simple, declare class member attributes, use @Value annotation to directly put configuration information into member attributes, format For: @Value("${xxx.xxx.xxx}").

The code is as follows:

    @Value("${sql.newrest.CAS_GRID}")
    private String CAS_GRID;

Note:

1. Same as the first method, the key must be written completely. Write as many layers as there are, and use points apart.

2. This method has the same limitations as the first method.

3. Advanced method

Define a tool class, annotate it with @Component to become a configuration class, then inherit ApplicationRunner and override run(), and then inject the Environment class to obtain the configuration. This can be done in Get configuration information anywhere and anytime.

The code is as follows:

1). Define the configuration class and declare some static properties for receiving configuration information

@Slf4j
@Component
public class BaseConfig implements ApplicationRunner {
    @Autowired
    private Environment environment;
    
    public static String pro1;
    public static String pro2;
    public static String pro3;
  
    @Override
    public void run(ApplicationArguments args){
        pro1=environment.getProperty("pro1");
        pro2=environment.getProperty("pro2");
        pro3=environment.getProperty("pro3");
    }
}

2).Use method

Configuration information can be obtained directly by calling the static properties of the configuration class. It is not limited to conventional methods, static methods, and static code blocks. In fact, it is equivalent to using a configuration class to indirectly obtain the configuration information.

The above is the detailed content of What are the methods for SpringBoot to read Yml configuration files?. For more information, please follow other related articles on the PHP Chinese website!