SpringBoot笔记：简述与应用

SpringBoot文章目录

第一章：简述与应用
第二章：源码剖析—源码环境搭建与依赖管理
第三章：源码剖析—自动配置

---

---

前言

主要是一些SpringBoot的功能介绍
每天学习一点点

---

一、SpringBoot 主要特性

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

---

二、SpringBoot 案例实现

案例需求： 使用Spring Initializr方式构建SpringBoot项目，并请求Controller中的目标方法，将返回值响应到页面

1. 使用Spring Initializr方式构建SpringBoot项目

本质上说，Spring Initializr是一个Web应用，它提供了一个基本的项目结构，能够帮助我们快速构建一个基础的SpringBoot项目
Project SDK”用于设置创建项目使用的JDK版本，这里，使用之前初始化设置好的JDK版本即可；在“Choose Initializr Service URL（选择初始化服务地址）”下使用默认的初始化服务地址“https://start.spring.io”进行SpringBoot项目创建。
注意：使用快速方式创建SpringBoot项目时，所在主机须在联网状态下

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

使用Spring Initializr方式构建的SpringBoot项目会默认生成项目启动类、存放前端静态资源和页面的文件夹、编写项目配置的配置文件以及进行项目单元测试的测试类。

2. 创建Controller

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

@RestController //该注解为组合注解，等同于Spring中@Controller+@ResponseBody注解
public class DemoController { 
	@RequestMapping("/demo") 
	public String demo(){ 
 		return "hello springBoot"; 
 	} 
}

3. 运行项目

运行主程序启动类SpringbootDemoApplication，项目启动成功后，在控制台上会发现SpringBoot项目默认启动的端口号为8080，此时，可以在浏览器上访问“http://localhost:8080/hello”。

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

解决中文乱码

解决方法一：

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

解决方法二：

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

---

三、热部署

在开发项目过程中，当修改了某些代码后需要本地验证时，需要重启本地服务进行验证，启动这个项目，如果项目庞大的话还是需要较长时间的，spring开发团队带来了一个插件：spring-boot-devtools，很好的解决了本地验证缓慢的问题。

1. 热部署实现演示

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

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

<!-- 引入热部署依赖 --> 
<dependency> 
	<groupId>org.springframework.boot</groupId> 
	<artifactId>spring-boot-devtools</artifactId> 
</dependency>

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

1.2 IDEA工具热部署设置

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

选择Build下的Compiler选项，在右侧勾选“Build project automatically”选项将项目设置为自动编译，单击【OK】按钮保存设置。
在项目任意页面中使用组合快捷键“Ctrl+Shift+Alt+/”打开Maintenance选项框，选中并打开Registry页面，具体如图:
列表中找到“compiler.automake.allow.when.app.running”，将该选项后的Value值勾选，用于指定IDEA工具在程序运行过程中自动编译，最后单击【Close】按钮完成设置。

1.3 热部署效果测试

启动项目，访问地址

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

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

2. 热部署原理分析

原理就是在编辑器上启动项目，然后改动相关的代码，然后编辑器自动触发编译替换掉历史的.class文件后，项目检测到有文件变更后会重启srpring-boot项目。
官网的触发描述：
译文： 当DevTools监视类路径资源时，触发重新启动的唯一方法是更新类路径。更新类路径的方式取决于所使用的IDE。在Eclipse中，保存修改后的文件会更新类路径并触发重新启动。在Intelli理念中，构建项目(构建+构建项目)具有相同的效果。

可以看到，引入了插件后，插件会监控classpath的资源变化，当classpath有变化后，会触发重启。
译文： 重启和重新加载SpringBoot提供的重启技术通过使用两个类加载器来工作。没有更改的类(例如，来自第三方jar的类)被加载到基类加载器中。正在积极开发的类被加载到重新启动的类加载器中。当应用程序重新启动时，重新启动的类加载器将被丢弃，并创建一个新的类加载器。这种方法意味着应用程序重启通常比“冷启动”要快得多，因为基类加载器已经可用并填充了。
如果您发现重启对应用程序来说不够快，或者遇到了类加载问题，您可以考虑从ZeroTurnaround重新加载JRebel这样的技术。它们的工作原理是在加载类时重写类，使它们更易于重载。

