SpringBoot

什么是Spring Boot？为什么要学Spring Boot？

Spring 的诞生是为了简化 Java 程序的开发的，而 Spring Boot 的诞生是为了简化 Spring 程序开发的。每次技术的诞生改进相比于之前的效率会有⼀个质的提升，而Spring Boot 相比于Spring 也是如此。

Spring Boot 优点

1.快速集成框架，Spring Boot 提供了启动添加依赖的功能，用于秒级集成各种框架。
2.内置运行容器，无需配置 Tomcat 等 Web 容器，直接运行和部署程序。
3.快速部署项目，无需外部容器即可启动并运行项目。
4.可以完全抛弃繁琐的 XML，使用注解和配置的方式进行开发。
5.支持更多的监控的指标，可以更好的了解项目的运行情况。

配置文件

1.配置文件作用

整个项目中所有重要的数据都是在配置文件中配置的，比如：
数据库的连接信息（包含用户名和密码的设置）；
项目的启动端口；
第三方系统的调用秘钥等信息；
用于发现和定位问题的普通日志和异常日志等。
想象⼀下如果没有配置信息，那么 Spring Boot 项目就不能连接和操作数据库，甚至是不能保存可以用于排查问题的关键日志，所以配置文件的作用是非常重要的

2.配置文件的格式

Spring Boot 配置文件主要分为以下两种格式：
properties
yml

这就好像连锁店里面的统⼀服装⼀样，有两种不同的款式，properties 类型的配置文件就属于老款“服饰”，也是创建 Spring Boot 项目时默认的文件格式，而yml 属于新版款式
特殊说明

1. 理论上讲 properties 可以和 yml ⼀起存在于⼀个项目当中，当 properties 和 yml ⼀起存在⼀个项目中时，如果配置文件中出现了同样的配置，比如 properties 和 yml 中都配置了“server.port”，那么这个时候会以 properties 中的配置为主，也就是 .properties 配置文件的优先级最高，但加载完 .properties 文件之后，也会加载 .yml 文件的配置信息。
2. 虽然理论上来讲 .properties 可以和 .yml 共存，但实际的业务当中，我们通常会采取⼀种统⼀的配置文件格式，这样可以更好的维护（降低故障率）。

3.properties 配置文件说明

properties 配置文件是最早期的配置文件格式，也是创建 Spring Boot 项目默认的配置文件

3.1 properties 基本语法

properties 是以键值的形式配置的，key 和 value 之间是以“=”连接的

# 配置项⽬端⼝号
server.port=8084
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/testdb?characterEncoding=
utf8
spring.datasource.username=root
spring.datasource.password=root
1
2
3
4
5
6

PS：小技巧：配置文件中使用“#”来添加注释信息

3.2 读取配置文件

如果在项目中，想要主动的读取配置文件中的内容，可以使用 @Value 注解来实现。
@Value 注解使用“${}”的格式读取，如下代码所示：

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
@Component
public class ReadYml {
 @Value("${server.port}")
 private String port;
 @PostConstruct
 public void postConstruct() {
 System.out.println("Read YML,port:" + port);
 }
}
1
2
3
4
5
6
7
8
9
10
11
12

@Component 在 Spring Boot 启动时候会注入到框架中，注入到框架中时会执行 @PostConstruc，初始化方法，这个时候就能读取到配置信息了。

3.3 properties 缺点分析

properties 配置是以 key-value 的形式配置的，如下图所示：
从上述配置key看出，properties 配置文件中会有很多的冗余的信息，比如这些：

想要解决这个问题，就可以使⽤ yml 配置文件的格式化了

4.yml 配置文件说明

yml 是 YAML 是缩写，它的全称 Yet Another Markup Language 翻译成中文就是“另⼀种标记语言”。
yml 优点分析
1.yml 是⼀个可读性高，写法简单、易于理解，它的语法和 JSON 语言类似。
2.yml 支持更多的数据类型，它可以简单表达清单（数组）、散列表，标量等数据形态。它使用空白符号缩进和大量依赖外观的特色，特别适合用来表达或编辑数据结构、各种配置文件等。
3.yml 支持更多的编程语言，它不止是 Java 中，还可以使用在Golang、PHP、Python、Ruby、JavaScript、Perl 中

4.1 yml 基本语法

yml 是树形结构的配置文件，它的基础语法是“key: value”，注意 key 和 value 之间使用英文冒汗加空格的方式组成的，其中的空格不可省略。
基础语法如下：

其中第一项的配置为正确的，key 也是高亮显示的，而第二项没有空格是错误的使用方式，第二项的key 也没有高亮显示。
使用 yml 连接数据库

