SpringBoot高级_01_SpringBoot基础回顾

1. SpringBoot基础回顾

1.1 约定优于配置

Build Anything with Spring Boot ： Spring Boot is the starting point for

building all Spring-based applications. Spring Boot is designed to get you up

and running as quickly as possible, with minimal upfront configuration of

Spring.

上面是引自官网的一段话，大概是说： Spring Boot 是所有基于 Spring 开发的项目的起点。 Spring

Boot 的设计是为了让你尽可能快的跑起来 Spring 应用程序并且尽可能减少你的配置文件。

约定优于配置（ Convention over Confifiguration ），又称按约定编程，是一种软件设计范式。

本质上是说，系统、类库或框架应该假定合理的默认值，而非要求提供不必要的配置。比如说模型中有一个名为User 的类，那么数据库中对应的表就会默认命名为 user 。只有在偏离这一个约定的时候，例如想要将该表命名为person ，才需要写有关这个名字的配置。

比如平时架构师搭建项目就是限制软件开发随便写代码，制定出一套规范，让开发人员按统一的要求进行开发编码测试之类的，这样就加强了开发效率与审查代码效率。所以说写代码的时候就需要按要求命名，这样统一规范的代码就有良好的可读性与维护性了

约定优于配置简单来理解，就是遵循约定

1.2 SpringBoot概念

1.2.1 spring优缺点分析

优点：

spring 是 Java 企业版 (Java Enterprise Edition ， JEE ，也称 J2EE) 的轻量级代替品。无需开发重量级的 Enterprise JavaBean(EJB)， Spring 为企业级 Java 开发提供了一种相对简单的方法，通过依赖注入和面向切面编程，用简单 的Java 对象 (Plain Old Java Object ， POJO) 实现了 EJB 的功能

缺点：

虽然 Spring 的组件代码是轻量级的，但它的配置却是重量级的。一开始， Spring 用 XML 配置，而且是很多XML 配 置。 Spring 2.5 引入了基于注解的组件扫描，这消除了大量针对应用程序自身组件的显式 XML配置。Spring 3.0 引入 了基于 Java 的配置，这是一种类型安全的可重构配置方式，可以代替 XML 。

所有这些配置都代表了开发时的损耗。因为在思考 Spring 特性配置和解决业务问题之间需要进行思维切换，所以编 写配置挤占了编写应用程序逻辑的时间。和所有框架一样，Spring 实用，但与此同时它要求的回报也不少。

除此之外，项目的依赖管理也是一件耗时耗力的事情。在环境搭建时，需要分析要导入哪些库的坐标，而且还需要分析导入与之有依赖关系的其他库的坐标，一旦选错了依赖的版本，随之而来的不兼容问题就会严重阻碍项目的开发进度

1.2.2 SpringBoot解决上述spring问题

SpringBoot 对上述 Spring 的缺点进行的改善和优化，基于约定优于配置的思想，可以让开发人员不必在配置与逻辑 业务之间进行思维的切换，全身心的投入到逻辑业务的代码编写中，从而大大提高了开发的效率，一定程度上缩短 了项目周期

起步依赖

起步依赖本质上是一个 Maven 项目对象模型 (Project Object Model ， POM) ，定义了对其他库的传递依赖，这些东西加在一起即支持某项功能。

简单的说，起步依赖就是将具备某种功能的坐标打包到一起，并提供一些默认的功能。

自动配置

springboot 的自动配置，指的是 springboot ，会自动将一些配置类的 bean 注册进 ioc 容器，我们可以需要的地方使用@autowired 或者 @resource 等注解来使用它。

“ 自动 ” 的表现形式就是我们只需要引我们想用功能的包，相关的配置我们完全不用管， springboot 会自动注入这些配置bean ，我们直接使用这些 bean 即可

springboot: 简单、快速、方便地搭建项目；对主流开发框架的无配置集成；极大提高了开发、部署效率

1.3 SpringBoot 案例实现

案例需求：请求 Controller 中的方法，并将返回值响应到页面

（ 1 ）使用 Spring Initializr 方式构建 Spring Boot 项目

本质上说， Spring Initializr 是一个 Web 应用，它提供了一个基本的项目结构，能够帮助我们快速

构建一个基础的 Spring Boot 项目

 