这里提到了，该插件重启快速的原因：这里对类加载采用了两种类加载器，对于第三方jar包采用base-classloader来加载，对于开发人员自己开发的代码则使用restartClassLoader来进行加载，这使得比停掉服务重启要快的多，因为使用插件只是重启开发人员编写的代码部分。

简单的验证:

@Component
public class Devtools implements InitializingBean {
    private static final Logger log = LoggerFactory.getLogger(Devtools.class);

    @Override
    public void afterPropertiesSet() throws Exception {
        log.info("guava-jar classLoader: " + DispatcherServlet.class.getClassLoader().toString());
        log.info("Devtools ClassLoader: " + this.getClass().getClassLoader().toString());
    }
}

先去除spring-boot-devtools插件，跑下工程：

可以看到，DispatcherServlet（第三方jar包）和Devtools(自己编写的类)使用的都是AppClassLoader加载的。
然后再加上插件，然后执行下代码：
发现第三方的jar包的类加载器确实是使用的系统的类加载器，而自己写的代码的类加载器为RestartClassLoader，并且每次重启，类加载器的实例都会改变。

3. 排除资源

某些资源在更改后不一定需要触发重新启动。
例如，Thymeleaf模板可以就地编辑。默认情况下，改变资源 /META-INF/maven ， /META-INF/resources ， /resources ， /static ， /public ， 或 /templates 不触发重新启动，但确会触发现场重装。
如果要自定义这些排除项，则可以使用该spring.devtools.restart.exclude 属性。例如，仅排除 /static ， /public 设置以下属性：

