Spring Boot从0开始学的个人笔记

没学过Spring,没学过MVC,跟着视频走的，不知道能学到多少
就跟这个视频学的

一、先直接来个例子吧

对于新手什么都不懂的我，说太深的概念我不知道是什么，所以还是直接来展示比较好吧

1、IDEA创建spring boot

2、创建spring boot主程序类

package com.qiang;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class HelloMainApplication {
    public static void main(String[] args) {
        //让春天跑起来
        SpringApplication.run(HelloMainApplication.class,args);
    }
}

• @SpringBootApplication,里面包含了很多的注解和类，只要输入这个，就会自动填充好很多spring boot的基本配置了
• 有了spring boot应用注解后，在main函数，实行SpringApplication.run()，方法，可以让程序跑起来，第一个参数是当前类的名称，就是HelloMainApplication.class,第二个是main函数的参数，就是args

3、创建spring boot的控制文件类

package com.qiang.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller//说明这是个控制文件
public class HelloController {
    @ResponseBody//把这个写给客户端
    @RequestMapping("/hello") //在服务器的哪里打开
    public String hello(){
        return "Hello world";
    }
}

• 这个是控制主程序的类，注解@Controller，说明这个类是个控制文件
• @ResponseBody：可以 写在函数前或者类前，写在类前就是这个类的所有方法都显示在客户端中显示，写在方法前就是这个方法在客户端显示
• @RequestMapping("/hello")：其中的hello呢，就是客户端向服务器端的请求名臣，就是比如客户端输入localhost:8080/hello，就能输出这个函数了。
• 或者，直接在开头写@RestController，这个包含了@ResponseBody和@Controller
• 这个函数呢，因为用了注解@ResponseBody，所以就能把return的东西返回给客户端看到

4、接下来运行

这里就运行了，是不是和php有点类似的东西？

5、或者也可以打包运行

XML里面导入

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
            plugin>
        plugins>
    build>

打包后生成

然后可以拉到桌面，通过cmd的cdxxx,运行


也可以运行

6、简单介绍各个文件干什么的

• static：保存所有的静态资源； js css images；
• templates：保存所有的模板页面；（Spring Boot默认jar包使用嵌入式的Tomcat，默认不支持JSP页面）；可以使用模板引擎（freemarker、thymeleaf）；
• application.properties：Spring Boot应用的配置文件；可以修改一些默认设置；

比如，在application.properties中修改端口号


可以换端口访问到

二、配置文件

1、YAML文件配置属性

这个YAML呢，是一个配置的东西，刚开始没有的，要自己手动创建才可以，而且名字是固定的:application.yml

2、基本语法：

①普通的值

v: 值
空格必须要有，而且左边对齐的话，是同一个层级的，而且字符串默认不用加上单引号或者双引号；
如果要用到""或者’'也可以

• “” ： 不会转义字符，如\n输出换行
• ‘’ :会转义字符，如输入\n输出\n

②对象、Map（属性和值）（键值对）

k: v: 值在下一行来写对象的属性和值的关系；注意缩进.对象还是k: v的方式
多行写法：

friend:
  name: 张三
  age: 20

单行写法：

friend: {name: 张三,age: 20}

③数组(List\Set)

多行写法：

pets:
  - cat
  - dog
  - pig

单行写法：

pets: [cat,dog,pig]

3、配置文件中值的注入（设置值，可以让后台看到）

package com.qiang.springbootfast.bean;

public class Gril {
    private String name;
    private int age;

