一、日志

  日志文件是用于记录系统操作事件的文件集合，具有处理历史数据、诊断问题的追踪以及理解系统的活动等重要作用。

  日志可分文两类：调试日志和系统日志。

• 调试日志:软件开发中，我们经常需要去调试程序，做一些信息、状态的输出便于我们查询程序的运行状况。为了让我们能够更加灵活和方便的控制这些调试的信息，所有我们需要专业的日志技术。java中寻找bug会需要重现，调试也就是debug 可以在程序运行中暂停程序运行，可以查看程序在运行中的情况。日志主要是为了更方便的去重现问题。软件上线时，我们需要关闭调试日志。
• 系统日志：系统日志是记录系统中硬件、软件和系统问题的信息，同时还可以监视系统中发生的事件。用户可以通过它来检查错误发生的原因，或者寻找受到攻击时攻击者留下的痕迹。系统日志包括系统日志、应用程序日志和安全日志。系统日志策略可以在故障刚刚发生时就向你发送警告信息，系统日志帮助你在最短的时间内发现问题。

二、日志框架

现有的日志框架：

• 日志实现：JUL（java util logging）、Logback、log4j、log4j2、

• 日志门面：JCL（Jakarta Commons Logging）、slf4j（ Simple Logging Facade for Java）

日志出现的历史顺序：log4j -->JUL–>JCL–> slf4j --> logback --> log4j2

1.JUL

  JUL全称Java util Logging是java原生的日志框架，使用时不需要另外引用第三方类库，相对其他日志框架使用方便，学习简单，能够在小型应用中灵活使用。

  JUL的基本原理：用户使用Logger记录器来进行日志记录，Logger持有若干个Handler，日志的输出操作是由Handler完成的。在Handler在输出日志前，会经过Filter的过滤，判断哪些日志级别（level）过滤（filter）放行哪些拦截，Handler会将日志内容输出到指定位置（日志文件、控制台等）。Handler在输出日志时会使用Layout模板，将输出内容进行排版。

//入门案例
public class JULTest {
  @Test
  public void testQuick() throws Exception {
    // 1.创建日志记录器对象
    Logger logger = Logger.getLogger("com.itheima.log.JULTest");
    // 2.日志记录输出
    logger.info("hello JUL");
    logger.log(Level.INFO, "info msg");
    String name = "jack";
    Integer age = 18;
    logger.log(Level.INFO, "用户信息：{0},{1}", new Object[]{name, age});
 }
}

①日志级别

  java.util.logging.Level中定义了日志的级别：

SEVERE  //（最高值）
WARNING
INFO    //（默认级别）
CONFIG
FINE
FINER
FINEST  //（最低值）
// 还有两个特殊的级别：
OFF     //可用来关闭日志记录。
ALL     //启用所有消息的日志记录

②父子关系

  JUL中Logger之间存在父子关系，这种父子关系通过树状结构存储，JUL在初始化时会创建一个顶层
RootLogger作为所有Logger父Logger，存储上作为树状结构的根节点。并父子关系通过路径来关联。

    @Test
    public void testLogParent() throws Exception {
      // 日志记录器对象父子关系
      Logger logger1 = Logger.getLogger("com.xiaomi.log");
      Logger logger2 = Logger.getLogger("com.xiaomi");
      System.out.println(logger1.getParent() == logger2);
      //true
      System.out.println("logger2 parent:" + logger2.getParent() + "，name：" + logger2.getParent().getName());
      //logger2 parent:java.util.logging.LogManager$RootLogger@7b49cea0，name：
      
      // 一、自定义日志级别
      // a.关闭系统默认配置
      logger2.setUseParentHandlers(false);
      // b.创建handler对象
      ConsoleHandler consoleHandler = new ConsoleHandler();
      // c.创建formatter对象
      SimpleFormatter simpleFormatter = new SimpleFormatter();
      // d.进行关联
      consoleHandler.setFormatter(simpleFormatter);
      logger2.addHandler(consoleHandler);
      // e.设置日志级别
      logger2.setLevel(Level.ALL);
      consoleHandler.setLevel(Level.ALL);
      // 测试日志记录器对象父子关系
      logger1.severe("severe");
      logger1.warning("warning");
      logger1.info("info");
      logger1.config("config");
      logger1.fine("fine");
      logger1.finer("finer");
      logger1.finest("finest");
    }

