【日志】java日志框架整理

2 现有的日志框架

2.1 日志门面和日志实现的关系

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

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

2.2 日志框架出现的历史顺序

log4j -->JUL-->JCL--> slf4j --> logback --> log4j2

2.3 日志门面

• JCL（Jakarta Commons Logging）(只能操作JUL和log4j)
• slf4j（ Simple Logging Facade for Java）（代替jcl，可以操作所有的日志框架）

2.4 日志实现

• JUL（java util logging）
• logback
• log4j
• log4j2（既是日志门面，也是日志实现，作为日志门面不常用，常用slf4j+log4j2）

3. (日志实现)JUL学习(支持占位符)

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

3.2 架构介绍

• Loggers：被称为记录器，应用程序通过获取Logger对象，调用其API来来发布日志信息。Logger通常是应用程序访问日志系统的入口程序。(每个记录器又一个唯一标识,通常以当前类的全限定类名命名)
• Appenders：也被称为Handlers(处理器)，每个Logger都会关联一组Handlers，Logger会将日志交给关联Handlers处理，由Handlers负责将日志做记录。Handlers在此是一个抽象，其具体的实现决定了
  日志记录的位置可以是控制台、文件、网络上的其他日志服务或操作系统日志等。
• Layouts：也被称为Formatters，它负责对日志事件中的数据进行转换和格式化。Layouts决定了数据在一条日志记录中的最终形式。
• Level：每条日志消息都有一个关联的日志级别。该级别粗略指导了日志消息的重要性和紧迫，可以将Level和Loggers、Appenders做关联以便于我们过滤消息。Loggers的日志级别用于控制记录哪些日志，而Appenders的日志级别用于控制日志信息的输出目标。通过合理配置Logger和Appender的日志级别，可以实现对日志信息的有效管理和利用。
• Filters：过滤器，根据需要定制哪些信息会被记录，哪些信息会被放过。

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

3.3 使用

//快速入门
    @Test
    public void test1() {
        //1.获取日志记录器对象
        Logger logger = Logger.getLogger("com.sitech.Test2");//通常以当前类的全限定类名命名,每个记录器的唯一标识
        //2.日志记录输出(info是级别）
        logger.info("hello jul===");

        //3.通用方法进行日志记录
        logger.log(Level.INFO, "message info");

        //4.通过占位符 方式输出变量值
        String name = "chenyanjei";
        Integer age = 123;
        logger.log(Level.INFO, "用户信息：{0},{1}", new Object[]{name, age});
    }

3.4 日志级别(7个)