Project SDK” 用于设置创建项目使用的 JDK 版本，这里，使用之前初始化设置好的 JDK 版本即可；在 “Choose Initializr Service URL（选择初始化服务地址）”下使用默认的初始化服务地址 “ https://start.spring.io ” 进行 Spring Boot 项目创建（注意使用快速方式创建 Spring Boot 项目时，所在主机须在联网状态下）

  

Spring Boot 项目就创建好了。创建好的 Spring Boot 项目结构如图：

 

使用 Spring Initializr 方式构建的 Spring Boot 项目会默认生成项目启动类、存放前端静态资源和页

面的文件夹、编写项目配置的配置文件以及进行项目单元测试的测试类

（ 2 ） 创建一个用于 Web 访问的 Controller

com.lagou 包下创建名称为 controller 的包，在该包下创建一个请求处理控制类 HelloController ，

并编写一个请求处理方法 ( 注意：将项目启动类 SpringBootDemoApplication 移动到 com.lagou 包下 )

@RestController // 该注解为组合注解，等同于 Spring 中 @Controller+@ResponseBody 注解

public class DemoController {

@RequestMapping ( "/demo" )

public String demo (){

return " 你好 spring Boot" ;

}

}

(3) 运行项目

运行主程序启动类 SpringbootDemoApplication ，项目启动成功后，在控制台上会发现 Spring

Boot 项目默认启动的端口号为 8080 ，此时，可以在浏览器上访问 “ http://localhost:8080/hello ”

@RestController // 该注解为组合注解，等同于 Spring 中 @Controller+@ResponseBody 注解

 

页面输出的内容是 “hello Spring Boot” ，至此，构建 Spring Boot 项目就完成了

附：解决中文乱码：

解决方法一：

@RequestMapping ( produces = "application/json; charset=utf-8" )

解决方法二：

# 设置响应为 utf-8

spring.http.encoding.force-response = true

1.4 单元测试与热部署

（1）单元测试

开发中，每当完成一个功能接口或业务方法的编写后，通常都会借助单元测试验证该功能是否正

确。 Spring Boot 对项目的单元测试提供了很好的支持，在使用时，需要提前在项目的 pom.xml 文件中添加spring-boot-starter-test 测试依赖启动器，可以通过相关注解实现单元测试

演示：

1 ．添加 spring-boot-starter-test 测试依赖启动器

在项目的 pom.xml 文件中添加 spring-boot-starter-test 测试依赖启动器，示例代码如下 ：

<dependency>

<groupId> org.springframework.boot </groupId>

<artifactId> spring-boot-starter-test </artifactId>

<scope> test </scope>

</dependency>

注意：使用 Spring Initializr 方式搭建的 Spring Boot 项目，会自动加入 spring-boot-starter-test 测试依赖启动器，无需再手动添加

2 ．编写单元测试类和测试方法

使用 Spring Initializr 方式搭建的 Spring Boot 项目，会在 src.test.java 测试目录下自动创建与项目主程序启动类对应的单元测试类

@RunWith ( SpringRunner . class ) // 测试启动器，并加载 Spring Boot 测试注解

@SpringBootTest // 标记为 Spring Boot 单元测试类，并加载项目的 ApplicationContext 上下文

环境

class SpringbootDemoApplicationTests {

@Autowired

private DemoController demoController ;

// 自动创建的单元测试方法实例

@Test

void contextLoads () {

String demo = demoController . demo ();

System . out . println ( demo );

}

}

上述代码中，先使用 @Autowired 注解注入了 DemoController 实例对象，然后在 contextLoads()

方法中调用了 DemoController 类中对应的请求控制方法 contextLoads() ，并输出打印结果

 

（2）热部署

在开发过程中，通常会对一段业务代码不断地修改测试，在修改之后往往需要重启服务，有些服

务需要加载很久才能启动成功，这种不必要的重复操作极大的降低了程序开发效率。为此， Spring

Boot 框架专门提供了进行热部署的依赖启动器，用于进行项目热部署，而无需手动重启项目

演示：

1 ．添加 spring-boot-devtools 热部署依赖启动器

在 Spring Boot 项目进行热部署测试之前，需要先在项目的 pom.xml 文件中添加 spring-boot-devtools 热部署依赖启动器:

<!-- 引入热部署依赖 -->

