日志学习笔记

Log4j

Log4j是Apache的一个开放源代码项目,通过使用Log4j,我们可以控制日志信息输送的目的地是控制台、文件、数据库等;我们也可以控制每一条日志的输出格式;通过定义每一条日志信息的级别,我们能够更加细致地控制日志的生成过程。 
Log4j有7种不同的log级别,按照等级从低到高依次为:TRACE、DEBUG、INFO、WARN、ERROR、FATAL、OFF。如果配置为OFF级别,表示关闭log。 
Log4j支持两种格式的配置文件:properties和xml。包含三个主要的组件:Logger、appender、Layout。

控制台输出 
通过如下配置,设定root日志的输出级别为INFO,appender为控制台输出stdout

# LOG4J配置
log4j.rootLogger=INFO,stdout
# 控制台输出
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} %5p %c{1}:%L - %m%n

输出到文件

在开发环境,我们只是输出到控制台没有问题,但是到了生产或测试环境,或许持久化日志内容,方便追溯问题原因。可以通过添加如下的appender内容,按天输出到不同的文件中去,同时还需要为log4j.rootLogger添加名为file的appender,这样root日志就可以输出到logs/springboot.log文件中了。输出到文件和输出到控制台是可以并行存在的。

# LOG4J配置
log4j.rootLogger=INFO,stdout,file
# 日志输出到文件
log4j.appender.file=org.apache.log4j.DailyRollingFileAppender
log4j.appender.file.file=logs/springboot.log
log4j.appender.file.DatePattern='.'yyyy-MM-dd
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} %5p %c{1}:%L - %m%n

分类输出 
当我们日志量较多的时候,查找问题会非常困难,常用的手段就是对日志进行分类,比如: 
可以按不同package进行输出。通过定义输出到logs/my.log的appender,并对com.test包下的日志级别设定为DEBUG级别、appender设置为输出到logs/my.log的名为testlog的appender。

# com.test包下的日志配置
log4j.logger.com.test=DEBUG, testlog
# com.test下的日志输出
log4j.appender.testlog=org.apache.log4j.DailyRollingFileAppender
log4j.appender.testlog.file=logs/my.log
log4j.appender.testlog.DatePattern='.'yyyy-MM-dd
log4j.appender.testlog.layout=org.apache.log4j.PatternLayout
log4j.appender.testlog.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} %5p %c{1}:%L ---- %m%n

可以对不同级别进行分类,比如对ERROR级别输出到特定的日志文件中,具体配置可以如下:

# LOG4J配置
log4j.rootCategory=INFO, stdout,errorfile
log4j.logger.error=errorfile # error日志输出
log4j.appender.errorfile=org.apache.log4j.DailyRollingFileAppender
log4j.appender.errorfile.file=logs/error.log
log4j.appender.errorfile.DatePattern='.'yyyy-MM-dd
log4j.appender.errorfile.Threshold = ERROR
log4j.appender.errorfile.layout=org.apache.log4j.PatternLayout
log4j.appender.errorfile.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} %5p %c{1}:%L - %m%n %5p %c{1}:%L - %m%n

输出到数据库 
将日志文件输出到数据库配置:

\# LOG4J配置
log4j.rootCategory=INFO,stdout,jdbc \# 数据库输出
log4j.appender.jdbc=org.apache.log4j.jdbc.JDBCAppender
log4j.appender.jdbc.driver=com.mysql.jdbc.Driver
log4j.appender.jdbc.URL=jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf8&useSSL=true
log4j.appender.jdbc.user=root
log4j.appender.jdbc.password=root
log4j.appender.jdbc.sql=insert into log_icecoldmonitor(level,category,thread,time,location,note) values('%p','%c','%t','%d{yyyy-MM-dd HH:mm:ss:SSS}','%l','%m')

引入数据库驱动:

<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>

创建表:

CREATE TABLE `log_icecoldmonitor` (
`Id` int(11) NOT NULL AUTO_INCREMENT,
`level` varchar(255) NOT NULL DEFAULT '' COMMENT '优先级',
`category` varchar(255) NOT NULL DEFAULT '' COMMENT '类目',
`thread` varchar(255) NOT NULL DEFAULT '' COMMENT '进程',
`time` varchar(30) NOT NULL DEFAULT '' COMMENT '时间',
`location` varchar(255) NOT NULL DEFAULT '' COMMENT '位置',
`note` text COMMENT '日志信息',
PRIMARY KEY (`Id`)
)