日志 从高到底 SEVERE> WARNING > INFO(默认） > CONFIG > FINE > FINER > FINEST

//日志级别  7个
    @Test
    public void test2() {
        Logger logger = Logger.getLogger("com.sitech.Test2");
        //日志 从高到底 SEVERE> WARNING > INFO(默认） >  CONFIG > FINE > FINER > FINEST
        
        //public static final Level SEVERE = new Level("SEVERE",1000, defaultBundle); 值越大,级别越高
        logger.log(Level.SEVERE, "sever");//错误信息
        logger.log(Level.WARNING, "WARNING");
        logger.log(Level.INFO, "INFO");//**默认日志级别**
        logger.log(Level.CONFIG, "CONFIG");//配置文件信息
        logger.log(Level.FINE, "FINE");//debug日志记录
        logger.log(Level.FINER, "FINER");//debug日志记录
        logger.log(Level.FINEST, "FINEST");//debug日志记录
    }

说明:
默认级别是info级别,所以不会输出级别低于INFO的日志.

3.5 自定义日志级别输出

//自定义日志级别
    @Test
    public void testLogConfig() throws IOException {
        //1.获取日志记录器对象
        Logger logger = Logger.getLogger("Test2");

        /**
         * 自定义配置日志级别
         */
        //2.创建ConsolHandler，控制台的输出
        ConsoleHandler consoleHandler = new ConsoleHandler();

        //3.创建简单格式转化对象
        SimpleFormatter simpleFormatter = new SimpleFormatter();
        //进行关联,handler管理formatter ,logger管理handler

        consoleHandler.setFormatter(simpleFormatter);
        logger.addHandler(consoleHandler);
        /**
         *    关闭系统默认配置
         *    配置具体的级别
         */
        logger.setUseParentHandlers(false);//关闭
        logger.setLevel(Level.ALL );//logger对象级别
        consoleHandler.setLevel(Level.ALL);//处理器handler的级别，默认info级别

        /**
         * 场景FileHandler，输出到文件
         */
        FileHandler fileHandler = new FileHandler("F:\\maven_study\\maven_log\\maven_jul\\src\\main\\java\\com\\sitech\\1.log");
        //进行关联
        fileHandler.setFormatter(simpleFormatter);
        logger.addHandler(fileHandler);
        //配置具体的级别
        fileHandler.setLevel(Level.WARNING);//处理器handler的级别，默认all

        logger.log(Level.SEVERE, "sever你好啊");
        logger.log(Level.WARNING, "WARNING");
        logger.log(Level.INFO, "INFO");//默认日志级别
        logger.log(Level.CONFIG, "CONFIG");
        logger.log(Level.FINE, "FINE");
        logger.log(Level.FINER, "FINER");
        logger.log(Level.FINEST, "FINEST");
    }

• 控制台输出
  

• 文件内容
  

3.6 Logger对象父子关系

@Test
    public void testLogParentRelation() {
        Logger logger1 = Logger.getLogger("com");//logger2 是logger1的子对象
        Logger logger2 = Logger.getLogger("com.sitech");
        System.out.println(logger1.getName());//com
        System.out.println(logger2.getName());//com.cskaoyan
        System.out.println(logger1);//Logger对象 java.util.logging.Logger@4dcbadb4
        System.out.println(logger2);//Logger对象 java.util.logging.Logger@4e515669
        Logger parent = logger2.getParent();
        System.out.println(parent);//Logger对象 java.util.logging.Logger@4dcbadb4
        System.out.println(parent.getName());//com
        System.out.println(parent.equals(logger1));//true

        Logger logger1Parent = logger1.getParent();
        System.out.println(logger1Parent);//LogManager$RootLogger所有日志记录器的顶级父元素
        System.out.println(logger1Parent.getName());//""空


        /**
         * 设置logger1的日志级别（父）
         */
        //2.创建ConsolHandler，控制台的输出
        ConsoleHandler consoleHandler = new ConsoleHandler();

        //3.创建简单格式转化对象
        SimpleFormatter simpleFormatter = new SimpleFormatter();
        //进行关联

        consoleHandler.setFormatter(simpleFormatter);
        logger1.addHandler(consoleHandler);
        /**
         *    关闭系统默认配置
         *    配置具体的级别
         */
        logger1.setUseParentHandlers(false);//关闭
        logger1.setLevel(Level.ALL );//logger对象级别
        consoleHandler.setLevel(Level.CONFIG);//处理器handler的级别，默认info级别

        //设置父日志对象级别后，子日志对象也会生效
        logger2.log(Level.SEVERE, "sever你好啊");
        logger2.log(Level.WARNING, "WARNING");
        logger2.log(Level.INFO, "INFO");//默认日志级别
        logger2.log(Level.CONFIG, "CONFIG");
        logger2.log(Level.FINE, "FINE");
        logger2.log(Level.FINER, "FINER");
        logger2.log(Level.FINEST, "FINEST");
    }

3.7 配置文件

• logging.properties

#RootLogger顶级父元素指定的默认处理器：
handlers= java.util.logging.ConsoleHandler,java.util.logging.FileHandler

#RootLOgger顶级父元素默认的日志级别为：ALL
.level= ALL


# 向日志文件输出的 handler 对象
#指定日志文件路径 D:/java%u.log
java.util.logging.FileHandler.pattern = ./java%u.log
# 指定日志文件内容大小
java.util.logging.FileHandler.limit = 50000
# 指定日志文件数量
java.util.logging.FileHandler.count = 1
# 指定 handler 对象日志消息格式对象
java.util.logging.FileHandler.formatter = java.util.logging.SimpleFormatter
# 指定以追加方式添加日志内容
java.util.logging.FileHandler.append = true
java.util.logging.FileHandler.level = WARNING



# 向控制台输出的 handler 对象
# 指定 handler 对象的日志级别
java.util.logging.ConsoleHandler.level = ALL
# 指定 handler 对象的日志消息格式对象
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter
# 指定 handler 对象的字符集
java.util.logging.ConsoleHandler.encoding = UTF-8
# 指定日志消息格式
java.util.logging.SimpleFormatter.format = %4$s: %5$s [%1$tc]%n


#配置自定义Logger
com.aa.handlers = java.util.logging.ConsoleHandler
com.aa.level = CONFIG
#关闭默认配置
com.aa.useParentHandlers = false

 /**
     * 加载自定义配置文件
     */
    @Test
    public  void testMyConfig() throws IOException {
        //读取配置文件
        InputStream resourceAsStream = Test2.class.getClassLoader().getResourceAsStream("logging.properties");
        //创建LogManager
        LogManager logManager = LogManager.getLogManager();
        //通过LogManager加载配置文件
        logManager.readConfiguration(resourceAsStream);

        //创建日志记录器
//        Logger logger = Logger.getLogger("com.aa.handlers");
        Logger logger = Logger.getLogger("com.aa.handlers.bb");
//        Logger logger = Logger.getLogger("com.Test2");
        logger.log(Level.SEVERE, "sever你好啊");
        logger.log(Level.WARNING, "WARNING");
        logger.log(Level.INFO, "INFO");//默认日志级别
        logger.log(Level.CONFIG, "CONFIG");
        logger.log(Level.FINE, "FINE");
        logger.log(Level.FINER, "FINER");
        logger.log(Level.FINEST, "FINEST");
    }

3.9 自定义logger

#配置自定义Logger
com.aa.handlers = java.util.logging.ConsoleHandler
com.aa.level = CONFIG
#关闭默认配置
com.aa.useParentHandlers = false

3.8 日志原理解析

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

4. (日志实现)LOG4J 学习 （不支持占位符）

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

官方网站： http://logging.apache.org/log4j/1.2/

4.1 Log4j入门

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

4.2 初步使用

 @Test
    public void fun1() {
        //初始化系统配置，不需要配置文件
        BasicConfigurator.configure();
        //创建日志记录器对象
        Logger logger = Logger.getLogger(FirstDemo.class);
        System.out.println(logger.getName());//com.sitech.FirstDemo
        //日志记录输出
        logger.info("hello log4j");
        //日志级别
        //fatal > error >warn >info >debug(默认) > trace
        logger.fatal("fatal");//严重错误，一般会造成系统崩溃和终止运行
        logger.error("error");//错误信息，但不会影响系统运行
        logger.warn("warn");//警告信息，可能会发生问题
        logger.info("info");//程序运行信息，数据库的连接、网络、IO操作等
        logger.debug("debug");//调试信息，一般在开发阶段使用，记录程序的变量、参数等
        logger.trace("trace");//追踪信息，记录程序的所有流程信息

    }

4.3 Log4j组件

Log4J 主要由 Loggers (日志记录器)、Appenders（输出端）和 Layout（日志格式化器）组成。其中

• Loggers 控制日志的输出级别与日志是否输出；
• Appenders 指定日志的输出方式（输出到控制台、文件等）；
• Layout 控制日志信息的输出格式。

4.3.1 Loggers

日志记录器，负责收集处理日志记录，实例的命名就是类“XX”的full quailied name（类的全限定名），Logger的名字大小写敏感，其命名有继承机制：例如：name为org.apache.commons的logger会继承
name为org.apache的logger。

Log4J中有一个特殊的logger叫做“root”，他是所有logger的根，也就意味着其他所有的logger都会直接或者间接地继承自root。root logger可以用Logger.getRootLogger()方法获取。
但是，自log4j 1.2版以来， Logger 类已经取代了 Category 类。对于熟悉早期版本的log4j的人来说，
Logger 类可以被视为 Category 类的别名。

4.3.2 Appenders

Appender 用来指定日志输出到哪个地方，可以同时指定日志的输出目的地。Log4j 常用的输出目的地有以下几种：

输出端类型	作用
ConsoleAppender	将日志输出到控制台
FileAppender	将日志输出到文件中
DailyRollingFileAppender	将日志输出到一个日志文件，并且每天输出到一个新的文件 (DailyRollingFileAppender并不管理已生成日志文件的删除或保留天数,无法限制存储日志的天数,时间一久导致日志文件很多)
RollingFileAppender	将日志信息输出到一个日志文件，并且指定文件的尺寸，当文件大小达到指定尺寸时，会自动把文件改名，同时产生一个新的文件(可以通过MaxBackupIndex控制文件个数, 超过个数后,会依次覆盖)
JDBCAppender	把日志信息保存到数据库中

4.3.3 Layouts

布局器 Layouts用于控制日志输出内容的格式，让我们可以使用各种需要的格式输出日志。Log4j常用的Layouts:

格式化器类型	作用
HTMLLayout	格式化日志输出为HTML表格形式
SimpleLayout	简单的日志输出格式化，打印的日志格式为（info - message）
PatternLayout	最强大的格式化期，可以根据自定义格式输出日志，如果没有指定转换格式，就是用默认的转换格式

4.4 Layout的格式(配置文件) （log4j.properties）

在 log4j.properties 配置文件中，我们定义了日志输出级别与输出端，在输出端中分别配置日志的输出格式。

* log4j 采用类似 C 语言的 printf 函数的打印格式格式化日志信息，具体的占位符及其含义如下：
%m 输出代码中指定的日志信息
%p 输出优先级，及 DEBUG、INFO 等
%n 换行符（Windows平台的换行符为 "\n"，Unix 平台为 "\n"）
%r 输出自应用启动到输出该 log 信息耗费的毫秒数
%c 输出打印语句所属的类的全名
%t 输出产生该日志的线程全名
%d 输出服务器当前时间，默认为 ISO8601，也可以指定格式，如：%d{yyyy年MM月dd日
HH:mm:ss}
%l 输出日志时间发生的位置，包括类名、线程、及在代码中的行数。如：
Test.main(Test.java:10)
%F 输出日志消息产生时所在的文件名称
%L 输出代码中的行号
%% 输出一个 "%" 字符
* 可以在 % 与字符之间加上修饰符来控制最小宽度、最大宽度和文本的对其方式。如：
%5c 输出category名称，最小宽度是5，category<5，默认的情况下右对齐
%-5c 输出category名称，最小宽度是5，category<5，"-"号指定左对齐,会有空格
%.5c 输出category名称，最大宽度是5，category>5，就会将左边多出的字符截掉，<5不
会有空格
%20.30c category名称<20补空格，并且右对齐，>30字符，就从左边交远销出的字符截掉

4.5 Appender的输出

控制台，文件，数据库

#指定日志的输出级别与输出端
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')

CREATE TABLE `log` (
`log_id` int(11) NOT NULL AUTO_INCREMENT,
`project_name` varchar(255) DEFAULT NULL COMMENT '目项名',
`create_date` varchar(255) DEFAULT NULL COMMENT '创建时间',
`level` varchar(255) DEFAULT NULL COMMENT '优先级',
`category` varchar(255) DEFAULT NULL COMMENT '所在类的全名',
`file_name` varchar(255) DEFAULT NULL COMMENT '输出日志消息产生时所在的文件名称 ',
`thread_name` varchar(255) DEFAULT NULL COMMENT '日志事件的线程名',
`line` varchar(255) DEFAULT NULL COMMENT '号行',
`all_category` varchar(255) DEFAULT NULL COMMENT '日志事件的发生位置',
`message` varchar(4000) DEFAULT NULL COMMENT '输出代码中指定的消息',
PRIMARY KEY (`log_id`)
);

4.6 自定义logger

log4j.logger.com.sitech.throwbill.easyask=INFO,console

4.7日志级别（6个日志级别）

fatal > error >warn >info >debug(默认) > trace

4.8 log4j.properties

#Log lever: off, fatal, error, warn, info, debug
# 指定RootLogger顶级父元素默认配置信息
# 指定日志级别=info , appender为： console,rollingFile,I,D,E
log4j.rootLogger=info,console,rollingFile,I,D,E

#Output target: org.apache.log4j.ConsoleAppender,
log4j.appender.console=org.apache.log4j.ConsoleAppender
#log4j.appender.console.layout=org.apache.log4j.HTMLLayout
#log4j.appender.console.layout=org.apache.log4j.SimpleLayout
#log4j.appender.console.layout=org.apache.log4j.xml.XMLLayout
#log4j.appender.console.layout=org.apache.log4j.TTCCLayout

#PatternLayout和conversionPattern配套使用
log4j.appender.console.layout=org.apache.log4j.PatternLayout 
#log4j.appender.console.layout.ConversionPattern=%X{traceId}--%-d{yyyy-MM-dd HH:mm:ss} [ %t:%r ] - [ %p ] %m%n
log4j.appender.console.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss} [ %t:%r ] - [ %p ] %m%n