<dependency>

<groupId> org.springframework.boot </groupId>

<artifactId> spring-boot-devtools </artifactId>

</dependency>

由于使用的是 IDEA 开发工具，添加热部署依赖后可能没有任何效果，接下来还需要针对 IDEA 开发

工具进行热部署相关的功能设置

2. IDEA 工具热部署设置

选择 IDEA 工具界面的【 File 】 -> 【 Settings 】选项，打开 Compiler 面板设置页面

 

选择 Build 下的 Compiler 选项，在右侧勾选 “Build project automatically” 选项将项目设置为自动编

译，单击【 Apply 】 → 【 OK 】按钮保存设置

在项目任意页面中使用组合快捷键 “Ctrl+Shift+Alt+/” 打开 Maintenance 选项框，选中并打开

Registry 页面，具体如图 1-17 所示

 

列表中找到 “compiler.automake.allow.when.app.running” ，将该选项后的 Value 值勾选，用于指

定 IDEA 工具在程序运行过程中自动编译，最后单击【 Close 】按钮完成设置

3 ．热部署效果测试

启动 chapter01 http://localhost:8080/hello

 

页面原始输出的内容是 “hello Spring Boot” 。

为了测试配置的热部署是否有效，接下来，在不关闭当前项目的情况下，将 DemoController 类中的请求处理方法hello() 的返回值修改为 “ 你好， Spring Boot” 并保存，查看控制台信息会发现项目能够自动构建和编译，说明项目热部署生效

可以看出，浏览器输出了 “ 你好， Spring Boot” ，说明项目热部署配置成功

1.5 全局配置文件

全局配置文件能够对一些默认配置值进行修改。 Spring Boot 使用一个 application.properties 或者

application.yaml 的文件作为全局配置文件，该文件存放在 src/main/resource 目录或者类路径

的 /confifig ，一般会选择 resource 目录。接下来，将针对这两种全局配置文件进行讲解 ：

1.5.1 application.properties配置文件

使用 Spring Initializr 方式构建 Spring Boot 项目时，会在 resource 目录下自动生成一个空的

application.properties 文件， Spring Boot 项目启动时会自动加载 application.properties 文件。

我们可以在 application.properties 文件中定义 Spring Boot 项目的相关属性，当然，这些相关属性可以是系统属性、环境变量、命令参数等信息，也可以是自定义配置文件名称和位置

server.port = 8081

spring.datasource.driver-class-name = com.mysql.jdbc.Driver

spring.config.additional-location =

spring.config.location =

spring.config.name = application

接下来，通过一个案例对 Spring Boot 项目中 application.properties 配置文件的具体使用进行讲解

演示：

预先准备了两个实体类文件，后续会演示将 application.properties 配置文件中的自定义配置属性注入到Person 实体类的对应属性中

（ 1 ）先在项目的 com.lagou 包下创建一个 pojo 包，并在该包下创建两个实体类 Pet 和 Person

public class Pet {

private String type ;

private String name ;

// 省略属性 getXX() 和 setXX() 方法

// 省略 toString() 方法

}

@Component // 用于将 Person 类作为 Bean 注入到 Spring 容器中 @ConfigurationProperties ( prefix = "person" ) // 将配置文件中以 person 开头的属性注入到该

类中

public class Person {

private int id ; //id

private String name ; // 名称

private List hobby ; // 爱好

private String [] family ; // 家庭成员

private Map map ;

private Pet pet ; // 宠物

// 省略属性 getXX() 和 setXX() 方法

// 省略 toString() 方法

}

@ConfifigurationProperties(prefifix = "person") 注解的作用是将配置文件中以 person 开头的属性值通过 setXX()方法注入到实体类对应属性中

@Component 注解的作用是将当前注入属性值的 Person 类对象作为 Bean 组件放到 Spring 容器中，只有这样才能被@ConfifigurationProperties 注解进行赋值

（ 2 ）打开项目的 resources 目录下的 application.properties 配置文件，在该配置文件中编写需要对

Person 类设置的配置属性

 

编写 application.properties 配置文件时，由于要配置的 Person 对象属性是我们自定义的， Spring

