服务器之家：专注于VPS、云服务器配置技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|Java教程|ASP教程|编程技术|正则表达式|C/C++|IOS|C#|Swift|Android|VB|R语言|JavaScript|易语言|vb.net|

服务器之家 - 编程语言 - Java教程 - SpringBoot加载配置文件的实现方式总结

SpringBoot加载配置文件的实现方式总结

2022-10-18 14:33鸭血粉丝Tang Java教程

在实际的项目开发过程中，我们经常需要将某些变量从代码里面抽离出来，放在配置文件里面，以便更加统一、灵活的管理服务配置信息。所以本文将为大家总结一下SpringBoot加载配置文件的常用方式，需要的可以参考一下

一、简介

在实际的项目开发过程中，我们经常需要将某些变量从代码里面抽离出来，放在配置文件里面，以便更加统一、灵活的管理服务配置信息。比如，数据库、eureka、zookeeper、redis、mq、kafka 等服务组件的连接参数配置，还有我们自定义的项目参数配置变量。

当然，实际上根据当前的业务需求，我们往往会自定义参数，然后注入到代码里面去，以便灵活使用!

今天，我们就一起来聊一聊SpringBoot加载配置文件的几种玩法!

SpringBoot 项目在启用时，首先会默认加载bootstrap.properties或者bootstrap.yml这两个配置文件(这两个优先级最高);接着会加载application.properties或application.yml;如果何配置了spring.profiles这个变量，同时还会加载对应的application-{profile}.properties或者application-{profile}.yml文件，profile为对应的环境变量，比如dev，如果没有配置，则会加载profile=default的配置文件。

虽然说配置项都写在同一个配置文件没有问题，但是很多时候我们仍然希望能分开写，这样会比较清晰，比如zookeeper的配置写在zookeeper.properties，数据库相关的配置写在datasource.properties等等，因此就需要设置加载外部配置文件!

具体该如何实现呢，我们一起来看看!

二、代码实践

2.1、通过@value注解实现参数加载

当我们想要在某个类里面注入某个变量，通过@value注解就可以简单实现参数的注入!

例如application.properties文件里，配置一个config.name的变量key，值为zhangsan；

?
1
2
//参数定义
config.name=zhangsan

然后在对应的类里面，通过参数@value注入即可!

?
1
2
3
4
5
6
7
8
9
10
11
@RestController
public class HelloController {
 
    @Value("${config.name}")
    private String config;
 
    @GetMapping("config")
    public String config(){
        return JSON.toJSONString(config);
    }
}

使用@value注解注入配置，通常情况下有个要求就是，注解里面的变量，必须在application.properties文件里面事先定义好，否则启动报错!

当然，如果我们不想让它抱错，我们可以给它一个缺省值xxx，比如：

?
1
2
@Value("${config.name:xxx}")
private String config;

这样，SpringBoot 项目在启用时不会报错!

2.2、通过@ConfigurationProperties注解实现参数加载

某些场景下，@value注解并不能满足我们所有的需求，比如参数配置的数据类型是一个对象或者数组，这个时候才用@ConfigurationProperties会是一个比较好的选择!

配置一个对象类型的参数

例如在application.properties文件里，当我们想配置一个对象类型的参数，我们可以这样操作!

?
1
2
3
//参数定义
config2.name=demo_1
config2.value=demo_value_1

然后，创建一个配置类Config2，用于将定义的变量映射到配置类里面。

?
1
2
3
4
5
6
7
8
9
10
@Component
@ConfigurationProperties(prefix = "config2")
public class Config2 {
 
    public String name;
 
    public String value;
 
    //...get、set
}

读取数据的方式，也很简单，直接注入到对应的类里面就可以了；

?
1
2
3
4
5
6
7
8
9
10
11
@RestController
public class HelloController {
 
    @Autowired
    private Config2 config2;
 
    @GetMapping("config2")
    public String config2(){
        return JSON.toJSONString(config2);
    }
}

配置一个Map类型的参数

例如在application.properties文件里，当我们想配置一个 Map 类型的参数，我们可以这样操作!

?
1
2
3
4
5
//参数定义
config3.map1.name=demo_id_1_name
config3.map1.value=demo_id_1_value
config3.map2.name=demo_id_2_name
config3.map2.value=demo_id_2_value

然后，创建一个配置类Config3，用于将定义的变量映射到配置类里面。

?
1
2
3
4
5
6
7
8
9
10
@Component
@ConfigurationProperties(prefix = "config3")
public class Config3 {
 
    private Map<String, String> map1 = new HashMap<>();
 
    private Map<String, String> map2 = new HashMap<>();
 
    //...get、set
}

读取数据的方式，与之类似!