spring:
 datasource:
 url: jdbc:mysql://127.0.0.0:3306/dbname?characterEncoding=utf8
 username: root
 password: root
1
2
3
4
5

4.2 yml 使用进阶

4.2.1 yml 配置不同数据类型及 null

# 字符串
string.value: Hello
# 布尔值，true或false
boolean.value: true
boolean.value1: false
# 整数
int.value: 10
int.value1: 0b1010_0111_0100_1010_1110 # ⼆进制
# 浮点数
float.value: 3.14159
float.value1: 314159e-5 # 科学计数法
# Null，~代表null
null.value: ~
1
2
3
4
5
6
7
8
9
10
11
12
13

4.2.2 yml 配置读取

yml 读取配置的方式和 properties 相同，使用 @Value 注解即可，实现代码如下：

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
@Component
public class ReadYml {
 @Value("${string.hello}")
 private String hello;
 @PostConstruct
 public void postConstruct() {
 System.out.println("Read YML,Hello:" + hello);
 }
}
1
2
3
4
5
6
7
8
9
10
11
12

4.2.3 配置对象

我们还可以在 yml 中配置对象，如下配置：

student:
 id: 1
 name: Java
 age: 18
1
2
3
4

这个时候就不能⽤ @Value 来读取配置中的对象了，此时要使用另⼀个注解@ConfigurationProperties 来读取，读取对象时候需要为对象设置get和set方法具体实现如下：

import org.springframework.boot.context.properties.ConfigurationProperties
;
import org.springframework.stereotype.Component;
@ConfigurationProperties(prefix = "student")
@Component
public class StudentComponent {
 private int id;
 private String name;
 private int age;
 public int getId() {
 return id;
 }
 public void setId(int id) {
 this.id = id;
 }
 public String getName() {
 return name;
 }
 public void setName(String name) {
 this.name = name;
 }
 public int getAge() {
 return age;
 }
 public void setAge(int age) {
 this.age = age;
 }
 @Override
 public String toString() {
 return "StudentComponent{" +
 "id=" + id +
 ", name='" + name + '\'' +
 ", age=" + age +
 '}';
 }
}
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

调用类实现如下

@Component
public class ReadYml2 {
 @Autowired
 private StudentComponent studentComponent;
 @PostConstruct
 public void postConstruct() {
 System.out.println(studentComponent);
 }
}
1
2
3
4
5
6
7
8
9

5.properties VS yml

1.properties 是以 key=value 的形式配置的键值类型的配置文件，而 yml 使用的是类似 json 格式的树形配置方式进行配置的，yml 层级之间使用换行缩进的方式配置，key 和 value 之间使用“: ”英文冒号加空格的方式设置，并且空格不可省略。
2.properties 为早期并且默认的配置文件格式，但其配置存在⼀定的冗余数据，使用 yml 可以很好的解决数据冗余的问题。
3.yml 通用性更好，支持更多语言，如 Java、Go、Python 等，如果是云服务器开发，可以使用⼀份配置文件作为 Java 和 Go 的共同配置文件。
4.yml 支持更多的数据类型。

Spring Boot 读取配置文件的 N 种⽅法

点这里

更多系统配置项

点这里

SpringBoot 日志文件

1.1.日志有什么用？

日志是程序的重要组成部分，想象一下，如果程序报错了，不让你打开控制台看日志，那么你能找到报错的原因吗？
答案是否定的，写程序不是买彩票，不能完全靠猜，因此日志对于我们来说，最主要的用途就是排除和定位问题。
除了发现和定位问题之外，我们还可以通过日志实现以下功能：
1.记录用户登录日志，方便分析用户是正常登录还是恶意破解用户。
2.记录系统的操作日志，方便数据恢复和定位操作⼈。
3.记录程序的执行时间，方便为以后优化程序提供数据⽀持。
以上这些都是日志提供的非常实用的功能。

2.日志怎么用

Spring Boot 项目在启动的时候默认就有日志输出，如下图所示：

以上内容就是 Spring Boot 输出的控制台日志信息。
通过上述日志信息我们能发现以下 3 个问题：
Spring Boot 内置了日志框架（不然也输出不了日志）。
默认情况下，输出的日志并非是开发者定义和打印的，那开发者怎么在程序中自定义打印日志呢？
日志默认是打印在控制台上的，而控制台的日志是不能被保存的，那么怎么把日志永久的保存下来呢？

3.自定义日志打印

开发者自定义打印日志的实现步骤：
1.在程序中得到日志对象。
2.使用日志对象的相关语法输出要打印的内容
接下来我们分别来看。

3.1在程序中得到日志对象。

在程序中获取日志对象需要使用日志工厂 LoggerFactory，如下代码所示：