这样就可以保存到日志到数据库了,可能会出现如下异常信息: 
Java连接Mysql数据库警告:Establishing SSL connection 
原因是MySQL在高版本需要指明是否进行SSL连接。解决方案如下: 
在mysql连接字符串url中加入ssl=true或者false即可,如下所示。 
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf8&useSSL=true

应用

  1. 引入log4j依赖 
    在创建Spring Boot工程时,我们引入了spring-boot-starter,其中包含了spring-boot-starter-logging,该依赖内容就是Spring Boot默认的日志框架Logback,所以我们在引入log4j之前,需要先排除该包的依赖,再引入log4j的依赖。
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</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-log4j</artifactId>
</dependency>

值得注意的是,spring boot 1.3版本支持log4j,在spring boot 1.4的版本中,就需要使用log4j2,否则会出现如下错误:Project build error: 'dependencies.dependency.version' for org.springframework.boot:spring-boot-starter-log4j:jar is missing.

  1. 配置log4j-spring.properties 
    在引入了log4j依赖之后,只需要在src/main/resources目录下加入log4j.properties(或log4j-spring.properties)配置文件,就可以开始对应用的日志进行配置使用。测试配置内容如下:
# DEBUG INFO WARN ERROR FATAL
log4j.rootLogger = info,stdout,errorlogfile log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Threshold = info
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern =%-d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] - %m%n
log4j.appender.stdout.ImmediateFlush = true log4j.appender.errorlogfile = org.apache.log4j.DailyRollingFileAppender
log4j.appender.errorlogfile.Threshold = INFO
log4j.appender.errorlogfile.layout = org.apache.log4j.PatternLayout
log4j.appender.errorlogfile.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] - %m%n
log4j.appender.errorlogfile.File = ../logs/testlog4j.log
log4j.appender.errorlogfile.Append = true
log4j.appender.errorlogfile.ImmediateFlush = true
  1. 配置application.properties 
    指定log配置文件
logging.config= classpath:log4j.properties
  • 1

在启动类中进行测试

private static Logger logger = Logger.getLogger(TestLog4jApplication.class);

public static void main(String[] args) {
logger.info("log4j----------------\n");
SpringApplication.run(TestLog4jApplication.class, args);
}

运行项目,即可看到控制台打印出的日志信息,同时在项目同级目录下的logs/testlog4j.log中也会打印出比较详尽的日志信息。

Log4j2

Spring Boot1.4以及之后的版本已经不支持log4j,log4j也很久没有更新了,现在已经有很多其他的日志框架对Log4j进行了改良,比如说SLF4J、Logback等。而且Log4j 2在各个方面都与Logback非常相似,那么为什么我们还需要Log4j 2呢? 
  1. 插件式结构。Log4j 2支持插件式结构。我们可以根据自己的需要自行扩展Log4j 2. 我们可以实现自己的appender、logger、filter。 
  2. 配置文件优化。在配置文件中可以引用属性,还可以直接替代或传递到组件。而且支持json格式的配置文件。不像其他的日志框架,它在重新配置的时候不会丢失之前的日志文件。 
  3. Java 5的并发性。Log4j 2利用Java 5中的并发特性支持,尽可能地执行最低层次的加锁。解决了在log4j 1.x中存留的死锁的问题。 
  4. 异步logger。Log4j 2是基于LMAX Disruptor库的。在多线程的场景下,和已有的日志框架相比,异步的logger拥有10倍左右的效率提升。 
   
官方建议一般程序员查看的日志改成异步方式,一些运营日志改成同步。日志异步输出的好处在于,使用单独的进程来执行日志打印的功能,可以提高日志执行效率,减少日志功能对正常业务的影响。异步日志在程序的classpath需要加载disruptor-3.0.0.jar或者更高的版本。

 <!-- log4j2异步日志需要加载disruptor-3.0.0.jar或者更高的版本 -->
<dependency>
<groupId>com.lmax</groupId>
<artifactId>disruptor</artifactId>
<version>3.3.6</version>
</dependency>

异步日志分为两种:

a.全异步模式 
这种异步日志方式,不需要修改修改原理的配置文件,Logger仍然使用<root> and <logger> 
只需要在主程序代码开头,加一句系统属性的代码:

System.setProperty("Log4jContextSelector", "org.apache.logging.log4j.core.async.AsyncLoggerContextSelector");  

b.异步和非异步混合输出模式

在配置文件中Logger使用<asyncRoot> or <asyncLogger>

<loggers>
<AsyncLogger name="AsyncLogger" level="trace" includeLocation="true">
<appender-ref ref="Console" />
<appender-ref ref="debugLog" />
<appender-ref ref="errorLog" />
</AsyncLogger> <asyncRoot level="trace" includeLocation="true">
<appender-ref ref="Console" />
</asyncRoot>
</loggers>

应用

  1. 引入log4j2依赖 
    在创建Spring Boot工程时,我们引入了spring-boot-starter,其中包含了spring-boot-starter-logging,该依赖内容就是Spring Boot默认的日志框架Logback,所以我们在引入log4j2之前,需要先排除该包的依赖,再引入log4j2的依赖。
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</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>
  1. log4j2.xml配置 
    有一点需要注意的是,假如想要在application.properties中指定日志文件存放路径或日志文件名,在log4j2.xml中使用${LOG_PATH}或者${LOG_FILE}来引用,是无法获取到的(在logback中可以尽情使用)。log4j2支持xml、json、yaml等格式的配置文件。
<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
<Properties>
<property name="LOG_PATH">../logs/</property>
<property name="LOG_FILE">testlog4j2</property>
</Properties>
<Appenders>
<Console name="Console" target="SYSTEM_OUT">
<PatternLayout>
<pattern>%-d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] - %m%n</pattern>
</PatternLayout>
</Console>
<RollingFile name="errorlogfile" fileName="${LOG_PATH}/${LOG_FILE}.log"
filePattern="${LOG_PATH}/$${date:yyyy-MM}/${LOG_FILE}-%d{yyyy-MM-dd HH-mm}-%i.log">
<PatternLayout>
<pattern>%-d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] - %m%n</pattern>
</PatternLayout>
<Policies>
<TimeBasedTriggeringPolicy />
<SizeBasedTriggeringPolicy size="50 MB" />
</Policies>
<DefaultRolloverStrategy max="20" />
</RollingFile>
</Appenders>
<Loggers>
<root level="info">
<AppenderRef ref="Console"/>
<AppenderRef ref="errorlogfile" />
</root>
</Loggers>
</Configuration>
  1. application.properties配置 
    指定log配置文件
logging.config= classpath:log4j2.xml
  • 1

在启动类中进行测试

private static Logger logger = LogManager.getLogger(TestLog4j2Application.class);

public static void main(String[] args) {
logger.error("log4j2----------------\n");
SpringApplication.run(TestLog4j2Application.class, args);
}

运行项目,即可看到控制台打印出的日志信息,同时在项目同级目录下的logs/testlog4j2.log中也会打印出比较详尽的日志信息。

SLF4J

SLF4J,即简单日志门面(Simple Logging Facade for Java),不是具体的日志解决方案,而是通过Facade Pattern提供一些Java logging API,它只服务于各种各样的日志系统。按照官方的说法,SLF4J是一个用于日志系统的简单Facade,允许最终用户在部署其应用时使用其所希望的日志系统。作者创建SLF4J的目的是为了替代Jakarta Commons-Logging。 
实际上,SLF4J所提供的核心API是一些接口以及一个LoggerFactory的工厂类。在使用SLF4J的时候,不需要在代码中或配置文件中指定你打算使用那个具体的日志系统。类似于Apache Common-Logging,SLF4J是对不同日志框架提供的一个门面封装,可以在部署的时候不修改任何配置即可接入一种日志实现方案。但是,他在编译时静态绑定真正的Log库。使用SLF4J时,如果你需要使用某一种日志实现,那么你必须选择正确的SLF4J的jar包的集合(各种桥接包)。SLF4J提供了统一的记录日志的接口,只要按照其提供的方法记录即可,最终日志的格式、记录级别、输出方式等通过具体日志系统的配置来实现,因此可以在应用中灵活切换日志系统。

