2.springboot基本配置

springboot基本配置

一、banner

支持文字和图片，会先找图片。

• 创建banner.txt /banner.png

• 自定义颜色，首行写

• 版本号：MANIFEST.MF中的版本号

  ${application.version}

  springboot 版本号

  ${spring-boot.version}

• 自定义路径
  spring.banner.location=classpath:""
  

二、容器基本配置

1.TomCat

自动引入tomcat，如果不想要可以用标签。

2.springboot容器配置

• spring.main.web-application-type=none  不使用web容器
  

• 端口配置
  server.port=8089
  #关闭所有http端口
  server.port=-1
  #随机端口
  server.port=0
  
  如果随机的怎么获取端口号呢？？  
  

  /**随机端口获取监听器*/
  public class MyAppliactionListener implements ApplicationListener<WebServerInitalizedEvent>{
      @Override
      public void onApplicationEvent(WebServerInitializedEvent){
          System.out.println("event.getWebServer().getPort()="+event.getWebServer().getPort());
      }
  }
  

• 响应压缩 gzip

  server.compression.enable=true
  

3.tomcat日志配置

3.1 访问日志 accesslog

默认不开启，请求的日志

开启：

#默认生成的日志格式 access_log.yyy-mm-dd.log
server.tomcat.accesslog.enabled=true
#开启访问日志，默认的日知为智在项目运行的临时目录，可以通过以下配置配置
server.tomcat.basedir=my-tomcat
#生成日志文件名的前缀，默认是access_log
server.tomcat.accesslog.prefix=wangze_log
#后缀
server.tomcat.accesslog.suffix=.log
#日期格式
server.tomcat.accesslog.file-date.tomcat=.yyymmdd
#日志文件内容格式 %h 请求客户端IP
#              %l  用户身份
#              %u  用户名
#              %t  请求时间
#              %r 请求地址
#              %s 响应状态码
#              %b 响应的大小
server.tomcat.accesslpg.pattern=%h %l %u %t \"%r\" %s %b

3.2 服务器内部日志

帮助我们解决运行中程序的内部问题

开启：

logging.level.org.apache.tomcat=debug
logging.level.org.appache.catalina=debug

4.tomcat HTTPS 证书配置

超文本传输安全协议(HyperText Transfer Protocol Secure)，缩写：HTTPS；常称为 HTTP over TLS、HTTP over SSL 或 HTTP Secure）是一种通过计算机网络进行安全通信的传输协议。HTTPS 经由 HTTP 进行通信，但利用 SSL/TLS 来加密数据包。HTTPS 开发的主要目的，是提供对网站服务器的身份认证，保护交换数据的隐私与完整性。这个协议由网景公司(Netscape)在 1994 年首次提出，随后扩展到互联网上。

历史上，HTTPS 连接经常用于网络上的交易支付和企业信息系统中敏感信息的传输。在 2000 年代末至 2010 年代初，HTTPS 开始广泛使用，以确保各类型的网页真实，保护账户和保持用户通信，身份和网络浏览的私密性。

另外，还有一种安全超文本传输协议（S-HTTP），也是 HTTP 安全传输的一种实现，但是 HTTPS 的广泛应用而成为事实上的 HTTP 安全传输实现，S-HTTP并没有得到广泛支持。

1.准备

进入到 %JAVVA_HOME%\bin 目录下，执行如下命令生成一个数字证书：

keytool -genkey -alias tomcathttps -keyalg RSA -keysize 2048  -keystore D:\wangze.p12 -validity 365

生成到当前目录下

命令含义如下：

• genkey 表示要创建一个新的密钥。
• alias 表示 keystore 的别名。
• keyalg 表示使用的加密算法是 RSA ，一种非对称加密算法。
• keysize 表示密钥的长度。
• keystore 表示生成的密钥存放位置。
• validity 表示密钥的有效时间，单位为天。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-s4JkHiW5-1621568417255)(D:\OneDrive\桌面\springboot2\springboot王泽\image-20210520214340965.png)]

命令执行完成后 ，我们在 D 盘目录下会看到一个名为wangze.p12 的文件。

2.引入HTTPS

