SpringBoot基础回顾

1.1约定优于配置

Spring Boot是基于Spring开发的项目的起点。SpringBoot的设计是为了尽可能快的跑起来，Spring应用程序并且尽可能减少配置文件。（因为它是遵循约定开发的）
约定优于配置(Convention over Configuration) ， 又称按约定编程，是一种软件设计范式。
本质上是说，系统、类库或框架应该假定合理的默认值，而非要求提供不必要的配置。比如说模型中有一个名为User的类， 那么数据库中对应的表就会默认命名为usser。只有在偏离这一个约定的时候， 例如想要将该表命名为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配置。Spring2.5引入了基于注解的组件扫描， 这消除了大量针对应用程序自身组件的显式XML配置。Spring3.0引入了基于Java的配置， 这是一种类型安全的可重构配置方式，可以代替XML。
所有这些配置都代表了开发时的损耗。因为在思考Spring特性配置和解决业务问题之间需要进行思维切换， 所以编写配置挤占了编写应用程序逻辑的时间。和所有框架一样， Spring实用， 但与此同时它要求的回报也不少。
除此之外，项目的依赖管理也是一件耗时耗力的事情。在环境搭建时，需要分析要导入哪些库的坐标，而且还需要分析导入与之有依赖关系的其他库的坐标，一旦选错了依赖的版本，随之而来的不兼容问题就会严重阻碍项目的开发进度
（1、配置繁琐，2、依赖管理也耗时耗力）

1.2.2 SpringBoot解决spring的上述问题

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

1、起步依赖

起步依赖本质上是一个Maven项目对象模型(Project Object Mode，POM)，定义了对其他库的传递依赖，这些东西加在一起即支持某项功能。（解决了依赖版本管理）
简单的说，起步依赖就是将具备某种功能的坐标打包到一起，并提供一些默认的功能。

2、自动配置

spring boot的自动配置，指的是spring boot，会自动将一些配置类的bean注册进ioc容器， 我们可以需要的地方使用@autowired或者@resource等注解来使用它。
“自动”的表现形式就是我们只需要引我们想用功能的包， 相关的配置我们完全不用管， spring boot会自动注入这些配置bean， 我们直接使用这些bean即可（解决了配置繁琐的问题）
spring boot：简单、快速、方便地搭建项目； 对主流开发框架的无配置集成； 极大提高了开发、部署效率

1.2.3 SpringBoot主要特性

1、 SpringBoot Starter：他将常用的依赖分组进行了整合，将其合并到一个依赖中，这样就可以一次 性添加到项目的Maven或Gradle构建中；
2、 使编码变得简单，SpringBoot采用 JavaConfig的方式对Spring进行配置，并且提供了大量的注解， 极大的提高了工作效率。
3、 自动配置：SpringBoot的自动配置特性利用了Spring对条件化配置的支持，合理地推测应用所需的 bean并自动化配置他们；
4、 使部署变得简单，SpringBoot内置了三种Servlet容器，Tomcat，Jetty,undertow.我们只需要一个 Java的运行环境就可以跑SpringBoot的项目了，SpringBoot的项目可以打成一个jar包。

1.3 Spring Boot案例实现

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

1.3.1 使用Spring Initializr方式构建Spring Boot项目

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

Spring Boot的项目就创建好了，创建好的Spring Boot项目的结构图如下

1.3.2 创建一个用于Web访问的Controller

将com.shanglin包下创建名称为controller的包， 在该包下创建一个请求处理控制类HelloController， 并编写一个请求处理方法( 注意：将项目启动类SpringBootDemoApplication移动到com.shanglin包下)

@RestController //该注解为组合注解， 等同于Spring中@controller+@ResponseBody注解
public class HelloController {
    //添加一个方法,添加映射
    @RequestMapping("/demo")
    public  String demo(){
        return "你好, Spring Boot";
    }
}

要使注解生效的话，必然要进行扫描。

因为项目启动后，会扫描注解，也就是会扫描主程序所在的包及其子包。
所以将主程序文件移动过去便于扫描。

如下图所示，会扫描com.shanglin的包及其子包

然后就是直接启动，SpringBoot会启动一个内置的Tomcat。

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

1.3.3 如果出现乱码

解决中文乱码： 解决方法一：

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

解决方法二：

#设置响应为utf-8
spring.http.encoding.force-response=true