?
1
2
3
4
5
6
7
8
9
10
11
@RestController
public class HelloController {
 
    @Autowired
    private Config3 config3;
 
    @GetMapping("config3")
    public String config3(){
        return JSON.toJSONString(config3);
    }
}

配置一个List类型的参数

例如在application.properties文件里，当我们想配置一个 List 类型的参数，我们可以这样操作!

?
1
2
3
4
5
6
7
8
9
10
11
12
//参数定义
config4.userList[0].enable=maillist_1_enable
config4.userList[0].name=maillist_1_name
config4.userList[0].value=maillist_1_value
 
config4.userList[1].enable=maillist_2_enable
config4.userList[1].name=maillist_2_name
config4.userList[1].value=maillist_2_value
 
config4.userList[2].enable=maillist_3_enable
config4.userList[2].name=maillist_3_name
config4.userList[2].value=maillist_3_value

然后，创建一个配置类Config4，用于将定义的变量映射到配置类里面。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Component
@ConfigurationProperties(prefix = "config4")
public class Config4 {
 
    private List<UserEntity> userList;
 
    public List<UserEntity> getUserList() {
        return userList;
    }
 
    public void setUserList(List<UserEntity> userList) {
        this.userList = userList;
    }
}
?
1
2
3
4
5
6
7
8
public class UserEntity {
 
    private String enable;
    private String name;
    private String value;
 
    //...get、set
}

读取数据的方式，与之类似!

?
1
2
3
4
5
6
7
8
9
10
11
@RestController
public class HelloController {
 
    @Autowired
    private Config4 config4;
 
    @GetMapping("config4")
    public String config4(){
        return JSON.toJSONString(config4);
    }
}

2.3、通过@PropertySource注解实现配置文件加载

正如我们最开始所介绍的，很多时间，我们希望将配置文件分卡写，比如zookeeper组件对应的服务配置文件是zookeeper.properties，redis组件对应的服务配置文件是redis.properties等等。

这种自定义的配置文件，我们应该如何加载到Spring容器里面呢?

其实方法也很简单，通过@PropertySource就可以实现!

首先，我们在resources资源文件夹下，创建两个配置文件test.properties和bussiness.properties，内容如下!

test.properties文件内容：

?
1
2
3
4
aaa.a1=aa1123
aaa.a2=aa2123
aaa.a3=aa3123
aaa.a4=aa4123

bussiness.properties文件内容：

?
1
2
3
4
bbbb.a1=bb1123
bbbb.a2=bb2123
bbbb.a3=bb3123
bbbb.a4=bb4123

在SpringBoot启动类上加载配置文件即可!

?
1
2
3
4
5
6
7
8
@SpringBootApplication
@PropertySource(value = {"test.properties","bussiness.properties"})
public class PropertyApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(PropertyApplication.class, args);
    }
}

读取数据的方式，与之类似!

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@RestController
public class HelloController {
 
    @Value("${aaa.a2}")
    private String a2;
 
    @Value("${bbbb.a1}")
    private String bbbbA1;
 
    @GetMapping("a2")
    public String a2(){
        return JSON.toJSONString(a2);
    }
 
    @GetMapping("bbbbA1")
    public String bbbbA1(){
        return JSON.toJSONString(bbbbA1);
    }
}

如果我们只是在业务中需要用到自定义配置文件的值，这样引入并没有什么问题;但是如果某些自定义的变量，在项目启动的时候需要用到，这种方式会存在一些问题，原因如下：

SpringBoot加载配置文件的实现方式总结

翻译过来的意思就是说：

虽然在@SpringBootApplication上使用@PropertySource似乎是在环境中加载自定义资源的一种方便而简单的方法，但我们不推荐使用它，因为SpringBoot在刷新应用程序上下文之前就准备好了环境。使用@PropertySource定义的任何键都加载得太晚，无法对自动配置产生任何影响。

因此，如果某些参数是启动项变量，建议将其定义在application.properties或application.yml文件里面，这样就不会有问题!

或者，采用【自定义环境处理类】来实现配置文件的加载!

2.4、通过自定义环境处理类，实现配置文件的加载

实现方法也很简单，首先，创建一个实现自EnvironmentPostProcessor接口的类，然后自行加载配置文件。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
public class MyEnvironmentPostProcessor implements EnvironmentPostProcessor {
 
 
    @Override
    public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
        //自定义配置文件
        String[] profiles = {
                "test.properties",
                "bussiness.properties",
                "blog.yml"
        };
 
