SpringBoot 多种读取配置文件中参数的方式
文章目录
!版权声明:本博客内容均为原创,每篇博文作为知识积累,写博不易,转载请注明出处。
系统环境:
- SpringBoot 版本:2.2.2
参考地址:
- @ConfigurationProperties 注解使用姿势,这一篇就够了
- 示例项目 Github 地址:https://github.com/my-dlq/blog-example/tree/master/springboot/springboot-read-config-example
一、简介
在日常开发使用 SpringBoot 框架时,经常有一些配置信息需要放置到配置文件中,我们需要手动读取这些配置到应用中进行一些逻辑,这里整理了一些常用读取配置的方法,简单介绍一下。
1、SpringBoot 中常用读取配置方法
SpringBoot 中常用的读取配置方法有:
- 使用 @Value 注解读取配置
- 使用 @ConfigurationProperties 注解读取配置
- 使用 Environment 对象读取配置
- 使用 PropertiesLoaderUtils 工具读取配置
2、@Value 和 @ConfigurationProperties 的区别
二者区别 | @ConfigurationProperties | @Value |
---|---|---|
功能 | 批量注入配置文件中的属性 | 一个个指定 |
松散绑定(松散语法) | 支持 | 不支持 |
SpEL | 不支持 | 支持 |
JSR303数据校验 | 支持 | 不支持 |
复杂类型封装 | 支持 | 不支持 |
下面会详细介绍使用各个方法是如何读取配置信息。
二、使用 @Value 读取配置
1、@Value 读取配置参数
application.properties 配置文件内容:
1my.name=mydlq
2my.age=18
使用 @Value 读取配置文件
1@Component
2public class ReadProperties {
3
4 @Value("${my.name}")
5 private String name;
6
7 @Value("${my.age}")
8 private Integer age;
9
10}
并且还可以设置一个默认值,放置未从配置文件中读取到该参数:
1通过 @Value 读取配置文件
2@Component
3public class ReadProperties {
4
5 @Value("${my.name:默认姓名}")
6 private String name;
7
8 @Value("${my.age:18}")
9 private Integer age;
10
11}
2、@Value 给参数设定值
使用 @Value 注解给参数设定值,达到跟“=”号一样的赋值效果:
1@Component
2public class ReadProperties {
3
4 @Value("#{'test value'}")
5 private String value;
6
7}
3、@Value 读取系统属性
使用 @Value 注解读取系统环境参数:
1@Component
2public class ReadProperties {
3
4 @Value("#{systemProperties['os.name']}")
5 private String systemPropertiesName;
6
7}
4、@Value 读取 Bean 的属性
测试用的实体对象:
1@Data
2public class User{
3 private String name;
4 private String age;
5}
使用 @Value 注解读取 Bean 中对象的属性:
1@Component
2public class ReadProperties {
3
4 @Bean
5 public User user(){
6 User user = new User();
7 user.setName("测试");
8 user.setAge("18");
9 return user;
10 }
11
12 @Value("#{user.name}")
13 private String value;
14
15}
5、@Value 使用 SpEL 表达式
在 @Value 注解中可以使用 SpEL 表达式,如下是使用 SpEL 表达式生成随机数:
1@Component
2public class ReadProperties {
3
4 @Value("#{ T(java.lang.Math).random() * 100.0 }")
5 private double random;
6
7}
6、@Value 读取 Resource 资源文件
使用 @Value 可以读取资源文件进行一些操作:
1@Component
2public class ReadProperties {
3
4 @Value("classpath:application.properties")
5 private Resource resourceFile;
6
7 public void test(){
8 // 如果文件存在,就输出文件名称
9 if(resourceFile.exists()){
10 System.out.println(resourceFile.getFilename());
11 }
12 }
13
14}
三、使用 @ConfigurationProperties 读取配置
1、@ConfigurationProperties 读取配置参数到 String 类型
application.properties 配置文件内容:
1my.name=mydlq
使用 @ConfigurationProperties 注解读取对应配置:
1@Configuration
2@ConfigurationProperties(prefix = "my") //配置 prefix 来过滤对应前缀
3public class ConfigurationReadConfig {
4
5 private String name;
6
7 public String getName() {
8 return name;
9 }
10 public void setName(String name) {
11 this.name = name;
12 }
13
14}
注意:使用 @ConfigurationProperties 注解读取配置,则需要配置文件内容中的参数添加统一的前缀,在 @ConfigurationProperties 注解中配置该前缀的值,然后前缀后的属性名要与加 @ConfigurationProperties 注解的类中成员变量名称保持一致。
2、@ConfigurationProperties 读取 List 类型参数
application.properties 配置文件内容:
1my.list[0]=a
2my.list[1]=b
3my.list[2]=c
使用 @ConfigurationProperties 注解读取对应配置:
1@Configuration
2@ConfigurationProperties(prefix = "my")
3public class ConfigurationReadConfig {
4
5 private List<String> list;
6
7 public List<String> getList() {
8 return list;
9 }
10 public void setList(List<String> list) {
11 this.list = list;
12 }
13
14}
3、@ConfigurationProperties 读取 Map 类型参数
application.properties 配置文件内容:
1my.map.name=xiao-li
2my.map.sex=man
3my.map.age=20
使用 @ConfigurationProperties 注解读取对应配置:
1@Configuration
2@ConfigurationProperties(prefix = "my")
3public class ConfigurationReadConfig {
4
5 private Map<String, String> map;
6
7 public Map<String, String> getMap() {
8 return map;
9 }
10 public void setMap(Map<String, String> map) {
11 this.map = map;
12 }
13
14}
4、@ConfigurationProperties 读取 Time 类型参数
application.properties 配置文件内容:
1my.time=20s
使用 @ConfigurationProperties 注解读取对应配置:
1@Configuration
2@ConfigurationProperties(prefix = "my")
3public class ConfigurationReadConfig {
4
5 /**
6 * 设置以秒为单位
7 */
8 @DurationUnit(ChronoUnit.SECONDS)
9 private Duration time;
10
11 public Duration getTime() {
12 return time;
13 }
14 public void setTime(Duration time) {
15 this.time = time;
16 }
17
18}
5、@ConfigurationProperties 读取 DataSize 类型参数
application.properties 配置文件内容:
1my.fileSize=10MB
使用 @ConfigurationProperties 注解读取对应配置:
1@Configuration
2@ConfigurationProperties(prefix = "my")
3public class ConfigurationReadConfig {
4
5 /**
6 * 设置以 MB 为单位
7 */
8 @DataSizeUnit(DataUnit.MEGABYTES)
9 private DataSize fileSize;
10
11 public DataSize getFileSize() {
12 return fileSize;
13 }
14 public void setFileSize(DataSize fileSize) {
15 this.fileSize = fileSize;
16 }
17
18}
6、@ConfigurationProperties 读取 DataSize 类型参数
application.properties 配置文件内容:
1my.fileSize=10MB
使用 @ConfigurationProperties 注解读取对应配置:
1@Configuration
2@ConfigurationProperties(prefix = "my")
3public class ConfigurationReadConfig {
4
5 /**
6 * 设置以 MB 为单位
7 */
8 @DataSizeUnit(DataUnit.MEGABYTES)
9 private DataSize fileSize;
10
11 public DataSize getFileSize() {
12 return fileSize;
13 }
14 public void setFileSize(DataSize fileSize) {
15 this.fileSize = fileSize;
16 }
17
18}
7、@ConfigurationProperties 读取配置参数并进行 Valid 效验
application.properties 配置文件内容:
1my.name=xiao-ming
2my.age=20
使用 @ConfigurationProperties 注解读取对应配置:
1@Validated // 引入效验注解
2@Configuration
3@ConfigurationProperties(prefix = "my")
4public class ConfigurationReadConfigAndValid {
5
6 @NotNull(message = "姓名不能为空")
7 private String name;
8 @Max(value = 20L,message = "年龄不能超过 20 岁")
9 private Integer age;
10
11 public String getName() {
12 return name;
13 }
14 public void setName(String name) {
15 this.name = name;
16 }
17 public Integer getAge() {
18 return age;
19 }
20 public void setAge(Integer age) {
21 this.age = age;
22 }
23
24}
8、@ConfigurationProperties 读取配置到新建 Spring Bean 中
application.properties 配置文件内容:
1user.name=mydlq
2user.age=22
User 实体类
1import lombok.Data;
2
3@Data
4public class User {
5 private String name;
6 private Integer age;
7}
使用 @ConfigurationProperties 注解读取对应配置到新建的 Bean 对象中
1@Configuration
2public class ConfigurationReadObject {
3
4 @Bean("user")
5 @ConfigurationProperties(prefix = "user")
6 public User createUser(){
7 return new User();
8 }
9
10}
9、从指定配置文件中读取参数
使用 @ConfigurationProperties 注解是默认从 application.properties 或者 application.yaml 中读取配置,有时候我们需要将特定的配置放到单独的配置文件中,这时候需要 @PropertySource 与 ConfigurationProperties 配置使用,使用 @PropertySource 注解指定要读取的文件,使用 @ConfigurationProperties 相关属性。
测试文件:
- 测试文件名称:test.txt
- 测试文件编码方式:UTF-8
- 测试文件目录:resources/test.txt
- 测试文件内容:
1my.name=mydlq
Java 中配置 @ConfigurationProperties 和 @PropertySource 注解读取对应配置:
1@Configuration
2@ConfigurationProperties(prefix = "my")
3@PropertySource(encoding = "UTF-8", ignoreResourceNotFound = true, value = "classpath:test.txt")
4public class ConfigurationReadConfig {
5
6 private String name;
7
8 public String getName() {
9 return name;
10 }
11 public void setName(String name) {
12 this.name = name;
13 }
14
15}
四、使用 Environment 对象读取配置
application.properties 配置文件内容:
1my.name=mydlq
使用 Environment 读取配置:
1@Component
2public class EnvironmentReadConfig {
3
4 private String name;
5
6 @Autowired
7 private Environment environment;
8
9 public String readConfig(){
10 name = environment.getProperty("my.name", "默认值");
11 }
12
13}
五、使用 PropertiesLoaderUtils 读取配置
application.properties 配置文件内容:
1my.name=mydlq
使用 Environment 读取配置:
1public class PropertiesReadConfig {
2
3 private String name;
4
5 public void readConfig() {
6 try {
7 ClassPathResource resource = new ClassPathResource("application.properties");
8 Properties properties = PropertiesLoaderUtils.loadProperties(resource);
9 name = properties.getProperty("my.name", "默认值");
10 } catch (IOException e) {
11 log.error("", e);
12 }
13 }
14
15}
六、读取配置文件示例项目
1、Maven 引入相关依赖
1<?xml version="1.0" encoding="UTF-8"?>
2<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
4 <modelVersion>4.0.0</modelVersion>
5
6 <parent>
7 <groupId>org.springframework.boot</groupId>
8 <artifactId>spring-boot-starter-parent</artifactId>
9 <version>2.2.2.RELEASE</version>
10 </parent>
11
12 <groupId>mydlq.club</groupId>
13 <artifactId>springboot-read-config-example</artifactId>
14 <version>0.0.1</version>
15 <name>springboot-read-config-example</name>
16 <description>Spring Boot Read Config</description>
17
18 <properties>
19 <java.version>1.8</java.version>
20 </properties>
21
22 <dependencies>
23 <!--SpringBoot Web 依赖-->
24 <dependency>
25 <groupId>org.springframework.boot</groupId>
26 <artifactId>spring-boot-starter-web</artifactId>
27 </dependency>
28 <!--用于 SpringBoot 生成配置 metadata 文件-->
29 <dependency>
30 <groupId>org.springframework.boot</groupId>
31 <artifactId>spring-boot-configuration-processor</artifactId>
32 <optional>true</optional>
33 </dependency>
34 <!--引入 Lombok 插件,方便操作实体对象-->
35 <dependency>
36 <groupId>org.projectlombok</groupId>
37 <artifactId>lombok</artifactId>
38 </dependency>
39 </dependencies>
40
41 <build>
42 <plugins>
43 <plugin>
44 <groupId>org.springframework.boot</groupId>
45 <artifactId>spring-boot-maven-plugin</artifactId>
46 </plugin>
47 </plugins>
48 </build>
49
50</project>
2、测试的配置文件
application.properties
1## 使用多种方法读取 String 参数
2my1.name=xiao-ming
3my1.sex=man
4my1.age=20
5
6## 使用 @ConfigurationProperties 读取 Map 参数
7my2.map.name=xiao-li
8my2.map.sex=man
9my2.map.age=20
10
11## 使用 @Value 读取 Map 参数
12my3.map={name:"xiao-ming",sex:"man",age:"20"}
13
14## 使用 @ConfigurationProperties 读取 List 参数
15my4.list[0]=xiao-li
16my4.list[1]=man
17my4.list[2]=20
18
19## 使用 @Value 读取 List 参数
20my5.list=xiao-ming,man,20
21
22## 使用 @ConfigurationProperties 读取 Time 参数
23my6.time=20s
24
25## 使用 @ConfigurationProperties 读取 DataSize 参数
26my7.fileSize=10MB
27
28## 使用 @ConfigurationProperties 读取参数并进行 @Valid 效验
29my8.name=xiao-ming
30my8.age=20
3、读取配置的多种方法
(1)、读取 String 配置的 Service
ConfigurationReadString
1import lombok.Data;
2import org.springframework.boot.context.properties.ConfigurationProperties;
3import org.springframework.context.annotation.Configuration;
4import org.springframework.context.annotation.PropertySource;
5
6/**
7 * 通过 @PropertySource 指定读取的文件中 String 配置,通过 @ConfigurationProperties 过滤前缀
8 */
9@Data
10@Configuration
11@PropertySource(encoding = "UTF-8", ignoreResourceNotFound = true, value = "classpath:application.properties")
12@ConfigurationProperties(prefix = "my1")
13public class ConfigurationReadString {
14
15 private String name;
16 private String sex;
17 private String age;
18
19 public String readString(){
20 return name + "," + sex + "," + age;
21 }
22
23}
EnvironmentReadString
1import org.springframework.beans.factory.annotation.Autowired;
2import org.springframework.core.env.Environment;
3import org.springframework.stereotype.Service;
4
5/**
6 * 从环境对象 Environment 中读取 String 配置
7 */
8@Service
9public class EnvironmentReadString {
10
11 @Autowired
12 private Environment environment;
13
14 public String readString(){
15 String name = environment.getProperty("my1.name", "");
16 String sex = environment.getProperty("my1.sex", "");
17 String age = environment.getProperty("my1.age", "18");
18 return name + "," + sex + "," + age;
19 }
20
21}
PropertiesUtilReadString
1import lombok.extern.slf4j.Slf4j;
2import org.springframework.core.io.ClassPathResource;
3import org.springframework.core.io.support.PropertiesLoaderUtils;
4import java.io.IOException;
5import java.util.Properties;
6
7/**
8 * 通过 properties 工具读取 String 配置
9 */
10@Slf4j
11public class PropertiesUtilReadString {
12
13 private PropertiesUtilReadString(){}
14
15 public static String readString() {
16 try {
17 ClassPathResource resource = new ClassPathResource("application.properties");
18 Properties properties = PropertiesLoaderUtils.loadProperties(resource);
19 String name = properties.getProperty("my1.name", "");
20 String sex = properties.getProperty("my1.sex", "");
21 String age = properties.getProperty("my1.age", "18");
22 return name + "," + sex + "," + age;
23 } catch (IOException e) {
24 log.error("", e);
25 }
26 return "";
27 }
28
29}
ValueReadString
1import org.springframework.beans.factory.annotation.Value;
2import org.springframework.stereotype.Service;
3
4/**
5 * 通过 @Value 读取 String 配置
6 */
7@Service
8public class ValueReadString {
9
10 @Value("${my1.name}")
11 private String name;
12
13 @Value("${my1.sex}")
14 private String sex;
15
16 @Value("${my1.age:18}")
17 private String age;
18
19 public String readString() {
20 return name + "," + sex + "," + age;
21 }
22
23}
(2)、读取 List 配置的 Service
ConfigurationReadList
1import lombok.Data;
2import org.springframework.boot.context.properties.ConfigurationProperties;
3import org.springframework.context.annotation.Configuration;
4import org.springframework.context.annotation.PropertySource;
5import java.util.List;
6
7/**
8 * 通过 @ConfigurationProperties 方式读取文件中的 List 数据
9 */
10@Data
11@Configuration
12@PropertySource(encoding = "UTF-8", ignoreResourceNotFound = true, value = "classpath:application.properties")
13@ConfigurationProperties(prefix = "my4")
14public class ConfigurationReadList {
15
16 private List<String> list;
17
18 public String readList() {
19 StringBuilder builder = new StringBuilder();
20 for (String str:list){
21 builder.append(str).append(",");
22 }
23 // 移除最后的“,”号
24 builder.delete(builder.length()-1,builder.length());
25 return builder.toString();
26 }
27
28}
ValueReadList
1import org.springframework.beans.factory.annotation.Value;
2import org.springframework.stereotype.Service;
3import java.util.List;
4
5/**
6 * 通过 @Value 方式读取文件中的 List 数据
7 */
8@Service
9public class ValueReadList {
10
11 @Value("#{'${my5.list}'.split(',')}")
12 private List<String> list;
13
14 public String readList() {
15 StringBuilder builder = new StringBuilder();
16 for (String str:list){
17 builder.append(str).append(",");
18 }
19 // 移除最后的“,”号
20 builder.delete(builder.length()-1,builder.length());
21 return builder.toString();
22 }
23
24}
(3)、读取 Map 配置的 Service
ConfigurationReadMap
1import lombok.Data;
2import org.springframework.boot.context.properties.ConfigurationProperties;
3import org.springframework.context.annotation.Configuration;
4import org.springframework.context.annotation.PropertySource;
5import java.util.Map;
6
7/**
8 * 通过 @ConfigurationProperties 方式读取文件中的 Map 数据
9 */
10@Data
11@Configuration
12@PropertySource(encoding = "UTF-8", ignoreResourceNotFound = true, value = "classpath:application.properties")
13@ConfigurationProperties(prefix = "my2")
14public class ConfigurationReadMap {
15
16 private Map<String,String> map;
17
18}
ValueReadMap
1import org.springframework.beans.factory.annotation.Value;
2import org.springframework.stereotype.Service;
3import java.util.Map;
4
5/**
6 * 通过 @Value 方式读取文件中的 Map 数据
7 */
8@Service
9public class ValueReadMap {
10
11 @Value("#{${my3.map}}")
12 private Map<String, String> map;
13
14 public String readMap(){
15 return map.get("name") + "," + map.get("sex") + "," + map.get("age");
16 }
17
18}
(4)、读取 Time 的 Service
1import lombok.Data;
2import org.springframework.boot.context.properties.ConfigurationProperties;
3import org.springframework.boot.convert.DurationUnit;
4import org.springframework.context.annotation.Configuration;
5import org.springframework.context.annotation.PropertySource;
6import java.time.Duration;
7import java.time.temporal.ChronoUnit;
8
9/**
10 * 通过 @ConfigurationProperties 读取 time 参数
11 */
12@Data
13@Configuration
14@PropertySource(encoding = "UTF-8", ignoreResourceNotFound = true, value = "classpath:application.properties")
15@ConfigurationProperties(prefix = "my6")
16public class ConfigurationReadTime {
17
18 /**
19 * 设置以秒为单位
20 */
21 @DurationUnit(ChronoUnit.SECONDS)
22 private Duration time;
23
24 public String readTime() {
25 return String.valueOf(time.getSeconds());
26 }
27
28}
常见单位如下:
B for bytes KB for kilobytes MB for megabytes GB for gigabytes TB for terabytes
(5)、读取 DataSize 的 Service
1import lombok.Data;
2import org.springframework.boot.context.properties.ConfigurationProperties;
3import org.springframework.boot.convert.DataSizeUnit;
4import org.springframework.context.annotation.Configuration;
5import org.springframework.context.annotation.PropertySource;
6import org.springframework.util.unit.DataSize;
7import org.springframework.util.unit.DataUnit;
8
9/**
10 * 通过 @ConfigurationProperties 读取 time 参数
11 */
12@Data
13@Configuration
14@PropertySource(encoding = "UTF-8", ignoreResourceNotFound = true, value = "classpath:application.properties")
15@ConfigurationProperties(prefix = "my7")
16public class ConfigurationReadDatasize {
17
18 /**
19 * 设置以秒为单位
20 */
21 @DataSizeUnit(DataUnit.MEGABYTES)
22 private DataSize fileSize;
23
24 public String readDatasize() {
25 return String.valueOf(fileSize.toMegabytes());
26 }
27
28}
常用单位如下:
- ns (纳秒)
- us (微秒)
- ms (毫秒)
- s (秒)
- m (分)
- h (时)
- d (天)
(6)、读取配置并进行 valie 效验的 service
1import lombok.Data;
2import org.springframework.boot.context.properties.ConfigurationProperties;
3import org.springframework.context.annotation.Configuration;
4import org.springframework.context.annotation.PropertySource;
5import org.springframework.validation.annotation.Validated;
6import javax.validation.constraints.Max;
7import javax.validation.constraints.NotNull;
8
9/**
10 * 通过 @ConfigurationProperties 读取配置并进行 valid 效验
11 */
12@Data
13@Validated // 效验注解
14@Configuration
15@PropertySource(encoding = "UTF-8", ignoreResourceNotFound = true, value = "classpath:application.properties")
16@ConfigurationProperties(prefix = "my8")
17public class ConfigurationReadConfigAndValid {
18
19 @NotNull(message = "姓名不能为空")
20 private String name;
21 @Max(value = 20L,message = "年龄不能超过 20 岁")
22 private Integer age;
23
24 public String readString() {
25 return name + "," + age;
26 }
27
28}
(7)、读取配置到 Spring Bean 对象中
1import lombok.Data;
2import org.springframework.boot.context.properties.ConfigurationProperties;
3import org.springframework.context.annotation.Bean;
4import org.springframework.context.annotation.Configuration;
5
6/**
7 * 通过 @ConfigurationProperties 读取到 Spring Bean 对象中
8 */
9@Configuration
10public class ConfigurationReadObject {
11
12 /**
13 * 测试的实体类对象
14 */
15 @Data
16 public static class User {
17 private String name;
18 private Integer age;
19 }
20
21 /**
22 * 读取以 my9 为前缀的参数的值,到新建的对象中
23 */
24 @Bean("user")
25 @ConfigurationProperties(prefix = "my9")
26 public User readObjectData(){
27 return new User();
28 }
29
30}
4、配置测试用的 Controller
(1)、读取 String 的 Controller
1import club.mydlq.service.string.*;
2import org.springframework.beans.factory.annotation.Autowired;
3import org.springframework.web.bind.annotation.GetMapping;
4import org.springframework.web.bind.annotation.RequestMapping;
5import org.springframework.web.bind.annotation.RestController;
6
7/**
8 * 读取 String Controller
9 */
10@RestController
11@RequestMapping("/string")
12public class ReadStringController {
13
14 @Autowired
15 private ValueReadString valueReadConfig;
16
17 @Autowired
18 private EnvironmentReadString environmentReadConfig;
19
20 @Autowired
21 private ConfigurationReadString configurationReadConfig;
22
23 @GetMapping("/value")
24 public String valueReadConfig(){
25 return valueReadConfig.readString();
26 }
27
28 @GetMapping("/env")
29 public String envReadConfig(){
30 return environmentReadConfig.readString();
31 }
32
33 @GetMapping("/util")
34 public String utilReadConfig(){
35 return PropertiesUtilReadString.readString();
36 }
37
38 @GetMapping("/configuration")
39 public String configurationReadConfig(){
40 return configurationReadConfig.readString();
41 }
42
43}
(2)、读取 List 的 Controller
1import club.mydlq.service.list.ConfigurationReadList;
2import club.mydlq.service.list.ValueReadList;
3import org.springframework.beans.factory.annotation.Autowired;
4import org.springframework.web.bind.annotation.GetMapping;
5import org.springframework.web.bind.annotation.RequestMapping;
6import org.springframework.web.bind.annotation.RestController;
7
8/**
9 * 读取 List Controller
10 */
11@RestController
12@RequestMapping("/list")
13public class ReadListController {
14
15 @Autowired
16 private ValueReadList vlueReadList;
17
18 @Autowired
19 private ConfigurationReadList configurationReadList;
20
21 @GetMapping("/value")
22 public String valueReadList(){
23 return vlueReadList.readList();
24 }
25
26 @GetMapping("/configuration")
27 public String configReadList(){
28 return configurationReadList.readList();
29 }
30
31}
(3)、读取 Map 的 Controller
1import club.mydlq.service.map.ConfigurationReadMap;
2import club.mydlq.service.map.ValueReadMap;
3import org.springframework.beans.factory.annotation.Autowired;
4import org.springframework.web.bind.annotation.GetMapping;
5import org.springframework.web.bind.annotation.RequestMapping;
6import org.springframework.web.bind.annotation.RestController;
7
8/**
9 * 读取 Map Controller
10 */
11@RestController
12@RequestMapping("/map")
13public class ReadMapController {
14
15 @Autowired
16 private ConfigurationReadMap configurationReadMap;
17
18 @Autowired
19 private ValueReadMap valueReadMap;
20
21 @GetMapping("/configuration")
22 public String configReadMap(){
23 return configurationReadMap.getMap().get("name") + "," + configurationReadMap.getMap().get("sex") + "," + configurationReadMap.getMap().get("age");
24 }
25
26 @GetMapping("/value")
27 public String valueReadMap(){
28 return valueReadMap.readMap();
29 }
30
31}
(4)、读取 Time 的 Controller
1import club.mydlq.service.time.ConfigurationReadTime;
2import org.springframework.beans.factory.annotation.Autowired;
3import org.springframework.web.bind.annotation.GetMapping;
4import org.springframework.web.bind.annotation.RequestMapping;
5import org.springframework.web.bind.annotation.RestController;
6
7/**
8 * 读取 time Controller
9 */
10@RestController
11@RequestMapping("/time")
12public class ReadTimeController {
13
14 @Autowired
15 private ConfigurationReadTime configurationReadTime;
16
17 @GetMapping("/configuration")
18 public String configReadList(){
19 return configurationReadTime.readTime();
20 }
21
22}
(5)、读取 Datasize 的 Controller
1import club.mydlq.service.datasize.ConfigurationReadDatasize;
2import org.springframework.beans.factory.annotation.Autowired;
3import org.springframework.web.bind.annotation.GetMapping;
4import org.springframework.web.bind.annotation.RequestMapping;
5import org.springframework.web.bind.annotation.RestController;
6
7/**
8 * 读取 Datasize Controller
9 */
10@RestController
11@RequestMapping("/data")
12public class ReadDatasizeController {
13
14 @Autowired
15 private ConfigurationReadDatasize configurationReadDatasize;
16
17 @GetMapping("/configuration")
18 public String configReadList(){
19 return configurationReadDatasize.readDatasize();
20 }
21
22}
(6)、读取 Datasize 的 Controller
1import club.mydlq.service.valid.ConfigurationReadConfigAndValid;
2import org.springframework.beans.factory.annotation.Autowired;
3import org.springframework.web.bind.annotation.GetMapping;
4import org.springframework.web.bind.annotation.RequestMapping;
5import org.springframework.web.bind.annotation.RestController;
6
7/**
8 * 读取参数进行 valid 效验的 Controller
9 */
10@RestController
11@RequestMapping("/valid")
12public class ReadValidController {
13
14 @Autowired
15 private ConfigurationReadConfigAndValid configurationReadConfigAndValid;
16
17 @GetMapping("/configuration")
18 public String configReadList(){
19 return configurationReadConfigAndValid.readString();
20 }
21
22}
(7)、读取参数到 Spring Bean 对象的 Controller
1import club.mydlq.service.string.ConfigurationReadObject;
2import org.springframework.beans.factory.annotation.Autowired;
3import org.springframework.web.bind.annotation.GetMapping;
4import org.springframework.web.bind.annotation.RequestMapping;
5import org.springframework.web.bind.annotation.RestController;
6
7/**
8 * 读取参数到对象
9 */
10@RestController
11@RequestMapping("/object")
12public class ReadObjectController {
13
14 @Autowired
15 private ConfigurationReadObject.User user;
16
17 @GetMapping("/value")
18 public Object valueReadConfig(){
19 return user;
20 }
21
22}
5、启动类
1import org.springframework.boot.SpringApplication;
2import org.springframework.boot.autoconfigure.SpringBootApplication;
3
4@SpringBootApplication
5public class Application {
6
7 public static void main(String[] args) {
8 SpringApplication.run(Application.class, args);
9 }
10
11}
---END---
!版权声明:本博客内容均为原创,每篇博文作为知识积累,写博不易,转载请注明出处。