Boot 无法自动识别，所以不会有任何书写提示。在实际开发中，为了出现代码提示的效果来方便配置，在使用@ConfifigurationProperties 注解进行配置文件属性值注入时，可以在 pom.xml 文件中添加一个Spring Boot提供的配置处理器依赖 :

<dependency>

<groupId> org.springframework.boot </groupId>

<artifactId> spring-boot-configuration-processor </artifactId>

<optional> true </optional>

</dependency>

在 pom.xml 中添加上述配置依赖后，还需要重新运行项目启动类或者使用 “Ctrl+F9” 快捷键（即

Build Project ）重构当前 Spring Boot 项目方可生效

（ 3 ）查看 application.properties 配置文件是否正确，同时查看属性配置效果，打开通过 IDEA 工具创建的项目测试类，在该测试类中引入Person 实体类 Bean ，并进行输出测试

@RunWith ( SpringRunner . class ) // 测试启动器，并加载 Spring Boot 测试注解

@SpringBootTest // 标记为 Spring Boot 单元测试类，并加载项目的 ApplicationContext 上下文

环境

class SpringbootDemoApplicationTests {

// 配置测试

@Autowired

private Person person ;

@Test

void configurationTest () {

System . out . println ( person );

}

}

打印结果：

可以看出，测试方法 confifigurationTest() 运行成功，同时正确打印出了 Person 实体类对象。至此，说明application.properties配置文件属性配置正确，并通过相关注解自动完成了属性注入

1.5.2 application.yaml配置文件

YAML 文件格式是 Spring Boot 支持的一种 JSON 超集文件格式，相较于传统的 Properties 配置文件，

YAML 文件以数据为核心，是一种更为直观且容易被电脑识别的数据序列化格式。 application.yaml 配置

文件的工作原理和 application.properties 是一样的，只不过 yaml 格式配置文件看起来更简洁一些。

• YAML文件的扩展名可以使用.yml或者.yaml。
• application.yml文件使用 “key:（空格）value”格式配置属性，使用缩进控制层级关系。

这里，针对不同数据类型的属性值，介绍一下 YAML

（ 1 ） value 值为普通数据类型（例如数字、字符串、布尔等）

当 YAML 配置文件中配置的属性值为普通数据类型时，可以直接配置对应的属性值，同时对于字符

串类型的属性值，不需要额外添加引号，示例代码如下

server :

port : 8081

path : /hello

上述代码用于配置 server 的 port 和 path 属性， port 和 path 属于一个级别

（ 2 ） value 值为数组和单列集合

当 YAML 配置文件中配置的属性值为数组或单列集合类型时，主要有两种书写方式：缩进式写法和行内式写法。

其中，缩进式写法还有两种表示形式，示例代码如下

person :

hobby :

- play

- read

- sleep

或者使用如下示例形式

person :

hobby :

play,

read,

sleep

上述代码中，在 YAML 配置文件中通过两种缩进式写法对 person 对象的单列集合（或数组）类型的爱好hobby赋值为 play 、 read 和 sleep 。其中一种形式为 “- （空格）属性值 ” ，另一种形式为多个属性值之前加英文逗号分隔（注意，最后一个属性值后不要加逗号）。

person :

hobby : [ play , read , sleep ]

通过上述示例对比发现， YAML 配置文件的行内式写法更加简明、方便。另外，包含属性值的中括

号 “[]” 还可以进一步省略，在进行属性赋值时，程序会自动匹配和校对

（ 3 ） value 值为 Map 集合和对象

当 YAML 配置文件中配置的属性值为 Map 集合或对象类型时， YAML 配置文件格式同样可以分为两种书写方式：缩进式写法和行内式写法。

其中，缩进式写法的示例代码如下

person :

map :

k1 : v1

k2 : v2

对应的行内式写法示例代码如下

person :

map : { k1 : v1 , k2 : v2 }

在 YAML 配置文件中，配置的属性值为 Map 集合或对象类型时，缩进式写法的形式按照 YAML 文件格式编写即可，而行内式写法的属性值要用大括号“{}” 包含。

接下来，在 Properties 配置文件演示案例基础上，通过配置 application.yaml 配置文件对 Person 对象进行赋值，具体使用如下

（ 1 ）在项目的 resources 目录下，新建一个 application.yaml 配置文件，在该配置文件中编写为 Person类设置的配置属性

# 对实体类对象 Person 进行属性配置

