日志文件是用于记录系统操作事件的文件集合。
日志文件它具有处理历史数据、诊断问题的追踪以及理解系统的活动等重要的作用。
日志可以分为：调式日志
系统日志：系统日志是用来记录系统中硬件、软件和系统相关问题的信息。同时还可以监视系统中发生的事件。用户可以通过它来检查错误发生的原因，或者寻找收到攻击是留下的痕迹。
系统日志：包括系统日志、应用日志和安全日志这几种分类。
日志的级别(通过源码查看，非常简单)
SEVERE :错误---最高级的日志级别
wARNING :警告
INFO : （默认级别）消息
CONFIG : 配置
FINE :详细信息（少)
FINER:详细信息(中)
FINEST :详细信息（多）---最低级的日志级别
两个特殊的级别
OFF 可用来关闭日志记录
ALL启用所有消息的日志记录
对于日志的级别,我们重点关注的是new对象的时候的第二个参数是一个数值
OFF Integer.MAX_VALUE整型最大值
ALL Integer. MIN_VALUE整型最小值
这个数值的意义在于，如果我们设置的日志的级别是INFO -- 800那么最终展现的日志信息，
必须是数值大于800的所有的日志信息最终展现的就是
SEVERE
wARNING
INFO
自定义日志的级别
*/
//日志记录器
Logger logger = Logger.getLogger("com.bjpowernode.jul.test.JuLTest");
/将默认的日志打印方式关闭掉
//参数设置为false，我们打印日志的方式就不会按照父logger默认的方式去进行操作
logger.setUseParentHandlers(false);
//处理器Handler
//在此我们使用的是控制台日志处理器，取得处理器对象
consoleHandler handler = new consoleHandler( );
//创建日志格式化组件对象
simpleFormatter formatter = new simpleFormatter();
//在处理器中设置输出格式
handler.setFormatter(formatter);
//在记录器中添加处理器
logger.addHandler(handler);
//设置日志的打印级别
//此处必须将日志记录器和处理器的级别进行统一的设置，才会达到日志显示相应级别的效果
logger.setLevel(Level.CONFIG);
handler.setLevei(Level.CONFIG);
/*
将日志输出到具体的磁盘文件中
这样做相当于是做了日志的持久化操作
*/
Logger logger = Logger.getLogger("com.bjpowernode.jul.test.JULTest");
logger.setUseParentHandlers(false);
//文件日志处理器
FileHandler handler = new FileHandler( patteyn: "文件路径");
simpleFormatter formatter = new simpleFormatter();
handler. setFormatter(formatter);
logger.addHandler(handler);
logger.setLevel(Level.ALL);
handler.setLevel(Level.ALL);
//文件日志处理器
FileHandler handler = new FileHandler( pattern:"文件路径");
simpleFormatter formatter = new simpleFormatter();
handler. setFormatter( formatter);
logger.addHandler(handler);
//也可以同时在控制台和文件中进行打印
consoleHandler handler2 = new consoleHandler();
handler2.setFormatter(formatter) ;
logger.addHandler(handler2); //可以在记录器中同时添加多个处理器
Logger的父子关系：
//父亲是RootLogger，名称默认是一个空的字符串
//RootLogger可以被称之为所有logger对象的顶层logger
父亲所做的设置，也能够同时作用于儿子
对logger1做日志打印相关的设置，然后我们使用logger2进行日志的打印
//父亲做设置
logger1.setuseParentHandlers(false);
ConsoleHandler handler = new ConsoleHandler();
simpleFormatter formatter = new simpleFormatter();
handler.setFormatter( formatter);
logger1.addHandler(handler);
handler.setLevel( Level.ALL);
logger1.setLevel(Leve1.ALL);
//儿子做打印
logger2.severe( msg: "severe信息");
logger2.warning( msg: "warning信息"");
以上所有的配置相关的操作，都是以java硬编码的形式进行的我们可以使用更加清晰，
更加专业的一种做法，就是使用配置文件如果我们没有自己添加配置文件，则会使用系统默认的配置文件这个配置文件:
owner.readPrimordialconfiguration( );
readconfiguration( );
java.home-->找到jre文件夹--> lib --logging . properties
//jul配置文件
#RootLogger使用的处理器，在获取RootLogger对象时进行的设置
#默认的情况下，下述配置的是控制台的处理器，只能往控制台上进行输出操作
#如果想要添加其他的处理器，在当前处理器类后面通过以逗号的形式进行分隔，可以添加多个处理器handlers= java.util.logging.ConsoleHandler
#RootLogger的日志级别
#默认的情况下，这是全局的日志级别，如果不手动配置其他的日志级别
#则默认输出下述配置的级别以及更高的级别
#文件处理器属性设置#输出日志文件的路径
java.util.logging.FileHandler.pattern = %h/java%u.log
#输出日志文件的限制(50000字节)
java.util.logging.FileHandler. limit = 50000
#设置日志文件的数量
java.util .logging.FileHandler.count = l
#输出日志的格式
#默认是以XML的方式进行的输出
java.util.logging.FileHandler.formatter = java.util.logging.XMLFormatter
#控制台处理器属性设置
#控制台输出默认的级别
java.util.logging. ConsoleHandler. level = INFO
#控制台默认输出的格式
java.util.logging.ConsoleHandler.formatter = java.util.logging.simpleFormatter
#也可以将日志级别设定到具体的某个包下
#com. xyz.foo.level = SEVERE
//自定义配置文件
Inputstream input = new FileInputstream( name: "D:\ltest\llogging.properties");
//取得日志管理器对象
LogManager logManager = LogManager.getLogManager();
//读取自定义的配置文件
logManager.readconfiguration( input);
Logger logger = Logger.getLogger("com.bjpowernode.jul.test.JuLTest");
//文件输出格式默认为不追加
#输出日志文件是否是追加
java. util.logging .FileHandler.append=truel
JUL日志框架使用方式总结（原理解析>
1.初始化LogManager
LogManager加载logging.properties配置文件添加Logger到LogManager
2.从单例的LogManager获取Logger
3.设置日志级别Level，在打印的过程中使用到了日志记录的LogRecord类
4.Filter作为过滤器提供了日志级别之外更细粒度的控制
5.Handler日志处理器，决定日志的输出位置，例如控制台、文件...6.Formatter是用来格式化输出的
LOG4J:
关于日志级别信息，例如 DEBUG、INFO、WARN、ERROR...级别是分大小的，DEBUG<INFO<WARN <ERROR，分别用来指定这条日志信息的重要程度，]
Log4j输出日志的规则是:只输出级别不低于设定级别的日志信息，
则是:只输出级别不低于设定级别的日志信息，假设Loggers 级别设定为INFO，则INFO,WARN、ERROR级别的日志信息都会输出，而级别比TNFO低的DEBUG则不会输出。
Appenders：
记录日志以及定义日志的级别仅仅是Log4j的基本功能,Log4j日志系统还提供许多强大的功能，
比如允许把日志输出到不同的地方，如控制台(Console)、文件(Files）等，可以根据天数或者文件大小产生新的文件，
可以以流的形式发送到其它地方等等。
常用Appenders:
ConsoleAppender
将日志输出到控制台
FileAppender
将日志输出到文件中
DailyRollingFileAppender
将日志输出到一个日志文件，并且每天输出到一个新的文件
RollingFileAppender
将日志信息输出到一个日志文件,并且指定文件的尺寸,当文件大小
达到指定尺寸会自动把文件改名，同时产生一个新的文件
JDBCAppender
把日志信息保存到数据库中
Layouts：
有时用户希望根据自己的喜好格式化自己的日志输出，Log4j可以在Appenders的后面附加Layouts来完成这个功能。Layouts提供四种日志输出样式，如根据HTML样式、自由指定样式、包含日志级别与信息的样式和包含日志时间、线程、类别等信息的样式。
常用Layouts:
HTMLLayout
格式化日志输出为HTML表格形式
SimpleLayout
简单的日志输出格式化，打印的日志格式如默认INFO级别的消息
PatternLayout
最强大的格式化组件，可以根据自定义格式输出日志，如果没有指定转换格式， 就是用默认的转换格式
日志输出格式说明：
使用PatternLayout可以自定义格式输出，是我们最常用的方式
这种格式化输出采用类似于 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字符，就从左边交远销出的字符截掉
LOG4J需要的依赖：
添加依赖：
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
Log4j入门案例
public void test01(){
/*
Log4j入门案例
*/
//加载初始化配置
Basicconfigurator.configure();
Logger logger = Logger.getLogger(Log4jTest01.class);
logger.info( "info信息");
}4
log4j日志级别说明：（在没有说明的情况下，debug是默认的级别）
Log4j旋供8个级别的日志输出，分别为
ALL 最低等级用于打开所有级别的日志记录
TRACE 程序推进下的追踪信息，这个追踪信息的日志级别非常低，一般情况下是不会使用的
DEBUG 指出细粒度信息事件对调试应用程序是非常有帮助的，主要是配合开发，在开发过程中打印一些重要的运行信息
INFO 消息的粗粒度级别运行信息
WARN 表示警告，程序在运行过程中会出现的有可能会发生的隐形的错误 注意，有些信息不是错误，但是这个级别的输出目的就是为了给程序员以提示
ERROR 系统的错误信息，发生的错误不影响系统的运行一般情况下，如果不想输出太多的日志，则使用该级别即可
FATAL 表示严重错误，它是那种一旦发生系统就不可能继续运行的严重错误如果这种级别的错误出现了，表示程序可以停止运行了
OFF 最高等级的级别，用户关闭所有的日志记录
日志管理器查看
便用自定义的配置文件来实现功能通过我们对于以上第一点的分析
我们的配置文件需要提供Logger、Appender、Layout这3个组件信息（通过配置来代替以上的代码)
分析:
Logger logger = Logger.getLogger(Log4jTest01.class );
进入到getLogger方法，会看到代码:
LogManager.getLogger(clazz.getName( ) );
LogManager:日志管理器
点击LogManager，看看这个日志管理器中都实现了什么
看到很多常量信息，他们代表的就是不同形式（后缀名不同）的配置文件，我们最常使用到的肯定是log4j.properties属性文件（语法简单，使用方便>
自定义输出格式
关于log4j.properties layout属性的配置
其中PatternLayout是日常使用最多的方式
查看其源码
setconversionPattern这个方法就是该PatternLayout的核心方法conversionPattern
在log4j.properties中将layout设置为PatternLayout
我们主要配置的是conversionPattern属性
[%p]%r %c%t%d{yyyy-MM-dd HH : mm : ss:sss}%m%n
可以在%与字符之间加上修饰符来控制最小宽度、最大宽度和文本的对其方式
[%10p]:[]中必须有10个字符，由空格来进行补齐，信息右对齐
[%-10p]:[门中必须有10个字符，由空格来进行补齐，信息左边对齐
log4j配置文件
1og4j.rootLogger=trace,console
#配置appender输出方式
log4j.appender.console=org.apache.log4j.consoleAppender
#配置输出的格式
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.conversionPattern=%r[%t]%p %c %x - %m%n
log4j将日志输出到文件
log4j.rootLogger=trace,file
#配置appender输出方式输出到文件
log4j.appender.file=org.apache. log4j.FileAppender
#配置输出到文件中的格式
log4j.appender.file.layout=org.apache. log4j.PatternLayout
log4j.appender.file.layout.conversionPattern=[%-10p]%r%c%t%d{yyyy-M-dd HH:mm:ss:sss} %m%n
log4j将日志输出到指定位置及字符编码设置
日志文件要保存到哪个磁盘相关的配置查看FileAppender的源码
看到属性信息
protected boolean fileAppend;表示是否追加信息，通过构造方法赋值为true
protected int buffersize;缓冲区的大小，通过构造方法赋值为8192
继续观察，找到setFile方法，这个方法就是用来指定文件位置的方法
通过ognl，可以推断setFile方法操作的属性就是file
如果有输出中文的需求怎么办观察FileAppender的父类
找到protected string encoding;属性
log4j.rootLogger=trace,file
#配置appender输出方式输出到文件
log4j.appender.file=org.apache. log4j.FileAppender
#配置输出到文件中的格式
log4j.appender.file.layout=org.apache. log4j.PatternLayout
log4j.appender.file.layout.conversionPattern=[%-10p]%r%c%t%d{yyyy-M-dd HH:mm:ss:sss} %m%n
#第一个file是我们自己命名的appenderName，第二个file是用来指定文件位置的属性
1og4j.appender.file.file=D: //test/ / log4j.log
#配置输出字符编码
logaj.appender.file.encoding=UTF-8
log4j如何将日志拆分
日志太多了，不方便管理和维护怎么办
FileAppender为我们提供了好用的子类来进一步的对于文件输出进行处理
RollingFileAppender
DailyRollingFileAppender
1.先来学习RollingFileAppender
这个类表示使用按照文件大小进行拆分的方式进行操作配置文件进行RollingFileAppender相关配置
如何进行拆分，观察RollingFileAppender的源码
protected long maxFilesize = 10485760L;表示拆分文件的大小
protected int maxBackupIndex = 1;表示拆分文件的数量
log4j.rootLogger=trace,rollingFile,console
#RollingFileAppender的配置，我们可以针对于实际含义起名
log4j.appender.rollingFile=org.apache.log4j.RollingFileAppender
log4j.appender.rollingFile.1ayout=org.apache.log4j.PatternLayout
log4j.appender.rollingFile.layout.conversionPattern=[%-10p]%r %c%t%d{yyyy-M-dd HH:mm:ss :sss] %m%n
log4j.appender.rollingFile.file=D: //test/ / log4j. log
log4j.appender.rollingFile.encoding=UTF-8
#指定日志文件内容大小
log4j.appender.rollingFile.maxFilesize=1MB
#指定日志文件的数量
log4j.appender.rollingFile.maxBackupIndex=5
如果5个文件不够怎么办，作为日志管理来讲，也不可能让日志无休止的继续增长下去所以，覆盖文件的策略是，按照时间来进行覆盖，原则就是保留新的，覆盖旧的
2.DailyRollingFileAppender
按照时间来进行文件的拆分查看源码属性:
private string datePattern = '.'"yyyy-MM-dd" ;默认是按照天来进行拆分的
log4j.rootLogger=trace,dailyRollingFile,console
#DailyRollingFileAppender的配置，我们可以针对于实际含义起名
log4j.appender.dailyRollingFile=org.apache.log4j.DailyRollingFileAppender
log4j.appender.dailyRollingFile.layout=org.apache.log4j.PatternLayout
log4j.appender .dailyRollingFile.layout.conversionPattern=[%-10p]%r %‰c%t%d{yyy-M-dd HH:mm:ss:ssS} %m%n
log4j.appender.dailyRollingFile.file=D: //test//log4j.log
1og4j.appender.dailyRollingFile.encoding=UTF-8
log4j.appender.dailyRollingFile.datePattern=' . 'yyyy-NM-dd HH-mm-ss
log4j日志持久化（写到数据库当中）
//添加数据库依赖
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.21 </version>
</dependency>
//配置文件
1og4j.rootLogger=trace,logDB
#配置appender输出方式输出到数据库表
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=123456
log4j.appender.logDB.sq1=INSERT INTO tbl_log(name,createTime,leve1,category,fileName,message)values( 'project_log' , ' %d{yyyy-MM-dd HH:mm:ss}' , '%p' , ' %c ', ' %F' , "%m')
log4j自定义logger和跟根节点同时配置时的问题
#配置自定义logger
log4j.logger.com.bjpowernode. log4j.test=info,file
观察结果!
从输出位置来看，控制台输出了信息，日志文件也输出了信息
所以可以得出结论，如果根节点的logger和自定义父logger配置的输出位置是不同的则取二者的并集，配置的位置都会进行输出操作
如果二者配置的日志级别不同，以按照我们自定的父logger的级别输出为主
SLF4J配置文件依赖：
<!--slf4j 核心依赖-->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.25</version>
</dependency>
<!--slf4j 自带的简单日志实现 -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
<version>1.7.25</version>
</dependency>
//设置jdk版本
<build>
<plugins>
<!-- 设置编译版本为1.8 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
</plugins>
</build>
//错误异常报错
Logger logger = LoggerFactory.getLogger(SLF4JTest01.class);
try {
class.forName( "aaa" );
} catch (classNotFoundException e) {
//打印栈追踪信息
//e.printstackTrace();
logger.info("xxx类中的xXX方法出现了异常，请及时关注信息");
//e是引用类型对象，不能根前面的做有效的字符串拼接
//logger.info("具体错误是:{]",e);
//我们不用加门,直接后面加上异常对象e即可
logger.info("具体错误是:",e);
集成其他日志实现之前观察官网图
SLF4]日志门面，共有3种情况对日志实现进行绑定
1.在没有绑定任何日志实现的基础之上，日志是不能够绑定实现任何功能的
值得大家注意的是，通过我们刚刚的演示，slf4j-simple是slf4j官方提供的使用的时候，也是需要导入依赖，自动绑定到slf4j门面上
如果不导入，slf4j核心依赖是不提供任何实现的
2.logback和simple（包括nop)
都是slf4j门面时间线后面提供的日志实现，所以API完全遵循slf4j进行的设计
那么我们只需要导入想要使用的日志实现依赖，即可与slf4j无缝衔接
值得一提的是nop虽然也划分到实现中了，但是他是指不实现日志记录（后续课程)
3.log4j和JUL
都是slf4j门面时间线前面的日志实现，所以API不遵循slf4j进行设计通过适配桥接的技术，完成的与日志门面的衔接
试着将logback日志框架集成进来
测试1:
在原有slf4j-simple日志实现的基础上，又集成了logback
通过测试，日志是打印出来了java.lang.classNotFoundException: aaa
通过这一句可以发现SLF4]: Actual binding is of type [org.slf4j.impl.simpleLoggerFactory]虽然集成了logback，但是我们现在使用的仍然是slf4j-simple
事实上只要出现了这个提示
SLF4]: class path contains multiple SLF4] bindings.在slf4j环境下，证明同时出现了多个日志实现
如果先导入logback依赖，后导入slf4j-simple依赖那么默认使用的就是logback依赖
如果有多个日志实现的话，默认使用先导入的实现
测试2:
将slf4j-simple注释掉
只留下logback，那么slf4j门面使用的就是logback日志实现值得一提的是，这一次没有多余的提示信息
所以在实际应用的时候，我们一般情况下，仅仅只是做一种日志实现的集成就可以了
SLF4J集成log4j的方式：
<!--导入log4j适配器依赖--><dependency>
<groupId>org.slf4j</groupId>
<artifactid>slf4j-log4j12</artifactId><version>1.7.25</version>
</dependency>
<!--导入log4j依赖-->
<dependency>
<groupId>log4j</grouprd>
<artifactId>log4j</ artifactId><version>1.2.17</version>
</dependency>
<!--导入log4j的配置文件-->
重构：
桥接器的使用步骤:
1.去除之前旧的日志框架依赖
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</ artifactId>
<version>1.2.17</version>
</ dependency>
2.添加slf4j提供的桥接组件
log4j相关的桥接器
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>log4j-over-slf4j< / artifactId>
<version>1.7.25</ver5ion>
< / dependency>
注意:
在桥接器加入之后，适配器就没有必要加入了桥接器和适配器不能同时导入依赖
LOGback:
Logback当前分成三个模块：logback-core,logback- classic和logback-access。
logback-core是其它两个模块的基础模块。
Logback配置文件:
Logback提供了3种配置文件
logback.groovy
logback-test.xml
logback.xml(一般会使用这个)
如果都不存在则采用默认的配置
Logback依赖：
导入依赖
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.25</version>
</dependency>
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.2.3</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
设置jdk版本
<build>
<plugins>
<!-- 设置编译版本为1.8 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
</plugins>
</build>
logback有5种级别的日志输出分别是：
trace < debug < info < warn < error
通过信息打印，默认的日志级别是debug，trace信息没有打印出来
Logback配置文件的使用：
在resources下面，创建一份配置文件，命名为logback.xml一切配置都是在根标签中进行操作的
<configuration>
以property的形式将日志输出格式配置成为文件的通用的属性
那么下面我们配置的输出方式中，就可以重复的引用该配置（以下的配置，对于输出格式就不用配置多次了)-->
<property name="pattern" value="[%-5level] %d{yyyy-w-d H:mm:ss .ss5} %c 0 %L thread %mKon"×</property>
<--配置控制台appender -->
<appender name="consoleAppender" class="ch.qos.logback.core.consoleAppender">
<--表示对于日志输出目标的配置
默认:system.out表示以黑色字体输出日志设置: System.er表示以红色字体输出日志-->
<target>
system. err
</target>
<! --
配置日志输出格式手动配置格式的方式直接引入上述的通用属性即可-->
<---输出在文件的配置
<! --配置文件的输出路径-->
<property name="logDir" value="D: //test"></property>
<!--配置文件的appender -->
<appender name="fileAppender" class="ch.qos.logback.core.FileAppender">
<! --引入文件位置-->
<file>${ logDir}/logback.log</file>
<!--设置输出格式-->
<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
<pattern>${pattern}</ pattern>
</ encoder>
-------------->
<encoder class="ch.qos.logback.classic.encoder.patternLayoutEncoder">
</--格式引用通用属性配置-->
<pattern>${pattern}</pattern>
</ encoder>
</ appender>
<! --日志记录器配置root logger,level:配置日志级别-->
<root level="ALL">
<l--引appender -->
<appender-ref ref="consoleAppender"/>
</root>
</ configuration>
Log4j2：
Log4j2特征：
性能提升：Log4j2包含基于LMAX Disruptor库的下一代异步记录器。在多线程场景中，异步记录器的吞吐量比Log4j 1.x和Logback高18倍，延迟低
自动重新加载配置：与Logback一样，Log4j2可以在修改时自动重新加载其配置。与Logback不同，它会在重新配置发生时不会丢失日志事件
高级过滤：与Logback一样，Log4j2支持基于Log事件中的上下文数据，标记，正则表达式和其他组件进行过滤。
此外，过滤器还可以与记录器关联。与Logback不同，Log4j2可以在任何这些情况下使用通用的Filter类
插件架构：Log4j使用插件模式配置组件。因此，您无需编写代码来创建和配置Appender，Layout，Pattern Converter等。在配置了的情况下，Log4j自动识别插件并使用它们。
无垃圾机制：在稳态日志记录期间，Log4j2 在独立应用程序中是无垃圾的，在Web应用程序中是低垃圾。这减少了垃圾收集器的压力，并且可以提供更好的响应性能。
Log4j2的相关依赖：
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-api</artifactId>
<version>2.12.1</version>
</dependency>
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-core</artifactId>
<version>2.12.1</version>
</dependency>
设置jdk版本
<build>
<plugins>
<!-- 设置编译版本为1.8 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
</plugins>
</build>
Log4j2入门案例：
/*入门案例
单纯的使用Log4j2的门面+实现
Log4j2和log4j提供了相同的日志级别输出默认为error级别信息的打印
ERROR statusLogger No Log4j 2 configuration file found.using default configuration
表示我们还没有建立自己的配置文件如果没有建立配置文件，则使用默认的配置
*/
Logger logger = LogManager.getLogger(Log4j2Test01.class);
logger.fatal( s: "fatal信息");
logger.error( s: "error信息");
logger.warn( s: "warn信息");
logger.info( s: "info信息");
logger.debug( s: "debug信息");
logger.trace( s: "trace信息");
使用配置文件:
log4j2是参考logback创作出来的，所以配置文件也是使用xml
log4j2同样是默认加载类路径（resources）下的log4j2.xml文件中的配置根标签,所有日志相关信息，
都是在根标签中进行配置
<configuration>
</Configuration>
根标签．所有目志相关信息，都是在根标签中进行配置<configuration status"debug"></ configuration>在根标签中，可以加属性
status="debug”日志框架本身的日志输出级别
<configuration>
<!--配置appender -->
<Appenders>
<console name="consoleAppender" target="sYSTEM_ERR">
</console>
</Appenders>
<!-- 配置logger -->
<Loggers>
<!-- 配置rootlogger -->
<Root level="trace">
<!--引用Appender -->
<AppenderRef ref="consoleAppender" />
</Root>
</Loggers>
</configuration>
最主流的日志使用搭配方式:slf4j+log4j2:
1.导入slf4j的日志门面
2.导入log4j2的适配器
3.导入log4j2的日志门面
4.导入log4j2的日志
实现执行原理:
slf4j门面调用的是log4j2的门面, 再由log4j2的门面调用log4j2的实现
日志文件输出：
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<! --配置全局通用属性-->
<properties>
<property name="logDir">D: / /test</ property>
</properties>
<!--配置appender -->
<Appenders>
<!--配置控制台输出 -->
<console name="consoleAppender" target="sYSTEM_ERR">
</console>
<!--配置文件输出-->
<File name="fileAppender" fileName="${logDir}//log4j2.log">
<! --配置文件输出格式-->
<PatternLayout pattern="[%-5level] %d{yyyy-MM-dd HH: mm:ss.sss} %m%n" />
</File>
</ Appenders>
<! --配置logger -->
<Loggers>
<!--配置rootlogger -->
<Root level="trace">
<!--引用Appender -->
<! --<AppenderRef ref="consoleAppender" / >-->
<AppenderRef ref="consoleAppender" / >
</Root>
</Loggers>
</configuration>
476
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