    @Override
    public String toString() {
        return "Gril{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

package com.qiang.springbootfast.bean;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.List;
import java.util.Map;

@Component//把这个类实例化到spring boot容器中，就是把这个类当作组件
@ConfigurationProperties(prefix = "person")
public class Person {
    private String name;
    private int age;
    private boolean boss;
    private Date birth;

    private Map<String,Object> maps;
    private List<Object> lists;
    private Gril gril;

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", boss=" + boss +
                ", birth=" + birth +
                ", maps=" + maps +
                ", lists=" + lists +
                ", gril=" + gril +
                '}';
    }

    
}

• @Component：把这个类实例化到spring boot容器中，就是把这个类当作组件
• @ConfigurationProperties(prefix = "person")：这个注解呢，就是告诉spring将本类中所有的属性和配置文件都与yml文件进行绑定，(prefix = "person")：配置文件（yml）中的person下面的属性一一配对
• 只有这个组件是容器中的组件，才能容器提供的@ConfigurationProperties功能；
• 用到@ConfigurationProperties，需要导入jar包

<dependency>
   <groupId>org.springframework.bootgroupId>
   <artifactId>spring-boot-configuration-processorartifactId>
   <optional>trueoptional>
dependency>

配置文件application.yml：

server:
  port: 8081


person:
  name: 小强
  age: 22
  boss: true
  birth: 2020/07/04
  maps: {k1: v1,k2: v2}
  lists:
    - 对象1
    - 对象2
  gril:
    name: 相泽南
    age: 25

在后台中查看

然后在测试用例中

package com.qiang.springbootfast;

import com.qiang.springbootfast.bean.Person;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class SpringBootFastApplicationTests {

    @Autowired
    Person person;

    @Test
    void contextLoads() {
        System.out.println(person);

    }
    
}

• @SpringBootTest:spring的单元测试
• @Autowired：创建的这个对象，自动获得与配置文件相对应的值

点这个：


可以看到，值已经传进来了

在网页端显示

控制类

package com.qiang.springbootfast.controller;
import com.qiang.springbootfast.bean.Person;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ControllerApplication {
    @Autowired
    Person person;

    @RequestMapping("/hello") //在服务器的哪里打开
    public String hello(){
        return person.toString();
    }
}

4、.properties文件配置属性

server.port=8081

person.name=小强
person.age=22
person.boss=true
person.birth=2020/07/11
person.maps.k1=v1
person.maps.k2=v2
person.lists=a,b,c,d
person.gril.name=相泽南
person.gril.age=18

注意：这里的properties文件中的person，是要在Person类中用@ConfigurationProperties(prefix = "person")进行绑定的

5、@Value赋值

在上面，我们都是用注解@ConfigurationProperties(prefix = "xxxx")来进行赋值的，这个注解是在yml或者properties中写好然后全部赋值的。
但是@Value是可以一个个地赋值的，可以只拿yml或者properties中的某些值，也可以在类中直接@Value("xxx")赋值
yml:

server:
  port: 8081


person:
  name: 小强
  age: 22
  boss: true
  birth: 2020/07/04
  maps: {k1: v1,k2: v2}
  lists:
    - 对象1
    - 对象2
  gril:
    name: 相泽南
    age: 25

Person类：

package com.qiang.springbootfast.bean;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.List;
import java.util.Map;

@Component//把这个类实例化到spring boot容器中，就是把这个类当作组件
//@ConfigurationProperties(prefix = "person")
public class Person {
    @Value("${person.name}")//在yml写好，然后@Value拿person.name过来
    private String name;
    @Value("#{11*2}")//进行计算
    private int age;
    @Value("true")//直接赋值
    private boolean boss;
    private Date birth;