### 输出到文件
#log4j.appender.file=org.apache.log4j.FileAppender
## 指定日志文件保存路径
#log4j.appender.file.File=${catalina.home}/logs/sdxtweb.log
##指定消息格式 layout：HTMLLayout / SimpleLayout/ PatternLayout/xml.XMLLayout
#log4j.appender.file.layout=org.apache.log4j.PatternLayout
#log4j.appender.file.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss} [ %t:%r ] - [ %p ] %m%n
## 指定日志文件的字符集
#log4j.appender.file.encoding = UTF-8
#log4j.appender.file.Threshold = INFO
#log4j.appender.file.MaxFileSize=102400KB
#log4j.appender.file.MaxBackupIndex=5
#log4j.appender.file.Append = true

#info日志  DailyRollingFileAppender并不管理已生成日志文件的删除或保留天数,无法限制存储日志的天数
log4j.appender.I = org.apache.log4j.DailyRollingFileAppender
log4j.appender.I.File = ${catalina.home}/logs/info-sdxtweb.log
log4j.appender.I.Append = true
log4j.appender.I.Threshold = INFO
log4j.appender.I.layout = org.apache.log4j.PatternLayout
log4j.appender.I.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss} [ %t:%r ] - [ %p ] %m%n
#这里是设置info日志过滤器的最小日志级别和最大日志级别，这样info-log就会过滤调除info以外的其他日志。
log4j.appender.I.filter.F1=org.apache.log4j.varia.LevelRangeFilter
log4j.appender.I.filter.F1.LevelMin=INFO
log4j.appender.I.filter.F1.LevelMax=INFO