配置文件
server.ssl.key-store=classpath:wangze.p12
server.ssl.key-alias=tomcathttps
server.ssl.key-store-password=111111

• key-store表示密钥文件名。
• key-alias表示密钥别名。
• key-store-password就是在cmd命令执行过程中输入的密码。

配置完成后，就可以启动 Spring Boot 项目了，此时如果我们直接使用 Http 协议来访问接口，就会看到如下错误：

改用 https 来访问 ，结果如下：

这是因为我们自己生成的 https 证书不被浏览器认可，不过没关系，我们直接点击继续访问就可以了（实际项目中只需要更换一个被浏览器认可的 https 证书即可）。

3.请求转发

考虑到 Spring Boot 不支持同时启动 HTTP 和 HTTPS ，为了解决这个问题，我们这里可以配置一个请求转发，当用户发起 HTTP 调用时，自动转发到 HTTPS 上。

@Configuration
public class TomcatConfig {
    @Bean
    TomcatServletWebServerFactory tomcatServletWebServerFactory() {
        TomcatServletWebServerFactory factory = new TomcatServletWebServerFactory(){
            @Override
            protected void postProcessContext(Context context) {
                SecurityConstraint constraint = new SecurityConstraint();
                constraint.setUserConstraint("CONFIDENTIAL");
                SecurityCollection collection = new SecurityCollection();
                collection.addPattern("/*");
                constraint.addCollection(collection);
                context.addConstraint(constraint);
            }
        };
        factory.addAdditionalTomcatConnectors(createTomcatConnector());
        return factory;
    }
    private Connector createTomcatConnector() {
        Connector connector = new
                Connector("org.apache.coyote.http11.Http11NioProtocol");
        connector.setScheme("http");
        connector.setPort(8081);
        connector.setSecure(false);
        connector.setRedirectPort(8080);
        return connector;
    }
}

在这里，我们配置了 Http 的请求端口为 8081，所有来自 8081 的请求，将被自动重定向到 8080 这个 https 的端口上。

如此之后，我们再去访问 http 请求，就会自动重定向到 https。

4.结束语

Spring Boot 中加入 https 其实很方便。如果你使用了 nginx 或者 tomcat 的话，https 也可以发非常方便的配置，从各个云服务厂商处申请到 https 证书之后，官方都会有一个详细的配置教程，一般照着做，就不会错了。

三、配置文件名称和位置

1.springboot约定

名称：application.properties

​ application.yml

​ application.yaml

位置（四个）：优先级顺序：

一般放在4位置！

2.自定义（一般没必要）

2.1自定义路径：

现在在 resources 目录下创建一个 javaboy 目录，目录中存放一个 application.properties 文件，那么正常情况下，当我们启动 Spring Boot 项目时，这个配置文件是不会被自动加载的。我们可以通过 spring.config.location 属性来手动的指定配置文件位置，指定完成后，系统就会自动去指定目录下查找 application.properties 文件。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-axtSc8Ra-1621568417261)(D:\OneDrive\桌面\springboot2\springboot王泽\11-2.png)]

此时启动项目，就会发现，项目以 classpath:/javaboy/application.propertie 配置文件启动。

这是在开发工具中配置了启动位置，如果项目已经打包成 jar ，在启动命令中加入位置参数即可：

java -jar properties-0.0.1-SNAPSHOT.jar --spring.config.location=classpath:/javaboy/

2.2.文件名自定义

对于 application.properties 而言，它不一定非要叫 application ，但是项目默认是去加载名为 application 的配置文件，如果我们的配置文件不叫 application ，也是可以的，但是，需要明确指定配置文件的文件名。

方式和指定路径一致，只不过此时的 key 是 spring.config.name 。

首先我们在 resources 目录下创建一个 app.properties 文件，然后在 IDEA 中指定配置文件的文件名：

指定完配置文件名之后，再次启动项目，此时系统会自动去默认的四个位置下面分别查找名为 app.properties 的配置文件。当然，允许自定义文件名的配置文件不放在四个默认位置，而是放在自定义目录下，此时就需要明确指定 spring.config.location 。

配置文件位置和文件名称可以同时自定义。

四、属性注入方式

1.@Value

user.name=wangze

@Controller
@RequestMapping("hello")
public class HelloController {
  