    private Map<String,Object> maps;
    private List<Object> lists;
    private Gril gril;

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", boss=" + boss +
                ", birth=" + birth +
                ", maps=" + maps +
                ", lists=" + lists +
                ", gril=" + gril +
                '}';
    }

   

@Value有几种赋值方式

1. @Value("xxx")直接赋值
2. @Value(${xxx})xxx里写yml或者properties的对应值
3. @Value(#{运算的结果})里面可以写#{11*2},的出来的就是@Value("22")，这个叫SpEL

6、番外篇：注解@Validated，数据校验

@Validated,这个注解是用来进行数据校验的，比如你在类上边写@Validated，那么在下面的属性前加上要校验的格式，就可以校验了，比如@Email，那么就会校验这个属性是不是邮箱格式，如果不是邮箱格式，那么会在控制台报错，如果是邮箱格式，那么就OK
但是这个@Validated注解，@ConfigurationProperties可以识别，@Value不能识别
需要导入jar包：

<dependency>
    <groupId>org.hibernategroupId>
    <artifactId>hibernate-validatorartifactId>
    <version>6.0.7.Finalversion>
dependency>

@Component//把这个类实例化到spring boot容器中，就是把这个类当作组件
@Validated//数据校验
public class Person {
    @Email//检查name是不是邮箱格式
    @Value("小强")
    private String name;
   }

7、@Value与@ConfigurationProperties区别

SpEL是${获取对应的值}
JSR303是@Validated数据校验

8、@PropertySource：加载指定的配置文件

上面的那些配置文件，都是配置在全局变量中的，但实际开发中，不会配置那么多在全局变量里面的，都是划分一堆文件，然后一个文件负责配置某几个类的赋值。那么要怎么获取那些分割开来的配置文件？用@PropertySource，把分割开来的放在resources中，内容的格式和properties的一样

person.name=小明
person.age=18
person.boss=false
person.birth=2020/07/11
person.maps.k1=v1
person.maps.k2=v2
person.lists=a,b,c,d
person.gril.name=小芳
person.gril.age=18

Person类

@PropertySource(value = {"classpath:person.properties"})
@Component//把这个类实例化到spring boot容器中，就是把这个类当作组件
@ConfigurationProperties(prefix = "person")//优先级是yml和properties的
public class Person {
    private String name;
    private int age;
    private boolean boss;
    private Date birth;

    private Map<String,Object> maps;
    private List<Object> lists;
    private Gril gril;

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", boss=" + boss +
                ", birth=" + birth +
                ", maps=" + maps +
                ", lists=" + lists +
                ", gril=" + gril +
                '}';
    }
}    

测试类：

//单元测试
@SpringBootTest
class SpringBootFastApplicationTests {

    @Autowired
    Person person;

    @Test
    void contextLoads() {
//        System.out.println(person);
        System.out.println(person);
    }
}

• @PropertySource(value = {"classpath:指定的文件"})：这个指定的文件必须是resources下的文件
• 配合@ConfigurationProperties(prefix = "xxxx")使用，xxx是指定文件下的对应值

9、@ImportResource：导入Spring的配置文件，让配置文件里面的内容生效

Spring Boot没有Spring的配置文件，我们自己写的配置文件呢，也没有办法识别，因为spring BOOT已经整合了，如果要加，那么就要用到@ImportResource注解
格式：

• @ImportResource(locations = {"classpath:配置文件.xml"})，该xml文件放在resource下

但由于我没学过spring，所以没有办法演示，但是！！！看不懂没关系，继续往下面走

10、@Configuration与@Bean

spring boot推荐我们给容器中添加组件的方式，是使用全注解的方式，省事又不用麻烦

====================================================

1）这里先说一个东西：番外篇

ApplicationContext这是一个类，类中有一个方法containsBean(组件名)，判断该容器是否有该组件，有就返回true，没就返回false
使用

@Autowired
ApplicationContext ioc;

可以自动获得值，这个包含很多东西，但是我们只要其中的一个ApplicationContext.containsBean方法而已
依赖

<dependency>
            <groupId>....org.springframeworkgroupId>
            <artifactId>spring-contextartifactId>
            <version>5.2.1.RELEASEversion>
        dependency>

============================================================

1. 首先，创建一个配置类，用@Configuration标识该类，就像@SpringBootApplication和@RestController一样，标识了主程序类和容器类
2. 在配置类中，用@Bean给容器中添加组件

• 先创建一个类，内容为空，把他当作组件类/service类
  
• 写配置类

@Configuration
public class MyAppConfig {
    //将方法的返回值添加到容器中；容器中这个组件默认的id就是方法名
    @Bean//将返回值添加到容器中
    public HelloService helloService(){
        System.out.println("配置类@Bean给容器中添加组件了...");
        return new HelloService();
    }
}

注意，这个容器的名字，就是这个方法的名字，就是该容器id为helloService

========================

测试类：

//单元测试
@SpringBootTest
class SpringBootFastApplicationTests {
    @Autowired
    ApplicationContext ioc;
    