log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
log4j.appender.D.File = ${catalina.home}/logs/debug-sdxtweb.log
log4j.appender.D.Append = true
log4j.appender.D.Threshold = DEBUG
log4j.appender.D.layout = org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss} [ %t:%r ] - [ %p ] %m%n
log4j.appender.D.filter.F1=org.apache.log4j.varia.LevelRangeFilter
log4j.appender.D.filter.F1.LevelMin=DEBUG
log4j.appender.D.filter.F1.LevelMax=DEBUG

log4j.appender.E = org.apache.log4j.DailyRollingFileAppender
log4j.appender.E.File = ${catalina.home}/logs/error-sdxtweb.log
log4j.appender.E.Append = true
log4j.appender.E.Threshold = ERROR
log4j.appender.E.layout = org.apache.log4j.PatternLayout
log4j.appender.E.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss} [ %t:%r ] - [ %p ] %m%n
log4j.appender.E.filter.F1=org.apache.log4j.varia.LevelRangeFilter
log4j.appender.E.filter.F1.LevelMin=ERROR
log4j.appender.E.filter.F1.LevelMax=ERROR


log4j.appender.rollingFile=org.apache.log4j.RollingFileAppender
log4j.appender.rollingFile.layout=org.apache.log4j.TTCCLayout
log4j.appender.rollingFile.File=${catalina.home}/logs/sdxtweb.log
log4j.appender.rollingFile.MaxFileSize=102400KB
#超过个数后会轮训覆盖
log4j.appender.rollingFile.MaxBackupIndex=5