person :

id : 1

name : lucy

hobby : [ 吃饭，睡觉，打豆豆 ]

family : [ father , mother ]

map : { k1 : v1 , k2 : v2 }

pet : { type : dog , name : 旺财 }

（ 2 ）再次执行测试

 

可以看出，测试方法 confifigurationTest() 同样运行成功，并正确打印出了 Person 实体类对象。

需要 说明 的是，本次使用 application.yaml 配置文件进行测试时需要提前将 application.properties 配置文件中编写的配置注释，这是因为application.properties 配置文件会覆盖 application.yaml 配置文件

1.6 配置文件属性值的注入

使用 Spring Boot 全局配置文件设置属性时：

如果配置属性是 Spring Boot 已有属性，例如服务端口 server.port ，那么 Spring Boot 内部会自动扫描并读取这些配置文件中的属性值并覆盖默认属性。

如果配置的属性是用户自定义属性，例如刚刚自定义的 Person 实体类属性，还必须在程序中注入这些配置属性方可生效。

Spring Boot 支持多种注入配置文件属性的方式，下面来介绍如何使用注解@ConfifigurationProperties和@Value 注入属性

1.6.1 使用@ConfifigurationProperties注入属性

Spring Boot 提供的 @ConfifigurationProperties 注解用来快速、方便地将配置文件中的自定义属性值批量注入到某个Bean 对象的多个对应属性中。假设现在有一个配置文件，如果使用

@ConfifigurationProperties 注入配置文件的属性，示例代码如下：

@Component

@ConfigurationProperties ( prefix = "person" )

public class Person {

private int id ;

// 属性的 setXX() 方法

public void setId ( int id ) {

this . id = id ;

}

}

上述代码使用 @Component 和 @ConfifigurationProperties(prefifix = “person”) 将配置文件中的每个属性映射到person 类组件中。

需要注意的是，使用 @ConfifigurationProperties

1.6.2 使用@Value注入属性

@Value 注解是 Spring 框架提供的，用来读取配置文件中的属性值并逐个注入到 Bean 对象的对应属性中，Spring Boot 框架从 Spring 框架中对 @Value 注解进行了默认继承，所以在 Spring Boot 框架中还可以使用该注解读取和注入配置文件属性值。使用@Value 注入属性的示例代码如下

@Component

public class Person {

@Value ( "${person.id}" )

private int id ;

}

上述代码中，使用 @Component 和 @Value 注入 Person 实体类的 id 属性。其中， @Value 不仅可以

将配置文件的属性注入 Person 的 id 属性，还可以直接给 id 属性赋值，这点是 @ConfifigurationProperties 不支持的

演示 @Value 注解读取并注入配置文件属性的使用 :

（ 1 ）在 com.lagou.pojo 包下新创建一个实体类 Student ，并使用 @Value 注解注入属性

@Component

public class Student {

@Value ( "${person.id}" )

private int id ;

@Value ( "${person.name}" )

private String name ; // 名称

// 省略 toString

}

Student 类使用 @Value 注解将配置文件的属性值读取和注入。

从上述示例代码可以看出，使用 @Value 注解方式需要对每一个属性注入设置，同时又免去了属性的 setXX()方法

（ 2 ）再次打开测试类进行测试

@Autowired

private Student student ;

@Test

public void studentTest () {

System . out . println ( student );

}

打印结果：

 

可以看出，测试方法 studentTest() 运行成功，同时正确打印出了 Student 实体类对象。需要说明的

是，本示例中只是使用 @Value 注解对实例中 Student 对象的普通类型属性进行了赋值演示，而 @Value 注解对于包含Map 集合、对象以及 YAML 文件格式的行内式写法的配置文件的属性注入都不支持，如果赋值会出现错误

1.7 自定义配置

spring Boot 免除了项目中大部分的手动配置，对于一些特定情况，我们可以通过修改全局配置文

件以适应具体生产环境，可以说，几乎所有的配置都可以写在 application.peroperties 文件中， Spring Boot会自动加载全局配置文件从而免除我们手动加载的烦恼。但是，如果我们自定义配置文件， Spring Boot是无法识别这些配置文件的，此时就需要我们手动加载。接下来，将针对 Spring Boot 的自定义配置文件及其加载方式进行讲解