    @Test
    public void test(){
        boolean b = ioc.containsBean("helloService");//检查该对象是否已经添加到容器中了
        System.out.println(b);
    }
}

可以看到，通过@Configuration设置配置类，用@Bean进行组件的添加，id为方法名，这样就可以把HelloService加到组件中了，这样，我们也不用写xml来进行配置了

11、配置文件占位符

在yml或者properties中，可以用到随机数，或者调用刚赋值的值，又或者创建不存在的东西

person:
  name: ${random.uuid}
  age: ${random.int(100)} #100是最大值
  boss: true
  birth: 2020/07/04
  maps: {k1: v1,k2: v2}
  lists:
    - ${person.no1}
    - ${person.no5:不存在的对应属性}
  gril:
    name: ${person.name}的女朋友
    age: 25

输出的结果

Person{name='36fff990-c76f-4a26-bf96-17a3a66c841a', age=79, boss=true, birth=Sat Jul 04 00:00:00 CST 2020, maps={k1=v1, k2=v2}, lists=[${person.no1}, 不存在的对应属性], gril=Gril{name='758b21da-011f-4f56-b843-69667ea30238的女朋友', age=25}}

名字是随机生成的，年龄最大时100，然后lists,第一个person.no1不存在，所以直接输出${person.no1}，第二个person.no5虽然也不存在，但是:赋值了，所以值为不存在的对应属性，然后下面，还调用了person.name

12、profile

这个profile呢，是Spring对不同环境提供提供不同配置的支持，比如开发环境配置开发环境的东西，还有测试环境，生产环境和运行环境，每个环境都可以设置不同的环境，这样就方便程序员操作了
这个profile的设置，有好几种方法
profile文件的格式是application-profile的环境.properties或者是application-profile的环境.yml

1）多profile文件在application.properties下激活

比如我们写了两个profile的文件，prod（生产环境）和dev（开发环境）分别对应不同的生产环境
application-prod.properties:

server.port=8083

application-dev.properties:

server.port=8082

这个时候，我们只是写好文件还没有激活，如果没激活的话，默认使用的是application.properties或者application.yml。
要激活的话，在application.properties或者application.yml里面写spring.profiles.active=对应的生产环境
比如在application.properties里面写

spring.profiles.active=dev

这里的dev对应了我们上面的application-dev.properties,对应的是dev这个profile环境名字
这里主程序运行

可以看到，我们的dev环境设置的是8082端口，这里也改成了8082端口，就对应上了，除了端口设置，还有很多其他的变量赋值都是同样的道理

2）单文件在yml的多文档块方式使用

番外篇================================

yml还支持多文档块的方式，就加---，就可以划分文档块

鼠标移上去，可以看到这是第几部分

=========================

注意，这个的yml可以用多文档块方式使用，也可以用单文档块使用，不过单文档块使用的话，要配合多profile文件一起使用

使用单文件在yml的多文档块方式使用要把profile文件给注释掉了，因为多文件有优先权
第一部分必须是配置选择的位置，剩下的是待选项

server:
  port: 8081
spring:
  profiles:
    active: prod #spring-profiles-active中选择配置的环境
---
server:
  port: 8085
spring:
  profiles: dev #表明这个环境是dev环境的
---
server:
  port: 8086
spring:
  profiles: prod #表明这个环境是prod环境的

3）前两种方法的注意事项

可以看到多profile文件与yml的多文档块方式是一样的，就是说，这两个取一种方法即可，不要两种都写

4）IDEA的自带命令行方式激活

除了在properties和yml激活，IDEA还自带了激活的方式


这里的激活格式为--spring.profiles.active=环境名，这个激活的方式优先于前边两个方式，即使你YML写的是prod，这里写了dev，会覆盖yml写的东西

5）打包后在CMD中指定环境激活

在CMD里面的指定方式，比前面的优先级都要高
就，很上面的笔记，把项目打包成jar，然后cmd打开他，在 打开的时候，在最后面加上一句话，--spring.profiles.active=dev，就ok了

6）虚拟机参数激活

-Dspring.profiles.active=环境名

13、配置文件加载位置

springboot 启动会扫描以下位置的application.properties或者application.yml文件作为Spring boot的默认配置文件

–file:./config/

–file:./

–classpath:/config/

–classpath:/

优先级由高到底，高优先级的配置会覆盖低优先级的配置；

SpringBoot会从这四个位置全部加载主配置文件；互补配置；

这里的classpath默认是resources，file就是这个项目

1）指定配置文件路径

项目打包好以后，我们可以使用命令行参数的形式，启动项目的时候来指定配置文件的新位置；指定配置文件和默认加载的这些配置文件共同起作用形成互补配置；

java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar --spring.config.location=G:/application.properties

2）番外篇

在application.properties可以配置项目访问路径
server.context-path=/boot02
这样，我们就要localhost:8080/boot02/访问的东西如(hello)

14、外部配置加载顺序

参考官方文档，里面列举的加载顺序由高到低
SpringBoot也可以从以下位置加载配置； 优先级从高到低；高优先级的配置覆盖低优先级的配置，所有的配置会形成互补配置

1. 命令行参数
2. 来自java:comp/env的JNDI属性
3. Java系统属性（System.getProperties()）
4. 操作系统环境变量
5. RandomValuePropertySource配置的random.*属性值
6. jar包外部的application-{profile}.properties或application.yml(带spring.profile)配置文件
7. jar包内部的application-{profile}.properties或application.yml(带spring.profile)配置文件
8. jar包外部的application.properties或application.yml(不带spring.profile)配置文件
9. jar包内部的application.properties或application.yml(不带spring.profile)配置文件
10. @Configuration注解类上的@PropertySource
11. 通过SpringApplication.setDefaultProperties指定的默认属性

1）命令行参数

比如用命令行来修改端口号
可以在IDEA下面这里，直接变成了CMD窗口了


java -jar spring-boot-fast-0.0.1-SNAPSHOT.jar --server.port=8000这个在CMD的时候，命令行修改参数
配置多个参数的时候，用空格隔开
--配置项=配置值

8）jar包外部的application.properties或application.yml(不带spring.profile)配置文件

这是个啥东西？简单来说 ，就是，cmd中可以添加指定的配置参数，但是一个个打太麻烦。就，当打包成jar包的时候，把application.properties和jar包放在一个文件夹，这样，直接执行jar包的时候，会自动加载外部的application.properties




也不用打什么设置加载这个文件的，只要和这个jar包同一个文件夹名叫application.properties，他就会一起加载的

15、@Conditional派生注解

@Conditional在Spring只有这个一个注解，但是在spring boot中拓展了，有很多个注解

这些，比如@ConditionalOnMissingBean(CharacterEncodingFilter.class)，判断容器中是不是没有CharacterEncodingFilter这个组件，如果没有这个组件类，返回true，就执行往后的代码；如果有，返回false，不执行往后的代码；其他的都一样，都是判断的，真就返回true

自动配置类必须在一定的条件下才能生效；

我们怎么知道哪些自动配置类生效；

我们可以通过启用 debug=true属性；来让控制台打印自动配置报告，这样我们就可以很方便的知道哪些自动配置类生效；

在application.properties中，输入debug=true,这样运行的时候，就可以看到哪些自动配置类有启动，哪些自动配置类没有启动

三、日志

1、概述

日志呢，有很多个日志框架，大家都没有统一起来的。其中，日志还分为两个部分，分为日志门面和日志实现

• 日志门面，就是一个日志的抽象层，具体是啥？我也不太清楚
• 日志实现，就是打代码的new什么东西，具体实现的东西

这些是主流的框架，使用的话，要用一个日志门面，再用一个日志实现。两者要配合起来才能用的
spring使用的是JCL
SpringBoot选用 SLF4j和logback；

2、SLF4j使用

以后开发的时候，日志记录方法的调用，不应该来直接调用日志的实现类，而是调用日志抽象层里面的方法；
简单的SLF4J使用

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

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

Logger是记录类，LoggerFactory.getLogger(类名)，参数是一个类的类名，一般是类.class

但是，我们使用的是SLF4J，这只是一个工具，真正要用的还是logback

3、适配器模式

这个了解一下怎么用就好了，我也不是很懂，就是slf4j使用后，用slf4j转换成其他日志抽象层的jar，就可以输出其他抽象层如JCL的东西了，这样，其他的电脑或者其他框架也能用到slf4

4、遗留问题

比如，我现在使用的是slf4j+logback，但是Spring（commons-logging）、Hibernate（jboss-logging）、MyBatis（又是一个新的），那么每个之间都不一样，一个项目可能会引入多个框架，这样的话，每一个框架使用的日志不一样，不就凉了？
不慌，spring boot为我们解决了
这个图的意思就是说，比如一个例子吧，A框架用的是SLF4J，而B框架用的是LOG4J，两者无法读取之间的数据，那么，spring boot导入一个包，SLF4J-LOG4J.jar，这个包的功能就是把SLF4J转换成LOG4J，这样，其他框架也能使用了

如何让系统中所有的日志都统一到slf4j；

1、将系统中其他日志框架先排除出去；（删除其他日志框架）

2、用中间包来替换原有的日志框架；（spring boot都写好了直接用就行）

3、我们导入slf4j其他的实现（格式用SLF4J）

5、spring boot日志关系

在pom.xml下，右键Diagrams–Show Dependencies，可以用视图的方式查看日志之间的关系

6、日志默认配置

• spring boot帮我们配置好默认日志了，但是我们也可以修改
• 日志有5个等级，由低到高分别是trace < debug < info < warn < error
• 等级是什么意思？就是你选了一个等级，日志就会记录该等级以及该等级之上的记录
• spring boot默认选择的等级是info，就是说可以显示info、warn、error级别的日志

1）举个例子

//单元测试
@SpringBootTest
class SpringBootFastApplicationTests {
	//记录器
    Logger logger = LoggerFactory.getLogger(this.getClass());