//得到日志对象
private static Logger logger=LoggerFactory.getLogger(UserController.class);
1
2

日志工厂需要将每个类的类型传递进去，这样我们才知道日志的归属类，才能更方便、更直观的定位到问题类。
注意：Logger 对象是属于 org.slf4j 包下的，不要导⼊错包。

3.2 使用日志对象打印日志

// 2.使⽤⽇志打印⽇志
logger.info("--------------要输出⽇志的内容----------------");
1
2

3.3日志格式说明

4.日志级别

4.1 日志级别有什么用

日志级别可以帮你筛选出重要的信息，比如设置日志级别为 error，那么就可以只看程序的报错日志了，对于普通的调试日志和业务日志就可以忽略了，从而节省开发者信息筛选的时间。
日志级别可以控制不同环境下，⼀个程序是否需要打印日志，如开发环境我们需要很详细的信息，而生产环境为了保证性能和安全性就会输⼊尽量少的日志，而通过日志的级别就可以实现此需求

4.2 日志级别的分类与使用

日志的级别分为：
trace：微量，少许的意思，级别最低
debug：需要调试时候的关键信息打印；
info：普通的打印信息（默认日志级别）；
warn：警告，不影响使用，但需要注意的问题；
error：错误信息，级别较高的错误日志信息；
fatal：致命的，因为代码异常导致程序退出执行的事件。

越往上接收到的消息就越少，如设置了 warn 就只能收到 warn、error、fatal 级别的日志了。

package com.example.demo.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
//RestController=@Controller+@ResponseBody
public class LogController {

    // 1.得到日志对象
    private static Logger log =
            LoggerFactory.getLogger(TestController.class);

    @RequestMapping("/log")
    public void log() {
        String msg = "今天我学了springboot的日志。";
        log.trace("trace -> " + msg);
        log.debug("debug -> " + msg);
        log.info("info -> " + msg);
        log.warn("warn -> " + msg);
        log.error("error -> " + msg);
    }
}
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

日志作用：过滤信息，把不想看到的信息过滤掉

4.3给某个文件单独设置默认级别

5.日志持久化（将日志保存下来）

普通的日志是在控制台，在控制台意味着重启服务器日志就消失了，那么怎么把它保存下来呢？

5.1.设置日志的保存路径

# 设置日志的保存路径
logging.file.path=D:\\image\\
# 设置日志时间的打印格式
logging.pattern.dateformat=yyyy-MM-dd HH:mm:ss
1
2
3
4

5.1.设置日志的保存文件名

# 设置日志的保存文件名
logging.file.name=D:\\image\\springboot.log
1
2

如果你的日志非常大的话，springboot会把你的日志分割成多份，比如你的日志15mb，固定日志大小是10mb，这时候springboot就会多创建出来一个文件把另外的5mb装进去，所以不用担心空间不够用的问题，同时还可以自己设置文件大小

6.更简单的日志输出-lombok

lombok是一个java库，它可以自动插入到编辑器和构建工具中，增强Java的性能，不再需要写getter和setter或equals等方法，只需要有一个注解，就有一个功能齐全的构建器，自动记录变量等

6.1认识lombok

package com.example.demo.model;
import lombok.Getter;
import lombok.Setter;

//@Setter
//@Getter
//@ToString
@Date
//@Date=setter+getter+Tostring
public class Student {
    private int id;
    private String name;
    private String password;
    public static void main(String[] args)
    {
    	Student stu=new Student();
    	stu.setId(1);
    	stu.strName("张三")
    	stu.setPassword("111");
    	System.out.println(stu.toString);
    } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

6.2更简单的输出日志

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@Slf4j  // 当前的类中就可以直接使用 log 对象，@Slf4j 产生一个 log 对象，直接使用
public class LogController2 {

    @RequestMapping("/log2")
    public void log2(){
        log.trace("trace log2");
        log.debug("debug log2");
        log.info("info log2");
        log.warn("warn log2");
        log.error("error log2");
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

lombok的作用如下图所示

在编译期把注解所对应的代码生成好了

总结

Spring Boot 是为了快速开发 Spring 而诞生的，Spring Boot 具备：
1.快速集成框架，Spring Boot 提供了启动添加依赖的功能，用于秒级集成各种框架。
2.内置运行容器，无需配置 Tomcat 等 Web 容器，直接运行和部署程序。
3.快速部署项目，无需外部容器即可启动并运行项目。
4.可以完全抛弃繁琐的 XML，使用注解和配置的方式进行开发。
5.支持更多的监控的指标，可以更好的了解项目的运行情况等特点。
6.Spring Boot 可使用 Idea 或网页创建，它的设计思想是约定大于配置，类上标注@SpringBootApplication 就可以启动 Spring Boot 项目了。