1.7.1 使用@PropertySource加载配置文件

对于这种加载自定义配置文件的需求，可以使用 @PropertySource 注解结合 @Confifiguration 注解

配置类的方式来实现。 @PropertySource 注解用于指定自定义配置文件的具体位置和名称。同时，为了保证Spring Boot 能够扫描该注解，还需要类上添加 @Confifiguration 注解将实体类作为自定义配置类。

当然，如果需要将自定义配置文件中的属性值注入到对应类的属性中，可以使用

@ConfifigurationProperties 或者 @Value 注解进行属性值注入

演示：

（ 1 ）打开 Spring Boot 项目的 resources 目录，在项目的类路径下新建一个 test.properties 自定义配

置文件，在该配置文件中编写需要设置的配置属性

# 对实体类对象 MyProperties 进行属性配置

test.id = 110

test.name = test

（ 2 ）在 com.lagou.pojo 包下新创建一个配置类 MyProperties ，提供 test.properties 自定义配置文件

中对应的属性，并根据 @PropertySource 注解的使用进行相关配置

@Configuration // 自定义配置类

@PropertySource ( "classpath:test.properties" ) // 指定自定义配置文件位置和名称

@EnableConfigurationProperties ( MyProperties . class ) // 开启对应配置类的属性注入功

能

@ConfigurationProperties ( prefix = "test" ) // 指定配置文件注入属性前缀

public class MyProperties {

private int id ;

private String name ;

// 省略属性 getXX() 和 setXX() 方法

// 省略 toString() 方法

}

主要是一个自定义配置类，通过相关注解引入了自定义的配置文件，并完成了自定义属性值的注

入。针对示例中的几个注解，具体说明如下

• @Confifiguration注解表示当前类是一个自定义配置类，并添加为Spring容器的组件，这里也可以使用传统的@Component注解；
• @PropertySource("classpath:test.properties")注解指定了自定义配置文件的位置和名称，此示例 表示自定义配置文件为classpath类路径下的test.properties文件；
• @ConfifigurationProperties(prefifix = "test")注解将上述自定义配置文件test.properties中以test开头的属性值注入到该配置类属性中。
• 如果配置类上使用的是@Component注解而非@Confifiguration注解，那么 @EnableConfifigurationProperties注解还可以省略

（ 3 ）进行测试

@Autowired

private MyProperties myProperties ;

@Test

public void myPropertiesTest () {

System . out . println ( myProperties );

}

打印结果：

 

1.7.2 使用@Confifiguration编写自定义配置类

在 Spring Boot 框架中，推荐使用配置类的方式向容器中添加和配置组件

在 Spring Boot 框架中，通常使用 @Confifiguration 注解定义一个配置类， Spring Boot 会自动扫描和识别配置类，从而替换传统Spring 框架中的 XML 配置文件。

当定义一个配置类后，还需要在类中的方法上使用 @Bean 注解进行组件配置，将方法的返回对象注入到Spring容器中，并且组件名称默认使用的是方法名，当然也可以使用 @Bean 注解的 name 或 value 属性自定义组件的名称

演示：

（ 1 ）在项目下新建一个 com.lagou.confifig 包，并在该包下新创建一个类 MyService ，该类中不需要编写任何代码

public class MyService {

}

创建了一个空的 MyService 类，而该类目前没有添加任何配置和注解，因此还无法正常被 Spring Boot 扫描和识别

（ 2 ） 在项目的com.lagou.confifig 包下，新建一个类 MyConfifig ，并使用 @Confifiguration 注解将该类声明一个配置类，内容如下：

@Configuration // 定义该类是一个配置类

public class MyConfig {

@Bean // 将返回值对象作为组件添加到 Spring 容器中，该组件 id 默认为方法名

public MyService myService (){

return new MyService ();

}

}

MyConfifig 是 @Confifiguration 注解声明的配置类（类似于声明了一个 XML 配置文件），该配置类会被Spring Boot 自动扫描识别；使用 @Bean 注解的 myService() 方法，其返回值对象会作为组件添加到了Spring容器中（类似于 XML 配置文件中的标签配置），并且该组件的 id 默认是方法名 myService

（ 3）测试类

@Autowired

private ApplicationContext applicationContext ;

@Test