    @Value("${name}")
    private String name;
}

1.1注意：

一般application配置文件不写这种类的属性注入

# user.properties
user.name=wangze

@Controller
@RequestMapping("hello")
@PropertySource("classpath:user.properties")
public class HelloController {
  
    @Value("${name}")
    private String name;
}

1.2 注入数组

#user.properties
user.hobby=健身，编程，美女

@Controller
@RequestMapping("hello")
@PropertySource("classpath:user.properties")
public class HelloController {
  
    @Value("${name}")
    private String name;
    @Value("${hobby}")
    private String[] hobby;
}

1.3 存在问题

如果需要注入的很多，太麻烦了！解决办法：使用springboot提供的属性注入

2.类型安全的属性注入

@ConfigurationProperties

@Controller
@RequestMapping("hello")
@ConfigurationProperties(prefix="user") //指定前缀
@PropertySource("classpath:user.properties")
public class HelloController {
  
    @Value("${name}")
    private String name;
    @Value("${hobby}")
    private String[] hobby;
}

3.配置文件引用maven配置

aa.name=wangze
bb.name=${aa.name}  #wangze

#如果与maven中的冲突
app.encoding=@project.build.sourceEncoding@   #引用maven中的
app.version =@java.version@

4.短命令行参数

打包之后，运行若是想改变端口号呢？

server.port=${port:8888} 有port按port，没有按8888

java -jar spring-properties-0.0.1-SNAOSHOT.jar --port=8081

5.YAML(YML)

1. 配置有顺序（加载有顺序）
2. 不可以用@PropertySource

server:
 port: 8080
 tomcat:
  accesslog:
   enabled: true

名:[空格]值

数组（集合）的写法

user:
 hobby:
  -健身
  -美女
  -编程

对象的写法

private List<Girl> girlFriend;

user:
 hobby:
  -健身
  -美女
  -编程
 girlFriend:
  -name: 刘雪梦
   age: 20
  -name: 小宝贝
   age: 20

思考：有一个java内省问题，名字不一致也能注入，名字与属性名无关，与get set方法有关！

6.profile问题

项目里会有很多不同的环境：开发，生产，测试

每个环境的配置不一样

application的衍生文件

• application-dev（开发环境）
• application-prod（生产环境）
• application-test（测试环境）

在propertises中

application.profiles.active=prod

7.总结比较

@Value获取值和@ConfigurationProperties获取值比较

	@ConfigurationProperties	@Value
绑定	批量注入配置文件中的属性	一个个指定
松散绑定（松散语法）	支持	支持有限
SpEL	不支持	支持
自动提示	支持	不支持

五、日志配置

1.java日志

• \1. Java 日志概览

• • 1.1 总体概览
  • 1.2 日志级别
  • 1.3 综合对比
  • 1.4 最佳实践

• \2. Spring Boot 日志实现

• • 2.1 Spring Boot 日志配置
  • 2.2 Logback 配置
  • 2.3 Log4j 配置

• 3.小结

之前录过一个视频和大家分享 Spring Boot 日志问题，但是总感觉差点意思，因此松哥打算再通过一篇文章来和大家捋一捋 Java 中的日志问题，顺便我们把 Spring Boot 中的日志问题也说清楚。

1. Java 日志概览

说到 Java 日志，很多初学者可能都比较懵，因为这里涉及到太多东西了：Apache Commons Logging、Slf4j、Log4j、Log4j2、Logback、Java Util Logging 等等，这些框架各自有什么作用？他们之间有什么区别？

1.1 总体概览

下面这张图很好的展示了 Java 中的日志体系：

可以看到，Java 中的日志框架主要分为两大类：日志门面和日志实现。

日志门面

日志门面定义了一组日志的接口规范，它并不提供底层具体的实现逻辑。Apache Commons Logging 和 Slf4j 就属于这一类。

日志实现

日志实现则是日志具体的实现，包括日志级别控制、日志打印格式、日志输出形式（输出到数据库、输出到文件、输出到控制台等）。Log4j、Log4j2、Logback 以及 Java Util Logging 则属于这一类。