③日志配置文件

默认配置文件路径$JAVAHOME\jre\lib\ logging.properties

## RootLogger使用的处理器（获取时设置）
handlers= java.util.logging.ConsoleHandler
# RootLogger日志等级
.level= INFO
## 自定义Logger
com.itheima.handlers= java.util.logging.FileHandler
# 自定义Logger日志等级
com.itheima.level= INFO
# 忽略父日志设置
com.itheima.useParentHandlers=false
## 控制台处理器
# 输出日志级别
java.util.logging.ConsoleHandler.level = INFO
# 输出日志格式
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter
## 文件处理器
# 输出日志级别
java.util.logging.FileHandler.level=INFO
# 输出日志格式
java.util.logging.FileHandler.formatter = java.util.logging.SimpleFormatter
# 输出日志文件路径
java.util.logging.FileHandler.pattern = /java%u.log
# 输出日志文件限制大小（50000字节）
java.util.logging.FileHandler.limit = 50000
# 输出日志文件限制个数
java.util.logging.FileHandler.count = 10
# 输出日志文件 是否是追加
java.util.logging.FileHandler.append=true

④日志原理

1. 初始化LogManager
2. LogManager加载logging.properties配置
3. 添加Logger到LogManager
4. 从单例LogManager获取Logger
5. 设置级别Level，并指定日志记录LogRecord
6. Filter提供了日志级别之外更细粒度的控制
7. Handler是用来处理日志输出位置
8. Formatter是用来格式化LogRecord的

2.LOG4J框架

  Log4j是Apache下的一款开源的日志框架，通过在项目中使用 Log4J，我们可以控制日志信息输出到控制台、文件、甚至是数据库中。我们可以控制每一条日志的输出格式，通过定义日志的输出级别，可以更灵活的控制日志的输出过程。方便项目的调试。

使用前需要导包：

 <dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
  </dependency>

直接上代码：

public class Log4jTest {
  @Test
  public void testQuick() throws Exception {
    // 初始化系统配置，不需要配置文件
    BasicConfigurator.configure();
    // 创建日志记录器对象
    Logger logger = Logger.getLogger(Log4jTest.class);
    // 日志记录输出
    logger.info("hello log4j");
    // 日志级别
    logger.fatal("fatal");  // 严重错误，一般会造成系统崩溃和终止运行
    logger.error("error");  // 错误信息，但不会影响系统运行
    logger.warn("warn");   // 警告信息，可能会发生问题
    logger.info("info");   // 程序运行信息，数据库的连接、网络、IO操作等
    logger.debug("debug");  // 调试信息，一般在开发阶段使用，记录程序的变量、参数等
    logger.trace("trace");  // 追踪信息，记录程序的所有流程信息
      //还有两个特殊的级别：
      //OFF，可用来关闭日志记录。
      //ALL，启用所有消息的日志记录。
 }
}

  Log4J 主要由 Loggers (日志记录器)、Appenders（输出端）和 Layout（日志格式化器）组成。其中Loggers 控制日志的输出级别与日志是否输出；Appenders 指定日志的输出方式（输出到控制台、文件等）；Layout 控制日志信息的输出格式。

  相应的其配置文件为log4j.properties 。

#指定日志的输出级别与输出端
log4j.rootLogger=INFO,Console
# 控制台输出配置
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=%d [%t] %-5p [%c] - %m%n
# 文件输出配置
log4j.appender.A = org.apache.log4j.DailyRollingFileAppender
#指定日志的输出路径
log4j.appender.A.File = D:/log.txt
log4j.appender.A.Append = true
#使用自定义日志格式化器
log4j.appender.A.layout = org.apache.log4j.PatternLayout
#指定日志的输出格式
log4j.appender.A.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss} [%t:%r] -
[%p] %m%n
#指定日志的文件编码
log4j.appender.A.encoding=UTF-8
#mysql
log4j.appender.logDB=org.apache.log4j.jdbc.JDBCAppender
log4j.appender.logDB.layout=org.apache.log4j.PatternLayout
log4j.appender.logDB.Driver=com.mysql.jdbc.Driver
log4j.appender.logDB.URL=jdbc:mysql://localhost:3306/test
log4j.appender.logDB.User=root
log4j.appender.logDB.Password=root
log4j.appender.logDB.Sql=INSERT INTO
log(project_name,create_date,level,category,file_name,thread_name,line,all_categ
ory,message) values('itcast','%d{yyyy-MM-dd
HH:mm:ss}','%p','%c','%F','%t','%L','%l','%m')