那么什么时候使用SLF4J比较合适呢? 
如果你开发的是类库或者嵌入式组件,那么就应该考虑采用SLF4J,因为不可能影响最终用户选择哪种日志系统。在另一方面,如果是一个简单或者独立的应用,确定只有一种日志系统,那么就没有使用SLF4J的必要。假设你打算将你使用log4j的产品卖给要求使用JDK 1.8 Logging的用户时,面对成千上万的log4j调用的修改,相信这绝对不是一件轻松的事情。但是如果开始便使用SLF4J,那么这种转换将是非常轻松的事情。

应用

例如上述内容中,log4j测试,使用

import org.apache.log4j.Logger;
private static Logger logger = Logger.getLogger(TestLog4jApplication.class);

而在log4j2测试使用

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
private static Logger logger = LogManager.getLogger(TestLog4j2Application.class);

假如后期改变log实现系统,所有调用log4j的代码都需要进行修改,假如一开始都使用slf4j.Logger,后期将无需修改代码。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static Logger logger = LoggerFactory.getLogger(TestLog4jApplication.class);
private static Logger logger = LoggerFactory.getLogger(TestLog4j2Application.class); 

假如遇到SLF4J: Class path contains multiple SLF4J bindings相关的错误提示,则是因为引入了多个日志系统,需要排除多余的依赖。

slf4j-simple是slf4j的一种日志系统实现,目前最新版本是1.7.7。

<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
<version>1.7.7</version>
</dependency>

Logback

Logback,一个“可靠、通用、快速而又灵活的Java日志框架”。logback当前分成三个模块:logback-core,logback- classic和logback-access。logback-core是其它两个模块的基础模块。logback-classic是log4j的一个改良版本。此外logback-classic完整实现SLF4J API使你可以很方便地更换成其它日志系统如log4j或JDK Logging。logback-access访问模块与Servlet容器集成提供通过Http来访问日志的功能。 
1. logback-core: Joran, Status, context, pattern parsing 
2. logback-classic: developer logging 
3. logback-access: The log generated when a user accesses a web-page on a web server. Integrates seamlessly with Jetty and Tomcat.

选择logback的理由: 
1. logback比log4j要快大约10倍,而且消耗更少的内存。 
2. logback-classic模块直接实现了SLF4J的接口,所以我们迁移到logback几乎是零开销的。 
3. logback不仅支持xml格式的配置文件,还支持groovy格式的配置文件。相比之下,Groovy风格的配置文件更加直观,简洁。 
4. logback-classic能够检测到配置文件的更新,并且自动重新加载配置文件。 
5. logback能够优雅的从I/O异常中恢复,从而我们不用重新启动应用程序来恢复logger。 
6. logback能够根据配置文件中设置的上限值,自动删除旧的日志文件。 
7. logback能够自动压缩日志文件。 
8. logback能够在配置文件中加入条件判断(if-then-else)。可以避免不同的开发环境(dev、test、uat…)的配置文件的重复。 
9. logback带来更多的filter。 
10. logback的stack trace中会包含详细的包信息。 
11. logback-access和Jetty、Tomcat集成提供了功能强大的HTTP-access日志。 
配置文件:需要在项目的src目录下建立一个logback.xml。 
注:(1)logback首先会试着查找logback.groovy文件; 
(2)当没有找到时,继续试着查找logback-test.xml文件; 
(3)当没有找到时,继续试着查找logback.xml文件; 
(4)如果仍然没有找到,则使用默认配置(打印到控制台)。