spring.devtools.restart.exclude=static/**,public/**

---

四、全局配置文件

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

全局配置文件能够对一些默认配置值进行修改及自定义配置。
SpringBoot使用一个application.properties或者application.yaml的文件作为全局配置文件。
也可以从ConfigFileApplicationListener这类便可看出，其中DEFAULT_SEARCH_LOCATIONS属性设置了加载的目录：
翻译成文件系统：

–file:./config/ 
–file:./ 
–classpath:/config/ 
–classpath:/

翻译成语言如下（ 按照优先级从高到低的顺序 ）：

1. 先去项目根目录找config文件夹下找配置文件件
2. 再去根目录下找配置文件
3. 去resources下找cofnig文件夹下找配置文件
4. 去resources下找配置文件

SpringBoot会从这四个位置全部加载主配置文件，如果高优先级配置文件属性与低优先级配置文件不冲突的属性，会共同存在互补配置 。
这里说的配置文件，都还是项目里面。最终都会被打进jar包里面的，需要注意。
1、如果同一个目录下，有application.yml也有application.properties，默认先读取 application.properties。
2、如果同一个配置属性，在多个配置文件都配置了，默认使用第1个读取到的，后面读取的不覆盖前面读取到的。
3、创建SpringBoot项目时，一般的配置文件放置在“项目的resources目录下”。

如果配置文件名字不叫application.properties或者application.yml，可以通过以下参数来指定
配置文件的名字，myproject是配置文件名。

$ java -jar myproject.jar --spring.config.name=myproject

同时也可以指定其他位置的配置文件来生效，指定配置文件和默认加载的这些配置文件共同起作用形成互补配置。

java -jar run-0.0.1-SNAPSHOT.jar -- spring.config.location=D:/application.properties

版本变化：

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

spring.config.use-legacy-processing = true

2. application.properties配置文件

使用SpringInitializr方式构建SpringBoot项目时，会在resource目录下自动生成一个空的application.properties文件，SpringBoot项目启动时会自动加载application.properties文件。
可以在application.properties文件中定义SpringBoot项目的相关属性，当然，这些相关属性可以是系统属性、环境变量、命令参数等信息，也可以是自定义配置文件名称和位置。

server.port=8081 
spring.datasource.driver-class-name=com.mysql.jdbc.Driver 
spring.config.name=application

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

1. 创建两个实体类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;
    private String name; //名称
    private List hobby; //爱好 
    private String[] family; //家庭成员 
    private Map map;
    private Pet pet; //宠物 
// 省略属性getXX()和setXX()方法 
// 省略toString()方法
}

@ConfigurationProperties(prefix = “person”)注解的作用是将配置文件中以person开头的属性值通过setXX()方法注入到实体类对应属性中。
@Component注解的作用是将当前注入属性值的Person类对象作为Bean组件放到Spring容器中，只有这样才能被@ConfigurationProperties注解进行赋值。

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

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

3. application.yaml配置文件

YAML文件格式是SpringBoot支持的一种JSON超集文件格式，以数据为中心，比properties、xml等更适合做配置文件。

• yml和xml相比，少了一些结构化的代码，使数据更直接，一目了然
• 相比properties文件更简洁
• YAML文件的扩展名可以使用.yml或者.yaml。
• application.yml文件使用 “key:（空格）value”格式配置属性，使用缩进控制层级关系。

YAML不同数据类型的属性值：

#对实体类对象Person进行属性配置
person: 
	id: 1 
	name: lucy 
	hobby: [吃饭，睡觉，打豆豆] 
	family: [father,mother] 
	map: {k1: v1,k2: v2} 
	pet: {type: dog,name: 旺财}

执行测试

---

五、属性注入

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

1. 属性注入常用注解

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

2. @Value属性值注入

2.1 引入数据源连接依赖

<dependency> 
	<groupId>com.github.drtrang</groupId> 
	<artifactId>druid-spring-boot2-starter</artifactId> 
	<version>1.1.10</version> 
</dependency>

2.2 application.properties添加信息

jdbc.driverClassName=com.mysql.jdbc.Driver 
jdbc.url=jdbc:mysql://127.0.0.1:3306/springboot_h 
jdbc.username=root 
jdbc.password=root

2.3 配置数据源

创建JdbcConfiguration类： 使用spring中的value注解对每个属性进行注入,用bean注解将返回值添加到容器中。

@Configuration
public class JdbcConfiguration {
    @Value("${jdbc.url}")
    String url;
    @Value("${jdbc.driverClassName}")
    String driverClassName;
    @Value("${jdbc.username}")
    String username;
    @Value("${jdbc.password}")
    String password;

    @Bean
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(url);
        dataSource.setDriverClassName(driverClassName);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }
}

3. @ConfigurationProperties批量注入

新建 JdbcProperties ，用来进行属性注入：

@ConfigurationProperties(prefix = "jdbc") //这里需要定义出在application文件中定义属 性值得前缀信息
public class JdbcProperties {
    private String url;
    private String driverClassName;
    private String username;
    private String password; // 注：要生成属性的set方法
}

注：添加@ConfigurationProperties注解后有警告：springBoot 配置注释处理器未配置（编写配置文件此时无提示）

添加spring-boot-configuration-processor后出现提示，加完依赖后通过Ctrl+F9来使之生效

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

接着发现，仍然有红色警告

@EnableConfigurationProperties 是 SpringBoot 提供的一个注解，使用该注解用于启用应用对另外一个注解 @ConfigurationProperties 的支持，用于设置一组使用了注解@ConfigurationProperties 的类,用于作为 bean 定义注册到容器中。

4. 第三方配置

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

例如：
创建一个其他组件类

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

创建MyService

@Configuration
public class MyService {
    @ConfigurationProperties("another")
    @Bean
    public AnotherComponent anotherComponent() {
        return new AnotherComponent();
    }
}

配置文件

another.enabled=true 
another.remoteAddress=192.168.22.1

测试类

@Autowired
private AnotherComponent anotherComponent;

@Test
public void myServiceTest() {
	System.out.println(anotherComponent);
}

测试可以获得AnotherComponent组件的实例对象。

5. 松散绑定

SpringBoot使用一些宽松的规则将环境属性绑定到@ConfigurationProperties bean，因此环境属性名和bean属性名之间不需要完全匹配。
例如：

@Data
@Component
@ConfigurationProperties("acme.my-person.person")
public class OwnerProperties {
    private String firstName;
}

acme: 
	my-person: 
		person: 
			first-name: 泰森

属性文件中配置	说明
acme.my-project.person.first-name	羊肉串模式case, 推荐使用
acme.myProject.person.firstName	标准驼峰模式
acme.my_project.person.first_name	下划线模式
ACME_MYPROJECT_PERSON_FIRSTNAME	大写下划线，如果使用系统环境时候推荐使用

6. @ConfigurationProperties vs @Value

特征	@ConfigurationProperties	@Value
宽松的绑定	yes	Limited（详见下方官网截图）
元数据支持	yes	no
SpEL 表达式	no	yes
应用场景	批量属性绑定	单个属性绑定

可以用翻译软件翻译一下。

---

六、SpringBoot日志框架

1. 日志框架介绍

在项目的开发中，日志是必不可少的一个记录事件的组件，不管是记录运行情况还是追踪线上问题，都离不开对日志的分析，所以也会相应的在项目中实现和构建所需要的日志框架。
市面上常见的日志框架有很多，比如：JCL、SLF4J、Jboss-logging、jUL、log4j、log4j2、logback等等，通常情况下，日志是由一个抽象层+实现层的组合来搭建的。

日志-抽象层	日志-实现层
JCL（Jakarta Commons Logging）、SLF4J（Simple LoggingFacade for Java）、jboss-logging	jul（java.util.logging）、log4j、logback、log4j2

Spring 框架选择使用了 JCL 作为默认日志输出。而 SpringBoot 默认选择了 SLF4J 结合 LogBack。

2. SLF4J 的使用

在开发的时候不应该直接使用日志实现类，应该使用日志的抽象层。具体参考 SLF4J 官方。
SLF4J 官方给出了简单示例。
首先要为系统导入 SLF4J 的 jar。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class HelloWorld {
    public static void main(String[] args) {
        elloWorld.class);
        logger.info("Hello World");
    }
}

下图是 SLF4J 结合各种日志框架的官方示例，从图中可以清晰的看出 SLF4J API 永远作为日志的门面，直接应用与应用程序中。
注意: 由于每一个日志的实现框架都有自己的配置文件，所以在使用 SLF4j 之后，配置文件还是要使用实现日志框架的配置文件。

3. 统一日志框架的使用

遗留问题：A项目（slf4J + logback）: Spring（commons logging）、Hibernate（jboss-logging）、mybatis…
一般情况下，在项目中存在着各种不同的第三方 jar ，且它们的日志选择也可能不尽相同，显然这样是不利于使用的，所以需要为项目设置统一的日志框架该，在 SLF4J 官方也给了参考的例子。
从图中可以得到一种统一日志框架使用的方式，可以使用一种和要替换的日志框架类完全一样的 jar 进行替换，这样不至于原来的第三方 jar 报错，而这个替换的 jar 其实使用了 SLF4J API. 这样项目中的日志就都可以通过 SLF4J API 结合自己选择的框架进行日志输出。
统一日志框架使用步骤归纳如下：

1. 排除系统中的其他日志框架。
2. 使用中间包替换要替换的日志框架。
3. 导入选择的 SLF4J 实现。

4. SpringBoot 的日志关系

4.1 排除其他日志框架

在 Spring Boot 的 Maven 依赖里可以清楚的看到 Spring Boot 排除了其他日志框架。
自行排除依赖时按照图中的方式进行排除。

4.2 统一框架引入替换包

SpringBoot 是使用了 SLF4J+logback 的日志框架组合，查看 SpringBoot 项目的 Maven 依赖关系可以看到 SpringBoot 的核心启动器 spring-boot-starter 引入了 spring-boot-starter-logging。

<dependency> 
	<groupId>org.springframework.boot</groupId> 
	<artifactId>spring-boot-starter-logging</artifactId> 
	<version>2.4.0.RELEASE</version> 
</dependency>

而 spring-boot-starter-logging 的 Maven 依赖主要引入了 logback-classic (包含了日志框架 Logback的实现)，log4j-to-slf4j (在 log4j 日志框架作者开发此框架的时候还没有想到使用日志抽象层进行开发，因此出现了 log4j 向 slf4j 转换的工具)，jul-to-slf4j ( Java 自带的日志框架转换为 slf4j)。

<dependencies> 
	<dependency> 
		<groupId>ch.qos.logback</groupId> 
		<artifactId>logback-classic</artifactId> 
		<version>1.2.3</version> 
		<scope>compile</scope> 
	</dependency> 
	<dependency> 
		<groupId>org.apache.logging.log4j</groupId> 
		<artifactId>log4j-to-slf4j</artifactId> 
		<version>2.13.3</version> 
		<scope>compile</scope> 
	</dependency>
	<dependency> 
		<groupId>org.slf4j</groupId> 
		<artifactId>jul-to-slf4j</artifactId> 
		<version>1.7.30</version> 
		<scope>compile</scope>
	</dependency> 
</dependencies>

使用 IDEA 工具查看 Maven 依赖关系，可以清晰的看到日志框架的引用。

由此可见，Spring Boot 可以自动的适配日志框架，而且底层使用 SLF4j + LogBack 记录日志，如果自行引入其他框架，需要排除其日志框架。

5. SpringBoot 的日志使用

日志级别和格式
Spring Boot 默认已经使用了 SLF4J + LogBack . 不进行任何额外操作的情况下就可以使用 SLF4J + Logback 进行日志输出。
编写 Java 测试类进行测试。

import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

/*** 测试日志输出， * SLF4J 日志级别从小到大trace,debug,info,warn,error **/
@RunWith(SpringRunner.class)
@SpringBootTest
public class LogbackTest {
    Logger logger = LoggerFactory.getLogger(getClass());