3.JCL

  JCL全称为Jakarta Commons Logging，是Apache提供的一个通用日志API。主要用于“为所有的Java日志实现提供一个统一的接口”（它类似一个门面）。JCL 有两个基本的抽象类：Log(基本记录器)和LogFactory(负责创建Log实例)。

使用前需要导包：

<dependency>
  <groupId>commons-logging</groupId>
  <artifactId>commons-logging</artifactId>
  <version>1.2</version>
</dependency>

直接上代码：

public class JCLTest {
  @Test
  public void testJCL() throws Exception {
    // 创建日志对象
    Log log = LogFactory.getLog(JULTest.class);
    // 日志记录输出
    log.fatal("fatal");
    log.error("error");
    log.warn("warn");
    log.info("info");
    log.debug("debug");
 }
}

①JCL原理

1. 通过LogFactory动态加载Log实现类

2. 日志门面支持的日志实现数组

   private static final String[] classesToDiscover =
     new String[]{"org.apache.commons.logging.impl.Log4JLogger",
           "org.apache.commons.logging.impl.Jdk14Logger",
           "org.apache.commons.logging.impl.Jdk13LumberjackLogger",
           "org.apache.commons.logging.impl.SimpleLog"};
   
   

3. 获取具体的日志实现

   for(int i = 0; i < classesToDiscover.length && result == null; ++i) {
     result = this.createLogFromClass(classesToDiscover[i], logCategory,true);
   }
   
   

②日志门面

  门面模式（Facade Pattern），也称之为外观模式，其核心为：外部与一个子系统的通信必须通过一个统一的外观对象进行，使得子系统更易于使用。 就像前面介绍的几种日志框架一样，每一种日志框架都有自己单独的API，要使用对应的框架就要使用其对应的API，这就大大的增加应用程序代码对于日志框架的耦合性。

  为了解决这个问题，就是在日志框架和应用程序之间架设一个沟通的桥梁，对于应用程序来说，无论底层的日志框架如何变，都不需要有任何感知。只要门面服务做的足够好，随意换另外一个日志框架，应用程序不需要修改任意一行代码，就可以直接上线。

为什么要使用日志门面？

1. 面向接口开发，不再依赖具体的实现类。减少代码的耦合
2. 项目通过导入不同的日志实现类，可以灵活的切换日志框架
3. 统一API，方便开发者学习和使用
4. 统一配置便于项目日志的管理

4.SLF4J

  当我们的系统变的更加复杂的时候，我们的日志就容易发生混乱。随着系统开发的进行，可能会更新不同的日志框架，造成当前系统中存在不同的日志依赖，让我们难以统一的管理和控制。就算我们强制要求所有的模块使用相同的日志框架，系统中也难以避免使用其他类似spring,mybatis等其他的第三方框架，它们依赖于我们规定不同的日志框架，而且他们自身的日志系统就有着不一致性，依然会出来日志体系的混乱。

  所以我们需要借鉴JDBC的思想，为日志系统也提供一套门面，那么我们就可以面向这些接口规范来开发，避免了直接依赖具体的日志框架。这样我们的系统在日志中，就存在了日志的门面和日志的实现。

使用前需要导包：

<!--slf4j core 使用slf4j必須添加--> 
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-api</artifactId>
  <version>1.7.27</version>
</dependency>
<!--slf4j 自带的简单日志实现 -->
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-simple</artifactId>
  <version>1.7.27</version>
</dependency>

直接上代码：

public class Slf4jTest {
  // 声明日志对象
  public final static Logger LOGGER = LoggerFactory.getLogger(Slf4jTest.class);
  @Test
  public void testQuick() throws Exception {
    //打印日志信息
    LOGGER.error("error");
    LOGGER.warn("warn");
    LOGGER.info("info");
    LOGGER.debug("debug");
    LOGGER.trace("trace");
    // 使用占位符输出日志信息
    String name = "jack";
    Integer age = 18;
    LOGGER.info("用户：{},{}", name, age);
    // 将系统异常信息写入日志
    try {
      int i = 1 / 0;
   } catch (Exception e) {
      // e.printStackTrace();
      LOGGER.info("出现异常：", e);
   }
 }
}