logback的一些配置介绍: 
* 控制台输出 
在Spring Boot中默认配置了ERROR、WARN和INFO级别的日志输出到控制台。我们可以通过两种方式切换至DEBUG级别: 
在运行命令后加入–debug标志,如:$ java -jar test.jar --debug 
在application.properties中配置debug=true,该属性置为true的时候,核心Logger(包含嵌入式容器、hibernate、spring)会输出更多内容,但是你自己应用的日志并不会输出为DEBUG级别。

  • 多彩输出 
    如果你的终端支持ANSI,设置彩色输出会让日志更具可读性。通过在application.properties中设置spring.output.ansi.enabled参数来支持。 
    NEVER:禁用ANSI-colored输出(默认项) 
    DETECT:会检查终端是否支持ANSI,是的话就采用彩色输出(推荐项) 
    ALWAYS:总是使用ANSI-colored格式输出,若终端不支持的时候,会有很多干扰信息,不推荐使用

  • 文件输出 
    Spring Boot默认配置只会输出到控制台,并不会记录到文件中,但是我们通常生产环境使用时都需要以文件方式记录。 
    若要增加文件输出,需要在application.properties中配置logging.file或logging.path属性。 
    logging.file,设置文件,可以是绝对路径,也可以是相对路径。如:logging.file=my.log 
    logging.path,设置目录,会在该目录下创建spring.log文件,并写入日志内容,如:logging.path=../logs 
    日志文件会在10Mb大小的时候被截断,产生新的日志文件,默认级别为:ERROR、WARN、INFO

  • 级别控制 
    在Spring Boot中只需要在application.properties中进行配置完成日志记录的级别控制。 
    配置格式:logging.level.*=LEVEL 
    logging.level:日志级别控制前缀,*为包名或Logger名 
    LEVEL:选项TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF 
    举例: 
    logging.level.com.test=DEBUG:com.test包下所有class以DEBUG级别输出 
    logging.level.root=WARN:root日志以WARN级别输出

  • 自定义输出格式 
    在Spring Boot中可以通过在application.properties配置如下参数控制输出格式: 
    logging.pattern.console:定义输出到控制台的样式(不支持JDK Logger) 
    logging.pattern.file:定义输出到文件的样式(不支持JDK Logger)

应用

logback是Spring Boot默认的日志系统,假如对日志没有特殊要求,可以完全零配置使用 SLF4J(Simple Logging Facade For Java)的logback来输出日志。

package com.jianeye.test;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication; SpringBootApplication
public class TestApplication { private static Logger logger = LoggerFactory.getLogger(TestApplication.class); public static void main(String[] args) {
logger.warn("logback --------------------------------\n");
SpringApplication.run(TestApplication.class, args);
logger.info("default log system *************************\n");
}
}

Spring Boot也支持自定义日志配置,有以下两种方式。 
1. 在 src/main/resources 下面创建logback.xml (根据不同环境来定义不同的日志输出,那么取名为logback-spring.xml 即可)文件,并按需求进行配置。

logback-spring.xml 文件:

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<include resource="org/springframework/boot/logging/logback/base.xml" />
<logger name="org.springframework.web" level="INFO"/>
<logger name="org.springboot.sample" level="TRACE" /> <springProfile name="dev">
<logger name="org.springboot.sample" level="DEBUG" />
</springProfile> <springProfile name="staging">
<logger name="org.springboot.sample" level="INFO" />
</springProfile>
</configuration>
  1. 使用最简单的方法,在 application 配置文件中配置。
logging:
config: classpath:logback-spring.xml
file: cuckoo3
path: /cuckoo3-log/logs
level:
com.jianeye.cuckoo3.webside: DEBUG

需要注意几点: 
1. 这里若不配置具体的包的日志级别,日志文件信息将为空 
2. 若只配置logging.path,那么将会在E:\logs文件夹生成一个日志文件为spring.log 
3. 若只配置logging.file,那将会在项目的当前路径下生成一个demo.log日志文件 
4. logging.path和logging.file同时配置,不会有在这个路径有E:\logs\demo.log日志生成,logging.path和logging.file不会进行叠加 
5. logging.path和logging.file的value都可以是相对路径或者绝对路径

Apache Commons Logging

Apache Commons Logging ,之前叫 Jakarta Commons Logging(JCL)提供的是一个日志(Log)接口(interface),同时兼顾轻量级和不依赖于具体的日志实现工具。它提供给中间件/日志工具开发者一个简单的日志操作抽象,允许程序开发人员使用不同的具体日志实现工具。用户被假定已熟悉某种日志实现工具的更高级别的细节。JCL提供的接口,对其它一些日志工具,包括Log4J, Avalon LogKit, and JDK 1.4+等,进行了简单的包装,此接口更接近于Log4J和LogKit的实现。 
common-logging是apache提供的一个通用的日志接口。用户可以自由选择第三方的日志组件作为具体实现,像log4j,或者jdk自带的logging, common-logging会通过动态查找的机制,在程序运行时自动找出真正使用的日志库。当然,common-logging内部有一个Simple logger的简单实现,但是功能很弱。所以使用common-logging,通常都是配合着log4j来使用。使用它的好处就是,代码依赖是common-logging而非log4j, 避免了和具体的日志方案直接耦合,在有必要时,可以更改日志实现的第三方库。 
使用common-logging的常见代码:

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory; public class A {
private static Log logger = LogFactory.getLog(this.getClass());
}