    @Test
    void contextLoads() {
        logger.trace("这是trace日志");
        logger.debug("这是debug日志...");
        //SpringBoot默认给我们使用的是info级别的，没有指定级别的就用SpringBoot默认规定的级别；root级别
        logger.info("这是info日志...");
        logger.warn("这是warn日志...");
        logger.error("这是error日志...");
    }
}

直接输出

2）改变日志等级

application.properties中添加参数
格式：logging.level.包名（一般是com.包名）=设置等级

logging.level.com.qiang=trace

3）保存日志文件

可以把日志，导出成.log文件
application.properties添加参数
有几种导入参数格式

1. 在当前文件夹生成日志文件:logging.file.name=文件名.log
2. 在指定路径生成日志文件：logging.file.name=绝对路径/文件名.log
3. 在当前目录下创建文件夹以及log文件：logging.file.path=spring/log，在当前文件夹生成了spring/log/spring.log，生成的.log日志名字是spring.log
4. 在指定目录下创建文件夹以及log文件：logging.file.path=E:/spring/log

4）输出格式

控制台与保存日志文件的格式默认都是
%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n

%d表示日期时间，
%thread表示线程名，
%-5level：级别从左显示5个字符宽度
%logger{50} 表示logger名字最长50个字符，否则按照句点分割。
%msg：日志消息，
%n是换行符

比如

2020-07-13 14:46:26.330 ERROR 12340 — [ main] c.q.s.SpringBootFastApplicationTests : 这是error日志…

• 在控制台输出的日志的格式：logging.pattern.console= 格式
• 指定文件中日志输出的格式：logging.pattern.file= 格式

保存的spring.log文件：

2020-07-13 === [main] === INFO  === c.q.springbootfast.SpringBootFastApplicationTests ==== Starting SpringBootFastApplicationTests on DESKTOP-J69KO73 with PID 1936 (started by master in D:\idea\spring-boot-fast)
2020-07-13 === [main] === DEBUG === c.q.springbootfast.SpringBootFastApplicationTests ==== Running with Spring Boot v2.3.1.RELEASE, Spring v5.2.7.RELEASE
2020-07-13 === [main] === INFO  === c.q.springbootfast.SpringBootFastApplicationTests ==== The following profiles are active: dev
2020-07-13 === [main] === INFO  === o.s.scheduling.concurrent.ThreadPoolTaskExecutor ==== Initializing ExecutorService 'applicationTaskExecutor'
2020-07-13 === [main] === INFO  === c.q.springbootfast.SpringBootFastApplicationTests ==== Started SpringBootFastApplicationTests in 4.15 seconds (JVM running for 6.675)
2020-07-13 === [main] === TRACE === c.q.springbootfast.SpringBootFastApplicationTests ==== 这是trace日志
2020-07-13 === [main] === DEBUG === c.q.springbootfast.SpringBootFastApplicationTests ==== 这是debug日志...
2020-07-13 === [main] === INFO  === c.q.springbootfast.SpringBootFastApplicationTests ==== 这是info日志...
2020-07-13 === [main] === WARN  === c.q.springbootfast.SpringBootFastApplicationTests ==== 这是warn日志...
2020-07-13 === [main] === ERROR === c.q.springbootfast.SpringBootFastApplicationTests ==== 这是error日志...
2020-07-13 === [SpringContextShutdownHook] === INFO  === o.s.scheduling.concurrent.ThreadPoolTaskExecutor ==== Shutting down ExecutorService 'applicationTaskExecutor'

7、指定配置

这个也可以在application.properties文件中一个个地去修改日志参数，但是和上一章的配置一样，application.properties是全局配置的，配置的东西最好还是分割分离配置好一点

每个日志框架放文件的规则，文件放在resource下：

我们spring boot用的是logback，拿这个来讲解

就你在resources下创建logback.xml，系统会自动加载里面的日志设置

但是，并不推荐这种写法，因为这个不能启动profile功能，就是对不同环境下进行不同赋值的那个东西
要用到profile功能，文件名必须是logback-spring.xml，比如在里面写

<configuration scan="false" scanPeriod="60 seconds" debug="false">
    