为什么要使用SLF4J作为日志门面？

SLF4J是目前市面上最流行的日志门面。现在的项目中，基本上都是使用SLF4J作为我们的日志系统。
SLF4J日志门面主要提供两大功能：日志绑定、日志桥接

①日志绑定

对于

<!--slf4j core 使用slf4j必須添加-->
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-api</artifactId>
  <version>1.7.27</version>
</dependency>
<!-- log4j-->
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-log4j12</artifactId>
  <version>1.7.27</version>
</dependency>
<dependency>
  <groupId>log4j</groupId>
  <artifactId>log4j</artifactId>
  <version>1.2.17</version>
</dependency>
<!-- jul -->
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-jdk14</artifactId>
  <version>1.7.27</version>
</dependency>
<!--jcl -->
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-jcl</artifactId>
  <version>1.7.27</version>
</dependency>
<!-- nop:关闭日志 -->
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-nop</artifactId>
  <version>1.7.27</version>
</dependency>

因此使用slf4j的日志绑定流程:

1. 添加slf4j-api的依赖

2. 使用slf4j的API在项目中进行统一的日志记录

3. 绑定具体的日志实现框架

   • 若绑定已经实现了slf4j的日志框架,直接添加对应依赖

   • 若绑定没有实现slf4j的日志框架,先添加日志的适配器,再添加实现类的依赖

4. slf4j有且仅有一个日志实现框架的绑定（如果出现多个默认使用第一个依赖日志实现）

②日志桥接

  如果我们要使用SLF4J的桥接器，替换原有的日志框架（当现有的日志框架满足不了开发需求时），那么我们需要做的第一件事情，就是删除掉原有项目中的日志框架的依赖，然后替换成SLF4J提供的桥接器（不需要修改代码），并添加新日志框架，。桥接解决的是项目中日志的遗留问题。

<!-- log4j-->
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>log4j-over-slf4j</artifactId>
  <version>1.7.27</version>
</dependency>
<!-- jul -->
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>jul-to-slf4j</artifactId>
  <version>1.7.27</version>
</dependency>
<!--jcl -->
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>jcl-over-slf4j</artifactId>
  <version>1.7.27</version>
</dependency>

注意：桥接器和适配器不能同时对一个日志框架使用。会出现日志引用死循环，导致栈内存溢出。

③SLF4J原理

1. SLF4J通过LoggerFactory加载日志具体的实现对象。
2. LoggerFactory在初始化的过程中，会通过performInitialization()方法绑定具体的日志实现。
3. 在绑定具体实现的时候，通过类加载器，加载org/slf4j/impl/StaticLoggerBinder.class。
4. 所以，只要是一个日志实现框架，在org.slf4j.impl包中提供一个自己的StaticLoggerBinder类，在其中提供具体日志实现的LoggerFactory就可以被SLF4J所加载。

5.Logback

Logback主要分为三个模块：

• logback-core ：其它两个模块的基础模块
• logback-classic ：它是log4j的一个改良版本，同时它完整实现了slf4j API
• logback-access ：访问模块与Servlet容器集成提供通过Http来访问日志的功能

logback会依次读取以下类型配置文件：

• logback.groovy
• logback-test.xml
• logback.xml 如果均不存在会采用默认配置

logback-access模块与Servlet容器（如Tomcat和Jetty）集成，以提供HTTP访问日志功能。我们可以使用logback-access模块来替换tomcat的访问日志。

6.Log4j2

  Apache Log4j 2是对Log4j的升级版，参考了logback的一些优秀的设计，并且修复了一些问题，因此带
来了一些重大的提升，主要有：

• 异常处理，在 logback中，Appender中的异常不会被应用感知到，但是在log4j2中，提供了一些异常处理机制。
• 性能提升， log4j2相较于log4j 和logback都具有很明显的性能提升，可以去看官方（ https://logging.apache.org/log4j/2.x/）测试的数据。
• 自动重载配置，参考了 logback的设计，当然会提供自动刷新参数配置，最实用的就是我们在生产上可以动态的修改日志的级别而不需要重启应用。
• 无垃圾机制， log4j2在大部分情况下，都可以使用其设计的一套无垃圾机制，避免频繁的日志收集
  导致的jvm gc。

  目前市面上最主流的日志门面就是SLF4J，虽然Log4j2也是日志门面，因为它的日志实现功能非常强大，性能优越。所以大家一般还是将Log4j2看作是日志的实现，Slf4j + Log4j2应该是未来的大势所趋。