slf4j 与 common-logging 比较 
common-logging通过动态查找的机制,在程序运行时自动找出真正使用的日志库; 
slf4j在编译时静态绑定真正的Log库。

java.util.logging.Logger

java.util.logging.Logger(JUL),JDK自带的日志系统,从JDK1.4就有了。关键元素包括: 
Logger:应用程序进行logging调用的主要实体。Logger 对象用来记录特定系统或应用程序组件的日志消息。 
LogRecord:用于在 logging 框架和单独的日志处理程序之间传递 logging 请求。 
Handler:将 LogRecord 对象导出到各种目的地,包括内存、输出流、控制台、文件和套接字。为此有各种的 Handler 子类。其他 Handler 可能由第三方开发并在核心平台的顶层实现。 
Level:定义一组可以用来控制 logging 输出的标准 logging 级别。可以配置程序为某些级别输出 logging,而同时忽略其他输出。 
Filter:为所记录的日志提供日志级别控制以外的细粒度控制。Logging API 支持通用的过滤器机制,该机制允许应用程序代码附加任意的过滤器以控制 logging 输出。 
Formatter:为格式化 LogRecord 对象提供支持。此包包括的两个格式化程序 SimpleFormatter 和 XMLFormatter 分别用于格式化纯文本或 XML 中的日志记录。与 Handler 一样,其他 Formatter 可能由第三方开发。

整个JVM内部所有logger的管理,logger的生成、获取等操作都依赖于LogManager,也包括配置文件的读取,LogManager与logger是1对多关系,整个JVM运行时只有一个LogManager,且所有的logger均在LogManager中。 
logger与handler是多对多关系,logger在进行日志输出的时候会调用所有的hanlder进行日志的处理。 
handler与formatter是一对一关系,一个handler有一个formatter进行日志的格式化处理。 
logger与level是一对一关系,hanlder与level也是一对一关系 。 
JDK默认的logging配置文件为:$JAVA_HOME/jre/lib/logging.properties,可以使用系统属性java.util.logging.config.file指定相应的配置文件对默认的配置文件进行覆盖。

小结

从下图中,我们可以看到4部分。

接口:将所有日志实现适配到了一起,用统一的接口调用。  
实现:目前主流的日志实现  
旧日志到slf4j的适配器:如果使用了slf4j,但是只想用一种实现,想把log4j的日志体系也从logback输出,这个是很有用的。  
slf4j到实现的适配器:如果想制定slf4j的具体实现,需要这些包。

slf4j跟commons-logging类似,是各种日志实现的通用入口,log4j、log4j2、logback、slf4j-simple和java.util.logging是比较常见的日志实现系统,目前应用比较广泛的是Log4j和logback,而logback作为后起之秀,以替代log4j为目的,整体性能比log4j较佳,log4j的升级版log4j2也是有诸多亮点,用户可以根据项目需求和个人习惯,选择合适的日志实现。

注:学习所用,大部分内容摘抄自网络各种大师总结,在此感谢!

