精华内容
下载资源
问答
  • Java日志
    千次阅读
    2021-02-12 17:02:39

    日志对于一个系统来说非常重要,查找异常信息、分析系统运行情况等都需要用到日志。所以无论是JDK还是第三方都提供了关于日志的相关工具,本文分别介绍以下几种工具,以及各种工具间的整合、原理。

    JDK的java.util.logging包

    第三方日志工具(commons-logging/slf4j,log4j/logback)

    JDK的java.util.logging包

    JDK1.4引入了java.util.logging包,包中主要的类包括:Logger、LogManager、Handler、Formatter。首先看一段比较简单的示例代码:

    packageme.likeyao.jdk.logger;importjava.util.logging.Formatter;importjava.util.logging.Handler;importjava.util.logging.Level;importjava.util.logging.LogRecord;importjava.util.logging.Logger;public classJDKLoggerTest {public static voidmain(String[] args) {

    Logger logger= Logger.getLogger("logger");

    logger.info("hello world");

    Handler handler= newHandler() {

    @Overridepublic voidpublish(LogRecord record) {

    }

    @Overridepublic voidflush() {

    }

    @Overridepublic void close()

    更多相关内容
  • Java日志体系详解

    千次阅读 2020-01-30 11:21:56
    JCL:Apache基金会所属的项目,是一套Java日志接口,之前叫Jakarta Commons Logging,后更名为Commons Logging SLF4J:是一套简易Java日志门面,本身并无日志的实现。(Simple Logging Facade for Java,缩写Slf4j...

    一、日志框架的分类

    1.1、门面型日志框架:

    1. JCL:Apache基金会所属的项目,是一套Java日志接口,之前叫Jakarta Commons Logging,后更名为Commons Logging
    2. SLF4J:是一套简易Java日志门面,本身并无日志的实现。(Simple Logging Facade for Java,缩写Slf4j)

    1.2、记录型日志框架:

    1. JUL:JDK中的日志记录工具,也常称为JDKLog、jdk-logging,自Java1.4以来的官方日志实现。
    2. Log4j:一个具体的日志实现框架。
    3. Log4j2: 一个具体的日志实现框架,是LOG4J1的下一个版本,与Log4j 1发生了很大的变化,Log4j 2不兼容Log4j 1
    4. Logback:一个具体的日志实现框架,和Slf4j是同一个作者,但其性能更好(推荐使用)。

    二、发展历程

    要搞清楚它们的关系,就要从它们是在什么情况下产生的说起。我们按照时间的先后顺序来介绍。

    Log4j:在JDK 1.3及以前,Java打日志依赖System.out.println(), System.err.println()或者e.printStackTrace(),Debug日志被写到STDOUT流,错误日志被写到STDERR流。这样打日志有一个非常大的缺陷,即无法定制化,且日志粒度不够细。
    于是, Gülcü 于2001年发布了Log4j,后来成为Apache 基金会的顶级项目。Log4j 在设计上非常优秀,对后续的 Java Log 框架有长久而深远的影响,它定义的Logger、Appender、Level等概念如今已经被广泛使用。Log4j 的短板在于性能,在Logback 和 Log4j2 出来之后,Log4j的使用也减少了。

    J.U.L:受Logj启发,Sun在Java1.4版本中引入了java.util.logging,但是j.u.l功能远不如log4j完善,开发者需要自己编写Appenders(Sun称之为Handlers),且只有两个Handlers可用(Console和File),j.u.l在Java1.5以后性能和可用性才有所提升。

    JCL(commons-logging):由于项目的日志打印必然选择两个框架中至少一个,这时候,Apache的JCL(commons-logging)诞生了。JCL 是一个Log Facade,只提供 Log API,不提供实现,然后有 Adapter 来使用 Log4j 或者 JUL 作为Log Implementation。
    在程序中日志创建和记录都是用JCL中的接口,在真正运行时,会看当前ClassPath中有什么实现,如果有Log4j 就是用 Log4j, 如果啥都没有就是用 JDK 的 JUL。
    这样,在你的项目中,还有第三方的项目中,大家记录日志都使用 JCL 的接口,然后最终运行程序时,可以按照自己的需求(或者喜好)来选择使用合适的Log Implementation。如果用Log4j, 就添加 Log4j 的jar包进去,然后写一个 Log4j 的配置文件;如果喜欢用JUL,就只需要写个 JUL 的配置文件。如果有其他的新的日志库出现,也只需要它提供一个Adapter,运行的时候把这个日志库的 jar 包加进去。
    不过,commons-logging对Log4j和j.u.l的配置问题兼容的并不好,使用commons-loggings还可能会遇到类加载问题,导致NoClassDefFoundError的错误出现。到这个时候一切看起来都很简单,很美好。接口和实现做了良好的分离,在统一的JCL之下,不改变任何代码,就可以通过配置就换用功能更强大,或者性能更好的日志库实现。

    SLF4J & Logback:SLF4J(Simple Logging Facade for Java)和 Logback 也是Gülcü 创立的项目,目的是为了提供更高性能的实现。从设计模式的角度说,SLF4J 是用来在log和代码层之间起到门面作用,类似于 JCL 的 Log Facade。对于用户来说只要使用SLF4J提供的接口,即可隐藏日志的具体实现,SLF4J提供的核心API是一些接口和一个LoggerFactory的工厂类,用户只需按照它提供的统一纪录日志接口,最终日志的格式、纪录级别、输出方式等可通过具体日志系统的配置来实现,因此可以灵活的切换日志系统。

    三、详细介绍

    Java日志体系(二)log4j

    Java日志体系(三)commons-logging

    Java日志体系(四)slf4j

    Java日志体系(五)logback

    Java日志体系(六)log4j2

    Java日志体系(七)日志框架切换

    Java日志框架性能比较

    四、最佳实践

    推荐使用 SLF4J + Logback。maven依赖如下,其中version字段用占位符代替,你应该根据项目的实际情况选择合适的版本:

    <!--  =================================================  -->
    <!--  日志及相关依赖(用slf4j+logback代替jcl+log4j)  -->
    <!--  =================================================  -->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>${version}</version>
    </dependency>
    <!-- 强制使用 logback的绑定 -->
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-core</artifactId>
        <version>${version}</version>
    </dependency>
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>${version}</version>
    </dependency>
    <!-- 强制使用 logback的绑定,这里去除对log4j 的绑定 -->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>99.0-does-not-exist</version>
    </dependency>
    <!-- slf4j 的桥接器,将第三方类库对 log4j 的调用 delegate 到 slf api 上 -->
    <!-- 这个桥接器是自己做的,主要是我们依赖的类库存在很多硬编码的引用 -->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>log4j-over-slf4j</artifactId>
        <version>${version}</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>jcl-over-slf4j</artifactId>
        <version>${version}</version>
    </dependency>
    <!-- 强制排除 log4j 的依赖,全部 delegate 到 log4j-over-slf4j 上 -->
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>99.0-does-not-exist</version>
    </dependency>
    <dependency>
        <groupId>apache-log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>999-not-exist</version>
    </dependency>
    <!-- slf4j + logback 配置结束 -->
    

    再提几点最佳实践:

    1. 总是使用 Log Facade,而不是具体的 Log Implementation
    2. 只添加一个 Log Implementation 依赖
    3. 具体的日志依赖应该设置为 optional,并使用 runtime scope
      设为optional,依赖不会传递,这样如果你是个lib项目,然后别的项目使用了你这个lib,不会被引入不想要的Log Implementation 依赖;
      Scope设置为runtime,是为了防止开发人员在项目中直接使用Log Implementation中的类,而不使用Log Facade中的类。
    4. 如果有必要, 排除依赖的第三方库中的Log Impementation依赖
      这是很常见的一个问题,第三方库的开发者未必会把具体的日志实现或者桥接器的依赖设置为optional,然后你的项目继承了这些依赖——具体的日志实现未必是你想使用的,比如他依赖了Log4j,你想使用Logback,这时就很尴尬。另外,如果不同的第三方依赖使用了不同的桥接器和Log实现,也极容易形成环。
      这种情况下,推荐的处理方法,是使用exclude来排除所有的这些Log实现和桥接器的依赖,只保留第三方库里面对Log Facade的依赖。

    参考资料

    展开全文
  • Java日志打印方法

    千次阅读 2021-02-12 09:29:48
    一、使用log4j打印日志1. 下载log4j.jar和commons-logging.jar。2.将准备好的两个jar包放到项目的lib包中(添加到项目的build path中)。方法:右键单击项目→选择“属性”→JavaBuild Path→Add External JARs。3.在...

    一、使用log4j打印日志

    1. 下载log4j.jar和commons-logging.jar。

    2.将准备好的两个jar包放到项目的lib 包中(添加到项目的build path中)。方法:右键单击项目→选择“属性”→Java Build Path→Add External JARs。

    3.在src路径下创建一个log4j.properties文件。创建方法:右键单击src→New→File,输入文件名。

    296a8144bdae79e9770b484582fa0fd9.gif

    4. 在log4j.properties文件中添加以下配置内容:

    a278ab523b9d6255ef0934d5671ba495.gif

    对配置信息进行解释:

    这里指定了日志输出的级别 INFO. 你也可以指定BEBUG、ERROR、 WARN,或者全部指定用CONSOLE

    stdout, logfile 指定日志输出的目的地。 这两个名字可以随便取,比如 A, 或B都可以。 实际的配置是 org.apache.log4j.ConsoleAppender 和RollingFileAppender 用于指定是控制台还是文件。

    另外还指定了输出的格式, 已经产生的file 的规则。

    log日志文件输出路径可以改,我写的是E:/logfile.log。

    1. rootLogger后面跟着输出日志的级别:

    1.1  ERROR 为严重错误 主要是程序的错误

    1.2  WARN 为一般警告,比如session丢失

    1.3  INFO 为一般要显示的信息,比如登录登出

    1.4  DEBUG 为程序的调试信息

    stdout, logfile 指定日志输出的目的地。 这两个名字可以随便取,比如 A, 或B都可以。

    2. appender.moder1定义的是Log输出的地方:

    2.1 org.apache.log4j.ConsoleAppender(控制台)

    2.2 org.apache.log4j.FileAppender(文件)

    2.3 org.apache.log4j.DailyRollingFileAppender(每天产生一个日志文件)

    2.4 org.apache.log4j.RollingFileAppender(文件大小到达指定尺寸的时候产生一个新的文件)

    2.5 org.apache.log4j.WriterAppender(将日志信息以流格式发送到任意指定的地方)

    3. appender.moder1.Layout定义的是日志信息的格式:

    3.1 org.apache.log4j.HTMLLayout(以HTML表格形式布局),

    3.2 org.apache.log4j.PatternLayout(可以灵活地指定布局模式),

    3.3 org.apache.log4j.SimpleLayout(包含日志信息的级别和信息字符串),

    3.4 org.apache.log4j.TTCCLayout(包含日志产生的时间、线程、类别等等信息)

    4. 在appender.moder1.Layout下定义的是PatternLayout才有log4j.appender.moder1.layout.ConversionPattern

    该属性自定义日志输出格式

    -X号: X信息输出时左对齐;

    %p: 输出日志信息优先级,即DEBUG,INFO,WARN,ERROR,FATAL,

    %d: 输出日志时间点的日期或时间,默认格式为ISO8601,也可以在其后指定格式,比如:%d{yyy MMM dd       HH:mm:ss,SSS},输出类似:2002年10月18日 22:10:28,921

    %r: 输出自应用启动到输出该log信息耗费的毫秒数

    %c: 输出日志信息所属的类目,通常就是所在类的全名

    %t: 输出产生该日志事件的线程名

    %l: 输出日志事件的发生位置,相当于%C.%M(%F:%L)的组合,包括类目名、发生的线程,以及在代码中的行数。 举例:Testlog4.main (TestLog4.

    %x: 输出和当前线程相关联的NDC(嵌套诊断环境),尤其用到像java servlets这样的多客户多线程的应用中。

    %%: 输出一个"%"字符

    %F: 输出日志消息产生时所在的文件名称

    %L: 输出代码中的行号

    %m: 输出代码中指定的消息,产生的日志具体信息

    %n: 输出一个回车换行符,Windows平台为"\r\n",Unix平台为"\n"输出日志信息换行。

    5. Threshold是个全局的过滤器,它将把低于所设置的level的信息过滤不显示出来。

    代码中使用:

    1. 代码中使用的包:  import org.apache.log4j.Logger;

    2. 定义使用log:private Logger log=Logger.getLogger(当前类名.class);

    3. 输出:

    log.info("this is info:"+s);

    log.error("this is error:"+s);

    log.debug("this is debug:"+s);

    二、AppendContentToFile追加写入日志

    1. 在项目中新建一个类,类名:AppendContentToFile。内容如下:

    import java.io.RandomAccessFile;

    public class AppendContentToFile {

    // 追加写入

    public static void Awrite(String fileName, String content) {

    try {

    // 打开一个随机访问文件流,按读写方式

    RandomAccessFile randomFile = new RandomAccessFile(fileName, "rw");

    // 文件长度,字节数

    long fileLength = randomFile.length();

    // 将写文件指针移到文件尾。

    randomFile.seek(fileLength);

    randomFile.write((content+"\r\n").getBytes());

    //randomFile.write(content.getBytes());

    //System.out.println(new String(randomFile.readLine().getBytes("ISO-8859-1"), "utf-8"));// 需要重新转码才能正常显示

    randomFile.close();

    } catch (IOException e) {

    e.printStackTrace();

    }

    }

    }

    2. 调用

    AppendContentToFile.Awrite("E:\\log.txt","打印内容");

    展开全文
  • Java日志--logback--配置/介绍/基础

    千次阅读 2021-09-24 00:31:26
    万字详解logback日志框架,再没这么全的了!_程序新视界-CSDN博客 logback基本使用_Python_dengjili的专栏-CSDN博客logback的使用和logback.xml详解 - 行走在云端的愚公 - 博客园 logback 常用配置详解(二) - ...

    原文网址:Java日志--logback--配置/介绍/基础_IT利刃出鞘的博客-CSDN博客

    简介

    说明

            本文介绍Logback的由来、配置等。

    官网

    Logback Manual

    Logback简介 

    Logback是由log4j创始人设计的另一个开源日志组件。它当前分为下面下个模块:

    • logback-core:其它两个模块的基础模块
    • logback-classic:log4j的一个改良版本,完整实现了slf4j API,可方便地更换成其它日志系统如log4j或JDK14 Logging
    • logback-access:访问模块与Servlet容器集成提供通过Http来访问日志的功能

    说明:如果使用maven,则只需写logback-classic依赖,则logback-core和slf4j-api依赖会自动被拉入。

    logback取代log4j的理由

    1. 更快的实现:Logback的内核重写了,在一些关键执行路径上性能提升10倍以上。而且logback不仅性能提升了,初始化内存加载也更小了。
    2. 非常充分的测试:Logback经过了几年,数不清小时的测试。Logback的测试比log4j测试强度高很多,完全不同级别的。
    3. Logback-classic非常自然实现了SLF4j:Logback-classic实现了SLF4j。在使用SLF4j中,你都感觉不到logback-classic。而且因为logback-classic非常自然地实现了slf4j , 所 以切换到log4j或者其他,非常容易,只需要提供成另一个jar包就OK,根本不需要去动那些通过SLF4JAPI实现的代码。
    4. 非常充分的文档 官方网站有两百多页的文档。
    5. 自动重新加载配置文件,当配置文件修改了,Logback-classic能自动重新加载配置文件。扫描过程快且安全,它并不需要另外创建一个扫描线程。这个技术充分保证了应用程序能跑得很欢在JEE环境里面。
    6. Lilith是log事件的观察者,和log4j的chainsaw类似。而lilith还能处理大数量的log数据 。
    7. 谨慎的模式和非常友好的恢复,在谨慎模式下,多个FileAppender实例跑在多个JVM下,能 够安全地写道同一个日志文件。RollingFileAppender会有些限制。Logback的FileAppender和它的子类包括 RollingFileAppender能够非常友好地从I/O异常中恢复。
    8. 配置文件可以处理不同的情况,开发人员经常需要判断不同的Logback配置文件在不同的环境下(开发,测试,生产)。而这些配置文件仅仅只有一些很小的不同,可以通过,和来实现,这样一个配置文件就可以适应多个环境。
    9. Filters(过滤器)有些时候,需要诊断一个问题,需要打出日志。在log4j,只有降低日志级别,不过这样会打出大量的日志,会影响应用性能。在Logback,你可以继续 保持那个日志级别而除掉某种特殊情况,如alice这个用户登录,她的日志将打在DEBUG级别而其他用户可以继续打在WARN级别。要实现这个功能只需加4行XML配置。可以参考MDCFIlter 。
    10. SiftingAppender(一个非常多功能的Appender):它可以用来分割日志文件根据任何一个给定的运行参数。如,SiftingAppender能够区别日志事件跟进用户的Session,然后每个用户会有一个日志文件。
    11. 自动压缩已经打出来的log:RollingFileAppender在产生新文件的时候,会自动压缩已经打出来的日志文件。压缩是个异步过程,所以甚至对于大的日志文件,在压缩过程中应用不会受任何影响。
    12. 堆栈树带有包版本:Logback在打出堆栈树日志时,会带上包的数据。
    13. 自动去除旧的日志文件:通过设置TimeBasedRollingPolicy或者SizeAndTimeBasedFNATP的maxHistory属性,你可以控制已经产生日志文件的最大数量。如果设置maxHistory 12,那那些log文件超过12个月的都会被自动移除。

    配置

    官网对配置的介绍:Logback Manual

    配置文件优先级

    以下文件依次查找,找到一个则停止

    1.  classpath下的logback-test.xml;
    2.  classpath下的logback.xml;
    3.  用BasicConfigurator自动对自己进行配置,这会导致记录输出到控制台。

            若配置文件 logback-test.xml 和 logback.xml 都不存在,那么 logback 默认地会调用BasicConfigurator ,创建一个最小化配置。最小化配置由一个关联到根 logger 的ConsoleAppender 组成。输出格式为:%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n 的 PatternLayoutEncoder 。root logger 默认级别是 DEBUG。

    简单配置示例

    最简配置

    <?xml version="1.0" encoding="UTF-8"?>
    <configuration>
        <!-- 控制台输出 -->
        <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
            <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
                <!--格式化输出:
                    %d:日期,
                    %thread:线程名,
                    %-5level:级别从左显示5个字符宽度
                    %msg:日志消息
                    %n:换行符
                -->
                <pattern>
                    %d{yyyy-MM-dd HH:mm:ss.SSS} [%.15thread] %-5level %-40logger{40} : %msg%n
                </pattern>
            </encoder>
        </appender>
        <!-- 日志输出级别 -->
        <root level="INFO">
            <appender-ref ref="STDOUT" />
        </root>
    </configuration>

    配置详解

    
    <?xml version="1.0" encoding="UTF-8"?>
    <!-- 不分级别同步文件日志输出配置 -->
    <!-- 级别从高到低 OFF 、 FATAL 、 ERROR 、 WARN 、 INFO 、 DEBUG 、 TRACE 、 ALL -->
    <!-- 日志输出规则 根据当前ROOT 级别,日志输出时,级别高于等于root默认的级别时 会输出 -->
    <!-- 以下 每个配置的 filter 是过滤掉输出文件里面,会出现高级别文件,依然出现低级别的日志信息,
           通过filter 过滤只记录本级别的日志 -->
    <!-- scan 当此属性设置为true时,配置文件如果发生改变,将会被重新加载,默认值为true。 -->
    <!-- scanPeriod 设置监测配置文件是否有修改的时间间隔,如果没有给出时间单位,默认单位是毫秒。
           当scan为true时,此属性生效。默认的时间间隔为1分钟。 -->
    <!-- debug 当此属性设置为true时,将打印出logback内部日志信息,实时查看logback运行状态。默认值为false。 -->
    <configuration scan="true" scanPeriod="60 seconds" debug="false" >
    
        <!-- logback项目名称 -->
        <property name="appName" value="noSeatBeltDev"/>
    
        <!-- 日志级别 -->
        <property name="logLevel" value="DEBUG"/>
    
        <!-- 日志地址 -->
        <property name="logPath" value="./logs"/>
    
        <!-- 最大保存时间 10天 -->
        <property name="maxHistory" value="10"/>
    
        <!-- 异步缓冲队列的深度,该值会影响性能.默认值为256 -->
        <property name="queueSize" value="512" />
    
        <!-- lOGGER  PATTERN  配置化输出语句 根据自己的喜好选择 -->
        <property name="logPattern" value="%d{yyyy-MM-dd HH:mm:ss.SSS} [%-5level] %logger - %msg%n"/>
        <!-- %d{yyyy-MM-dd HH:mm:ss.SSS} [%-5level] %logger - %msg%n -->
        <!-- %d{yyyy-MM-dd HH:mm:ss} %-4relative [%thread] %-5level %logger{35} - %msg %n -->
        <!-- [ %-5level] [%date{yyyy-MM-dd HH:mm:ss.SSS}] %logger{96} [%line] [%thread]- %msg%n  -->
    
    
        <!-- 控制台打印日志的相关配置 -->
        <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
            <!-- 日志格式 -->
            <encoder>
                <charset>UTF-8</charset>
                <pattern>${logPattern}</pattern>
            </encoder>
        </appender>
    
        <!-- 文件保存日志的相关配置 -->
        <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <!-- 保存日志文件的路径 -->
            <file>${logPath}/${appName}.log</file>
    
            <!-- 日志格式 -->
            <encoder>
                <pattern>${logPattern}</pattern>
            </encoder>
            <filter class="ch.qos.logback.classic.filter.LevelFilter">
                <level>${logLevel}</level>
                <onMatch>ACCEPT</onMatch>
                <onMismatch>DENY</onMismatch>
            </filter>
    
            <!-- 循环政策:基于时间创建日志文件 -->
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <!-- 日志文件名格式 -->
                <fileNamePattern>${logPath}/${appName}-%d{yyyy-MM-dd}.log</fileNamePattern>
                <!-- 最大保存时间-->
                <maxHistory>${maxHistory}</maxHistory>
            </rollingPolicy>
        </appender>
    
        <!--配置mybatis sql 日志-->
        <logger name="com.pf.org.cms.mapper" level="DEBUG"/>
        <!-- 基于INFO处理日志:具体控制台或者文件对日志级别的处理还要看所在appender配置的filter,
                    如果没有配置filter,则使用root配置 -->
    
        <root level="${logLevel}">
            <appender-ref ref="STDOUT" />
            <!-- 开发可以只要控制台就OK -->
            <!-- <appender-ref ref="FILE" /> -->
        </root>
    </configuration>

    正式环境配置示例

    <?xml version="1.0" encoding="UTF-8"?>
    <!-- 分级别异步文件日志输出配置 -->
    <!-- 级别从高到低 OFF 、 FATAL 、 ERROR 、 WARN 、 INFO 、 DEBUG 、 TRACE 、 ALL -->
    <!-- 日志输出规则 根据当前ROOT 级别,日志输出时,级别高于root默认的级别时 会输出 -->
    <!-- 以下 每个配置的 filter 是过滤掉输出文件里面,会出现高级别文件,依然出现低级别的日志信息,
                通过filter 过滤只记录本级别的日志 -->
    <!-- scan 当此属性设置为true时,配置文件如果发生改变,将会被重新加载,默认值为true。 -->
    <!-- scanPeriod 设置监测配置文件是否有修改的时间间隔,如果没有给出时间单位,默认单位是毫秒。
                当scan为true时,此属性生效。默认的时间间隔为1分钟。 -->
    <!-- debug 当此属性设置为true时,将打印出logback内部日志信息,实时查看logback运行状态。默认值为false。 -->
    <configuration scan="true" scanPeriod="60 seconds" debug="false">
    
        <!-- logback项目名称 -->
        <property name="appName" value="noSeatBeltProd"></property>
    
        <!-- 日志级别 DEBUGER INFO WARN ERROR -->
        <property name="logLevel" value="INFO"></property>
    
        <!-- 日志路径-->
        <property name="logPath" value="./logs"></property>
    
        <!-- 最大保存时间 30天-->
        <property name="maxHistory" value="3"/>
    
        <!-- 异步缓冲队列的深度,该值会影响性能.默认值为256 -->
        <property name="queueSize" value="256"></property>
    
        <!-- lOGGER  PATTERN 根据个人喜好选择匹配  -->
        <property name="logPattern" value="[ %-5level] [%date{yyyy-MM-dd HH:mm:ss.SSS}] %logger{96} [%line] [%thread]- %msg%n"></property>
        <!-- %d{yyyy-MM-dd HH:mm:ss.SSS} [%-5level] %logger - %msg%n -->
        <!-- %d{yyyy-MM-dd HH:mm:ss} %-4relative [%thread] %-5level %logger{35} - %msg %n -->
        <!-- [ %-5level] [%date{yyyy-MM-dd HH:mm:ss.SSS}] %logger{96} [%line] [%thread]- %msg%n  -->
    
        <!-- 动态日志级别 -->
        <jmxConfigurator/>
    
        <!-- 控制台的标准输出 -->
        <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
            <encoder>
                <charset>UTF-8</charset>
                <pattern>${logPattern}</pattern>
            </encoder>
        </appender>
    
        <!-- DUBUG 日志记录  -->
        <appender name="FILE_DEBUG"  class="ch.qos.logback.core.rolling.RollingFileAppender">
            <filter class="ch.qos.logback.classic.filter.LevelFilter">
                <level>DEBUG</level>
                <onMatch>ACCEPT</onMatch>
                <onMismatch>DENY</onMismatch>
            </filter>
            <file>${logPath}/${appName}_debug.log</file>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>
                    ${logPath}/debug/${appName}_debug.log.%d{yyyy-MM-dd}.zip
                </fileNamePattern>
                <maxHistory>${maxHistory}</maxHistory>
            </rollingPolicy>
            <encoder>
                <pattern>${logPattern}</pattern>
            </encoder>
        </appender>
    
        <!-- INFO 级别的日志记录  -->
        <appender name="FILE_INFO" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <filter class="ch.qos.logback.classic.filter.LevelFilter">
                <level>INFO</level>
                <onMatch>ACCEPT</onMatch>
                <onMismatch>DENY</onMismatch>
            </filter>
            <file>${logPath}/${appName}_info.log</file>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>
                    ${logPath}/info/${appName}_info.log.%d{yyyy-MM-dd}.zip
                </fileNamePattern>
                <maxHistory>${maxHistory}</maxHistory>
            </rollingPolicy>
            <encoder>
                <pattern>${logPattern}</pattern>
            </encoder>
        </appender>
    
        <!--  WARN 级别的日志记录 -->
        <appender name="FILE_WARN" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <filter class="ch.qos.logback.classic.filter.LevelFilter">
                <level>WARN</level>
                <onMatch>ACCEPT</onMatch>
                <onMismatch>DENY</onMismatch>
            </filter>
            <file>${logPath}/${appName}_warn.log</file>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>
                    ${logPath}/warn/${appName}_warn.log.%d{yyyy-MM-dd}.zip
                </fileNamePattern>
                <maxHistory>${maxHistory}</maxHistory>
            </rollingPolicy>
            <encoder>
                <pattern>${logPattern}</pattern>
            </encoder>
        </appender>
    
        <!-- Error 级别的日志记录 -->
        <appender name="FILE_ERROR" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <filter class="ch.qos.logback.classic.filter.LevelFilter">
                <level>ERROR</level>
                <onMatch>ACCEPT</onMatch>
                <onMismatch>DENY</onMismatch>
            </filter>
            <file>${logPath}/${appName}_error.log</file>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>
                    ${logPath}/error/${appName}_error.log.%d{yyyy-MM-dd}.zip
                </fileNamePattern>
                <maxHistory>${maxHistory}</maxHistory>
            </rollingPolicy>
            <encoder>
                <pattern>${logPattern}</pattern>
            </encoder>
        </appender>
    
        <!-- ASYNC_LOG_DEBUG  -->
        <appender name="ASYNC_LOG_DEBUG" class="ch.qos.logback.classic.AsyncAppender">
            <!-- 不丢失日志.默认的,如果队列的80%已满,则会丢弃TRACT、DEBUG、INFO级别的日志 -->
            <discardingThreshold>0</discardingThreshold>
            <!-- 更改默认的队列的深度,该值会影响性能.默认值为256 -->
            <queueSize>${queueSize}</queueSize>
            <appender-ref ref="FILE_DEBUG"/>
        </appender>
    
        <!-- ASYNC_LOG_INFO -->
        <appender name="ASYNC_LOG_INFO" class="ch.qos.logback.classic.AsyncAppender">
            <!-- 不丢失日志.默认的,如果队列的80%已满,则会丢弃TRACT、DEBUG、INFO级别的日志 -->
            <discardingThreshold>0</discardingThreshold>
            <!-- 更改默认的队列的深度,该值会影响性能.默认值为256 -->
            <queueSize>${queueSize}</queueSize>
            <appender-ref ref="FILE_INFO"/>
        </appender>
    
        <!-- ASYNC_LOG_WARN -->
        <appender name="ASYNC_LOG_WARN" class="ch.qos.logback.classic.AsyncAppender">
            <!-- 不丢失日志.默认的,如果队列的80%已满,则会丢弃TRACT、DEBUG、INFO级别的日志 -->
            <discardingThreshold>0</discardingThreshold>
            <!-- 更改默认的队列的深度,该值会影响性能.默认值为256 -->
            <queueSize>${queueSize}</queueSize>
            <appender-ref ref="FILE_WARN"/>
        </appender>
    
        <!--ASYNC_LOG_ERROR  -->
        <appender name="ASYNC_LOG_ERROR" class="ch.qos.logback.classic.AsyncAppender">
            <!-- 不丢失日志.默认的,如果队列的80%已满,则会丢弃TRACT、DEBUG、INFO级别的日志 -->
            <discardingThreshold>0</discardingThreshold>
            <!-- 更改默认的队列的深度,该值会影响性能.默认值为256 -->
            <queueSize>${queueSize}</queueSize>
            <appender-ref ref="FILE_ERROR"/>
        </appender>
    
        <!-- 日志的记录级别 -->
        <!-- 在定义后引用APPENDER -->
        <root level="${logLevel}">
            <!--  控制台  -->
            <appender-ref ref="STDOUT"/>
    
            <!-- 具体的日志级别和文件的配置 -->
            <appender-ref ref="ASYNC_LOG_DEBUG"/>
            <appender-ref ref="ASYNC_LOG_INFO"/>
            <appender-ref ref="ASYNC_LOG_WARN"/>
            <appender-ref ref="ASYNC_LOG_ERROR"/>
        </root>
    </configuration>

    日志格式

    其他网址

    官网:Chapter 6: Layouts

    变量名

    符号

    含义

    %logger(简写:%c或%lo)

    输出日志的logger名,可有一个整形参数用于缩短logger名,设置为0表示只输入logger最右边点符号之后的字符串。
    Conversion specifierLogger nameResult
    %loggermainPackage.sub.sample.BarmainPackage.sub.sample.Bar
    %logger{0}mainPackage.sub.sample.BarBar
    %logger{5}mainPackage.sub.sample.Barm.s.s.Bar
    %logger{10}mainPackage.sub.sample.Barm.s.s.Bar
    %logger{15}mainPackage.sub.sample.Barm.s.sample.Bar
    %logger{16}mainPackage.sub.sample.Barm.sub.sample.Bar
    %logger{26}mainPackage.sub.sample.BarmainPackage.sub.sample.Bar

    %caller

    输出生成日志的调用者的位置信息,整数选项表示输出信息深度。

    格式:%caller{depth}caller{depth, evaluator-1, ... evaluator-n}

    例如, %caller{2}   输出为:

    0    [main] DEBUG - logging statement 
    Caller+0   at mainPackage.sub.sample.Bar.sampleMethodName(Bar.java:22)
    Caller+1   at mainPackage.sub.sample.Bar.createLoggingRequest(Bar.java:17)

    例如, %caller{3}   输出为:

    16   [main] DEBUG - logging statement 
    Caller+0   at mainPackage.sub.sample.Bar.sampleMethodName(Bar.java:22)
    Caller+1   at mainPackage.sub.sample.Bar.createLoggingRequest(Bar.java:17)
    Caller+2   at mainPackage.ConfigTester.main(ConfigTester.java:38)

    %thread(简写:%t)

    输出产生日志的线程名。输出示例:main

    %level(简写:%p或%le)

    日志级别。输出示例:INFO

    %date(简写:%d)

    日期,模式语法与java.text.SimpleDateFormat 兼容。

    Conversion PatternResult
    %d2006-10-20 14:06:49,812
    %date2006-10-20 14:06:49,812
    %date{yyyy-MM-dd HH:mm:ss.SSS}2018-12-15 21:40:12,890
    %date{ISO8601}2006-10-20 14:06:49,812
    %date{HH:mm:ss.SSS}14:06:49.812
    %date{dd MMM yyyy ;HH:mm:ss.SSS}20 oct. 2006;14:06:49.812

    %msg(简写:%m)

    日志记录内容。输出示例:Tomcat initialized with port(s): 8080 (http)

    %exception(简写:%ex)

    异常记录。

    %ex{depth}

    %ex{full}         //打印所有

    %ex{depth, evaluator-1, …, evaluator-n}
    %throwable{depth}
    %throwable{depth, evaluator-1, …, evaluator-n}

    %relative(简写:%r)输出从程序启动到创建日志记录的时间,单位是毫秒

    %class(简写:%C)

    输出执行记录请求的调用者的全限定名。参数与上面的%logger一样。尽量避免使用,除非执行速度不造成任何问题。

    %file(简写:%F)输出执行记录请求的java源文件名。尽量避免使用,除非执行速度不造成任何问题。
    %line(简写:%L)输出执行日志请求的行号。尽量避免使用,除非执行速度不造成任何问题。
    %contextName(简写:%cn)输出上下文名称。

    %method(简写:%M)

    输出执行日志请求的方法名。尽量避免使用,除非执行速度不造成任何问题。

    输出示例:main

    %replace(p ){r, t}

    p 为日志内容,r 是正则表达式,将p 中符合r 的内容替换为t 。

    例如, "%replace(%msg){'\s', ''}"

    宽度

    符号

    含义

    %20logger

    字符数少于20个字符时,则左侧留空白;

    %-20logger

    当字符数少于20个字符时,则右侧留空白;

    %.20logger

    当字符数据大于20个时,则从前边截断;

    %.-20logger当字符数据大于20个时,则从后边截断;

    显示设置

    符号

    含义

    %highligth

    突出显示

    %green(%red、%blue、%white)

    字体显示为指定颜色

    {length}

    可指定长度,如%logger{36}

    网络访问设置(依赖logger-access包)

    符号

    含义

    %remoteIP(简写:%a)

    远程ip;

    %localIP(简写:%A)

    本地ip;

    %clientHost(简写:%h)

    远程主机名;

    %localPort

    本地端口;

    %requestMethod(简写:%m)

    http请求方法;

    %protocol(简写:%H)

    http请求协议;

    %statusCode(简写:%s)

    http请求statuscode;

    %requestURL(简写:%r)

    http请求地址;

    %requestURI(简写:%U)

    http请求资源地址;

    %queryString(简写:%q)

    http请求参数;

    %server(简写:%v)

    服务器地址;

    %elapsedTime(简写:%D)

    http请求处理的时间,单位是毫秒;

    %elapsedSeconds(简写:%T)

    http请求处理的时间,单位是秒;

    %date(简写:%t)

    日志记录时间;

    %threadName(简写:%I)

    处理请求的线程名;

    %reqAttribute{attributeName}

    http请求attribute值;

    %reqCookie{cookie}

    http请求cookie值;

    %reqContent

    请求体内容;

    %fullRequest

    http完整请求;

    %responseContent

    http响应;

    %fullResponse

    http完整响应;

    简单示例

    java文件

    package com.example;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    public class HelloWorld {
        private static final Logger logger = LoggerFactory.getLogger(HelloWorld.class);
    
        public static void main(String[] args) {
            logger.error("logback error测试");
            logger.info("logback info测试");
            logger.debug("logback debug测试");
        }
    }
    

    pom.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.example</groupId>
        <artifactId>mytest</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <dependencies>
            <!-- https://mvnrepository.com/artifact/ch.qos.logback/logback-classic -->
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-classic</artifactId>
                <version>1.2.3</version>
            </dependency>
        </dependencies>
    </project>

    logback.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <configuration>
    	<!-- 控制台输出 -->
    	<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
    		<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
    			<!--格式化输出:%d表示日期,%thread表示线程名,
                              %-5level:级别从左显示5个字符宽度;
                              %msg:日志消息,%n是换行符 -->
    			<pattern>
    				%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n
    			</pattern>
    		</encoder>
    	</appender>
    	<!-- 日志输出级别 -->
    	<root level="INFO">
    		<appender-ref ref="STDOUT" />
    	</root>
    </configuration>

    测试

    2020-03-05 16:57:47.397 [main] ERROR com.example.HelloWorld - logback error测试
    2020-03-05 16:57:47.400 [main] INFO  com.example.HelloWorld - logback info测试

    其他网址

    万字详解logback日志框架,再没这么全的了!_程序新视界-CSDN博客

    logback基本使用_Python_dengjili的专栏-CSDN博客
    logback的使用和logback.xml详解 - 行走在云端的愚公 - 博客园

    logback 常用配置详解(二) - mingyue1818 - 博客园

    展开全文
  • 一文搞懂Java日志级别,重复记录、丢日志问题

    万次阅读 多人点赞 2020-12-06 21:33:46
    13 | 日志日志记录真没你想象的那么简单 2020-04-07 朱晔 你好,我是朱晔。今天,我和你分享的是,记录日志可能会踩的坑。 一些同学可能要说了,记录日志还不简单,无非是几个常用的API方法,比如debug、info、...
  • java日志使用

    万次阅读 多人点赞 2019-06-08 09:56:58
    java日志:日志就是记录程序的运行轨迹,方便查找关键信息,也方便快速定位解决问题。 常用的日志框架:Log4j、Slf4j 、Logback 。 在JDK 1.3及以前,Java打日志依赖System.out.println(), System.err.println()...
  • 一种Java日志系统框架的设计与实现

    热门讨论 2011-03-28 09:18:24
    一种Java日志系统框架的设计与实现( 一种Java日志系统框架的设计与实现( 一种Java日志系统框架的设计与实现( 一种Java日志系统框架的设计与实现
  • Java日志记录-我的日志文件在哪里?

    千次阅读 2021-02-12 13:19:00
    我java.util.logging在Windows XP的Eclipse 3.7.1中使用Java日志记录-。我logging.properties文件的相关行是:handlers= java.util.logging.FileHandler, java.util.logging.ConsoleHandler.level=INFOjava.util....
  • Java的8个Java日志工具

    千次阅读 2018-06-28 23:49:47
    摘要 : 本文要来分享一些Java程序员最常用的Java日志框架组件。 日志工具 log4j – 最受欢迎的Java日志组件 Log4j是一款基于Java的开源日志组件,Log4j功能非常强大,我们可以将日志信息输出到控制台、文件、用户...
  • Java日志记录函数调用栈方法

    千次阅读 2022-02-21 15:43:11
    关于getStackTrace() public StackTraceElement[] getStackTrace() 返回一个表示该线程堆栈转储的堆栈跟踪元素...android/java 调用栈 将以下代码加入被调用的函数中即可 for (StackTraceElement i : Thread.current
  • ELK收集java日志

    千次阅读 2020-07-01 10:59:36
    由于elasticsearch本身产生的日志就是java日志,所以我们可以通过ELK平台直接收集elasticsearch日志 1.修改filebeat配置文件 [root@db01 ~]# vim /etc/filebeat/filebeat.yml filebeat.inputs: - type: log enabled...
  • java日志级别

    千次阅读 2020-03-03 17:58:18
    java日志级别有7 个级别:severe、Warning、info、config、fine、finer、finest。默认情况只记录前三个级别。另外可以使用Level.ALL开启所有的级别记录。或者使用Level.OFF关闭所有的级别记录。 log4j中日志级别...
  • java日志文件内容中文乱码

    千次阅读 2021-02-08 17:46:51
    3台机器,其中2台机器的log4j日志中文内容是正常的,但到另外1台中文全部变成了问号, 启动命令增加 -Dfile.encoding=UTF-8最终解决: java-Dfile.encoding=UTF-8 -jar xxx-0.0.1-SNAPSHOT.jar
  • java日志框架详解总结(含配置)

    千次阅读 2018-05-25 10:17:41
    该篇是集合了百度众多的日志框架详解,java日志框架分析的总结篇。 具体网址: https://blog.csdn.net/foreverling/article/details/51385128 https://blog.csdn.net/chszs/article/details/8653460 ...
  • 最全Java日志框架详解

    万次阅读 2018-09-21 18:23:51
    最全Java日志框架详解  在项目开发过程中,我们可以通过 debug 查找问题。而在线上环境我们查找问题只能通过打印日志的方式查找问题。因此对于一个项目而言,日志记录是一个非常重要的问题。因 此,如何选择一个...
  • java 日志打印规范

    千次阅读 2019-08-16 11:43:00
    日志要求: 重要日志一定要打印到日志文件 日志文件应该每天滚动一次,日志多的可以每个小时滚动一次 日期必须精确到毫秒,而不是秒 确保日志是按事件顺序输出 【推荐】最好能打印调用方信息,比如访问者ip等信息 ...
  • Java 日志相关的面试

    千次阅读 2018-06-25 15:28:07
    近期整理的关于日志的面试题,对于初级者来说,很少会涉及...1. 常用的日志框架 Java Logging API(Oracle)—— Java默认的日志框架 Log4j(Apache)——开源日志框架 Logback(Logback Project)——开源项目,...
  • JAVA 日志级别

    千次阅读 2019-03-15 11:08:00
    log4j定义了8个级别的log(除去OFF和ALL,可以说分为6个级别),优先级从高...ALL:最低等级的,用于打开所有日志记录。 TRACE:designates finer-grained informational events than the DEBUG.Since:1.2.12,很低...
  • Java日志体系总结

    千次阅读 2021-11-19 13:10:10
    本文的目的是搞清楚Java中各种日志Log之间是怎么的关系,如何作用、依赖,好让我们平时在工作中如果遇到“日志打不出”或者“日志jar包冲突”等之类的问题知道该如何入手解决,以及在各种场景下如何调整项目中的各个...
  • java日志管理

    万次阅读 2016-10-08 10:20:44
    我们在日常开发中主要使用的java日志框架组件是:log4j、SLF4J、Commons Logging 日志级别一般分为7个打印级别(不同的日志框架组件可能打印的日志级别区别不大): OFF-关闭所有日志; FATAL-记录严重的错误,并且...
  • Java日志全解析(上) - 源流

    千次阅读 2017-03-31 16:28:28
    作为Java程序员,幸运的是,Java 拥有功能和性能都非常强大的日志库;不幸的是,这样的日志库有不止一个——相信每个人都曾经迷失在JUL(Java Util Log), JCL(Commons Logging), Log4j, SLF4J, Logback,Log4j2 等等...
  • java日志中的info是啥意思

    千次阅读 2021-03-06 22:26:07
    2019-03-21 回答首先,在项目中的classes 中新建立一个log4j.properties文件即可;...log4j支持两种配置文件格式,一种是xml格式的文件,一种是java properties(key=value)【java特性文件(键=值)】。...
  • java日志级别动态调整

    千次阅读 2018-03-10 12:13:25
    java日志级别动态调整 近期在web项目维护过程中,发现一个令人脑袋大的事,线上的项目出了bug,必须日志开启debug才能看到错误。总不能没事重启一下吧?em……,老大听了想打人。后来查了下,其实可以通过动态的...
  • java日志系统框架整理(转载)

    万次阅读 2018-02-06 11:45:38
    参考:(方便记录,直接将内容贴过来了。如有侵权,请留言删除,此致敬意!) 首先,在日志系统的森林里面理理头绪,修炼内功。参考文章如下: 1.... ...Java日志系统确实比较丰富,常用的
  • 十一、k8s收集 pod中 java日志

    千次阅读 2019-01-14 15:55:37
    这里我们采取用伴生容器的形式采集java日志 tomcat日志 1、部署一个configmap用来保存filebeat配置: [root@master yml_files]# cat filebeat-tomcat-configmap.yaml apiVersion: v1 kind: ConfigMap metadata: ...
  • 配置logstash收集java日志

    千次阅读 2019-03-09 11:02:29
    0.默认已经安装了ELK,并已经成功运行。如需安装,请移步此处...sudo vim /etc/logstash/conf.d/java.conf #添加以下配置 input{ file{ path=&gt;"/var/log/elasticsearch/elasticsearch.log" ...
  • 简易Java日志(Log)输出工具的封装

    万次阅读 多人点赞 2017-04-22 23:22:01
    平时 Java 项目的开发通常需要统一管理日志(Log)的输出,例如控制日志信息输送的目的地(控制台、文件等),控制每一条日志的输出格式,把日志分为不同的级别等。常用的比较成熟的 Java 日志管理工具有 Apache 的 ...
  • 上周Java日志库Log4j2的注入漏洞CVE-2021-44228,被定义为极高危漏洞,国外评分为10(满分为10)。让各厂的工程师忙的不可开交,加急通宵处理这个漏洞。为什么大家都这么重...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 893,921
精华内容 357,568
关键字:

java日志

java 订阅
友情链接: guiyiu_v34.zip