public void iocTest () {

System . out . println ( applicationContext . containsBean ( "myService" ));

}

上述代码中，先通过 @Autowired 注解引入了 Spring 容器实例 ApplicationContext ，然后在测试方法

iocTest() 中测试查看该容器中是否包括 id 为 myService 的组件。

执行测试方法 iocTest() ，查看控制台输出效果，结果如下：

 

从测试结果可以看出，测试方法 iocTest() 运行成功，显示运行结果为 true ，表示 Spirng 的 IOC 容器中也已经包含了id 为 myService 的实例对象组件，说明使用自定义配置类的形式完成了向 Spring 容器进行组件的添加和配置

1.8 随机数设置及参数间引用

在 Spring Boot 配置文件中设置属性时，除了可以像前面示例中显示的配置属性值外，还可以使用

随机值和参数间引用对属性值进行设置。下面，针对配置文件中这两种属性值的设置方式进行讲解

1.8.1随机值设置

在 Spring Boot 配置文件中，随机值设置使用到了 Spring Boot 内嵌的

RandomValuePropertySource 类，对一些隐秘属性值或者测试用例属性值进行随机值注入

随机值设置的语法格式为 ${random.xx} ， xx 表示需要指定生成的随机数类型和范围，它可以生成

随机的整数、 uuid 或字符串，示例代码如下

my.secret = ${random.value} // 配置随机值

my.number = ${random.int} // 配置随机整数

my.bignumber = ${random.long} // 配置随机 long 类型数

my.uuid = ${random.uuid} // 配置随机 uuid 类型数

my.number.less.than.ten = ${random.int(10)} // 配置小于 10 的随机整数

my.number.in.range = ${random.int[1024,65536]} // 配置范围在 [1024,65536] 之间的随机整数

上述代码中，使用 RandomValuePropertySource 类中 random 提供的随机数类型，分别展示了不

同类型随机值的设置示例

1.8.2参数间引用

在 Spring Boot 配置文件中，配置文件的属性值还可以进行参数间的引用，也就是在后一个配置的

属性值中直接引用先前已经定义过的属性，这样可以直接解析其中的属性值了。

使用参数间引用的好处就是，在多个具有相互关联的配置属性中，只需要对其中一处属性预先配置，其他地方都可以引用，省去了后续多处修改的麻烦

参数间引用的语法格式为 ${xx} ， xx 表示先前在配置文件中已经配置过的属性名，示例代码如下

app.name = MyApp

app.description = ${app.name} is a Spring Boot application

上述参数间引用设置示例中，先设置了 “app.name=MyApp” ，将 app.name 属性的属性值设置为了

MyApp ；接着，在 app.description 属性配置中，使用 ${app.name} 对前一个属性值进行了引用

接下来，通过一个案例来演示使用随机值设置以及参数间引用的方式进行属性设置的具体使用和

效果，具体步骤如下

（ 1 ）打开 Spring Boot 项目 resources 目录下的 application.properties 配置文件，在该配置文件中

分别通过随机值设置和参数间引用来配置两个测试属性，示例代码如下

# 随机值设置以及参数间引用配置

tom.age = ${random.int[10,20]}

tom.description = tom 的年龄可能是 ${tom.age}

在上述 application.properties 配置文件中，先使用随机值设置了 tom.age 属性的属性值，该属性

值设置在了 [10,20] 之间，随后使用参数间引用配置了 tom.description 属性

（ 2 ）打开 \ 项目的测试类，在该测试类中新增字符串类型的 description 属性，并将配置文件中的

tom.description 属性进行注入，然后新增一个测试方法进行输出测试，示例代码如下

@Value ( "${tom.description}" )

private String description ;

@Test

public void placeholderTest () {

System . out . println ( description );

}

上述代码中，通过 @Value("${tom.description}") 注解将配置文件中的 tom.description 属性值注入到了对应的description 属性中，在测试方法 placeholderTest() 中对该属性值进行了输出打印。

执行测试方法 placeholderTest() ，查看控制台输出效果

 

可以看出，测试方法 placeholderTest() 运行成功，并打印出了属性 description 的注入内容，该内

容与配置文件中配置的属性值保持一致。接着，重复执行测试方法 placeholderTest() ，查看控制台输出语句中显示的年龄就会在[10,20] 之间随机显示