Log4j,Log4j2,logback,slf4j日志学习的更多相关文章

  1. Log4j,Log4j2,logback,slf4j日志学习(转)

    日志学习笔记Log4jLog4j是Apache的一个开放源代码项目,通过使用Log4j,我们可以控制日志信息输送的目的地是控制台.文件.数据库等:我们也可以控制每一条日志的输出格式:通过定义每一条日志 ...

  2. SLF4J其实只是一个门面服务而已,他并不是真正的日志框架,真正的日志的输出相关的实现还是要依赖Log4j、logback等日志框架的。

    小结: 1.加层: 每一种日志框架都有自己单独的API,要使用对应的框架就要使用其对应的API,这就大大的增加应用程序代码对于日志框架的耦合性. 为了解决这个问题,就是在日志框架和应用程序之间架设一个 ...

  3. 常见java日志系统的搭配详解:关于slf4j log4j log4j2 logback jul jcl commons-logging jdk-logging

    先看一张图: 是不是有点晕, 晕就对了.这个仅仅是 slf4j 的情况,实际上, 我们不仅要接触到 slf4j ,有时候还会接触其他的日志系统.且看下文分解. 1 直接使用各个日志系统 1.1 直接使 ...

  4. Spring Boot 使用 Log4j2 & Logback 输出日志到 EKL

    文章目录 1.ELK 介绍 2.环境.软件准备 3.ELK 环境搭建 4.Spring Boot 配置示例 4.1.Log4j2 方式配置 4.2.Logback 方式配置 1.ELK 介绍 ELK ...

  5. 拨云见日,彻底弄清楚Java日志框架 log4j, logback, slf4j的区别与联系

    log4j 以及 logback, slf4j 官网 日志框架的困惑 作为一个正常的项目,是必须有日志框架的存在的,没有日志,很难追踪一些奇奇怪怪的系统问题. 但是,我们经常在项目的依赖中,见到奇奇怪 ...

  6. 关于slf4j log4j log4j2的jar包配合使用的那些事

    由于java日志框架众多(common-logging,log4j,slf4j,logback等),引入jar包的时候,就要为其添加对应的日志实现.. 不同的jar包,可能用了不同的日志框架,那引用了 ...

  7. 日志套餐篇 - log4j2 logback全量套餐

    日志套餐篇 - log4j2 logback全量套餐 前情提要: Log4j Log4j2 logback是当下主流的日志框架 slf4j则是新一代的日志框架接口,logback直接实现了slf4j接 ...

  8. java日志学习(持续更新)

    1.Java实现日志 java日志体系大体可以分为三个部分:日志门面接口.桥接器.日志框架具体实现.原生日志实现(http://www.importnew.com/16331.html) Java日志 ...

  9. Java日志之Slf4j,Log4J,logback原理总结

    几乎任何应用,一定是需要日志的. 那么,面对种类繁多的日志框架和配置,我们该何去何从? 1.前奏:我是在研究mybatis源码的过程中才意识到需要搞明白日志原理这回事,因为mybatis(和一些其他开 ...

随机推荐

  1. POJ 3295 Tautology (构造法)

    Tautology Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 7716   Accepted: 2935 Descrip ...

  2. Eclipse折叠代码 coffee bytes code folding

    提供一个插件下载地址,博客园的: http://files.cnblogs.com/wucg/com.cb.eclipse.folding_1.0.6.jar.zip  将下载的zip文件解压出来的j ...

  3. RabbitMQ 安装和监控[原,转]

    在Windows上安装Rabbit MQ 指南,最好的是这篇<Rabbit MQ Windows Installation guide>,其中还包括了使用.NET RabbitMQ.Cli ...

  4. android自定义控件实例

    很多时候android常用的控件不能满足我们的需求,那么我们就需要自定义一个控件了.今天做了一个自定义控件的实例,来分享下. 首先定义一个layout实现按钮内部布局: 01 <?xml ver ...

  5. SICP 习题 (2.8) 解题总结:区间的减法

    SICP 习题 2.8 须要我们完毕区间运算的减法.区间运算的加法书中已经有了,代码例如以下: (define (add-interval x y) (make-interval (+ (lower- ...

  6. PSAPI和ToolHelpAPI学习笔记

    标 题: PSAPI学习笔记 作 者:北极星2003 时 间:2005-07-24 18:36 链 接:http://bbs.pediy.com/showthread.php?threadid=154 ...

  7. 关于 二维码 与 NFC 之间的出身贫贱说

    关于 二维码 与 NFC 之间的出身贫贱说 太阳火神的漂亮人生 (http://blog.csdn.net/opengl_es) 本文遵循"署名-非商业用途-保持一致"创作公用协议 ...

  8. paip.中文 分词 ---paoding 3.1 的使用

    paip.中文 分词 ---paoding 3.1 的使用 paoding 3.1 下载: 1 设置字典路径 1 测试代码 1 作者Attilax  艾龙,  EMAIL:1466519819@qq. ...

  9. SGMII 和 Serdes 的详细说明

    Serdes  : SERDES是英文SERializer(串行器)/DESerializer(解串器)的简称.它是一种时分多路复用(TDM).点对点的通信技术,即在发送端多路低速并行信号被转换成高速 ...

  10. iphone CGContextSetLineWidth 画线的问题

    转自:http://blog.csdn.net/jxncwzb/article/details/6267154 CGContextRef context = UIGraphicsGetCurrentC ...