1.3.4 疑问

1. starter是什么？我们如何去使用这些starter？
   2. 为什么包扫描只会扫描核心启动类所在的包及其子包
   3. 在springBoot启动的过程中，是如何完成自动装配的？
   4. 内嵌Tomcat是如何被创建及启动的？
   5. 使用了web场景对应的starter，springmvc是如何自动装配？
   （保留疑问：在源码剖析部分，主要将以上疑问进行解答）

1.4单元测试与热部署

1.4.1 单元测试

开发中，每当完成一个功能接口或业务方法的编写后，通常都会借助单元测试验证该功能是否正确。
Spring Boot对项目的单元测试时， 需要提前在项目的pom.xml文件中添加 spring-boot-starter-test测试依赖启动器， 可以通过相关注解实现单元测试。

1、添加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 {
    // 要调用写好的HelloController方法，就需要先将这个类注入进来
    @Autowired
    private HelloController helloController;
    @Test
    void contextLoads() {
    // 自动注入之后呢，就可以进行调用了
        String demo = helloController.demo();
        System.out.println(demo);
    }
}

3、测试结果如下

1.4.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>

2、IDEA工具热部署设置

由于使用IDEA开发工具， 添加热部署依赖后可能没有任何效果， 接下来还需要针对IDEA开发工具进行热部署相关的功能设置。
选择IDEA工具界面的【File】【Settings】选项， 打开Compiler面板设置页面

在项目任意页面中按快捷键”Ctrl+Shift+Alt+/“打开Maintenance选项框，
选中并打开Registry页面，如图所示

列表中找到compiler.automake.allow.when.app.running“，
将该选项后的Value值勾选， 用于指定IDEA工具在程序运行过程中自动编译，
最后单击【Close】按钮完成设置

3、热部署效果测试

访问后。页面原始输出的内容是”hello Spring Boot”。

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

到此，说明热部署的配置成功。

1.5 全局配置文件

全局配置文件能够对一些默认配置值进行修改。Spring Boot使用一个application.properties或者application.yaml的文件作为全局配置文件（支持这两种配置文件格式）， 该文件存放在src/main/resource目录或者类路径的/config， 一般会选择resource目录。
接下来， 将针对这两种全局配置文件进行解析：

1.5.1 全局配置文件概述及优先级

全局配置文件能够对一些默认配置值进行修改及自定义配置。 Spring Boot使用一个application.properties或者application.yaml的文件作为全局配置文件

也可以从ConfigFileApplicationListener这类便可看出，其中DEFAULT_SEARCH_LOCATIONS属性设置 了加载的目录：

知识点补充！

Spring Boot 2.4 改进了处理 application.properties 和 application.yml 配置文件的方式， 如果是2.4.0之前版本，优先级properties>yaml 但是如果是2.4.0的版本，优先级yaml>properties 如果想继续使用 Spring Boot 2.3 的配置逻辑，也可以通过在 application.properties 或者 application.yml 配置文件中添加以下参数：

spring.config.use-legacy-processing = true

1.5.2 application.properties配置文件

a、对默认属性的修改

使用Spring Initializr方式构建Spring Boot项目时， 会在resource目录下自动生成一个空的application.properties文件， Spring Boot项目启动时会自动加载application.properties文件。

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

server.port=8081   ##项目默认的访问端口是8080，现在修改默认配置改为8081
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.config.additional-location=
spring.config.location=
spring.config.name=application

直接从项目启动类的main方法进行启动，SpringBoot启动后，会对application.properties进行加载，并且将端口改为8081

b、对自定义的属性配置

下面通过一个案例对Spring Boot项目中application.properties配置文件的自定义属性配置的具体使用，进行演示：
先准备了两个实体类文件， 然后
将application.properties配置文件中的自定义配置属性注入到Person实体类的对应属性中

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

public class Pet {
    private String type;//类型
    private String name;// 名字
   // 省略get set方法，还有toString
}

@Component // 将当前已经注入属性值的Person类对象，作为Bean组件放到Spring容器中
public class Person {
    private int id;  // id
    private String name; // 名称
    private List hobby;  // 爱好
    private String[] family; // 家庭成员
    private Map map;  // map集合
    private Pet pet;  // 宠物
    // 省略了get 和set 方法，还有toString
}

要将Person打印出来，得先将Person存到容器中。那么如何把Person生成的实例存到容器中呢？就需要添加@Component注解