log4j.appender.dailyRollingFile=org.apache.log4j.DailyRollingFileAppender
log4j.appender.dailyRollingFile.layout=org.apache.log4j.TTCCLayout
log4j.appender.dailyRollingFile.File=${catalina.home}/tmp/logs/sdxtweb.log
log4j.appender.dailyRollingFile.DatePattern=yyyy-MM-dd-HH-mm
#
#log4j.logger.java.sql.ResultSet=INFO
#log4j.logger.org.apache=INFO
#log4j.logger.java.sql.Connection=DEBUG
#log4j.logger.java.sql.Statement=DEBUG
#log4j.logger.java.sql.PreparedStatement=DEBUG
#log4j.logger.org.mybatis=DEBUG

log4j.logger.com.sitech.throwbill.easyask=INFO

5. JCL 学习（日志门面）（不支持占位符）

全称为Jakarta Commons Logging，是Apache提供的一个通用日志API。
它是为 "所有的Java日志实现"提供一个统一的接口，它自身也提供一个日志的实现，但是功能非常常弱（SimpleLog）。所以一般不会单独使用它。他允许开发人员使用不同的具体日志实现工具: Log4j, Jdk, 默认使用JDK
自带的日志（JUL)
JCL 有两个基本的抽象类：Log(基本记录器)和LogFactory(负责创建Log实例)。

5.1 初步使用

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

@Test
    public void test1() {
        //获取Log日志记录器对象
        Log log= LogFactory.getLog(Demo1.class);
        //日志记录输出
        log.info("JCL Hello");

        log.fatal("fatal");//
        log.error("error");//
        log.warn("warn");//警告
        log.info("info");//运行
        log.debug("debug");//
        log.trace("trace");//
    }

我们为什么要使用日志门面：

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

5.2 原理