    <property name="LOG_HOME" value="/app/log" />
    
    <property name="appName" value="atguigu-springboot">property>
    
    <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
        
        <layout class="ch.qos.logback.classic.PatternLayout">
            <springProfile name="dev">
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ----> [%thread] ---> %-5level %logger{50} - %msg%npattern>
            springProfile>
            <springProfile name="!dev">
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ==== [%thread] ==== %-5level %logger{50} - %msg%npattern>
            springProfile>
        layout>
    appender>

    
    <appender name="appLogAppender" class="ch.qos.logback.core.rolling.RollingFileAppender">
        
        <file>${LOG_HOME}/${appName}.logfile>
        
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            
            <fileNamePattern>${LOG_HOME}/${appName}-%d{yyyy-MM-dd}-%i.logfileNamePattern>
            
            <MaxHistory>365MaxHistory>
            
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MBmaxFileSize>
            timeBasedFileNamingAndTriggeringPolicy>
        rollingPolicy>
        
        <layout class="ch.qos.logback.classic.PatternLayout">
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [ %thread ] - [ %-5level ] [ %logger{50} : %line ] - %msg%npattern>
        layout>
    appender>

    
    
    <logger name="com.atguigu" level="debug" />
    
    <logger name="org.springframework" level="debug" additivity="false">logger>



    
    <root level="info">
        <appender-ref ref="stdout" />
        <appender-ref ref="appLogAppender" />
    root>
configuration>

xml文件我也不会写。。。但是主要是学一个思维，看到这里

<layout class="ch.qos.logback.classic.PatternLayout">
    <springProfile name="dev">
        <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ----> [%thread] ---> %-5level %logger{50} - %msg%npattern>
    springProfile>
    <springProfile name="!dev">
        <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ==== [%thread] ==== %-5level %logger{50} - %msg%npattern>
    springProfile>
layout>

这里的意思是，当profile设置环境为dev的时候，控制台日志就输出那种格式，当profile设置环境不为dev的时候，控制台输出日志是另外一个格式

原本是这样的，没有加xml文件的时候

在yml或者properties中设置profile环境为dev，就成了这样

当设置环境不为dev的时候，就成了这样