将日志门面和日志实现分离其实是一种典型的门面模式，这种方式可以让具体业务在不同的日志实现框架之间自由切换，而不需要改动任何代码，开发者只需要掌握日志门面的 API 即可。

日志门面是不能单独使用的，它必须和一种具体的日志实现框架相结合使用。

那么日志框架是否可以单独使用呢？

技术上来说当然没问题，但是我们一般不会这样做，因为这样做可维护性很差，而且后期扩展不易。例如 A 开发了一个工具包使用 Log4j 打印日志，B 引用了这个工具包，但是 B 喜欢使用 Logback 打印日志，此时就会出现一个业务使用两个甚至多个日志框架，开发者也需要维护多个日志的配置文件。因此我们都是用日志门面打印日志。

1.2 日志级别

使用日志级别的好处在于，调整级别，就可以屏蔽掉很多调试相关的日志输出。不同的日志实现定义的日志级别不太一样，不过也都大同小异。

Java Util Logging

Java Util Logging 定义了 7 个日志级别，从严重到普通依次是：

• SEVERE
• WARNING
• INFO
• CONFIG
• FINE
• FINER
• FINEST

因为默认级别是 INFO，因此 INFO 级别以下的日志，不会被打印出来。

Log4j

Log4j 定义了 8 个日志级别（除去 OFF 和 ALL，可以说分为 6 个级别），从严重到普通依次是：

• OFF：最高等级的，用于关闭所有日志记录。
• FATAL：重大错误，这种级别可以直接停止程序了。
• ERROR：打印错误和异常信息，如果不想输出太多的日志，可以使用这个级别。
• WARN：警告提示。
• INFO：用于生产环境中输出程序运行的一些重要信息，不能滥用。
• DEBUG：用于开发过程中打印一些运行信息。
• TRACE
• ALL 最低等级的，用于打开所有日志记录。

Logback

Logback 日志级别比较简单，从严重到普通依次是：

• ERROR
• WARN
• INFO
• DEBUG
• TRACE

1.3 综合对比

Java Util Logging 系统在 JVM 启动时读取配置文件并完成初始化，一旦应用程序开始运行，就无法修改配置。另外，这种日志实现配置也不太方便，只能在 JVM 启动时传递参数，像下面这样：

-Djava.util.logging.config.file=<config-file-name>。

由于这些局限性，导致 Java Util Logging 并未广泛使用。

Log4j 虽然配置繁琐，但是一旦配置完成，使用起来就非常方便，只需要将相关的配置文件放到 classpath 下即可。在很多情况下，Log4j 的配置文件我们可以在不同的项目中反复使用。

Log4j 可以和 Apache Commons Logging 搭配使用，Apache Commons Logging 会自动搜索并使用 Log4j，如果没有找到 Log4j，再使用 Java Util Logging。

比 Log4j + Apache Commons Logging 组合更得人心的是 Slf4j + Logback 组合。

Logback 是 Slf4j 的原生实现框架，它也出自 Log4j 作者（Ceki Gülcü）之手，但是相比 Log4j，它拥有更多的优点、特性以及更强的性能。

1.4 最佳实践

• 如果不想添加任何依赖，使用 Java Util Logging 或框架容器已经提供的日志接口。
• 如果比较在意性能，推荐：Slf4j + Logback。
• 如果项目中已经使用了 Log4j 且没有发现性能问题，推荐组合为：Slf4j + Log4j2。

2. Spring Boot 日志实现

Spring Boot 使用 Apache Commons Logging 作为内部的日志框架门面，它只是一个日志接口，在实际应用中需要为该接口来指定相应的日志实现。

Spring Boot 默认的日志实现是 Logback。这个很好查看：随便启动一个 Spring Boot 项目，从控制台找一行日志，例如下面这样：

考虑到最后的 prod 是一个可以变化的字符，我们在项目中全局搜索：The following profiles are active，结果如下：

在日志输出的那一行 debug。然后再次启动项目，如下图：

此时我们就可以看到真正的日志实现是 Logback。

其他的诸如 Java Util Logging、Log4j 等框架，Spring Boot 也有很好的支持。

在 Spring Boot 项目中，只要添加了如下 web 依赖，日志依赖就自动添加进来了：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

2.1 Spring Boot 日志配置