    @Test
    public void testLog() {
        logger.trace("Trace 日志...");
        logger.debug("Debug 日志...");
        logger.info("Info 日志...");
        logger.warn("Warn 日志...");
        logger.error("Error 日志...");
    }
}

已知日志级别从小到大为 trace < debug < info < warn < error . 运行得到输出如下。由此可见 SpringBoot 默认日志级别为 INFO.

2021-04-20 09:29:34.845 INFO 39940 --- [ main] com.lagou.LogbackTest : Info 日志... 
2021-04-20 09:29:34.845 WARN 39940 --- [ main] com.lagou.LogbackTest : Warn 日志... 
2021-04-20 09:29:34.845 ERROR 39940 --- [ main] com.lagou.LogbackTest : Error 日志...

从上面的日志结合 Logback 日志格式可以知道 Spring Boot 默认日志格式是

%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n 
# %d{yyyy-MM-dd HH:mm:ss.SSS} 时间 
# %thread 线程名称 
# %-5level 日志级别从左显示5个字符宽度 
# %logger{50} 类名 
# %msg%n 日志信息加换行

6. 自定义日志输出

直接在配置文件编写日志相关配置

# 日志配置 # 指定具体包的日志级别 
logging.level.com.lagou=debug 
# 控制台和日志文件输出格式 
logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n 
logging.pattern.file=%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n 
# 日志输出路径，默认文件spring.log 
logging.file.path=spring.log 
#logging.file.name=log.log

日志的输出路径，可以使用 logging.file 或者 logging.path 进行定义，两者存在关系如下:

logging.file	logging.path	例子	描述
（没有）	（没有）		仅控制台记录。
元数据支持	（没有）	my.log	写入指定的日志文件，名称可以是精确位置或相对于当前目录。
（没有）	具体目录	/var/log	写入 spring.log 指定的目录，名称可以是精确位置或相对于当前目录。

7. 替换日志框架

因为 Log4j 日志框架已经年久失修，原作者都觉得写的不好，所以演示替换日志框架为 Log4j2 的方式。根据官网 Log4j2 与 logging 需要二选一，因此修改 pom如下

<dependency> 
	<groupId>org.springframework.boot</groupId> 
	<artifactId>spring-boot-starter-web</artifactId> 
	<exclusions> 
		<exclusion>
			<artifactId>spring-boot-starter-logging</artifactId> 
			<groupId>org.springframework.boot</groupId> 
		</exclusion> 
	</exclusions> 
</dependency> 
<dependency> 
	<groupId>org.springframework.boot</groupId> 
	<artifactId>spring-boot-starter-log4j2</artifactId> 
</dependency>