5.3 日志级别(6个日志 级别）

fatal > error >warn >info >debug(默认) > trace

5.4 分析

如果后续有新的日志框架, 就无法扩展了 （所以后续被淘汰了），后续引入slf4j日志门面技术，支持主流框架，并且后续可以扩展。
JCL在2014年被apache淘汰,推出了更优秀的日志门面框架.

6. slf4j日志门面(支持占位符)

简单日志门面(Simple Logging Facade For Java) SLF4J主要是为了给Java日志访问提供一套标准、规范的API框架，其主要意义在于提供接口，具体的实现可以交由其他日志框架，例如log4j和logback等。
当然slf4j自己也提供了功能较为简单的实现，但是一般很少用到。对于一般的Java项目而言，日志框架
会选择slf4j-api作为门面，配上具体的实现框架（log4j、logback等），中间使用桥接器完成桥接。

官方网站： https://www.slf4j.org/

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

1. 日志框架的绑定
2. 日志框架的桥接

6.1 依赖

 <!--slf4j日志门面-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.26</version>
        </dependency>

        <!--******************************slf4j内置的简单实现******************************-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>1.7.8</version>
        </dependency>

6.2 初步使用

public class Demo1 {
    private static final Logger logger= LoggerFactory.getLogger(Demo1.class);

    //快速入门
    @Test
    public void test1() {
        //日志输出
        //日志级别:error > warn > info(默认) > debug > trace
       logger.error("error");
       logger.warn("warn");
       logger.info("info");
       logger.debug("debug");
       logger.trace("trace");
       //使用占位符，输出日志信息
        String name="陈彦杰";
        Integer age=14;
        logger.info("用户:{},{}",name,age);
        //将系统的异常信息输出
        try {
            int i = 1 / 0;
        } catch (Exception e) {
            logger.error("错误信息为:{}",e.getMessage(),e);
        }
    }
}

6.3 slf4j-simple 日志级别(5个)

error > warn > info(默认) > debug > trace

6.4 日志绑定

SLF4J支持各种日志框架。SLF4J发行版附带了几个称为“SLF4J绑定”的jar文件，每个绑定对应一个受支持的框架。
使用slf4j的日志绑定流程:

1. 添加slf4j-api的依赖
2. 使用slf4j的API在项目中进行统一的日志记录
3. 绑定具体的日志实现框架
   1. 绑定已经实现了slf4j的日志框架,直接添加对应依赖
   2. 绑定没有实现slf4j的日志框架,先添加日志的适配器,再添加实现类的依赖
4. slf4j有且仅有一个日志实现框架的绑定（如果出现多个默认使用第一个依赖日志实现）

6.4.1 自带日志简单日志实现

<!--slf4j日志门面-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.26</version>
        </dependency>
         <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>1.7.8</version>
        </dependency>

6.4.2 logback

 		<dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.26</version>
        </dependency>
		<dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>

6.4.3 开关关闭nop

		<dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.26</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-nop</artifactId>
            <version>1.7.25</version>
        </dependency>

6.4.4 log4j

  <!--log4j日志框架的使用  适配器+slf4j日志框架-->
       <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.26</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.12</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

6.4.5 jul

		 <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.26</version>
        </dependency>
	   <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-jdk14</artifactId>
            <version>1.7.25</version>
        </dependency>

6.5 桥接器

通常，您依赖的某些组件依赖于SLF4J以外的日志记录API。您也可以假设这些组件在不久的将来不会切
换到SLF4J。为了解决这种情况，SLF4J附带了几个桥接模块，这些模块将对log4j，JCL和java.util.logging API的调用重定向，就好像它们是对SLF4J API一样。
桥接解决的是项目中日志的遗留问题，当系统中存在之前的日志API，可以通过桥接转换到slf4j的实现

1. 先去除之前老的日志框架的依赖
2. 添加SLF4J提供的桥接组件
3. 为项目添加SLF4J的具体实现

**注意:**(本地学习测试没有复现报错的情况)

1. jcl-over-slf4j.jar和 slf4j-jcl.jar不能同时部署。前一个jar文件将导致JCL将日志系统的选择委托给SLF4J，后一个jar文件将导致SLF4J将日志系统的选择委托给JCL，从而导致无限循环。
2. log4j-over-slf4j.jar和slf4j-log4j12.jar不能同时出现
3. jul-to-slf4j.jar和slf4j-jdk14.jar不能同时出现
4. 所有的桥接都只对Logger日志记录器对象有效，如果程序中调用了内部的配置类或者是
   Appender,Filter等对象，将无法产生效果。

eg:
旧项目是log4j
改成slf4j和logback

 <!--slf4j日志门面-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.26</version>
        </dependency>
         <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>
          <!--配置log4j-over-slf4j桥接器-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>log4j-over-slf4j</artifactId>
            <version>1.7.25</version>
        </dependency>
        

7.logback（springboot默认的实现）

Logback是由log4j创始人设计的另一个开源日志组件，性能比log4j要好。
官方网站：https://logback.qos.ch/index.html

Logback主要分为三个模块：

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

后续的日志代码都是通过SLF4J日志门面搭建日志系统，所以在代码是没有区别，主要是通过修改配置
文件和pom.xml依赖

7.1 依赖

   <!--slf4j日志门面-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.26</version>
        </dependency>
        <!--logback日志实现-->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>

7.2 使用

 @Test
    public void test1() {
        System.out.println("rrr");
        //日志输出
       logger.error("error");
       logger.warn("warn");
       logger.info("info");
       logger.debug("debug");
       logger.trace("trace");
       //使用占位符，输出日志信息
        String name="123";
        Integer age=14;
        logger.info("用户:{},{}",name,age);
        //将系统的异常信息输出
        try {
            int i = 1 / 0;
        } catch (Exception e) {
            logger.error("错误信息为:{}",e.getMessage(),e);
        }
    }

7.3 日志级别（5个）

error > warn > info > debug(默认) > trace

7.4 配置文件

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

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

• logback组件之间的关系
  1. Logger:日志的记录器，把它关联到应用的对应的context上后，主要用于存放日志对象，也
     可以定义日志类型、级别。
  2. Appender:用于指定日志输出的目的地，目的地可以是控制台、文件、数据库等等。
  3. Layout:负责把事件转换成字符串，格式化的日志信息的输出。在logback中Layout对象被封
     装在encoder中。

7.4.1 根节点<configuration>

● scan:当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true。
● scanPeriod:设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。当scan为true时，此属性生效。默认的时间间隔为1分钟。
● debug:当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。

<configuration scan="true" scanPeriod="60 seconds" debug="false">  
      <!-- 其他配置省略-->  
</configuration>  

7.4.2 完整配置文件

<?xml version="1.0" encoding="UTF-8"?>
<configuration scan="true" scanPeriod="60 seconds" debug="false">
    <!--配置集中管理属性
        后期，我们可以直接修改属性的value值
        格式：${name}
    -->

    <property name="pattern" value="[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} %c %M %L %m %n"></property>
    <!--日志输出格式：-->
    <!--%-5level-->
    <!--%d{yyyy-MM-dd HH:mm:ss.SSS}日期-->
    <!--%c类的完整名称-->
    <!--%M为method-->
    <!--%L为行号-->
    <!--%thread线程名称-->
    <!--%m或者%msg为信息-->
    <!--%n换行-->

    <!--控制台日志输出的 appender-->
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <!--控制输出流对象，默认System.out(白色), 改为System.err(红色) -->
<!--        <target>System.err</target>-->
        <target>System.out</target>
        <!--日志消息格式配置-->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>


    <!--定义日志文件保存路径属性-->
    <property name="log_dir" value="D:/logs"></property>、
    <!--根目录-->
    <!--<property name="log_dir" value="./logs"></property>-->


    <!--日志文件输出的appender-->
    <!--<appender name="file" class="ch.qos.logback.core.FileAppender">-->
    <!--    &lt;!&ndash;日志文件保存路径&ndash;&gt;-->
    <!--    <file>${log_dir}/logback.log</file>-->
    <!--    &lt;!&ndash;日志消息格式配置&ndash;&gt;-->
    <!--    <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">-->
    <!--        <pattern>${pattern}</pattern>-->
    <!--    </encoder>-->
    <!--</appender>-->

    <!--Appender: 设置日志信息的去向,常用的有以下几个
        ch.qos.logback.core.ConsoleAppender (控制台)
        ch.qos.logback.core.rolling.RollingFileAppender (文件大小到达指定尺寸的时候产生一个新文件)
        ch.qos.logback.core.FileAppender (文件)
    -->

    <!--html格式日志文件输出， appender-->
    <!--<appender name="htmlfile" class="ch.qos.logback.core.FileAppender">-->
    <!--    &lt;!&ndash;日志文件保存路径&ndash;&gt;-->
    <!--    &lt;!&ndash;<file>${log_dir}/logback.log</file>&ndash;&gt;-->
    <!--    <file>${log_dir}/logback.html</file>-->
    <!--    &lt;!&ndash;html 消息格式配置&ndash;&gt;-->
    <!--    <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">-->
    <!--        <layout class="ch.qos.logback.classic.html.HTMLLayout">-->
    <!--            &lt;!&ndash;<pattern>${pattern}</pattern>&ndash;&gt;-->
    <!--            <pattern>%-5level%d{yyyy-MM-dd HH:mm:ss.SSS}%c%M%L%m%n</pattern>-->
    <!--        </layout>-->
    <!--    </encoder>-->
    <!--</appender>-->


    <!--日志拆分和归档压缩的appender对象-->
    <appender name="rollFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!--日志文件保存路径-->
        <file>${log_dir}/roll_logback.log</file>
        <!--日志消息格式配置-->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
        <!--指定拆分规则-->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <!--按照时间和压缩格式声明拆分的文件名-->
            <!--日志文件拆分规则：日志压缩文件按照秒拆分（精确到秒），当日志文件超过 1 MB 时，
            日志文件会再次进行拆分，且日志文件名中的 .log%i.gz 中的 i 就会自加。-->
            <fileNamePattern>${log_dir}/rolling.%d{yyyy-MM-dd-HH-mm-ss}.log%i.gz</fileNamePattern>
            <!--<fileNamePattern>${log_dir}/rolling.%d{yyyy-MM-dd-HH-mm-ss}.log%i.gz</fileNamePattern>-->
            <!--以天拆分-->
            <!--<fileNamePattern>${log_dir}/rolling.%d{yyyy-MM-dd}.log%i.gz</fileNamePattern>-->
            <!--按照文件大小拆分-->
            <maxFileSize>1MB</maxFileSize>
        </rollingPolicy>
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
<!--            日志过滤规则,超过INFO级别的,接受,  非超过的,拒绝-->
            <level>INFO</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

<!--    异步日志-->
    <appender name="async" class="ch.qos.logback.classic.AsyncAppender">
<!--        指定具体某个appender-->
        <appender-ref ref="rollFile"/>
    </appender>

    <!--root logger配置-->
    <root level="INFO">
        <appender-ref ref="console"/>
        <appender-ref ref="rollFile"/>
<!--        <appender-ref ref="async"/>-->
    </root>
<!--
自定义logger
additivity="false" 自定义logger对象是否向上级传递


-->
    <logger  level="ERROR" name="com.sitech" additivity="false">
        <appender-ref ref="console"/>
        <appender-ref ref="rollFile"/>
    </logger>

</configuration>

8.log4j2（目前性能最好，没有之一）

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

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

官网： https://logging.apache.org/log4j/2.x/

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

8.1 作为日志门面+实现时依赖

<!-- 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>

8.2 作为日志门面+实现时使用

@Test
    public void test1() {
        System.out.println("rrr");
        //日志输出
        // fatal > error(默认） > warn > info > debug > trace
        logger.fatal("fatal");
        logger.error("error");
        logger.warn("warn");
        logger.info("info");
        logger.debug("debug");
        logger.trace("trace");
       //使用占位符，输出日志信息
        String name="123";
        Integer age=14;
        logger.info("用户:{},{}",name,age);
        //将系统的异常信息输出
        try {
            int i = 1 / 0;
        } catch (Exception e) {
            logger.error("错误信息为:{}",e.getMessage(),e);
        }
    }

8.3 作为日志门面+实现时日志级别（6个）

fatal > error(默认） > warn > info > debug > trace

8.4 使用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>

9. SpringBoot中的日志使用

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

总结：
1. springboot 底层默认使用logback作为日志实现。
2. 使用了SLF4J作为日志门面
3. 将JUL也转换成slf4j
4. 也可以使用log4j2作为日志门面，但是最终也是通过slf4j调用logback

9.1 日志级别

error > warn > info(默认） > debug > trace

9.2 在springboot中测试打印日志

//记录器
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");
}

9.3 修改默认日志配置(方式一）

直接在配置文件中修改

logging.level.com.itheima=trace
  # 在控制台输出的日志的格式 同logback
logging.pattern.console=%d{yyyy-MM-dd} [%thread] [%-5level] %logger{50} -%msg%n
  # 指定文件中日志输出的格式
logging.file=D:/logs/springboot.log
logging.pattern.file=%d{yyyy-MM-dd} [%thread] %-5level %logger{50} - %msg%n

9.4 指定配置文件（方式二）

• 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

9.5 将日志切换为log4j2

<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>

问题记录

在tomcat的Catalina.out可以看到报错记录，但是日志文件info，debug都无法看到

public static void main(String[] args) {
        //日志记录输出
        System.out.println("ff");
        logger.info("hello log4j");
        logger.error("hello", "f", "f");
        try {
            int a = 1 / 0;
        } catch (Exception e) {
            e.printStackTrace();//日志文件中没有
            logger.error("错误:{}", e.getMessage(), e);
        }
    }

e.printStackTrace()只会将日志打印到控制台，不会进入日志文件，类似的还有
System.out.println("ff")也不会打印进日志文件。