因为：
@ConfigurationProperties(prefix=”person”) 注解的作用是将配置文件中以person开头的属性值通过setXX() 方法注入到实体类对应属性中

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

（首先作为一个bean对象放入到容器，但是还是空对象，属性是没值，然后再通过setXXX的方式注入配置的属性）

(2) 打开项目的resources目录下的application.properties配置文件，
在该文件中编写Person类的配置属性

a、添加提示依赖

@Component // 将当前已经注入属性值的Person类对象作为Bean组件放到Spring容器中
@ConfigurationProperties(prefix = "person") 
// 1、是提示功能，2、是将配置文件中以person开头的属性注入到该实体类中
public class Person {
...
}

在编写application.properties配置文件时， 由于要配置的Person对象属性是我们自定义的， Spring Boot无法自动识别，所以不会有任何书写提示。在实际开发中，为了能出现代码提示的效果来方便配置，在使用@ConfigurationProperties注解进行配置文件属性值注入时， 可以在pom.xml文件中添加一个SpringBoot提供的配置处理器依赖：

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-configuration-processor</artifactId>
 <optional>true</optional>
</dependency

在pom.xml中添加上述配置依赖后， 还需重新运行项目启动类或者使用”Ctrl+F 9”快捷键(即BuildProject) 重构当前Spring Boot项目方可生效。

b、添加自定义属性配置

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

@RunWith(SpringRunner.class) // 测试启动器，并加载Spring Boot测试注解
@SpringBootTest // 标记为Spring Boot单元测试类，并加载项目的ApplicationContext上下文
环境
class SpringbootDemoApplicationTests {
    // 要将某个对象打印出来，需要先将对象通过Autowired注解注入进来
    @Autowired
    private Person person;
    @Test
    void configrationTest() {
        // 自动注入之后呢，就可以进行调用了
        System.out.println(person);
    }
}

下面已经成功打印出来了，虽然出现了乱码。但不影响输出

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

1.5.3 application.yaml配置文件

yaml文件格式是Spring Boot支持的一种json超集文件格式，相较于传统的Properties配置文件，yaml文件以数据为核心，是一种更为直观且容易被电脑识别的数据序列化格式。application.yaml配置文件的工作原理和application.properties是一样的，只不过yaml格式配置文件看起来更简洁一些。

1. yaml文件的扩展名可以使用.yml或者.yaml。
2. application.yml文件使用 “key：(空格) value” 格式配置属性，使用缩进控制层级关系。

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

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

当yaml配置文件中，配置的属性值为普通数据类型时，可以直接配置对应的属性值（如 port: 8080），同时对于字符串类型的属性值，不需要额外添加引号，示例代码如下

server:
  port: 8081  // 先加一个缩进，表示port是server的下一层级。后面再跟值
  path: /hello

上述代码用于配置server的port和path属性，*（保持相同的缩进） port和path属于一个级别

(2) value值为数组和单列集合

当yaml配置文件中配置的属性值为数组或单列集合类型时(用中括号)， 主要有两种书写方式：缩进式写法和行内式写法。
其中，缩进式写法还有两种表示形式，示例代码如下。只写行内式
下面的行内式包含属性值的中括号”[]”还可以进一步省略，在进行属性赋值时，程序会自动匹配和校对。

person:
 hobby: [play,read,sleep]

(3) value值为Map集合和对象

当yaml配置文件中配置的属性值为Map集合或对象类型时（用大括号）， yaml配置文件格式同样可以分为两种书写
方式：缩进式写法和行内式写法。下面只写行内式

person:
 map: {k1: v1,k2: v2}

缩进表示层级关系、普通的直接配置属性，数组型的用[] ，Map型的用 {}

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

(1) 在项目的resources目录下， 新建一个application.yaml配置文件

(2) 在配置文件中编写为Person类设置的配置属性

需要说明的是， 本次使用application.yaml配置文件进行测试时，需要提前将application.properties配置文件中编写的配置进行注释掉， 这是因为application.properties配置文件会覆盖application.yaml配置文件它们的执行顺序通过源码可以晓得：打开pom.xml文件，找到spring-boot-starter-parent点击进去

1.6配置文件属性值的注入