Spring Boot 的日志系统会自动根据 classpath 下的内容选择合适的日志配置，在这个过程中首选 Logback。

如果开发者需要修改日志级别，只需要在 application.properties 文件中通过 logging.level 前缀+包名 的形式进行配置即可，例如下面这样：

logging.level.org.springframework.web=debug
logging.level.org.hibernate=error

如果你想将日志输出到文件，可以通过如下配置指定日志文件名：

logging.file.name=javaboy.log

logging.file.name 可以只指定日志文件名，也可以指定日志文件全路径，例如下面这样：

logging.file.name=/Users/sang/Documents/javaboy/javaboy.log

如果你只是想重新定义输出日志文件的路径，也可以使用 logging.file.path 属性，如下：

logging.file.path=/Users/sang/Documents/javaboy

如果想对输出到文件中的日志进行精细化管理，还有如下一些属性可以配置：

• logging.logback.rollingpolicy.file-name-pattern：日志归档的文件名，日志文件达到一定大小之后，自动进行压缩归档。
• logging.logback.rollingpolicy.clean-history-on-start：是否在应用启动时进行归档管理。
• logging.logback.rollingpolicy.max-file-size：日志文件大小上限，达到该上限后，会自动压缩。
• logging.logback.rollingpolicy.total-size-cap：日志文件被删除之前，可以容纳的最大大小。
• logging.logback.rollingpolicy.max-history：日志文件保存的天数。

日志文件归档这块，小伙伴们感兴趣可以自己试下，可以首先将 max-file-size 属性调小，这样方便看到效果：

logging.logback.rollingpolicy.max-file-size=1MB

然后添加如下接口：

@RestController
public class HelloController {
    private static final Logger logger = getLogger(HelloController.class);
    @GetMapping("/hello")
    public void hello() {
        for (int i = 0; i < 100000; i++) {
            logger.info("hello javaboy");
        }
    }
}

访问该接口，可以看到最终生成的日志文件被自动压缩了：

application.properties 中还可以配置日志分组。

日志分组能够把相关的 logger 放到一个组统一管理。

例如我们可以定义一个 tomcat 组：

logging.group.tomcat=org.apache.catalina,org.apache.coyote, org.apache.tomcat

然后统一管理 tomcat 组中的所有 logger：

logging.level.tomcat=TRACE

Spring Boot 中还预定义了两个日志分组 web 和 sql，如下：

不过在 application.properties 中只能实现对日志一些非常简单的配置，如果想实现更加细粒度的日志配置，那就需要使用日志实现的原生配置，例如 Logback 的 classpath:logback.xml，Log4j 的 classpath:log4j.xml 等。如果这些日志配置文件存在于 classpath 下，那么默认情况下，Spring Boot 就会自动加载这些配置文件。

2.2 Logback 配置

2.2.1 基本配置

默认的 Logback 配置文件名有两种：

• logback.xml：这种配置文件会直接被日志框架加载。
• logback-spring.xml：这种配置文件不会被日志框架直接加载，而是由 Spring Boot 去解析日志配置，可以使用 Spring Boot 的高级 Profile 功能。

Spring Boot 中为 Logback 提供了四个默认的配置文件，位置在 org/springframework/boot/logging/logback/，分别是：

• defaults.xml：提供了公共的日志配置，日志输出规则等。
• console-appender.xml：使用 CONSOLE_LOG_PATTERN 添加一个ConsoleAppender。
• file-appender.xml：添加一个 RollingFileAppender。
• base.xml：为了兼容旧版 Spring Boot 而提供的。

如果需要自定义 logback.xml 文件，可以在自定义时使用这些默认的配置文件，也可以不使用。一个典型的 logback.xml 文件如下（resources/logback.xml）：

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <include resource="org/springframework/boot/logging/logback/defaults.xml"/>
    <include resource="org/springframework/boot/logging/logback/console-appender.xml" />
    <root level="INFO">
        <appender-ref ref="CONSOLE" />
    </root>
    <logger name="org.springframework.web" level="DEBUG"/>
</configuration>

可以通过 include 引入 Spring Boot 已经提供的配置文件，也可以自定义。

2.2.2 输出到文件