        //循环添加
        for (String profile : profiles) {
            //从classpath路径下面查找文件
            Resource resource = new ClassPathResource(profile);
            //加载成PropertySource对象，并添加到Environment环境中
            environment.getPropertySources().addLast(loadProfiles(resource));
        }
    }
 
    //加载单个配置文件
    private PropertySource<?> loadProfiles(Resource resource) {
        if (!resource.exists()) {
            throw new IllegalArgumentException("资源" + resource + "不存在");
        }
        if(resource.getFilename().contains(".yml")){
            return loadYaml(resource);
        } else {
            return loadProperty(resource);
        }
    }
 
    /**
     * 加载properties格式的配置文件
     * @param resource
     * @return
     */
    private PropertySource loadProperty(Resource resource){
        try {
            //从输入流中加载一个Properties对象
            Properties properties = new Properties();
            properties.load(resource.getInputStream());
            return new PropertiesPropertySource(resource.getFilename(), properties);
        }catch (Exception ex) {
            throw new IllegalStateException("加载配置文件失败" + resource, ex);
        }
    }
 
    /**
     * 加载yml格式的配置文件
     * @param resource
     * @return
     */
    private PropertySource loadYaml(Resource resource){
        try {
            YamlPropertiesFactoryBean factory = new YamlPropertiesFactoryBean();
            factory.setResources(resource);
            //从输入流中加载一个Properties对象
            Properties properties = factory.getObject();
            return new PropertiesPropertySource(resource.getFilename(), properties);
        }catch (Exception ex) {
            throw new IllegalStateException("加载配置文件失败" + resource, ex);
        }
    }
}

接着，在resources资源目录下，我们还需要创建一个文件META-INF/spring.factories，通过spi方式，将自定义环境处理类加载到Spring处理器里面，当项目启动时，会自动调用这个类!

?
1
2
#启用我们的自定义环境处理类
org.springframework.boot.env.EnvironmentPostProcessor=com.example.property.env.MyEnvironmentPostProcessor

SpringBoot加载配置文件的实现方式总结

这种自定义环境处理类方式，相对会更佳灵活，首先编写一个通用的配置文件解析类，支持properties和yml文件的读取，然后将其注入到Spring容器里面，基本上可以做到一劳永逸!

2.5、最后，我们来介绍一下yml文件读取

在上文中，我们大部分都是以properties为案例进行介绍，可能有的人已经踩过坑了，在项目中使用@PropertySource注解来加载yml文件，结果启动直接报错，原因是@PropertySource不支持直接解析yml文件，只能解析properties文件。

那如果，我想单独解析yml文件，也不想弄一个【自定义环境处理类】这种方式来读取文件，应该如何处理呢?

操作方式也很简单，以自定义的blog.yml文件为例!

blog.yml文件内容：

?
1
2
pzblog:
  name: helloWorld

然后，创建一个读取yml文件的配置类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Configuration
public class ConfigYaml {
 
    /**
     * 加载YML格式自定义配置文件
     * @return
     */
    @Bean
    public static PropertySourcesPlaceholderConfigurer properties() {
        PropertySourcesPlaceholderConfigurer configurer = new PropertySourcesPlaceholderConfigurer();
        YamlPropertiesFactoryBean yaml = new YamlPropertiesFactoryBean();
        yaml.setResources(new ClassPathResource("blog.yml"));
        configurer.setProperties(yaml.getObject());
        return configurer;
    }
}

读取数据的方式，与之类似!

?
1
2
3
4
5
6
7
8
9
10
11
@RestController
public class HelloController {
 
    @Value("${pzblog.name}")
    private String pzblogName;
 
    @GetMapping("pzblogName")
    public String pzblogName(){
        return JSON.toJSONString(pzblogName);
    }
}

三、小结

本文主要围绕 SpringBoot 加载配置文件的几种实现方式，做了一次内容总结，如果有遗漏的地方，欢迎网友批评指出!

以上就是SpringBoot加载配置文件的实现方式总结的详细内容，更多关于SpringBoot加载配置文件的资料请关注服务器之家其它相关文章！

原文链接：https://developer.51cto.com/article/704610.html

  • 配置文件
  • springboot
  • 加载

    • 延伸 · 阅读

    精彩推荐
    最近更新
    编辑推荐
    阅读排行
    热门标签
    501 　 406 　 415 　 2000 　 1433 　 401 　 330 　 204 　 选择排序法 　 随机抽取 　 内存卡 　 下载器 　 十六进制字符 　 响应 　 静态工厂 　 构造函数 　 swt 　 Overview 　 对象池模式 　 数据返回 　 支票 　 金额大写转换 　 空心菱形 　 AspectJ 　 面向切面编程 　 方法名 　 网址信息 　 动态代理模式 　 线程安全 　 htmlparser 　
    © 2019-2022 服务器之家(www.tuohang.net) 版权所有关于我们联系我们版权申明网站地图