使用Spring Boot全局配置文件设置属性时：
1、如果配置属性是Spring Boot已有属性， 例如服务端口server.port， 那么Spring Boot内部会自动扫描并读取这些配置文件中的属性值并覆盖默认属性。
2、如果配置的属性是用户自定义属性， 例如刚刚自定义的Person实体类属性， 还必须在程序中注入这些配置属性方可生效。
Spring Boot支持多种注入配置文件属性的方式，

1.6.1 属性注入常用注解

@Configuration：声明一个类作为配置类
@Bean：声明在方法上，将方法的返回值加入Bean容器
@Value：属性注入
@ConfigurationProperties(prefix = “jdbc”)：批量属性注入
@PropertySource(“classpath:/jdbc.properties”)指定外部属性文件。在类上添加

下面介绍如何使用注解注入属性

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属性赋值， 这点是@ConfigurationProperties不支持的。

演示@Value注解读取并注入配置文件属性的使用：
(1) 在com.shanglin.pojo包下新创建一个实体类Student， 并使用@Value注解注入属性。
使用@Value的时候，就不需要生成其属性的set方法。要用到{} 。

@Component // 用来生成实例放到容器中进行管理
public class Student {
 @Value("${person.id}")
 private int id;
 @Value("${person.name}")
 private String name; //ݷᑍ
 //省略toString
 }

Student类使用@Value注解将配置文件的属性值读取和注入。
从上述示例代码可以看出，
使用@Value注解方式需要对每一个属性注入设置， 同时又免去了属性的setXX() 方法

(2)再次打开测试类进行测试

    // 要将某个对象打印出来，需要先将对象通过Autowired注解注入进来
    @Autowired
    private Student student;
    @Test
    void studentTest() {
        // 自动注入之后呢，就可以进行调用了
        System.out.println(student);
    }

1.6.3使用@ConfigurationProperties注入属性（属于批量注入）

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

@Component
@ConfigurationProperties(prefix = "person") 
// 1、是提示功能，2、是将配置文件中以person开头的属性注入到该类中
public class Person {
 private int id; 
 // 属性的set方法
 public void setId(int id) {
 this.id = id;
 }

然后将配置文件里面的值，批量的注入给实体类Person里面的这些属性，其注入使用到属性的setXX()方法。
上述代码使用@Component和@ConfigurationProperties(prefix=“person”) 将配置文件中的每个属性映射到person类组件中。
需要注意的是， 使用@ConfigurationProperties使用到setXX()方法。

1.6.4 第三方配置

除了 @ConfigurationProperties 用于注释类之外，您还可以在公共 @Bean 方法上使用它。当要将属 性绑定到控件之外的第三方组件时，这样做特别有用。

@Data
public class AnotherComponent {
  private boolean enabled;
  private InetAddress remoteAddress;
}

1.7自定义配置

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

1.7.1使用@PropertySource加载配置文件

对于加载自定义配置文件的需求， 可以用@PropertySource注解结合@Configuration注解配置类的方式来实现。
@PropertySource注解用于指定自定义配置文件的具体位置和名称。同时，为了保证Spring Boot能够扫描该注解， 还需要类上添加@Configuration注解，将实体类作为自定义配置类。
当然，如果需要将自定义配置文件中的属性值注入到对应类的属性中，可以使用@ConfigurationProperties或者@Value注解进行属性值注入。

演示如下：

(1) 打开Spring Boot项目的resources目录， 在项目的类路径下新建一个test.properties自定义配置文件，在该配置文件中编写需要设置的配置属性

#对实体类对象MyProperties进行属性配置
test.id= 110
test.name=test

(2)
A、在com.shanglin.pojo包下新创建一个配置类MyProperties
B、用@ConfigurationProperties(prefix=”test”)获取test.properties自定义配置文件中对应的属性
C、并根据@PropertySource注解的使用进行相关配置
主要是一个自定义配置类，通过相关注解引入了自定义的配置文件，并完成了自定义属性值的注入。

@Component
@PropertySource("classpath:test.properties")// 手动的将自定配置文件的名字及位置进行配置
@ConfigurationProperties(prefix = "test")
public class Myproperties {
    private int id;
    private String name;
// 省略get set toString方法
}

针对示例中的几个注解，具体说明如下
@Configuration注解表示当前类是一个自定义配置类， 并添加为Spring容器的组件， 这里也可以使用传统的@Component注解；
@PropertySource(“classpath：test.properties”) 注解指定了自定义配置文件的位置和名称， 此示例表示自定义配置文件为classpath类路径下的test.properties文件；
@ConfigurationProperties(prefix=”test”) 注解将上述自定义配置文件test.properties中以test开头的属性值注入到该配置类属性中。
如果配置类上使用的是@Component注解而非@Configuration注解， 那么@EnableConfigurationProperties注解还可以省略

(3)进行测试