如果想禁止控制台的日志输出，转而将日志内容输出到一个文件，我们可以自定义一个 logback-spring.xml 文件，并引入前面所说的 file-appender.xml 文件。

像下面这样（resources/logback-spring.xml）：

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <include resource="org/springframework/boot/logging/logback/defaults.xml" />
    <property name="LOG_FILE" value="${LOG_FILE:-${LOG_PATH:-${LOG_TEMP:-${java.io.tmpdir:-/tmp}}/}spring.log}"/>
    <include resource="org/springframework/boot/logging/logback/file-appender.xml" />
    <root level="INFO">
        <appender-ref ref="FILE" />
    </root>
</configuration>

2.3 Log4j 配置

如果 classpath 下存在 Log4j2 的依赖，Spring Boot 会自动进行配置。

默认情况下 classpath 下当然不存在 Log4j2 的依赖，如果想使用 Log4j2，可以排除已有的 Logback，然后再引入 Log4j2，如下：

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

Log4j2 的配置就比较容易了，在 reources 目录下新建 log4j2.xml 文件，内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<configuration status="warn">
    <properties>
        <Property name="app_name">logging</Property>
        <Property name="log_path">logs/${app_name}</Property>
    </properties>
    <appenders>
        <console name="Console" target="SYSTEM_OUT">
            <PatternLayout pattern="[%d][%t][%p][%l] %m%n" />
        </console>
        <RollingFile name="RollingFileInfo" fileName="${log_path}/info.log"
                     filePattern="${log_path}/$${date:yyyy-MM}/info-%d{yyyy-MM-dd}-%i.log.gz">
            <Filters>
                <ThresholdFilter level="INFO" />
                <ThresholdFilter level="WARN" onMatch="DENY"
                                 onMismatch="NEUTRAL" />
            </Filters>
            <PatternLayout pattern="[%d][%t][%p][%c:%L] %m%n" />
            <Policies>
                <TimeBasedTriggeringPolicy interval="1" modulate="true" />
                <SizeBasedTriggeringPolicy size="2 MB" />
            </Policies>
            <DefaultRolloverStrategy compressionLevel="0" max="10"/>
        </RollingFile>
        <RollingFile name="RollingFileWarn" fileName="${log_path}/warn.log"
                     filePattern="${log_path}/$${date:yyyy-MM}/warn-%d{yyyy-MM-dd}-%i.log.gz">
            <Filters>
                <ThresholdFilter level="WARN" />
                <ThresholdFilter level="ERROR" onMatch="DENY"
                                 onMismatch="NEUTRAL" />
            </Filters>
            <PatternLayout pattern="[%d][%t][%p][%c:%L] %m%n" />
            <Policies>
                <TimeBasedTriggeringPolicy interval="1" modulate="true" />
                <SizeBasedTriggeringPolicy size="2 MB" />
            </Policies>
            <DefaultRolloverStrategy compressionLevel="0" max="10"/>
        </RollingFile>

        <RollingFile name="RollingFileError" fileName="${log_path}/error.log"
                     filePattern="${log_path}/$${date:yyyy-MM}/error-%d{yyyy-MM-dd}-%i.log.gz">
            <ThresholdFilter level="ERROR" />
            <PatternLayout pattern="[%d][%t][%p][%c:%L] %m%n" />
            <Policies>
                <TimeBasedTriggeringPolicy interval="1" modulate="true" />
                <SizeBasedTriggeringPolicy size="2 MB" />
            </Policies>
            <DefaultRolloverStrategy compressionLevel="0" max="10"/>
        </RollingFile>
    </appenders>
    <loggers>
        <root level="info">
            <appender-ref ref="Console" />
            <appender-ref ref="RollingFileInfo" />
            <appender-ref ref="RollingFileWarn" />
            <appender-ref ref="RollingFileError" />
        </root>
    </loggers>
</configuration>

首先在 properties 节点中指定了应用名称以及日志文件位置。

然后通过几个不同的 RollingFile 对不同级别的日志分别处理，不同级别的日志将输出到不同的文件，并按照各自的命名方式进行压缩。

这段配置比较程式化，小伙伴们可以保存下来做成 IntelliJ IDEA 模版以便日常使用。