使用前需添加依赖：

<!-- Log4j2 门面API-->
<dependency>
  <groupId>org.apache.logging.log4j</groupId>
  <artifactId>log4j-api</artifactId>
  <version>2.11.1</version>
</dependency>
<!-- Log4j2 日志实现 -->
<dependency>
  <groupId>org.apache.logging.log4j</groupId>
  <artifactId>log4j-core</artifactId>
  <version>2.11.1</version>
</dependency>
<!--使用slf4j作为日志的门面,使用log4j2来记录日志 -->
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-api</artifactId>
  <version>1.7.25</version>
</dependency>
<!--为slf4j绑定日志实现 log4j2的适配器 -->
<dependency>
  <groupId>org.apache.logging.log4j</groupId>
  <artifactId>log4j-slf4j-impl</artifactId>
  <version>2.10.0</version>
</dependency>

直接上代码：

public class Log4j2Test {
  public static final Logger LOGGER = LogManager.getLogger(Log4j2Test.class);
  @Test
  public void testQuick() throws Exception {
    LOGGER.fatal("fatal");
    LOGGER.error("error");
    LOGGER.warn("warn");
    LOGGER.info("info");
    LOGGER.debug("debug");
    LOGGER.trace("trace");
 }
}

log4j2默认加载classpath下的 log4j2.xml 文件中的配置。

①异步日志

log4j2最大的特点就是异步日志，其性能的提升主要也是从异步日志中受益。

Log4j2 提供了两种实现日志的方式，一个是通过AsyncAppender，一个是通过AsyncLogger，分别对应前面我们说的Appender组件和Logger组件。AsyncLogger才是log4j2 的重头戏，也是官方推荐的异步方式。它可以使得调用Logger.log返回的更快。通过它可以有两种选择：全局异步和混合异步。

使用异步日志需要注意两点：

• 如果使用异步日志，AsyncAppender、AsyncLogger和全局日志，不要同时出现。性能会和AsyncAppender一致，降至最低。

• 设置includeLocation=false ，打印位置信息会急剧降低异步日志的性能，比同步日志还要慢。

三、Spring Boot中日志的使用

  Spring Boot框架在企业中的使用越来越普遍，springboot日志也是开发中常用的日志系统。Spring Boot默认的是使用SLF4J作为日志门面，logback作为日志实现来记录日志。

Spring Boot底层默认使用logback作为日志实现，并使用了SLF4J作为日志门面。能将JUL也转换为SLF4J，也可以将log4j作为日志门面，但是最终也是通过SLF4J调用logback。

导入默认依赖：

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

直接上代码：

@SpringBootTest
class SpringbootLogApplicationTests {
  //记录器
 public static final Logger LOGGER = LoggerFactory.getLogger(SpringbootLogApplicationTests.class);
  @Test
  public void contextLoads() {
    // 打印日志信息
    LOGGER.error("error");
    LOGGER.warn("warn");
    LOGGER.info("info"); // 默认日志级别
    LOGGER.debug("debug");
    LOGGER.trace("trace");
    }
}

配置文件：

给类路径下放上每个日志框架自己的配置文件；SpringBoot就不使用默认配置的了

日志框架	配置文件
Logback	logback-spring.xml , logback.xml
Log4j2	log4j2-spring.xml ， log4j2.xml
JUL	logging.properties

logback-spring.xml：由SpringBoot解析日志配置

<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
      <springProfile name="dev">
        <pattern>${pattern}</pattern>
      </springProfile>
      <springProfile name="pro">
        <pattern>%d{yyyyMMdd:HH:mm:ss.SSS} [%thread] %-5level %msg%n</pattern>
      </springProfile>
</encoder>

在配置文件中application.properties配置：

spring.profiles.active=dev

日志切换

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
  <exclusions>
    <!--排除logback-->
    <exclusion>
      <artifactId>spring-boot-starter-logging</artifactId>
      <groupId>org.springframework.boot</groupId>
    </exclusion>
  </exclusions>
</dependency>
<!-- 添加log4j2 -->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-log4j2</artifactId>
</dependency>