 // 要将某个对象打印出来，需要先将对象通过Autowired注解注入进来
    @Autowired
    private Myproperties myproperties;
    @Test
    void mypropertiesTest() {
        // 自动注入之后呢，就可以进行调用了
        System.out.println(myproperties);
    }

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

在Spring Boot框架中， 推荐使用配置类的方式向容器中添加和配置组件
在Spring Boot框架中， 通常使用@Configuration注解定义一个配置类， Spring Boot会自动扫描和识别配置类， 从而替换传统Spring框架中的XML配置文件。
当定义一个配置类后， 还需要在类中的方法上使用@Bean注解进行组件配置， 将方法的返回对象注入到Spring容器中， 并且组件名称默认使用的是方法名， 当然也可以使用@Bean注解的name或value属性自定义组件的名称
演示：

(1) 在项目下新建一个com.shanglin.config包， 并在该包下新创建一个类MyService， 该类中不需要编写任何代码

使用@Configuration注解将该类声明一个配置类，该类就能正常被Spring Boot扫描和识别

2、下面是实现通过MyConfig这个配置类将Myservice生成的实例存到容器中

@Configuration // 标明该类为配置类
public class MyConfig {
    // 需要MyConfig配置类加载的时候自动的调用myService这个方法。从而将返回的实例存到容器中
    // 需要借助@Bean, 将返回值对象作为组件添加到Spring容器中，标识id默认是方法名myService
    // 如果不想用该方法名，就需要自定义一个如：   @Bean(name="iservice")  就是iservice了
    @Bean(name="iservice")
    public  MyService myService()
    {
        return  new MyService();
    }
}

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

3、测试

    // 要将某个对象打印出来，需要先将对象通过Autowired注解注入进来
    @Autowired
    private ApplicationContext applicationContext; // 这是一个容器对象
    @Test
    void iocTest() {
        // 自动注入之后呢，就可以进行调用了
        System.out.println(applicationContext.containsBean("iservice "));
    }
}

打印结果是true，则说明自定义配置类已经成功，如果是false则不成功。

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

在Spring Boot配置文件中设置属性时， 除了可以像前面示例中显示的配置属性值外， 还可以使用随机值和参数间引用对属性值进行设置。下面，针对配置文件中这两种属性值的设置方式进行讲解

1.8.1随机值设置

在Spring Boot配置文件中， 随机值设置使用到了Spring Boot内嵌的RandomValuePropertySource类，对一些隐秘属性值或者测试用例属性值进行随机值注入。随机值设置的语法格式为${random.xx} ， xx表示需要指定生成的随机数类型和范围， 它可以生成随机的整数、uuid或字符串， 示例代码如下。

1.8.2参数间引用

在Spring Boot配置文件中， 配置文件的属性值还可以进行参数间的引用， 也就是在后一个配置的属性值中直接引用先前已经定义过的属性，这样可以直接解析其中的属性值了。使用参数间引用的好处就是，在多个具有相互关联的配置属性中，只需要对其中一处属性预先配置，其他地方都可以引用，省去了后续多处修改的麻烦。参数间引用的语法格式为${xx}，xx表示先前在配置文件中已经配置过的属性名，示例代码如下

上述参数间引用设置示例中
1、先设置了”app.name=MyApp”， 将app.name属性的属性值设置为了MyApp；
2、在app.description属性配置中， 使用${app.name} 对前一个属性值进行了引用。
接下来通过一个案例来演示使用随机值设置以及参数间引用的方式进行属性设置的具体使用和效果。
具体步骤如下

(1) 打开Spring Boot项目resources目录下的application.properties配置文件， 在该配置文件中分别通过随机值设置和参数间引用来配置两个测试属性，示例代码如下

(2) 测试

   // 设置一个属性，然后用@Value将{tom.description的值注入进来。
    @Value("${tom.description}")
    private String description;
    @Test
    void descTest(){
        System.out.println(description);
    }

1.9 SpringBoot日志框架

1.9.1 日志框架介绍