log4j 订阅
Log4j是Apache的一个开源项目,通过使用Log4j,我们可以控制日志信息输送的目的地是控制台、文件、GUI组件,甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护进程等;我们也可以控制每一条日志的输出格式;通过定义每一条日志信息的级别,我们能够更加细致地控制日志的生成过程。最令人感兴趣的就是,这些可以通过一个配置文件来灵活地进行配置,而不需要修改应用的代码。 展开全文
Log4j是Apache的一个开源项目,通过使用Log4j,我们可以控制日志信息输送的目的地是控制台、文件、GUI组件,甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护进程等;我们也可以控制每一条日志的输出格式;通过定义每一条日志信息的级别,我们能够更加细致地控制日志的生成过程。最令人感兴趣的就是,这些可以通过一个配置文件来灵活地进行配置,而不需要修改应用的代码。
信息
版    本
Apache License V2.0
别    名
log4j--log for java
中文名
java日志
外文名
log4j
log4j定义
log4j--log for java(java的日志)在强调可重用组件开发的今天,除了自己从头到尾开发一个可重用的日志操作类外,Apache为我们提供了一个强有力的日志操作包-Log4j。此外,通过Log4j其他语言接口,您可以在C、C++、.Net、PL/SQL程序中使用Log4j,其语法和用法与在Java程序中一样,使得多语言分布式系统得到一个统一一致的日志组件模块。而且,通过使用各种第三方扩展,您可以很方便地将Log4j集成到J2EE、JINI甚至是SNMP应用中。说明:下面分为三部分,第一部分讲解如何配置log4j;第二部分为对log4j.properties配置文件中的各个属性的讲解;第三部分为对log4j的详细讲解。如果只想配置上log4j,那么只需要看前两个部分就可以,如果想对log4j深入了解,则还需看第三部分。使用的license: Apache License V2.0。
收起全文
精华内容
参与话题
问答
  • 最详细的Log4J使用教程

    万次阅读 多人点赞 2018-03-11 17:17:55
    地址:http://www.codeceo.com/log4j-usage.html ...在apache网站:jakarta.apache.org/log4j可以免费下载到Log4j最新版本的软件包。 一、入门实例 1.新建一个JAva工程,导入包log4j-1.2.17.jar,整个...

    地址:http://www.codeceo.com/log4j-usage.html

    日志是应用软件中不可缺少的部分,Apache的开源项目log4j是一个功能强大的日志组件,提供方便的日志记录。在apache网站:jakarta.apache.org/log4j 可以免费下载到Log4j最新版本的软件包。

    一、入门实例

    1.新建一个JAva工程,导入包log4j-1.2.17.jar,整个工程最终目录如下

    2、src同级创建并设置log4j.properties

     ### 设置###
    log4j.rootLogger = debug,stdout,D,E
    
    ### 输出信息到控制抬 ###
    log4j.appender.stdout = org.apache.log4j.ConsoleAppender
    log4j.appender.stdout.Target = System.out
    log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
    log4j.appender.stdout.layout.ConversionPattern = [%-5p] %d{yyyy-MM-dd HH:mm:ss,SSS} method:%l%n%m%n
    
    ### 输出DEBUG 级别以上的日志到=E://logs/error.log ###
    log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
    log4j.appender.D.File = E://logs/log.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
    
    ### 输出ERROR 级别以上的日志到=E://logs/error.log ###
    log4j.appender.E = org.apache.log4j.DailyRollingFileAppender
    log4j.appender.E.File =E://logs/error.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.rootLogger = debug,stdout,D,E
    
    ### 输出信息到控制抬 ###
    log4j.appender.stdout = org.apache.log4j.ConsoleAppender
    log4j.appender.stdout.Target = System.out
    log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
    log4j.appender.stdout.layout.ConversionPattern = [%-5p] %d{yyyy-MM-dd HH:mm:ss,SSS} method:%l%n%m%n
    
    ### 输出DEBUG 级别以上的日志到=E://logs/error.log ###
    log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
    log4j.appender.D.File = E://logs/log.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
    
    ### 输出ERROR 级别以上的日志到=E://logs/error.log ###
    log4j.appender.E = org.apache.log4j.DailyRollingFileAppender
    log4j.appender.E.File =E://logs/error.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

    3、设置日志内容

    package com.mucfc;
    import org.apache.log4j.Logger;
    /**
     *@author linbingwen
     *@2015年5月18日9:14:21
     */
    public class Test {
    	private static Logger logger = Logger.getLogger(Test.class);  
    
        /** 
         * @param args 
         */  
        public static void main(String[] args) {  
            // System.out.println("This is println message.");  
    
            // 记录debug级别的信息  
            logger.debug("This is debug message.");  
            // 记录info级别的信息  
            logger.info("This is info message.");  
            // 记录error级别的信息  
            logger.error("This is error message.");  
        }  
    
    } com.mucfc;
    import org.apache.log4j.Logger;
    /**
     *@author linbingwen
     *@2015年5月18日9:14:21
     */
    public class Test {
    	private static Logger logger = Logger.getLogger(Test.class);  
    
        /** 
         * @param args 
         */  
        public static void main(String[] args) {  
            // System.out.println("This is println message.");  
    
            // 记录debug级别的信息  
            logger.debug("This is debug message.");  
            // 记录info级别的信息  
            logger.info("This is info message.");  
            // 记录error级别的信息  
            logger.error("This is error message.");  
        }  
    
    }

    4、输出结果

    (1)首先是控制台的信息

    (2)再来看输出的文件

    内容如下,发现已按照要求输出到对应的文档中去了。

    二、Log4j基本使用方法

    Log4j由三个重要的组件构成:日志信息的优先级,日志信息的输出目的地,日志信息的输出格式。日志信息的优先级从高到低有ERROR、WARN、 INFO、DEBUG,分别用来指定这条日志信息的重要程度;日志信息的输出目的地指定了日志将打印到控制台还是文件中;而输出格式则控制了日志信息的显 示内容。

    2.1、定义配置文件

    其实您也可以完全不使用配置文件,而是在代码中配置Log4j环境。但是,使用配置文件将使您的应用程序更加灵活。Log4j支持两种配置文件格式,一种是XML格式的文件,一种是Java特性文件(键=值)。下面我们介绍使用Java特性文件做为配置文件的方法:
    1.配置根Logger,其语法为:

    log4j.rootLogger = [ level ] , appenderName, appenderName, …4j.rootLogger = [ level ] , appenderName, appenderName, …

    其中,level 是日志记录的优先级,分为OFF、FATAL、ERROR、WARN、INFO、DEBUG、ALL或者您定义的级别。Log4j建议只使用四个级别,优 先级从高到低分别是ERROR、WARN、INFO、DEBUG。通过在这里定义的级别,您可以控制到应用程序中相应级别的日志信息的开关。比如在这里定 义了INFO级别,则应用程序中所有DEBUG级别的日志信息将不被打印出来。 appenderName就是指B日志信息输出到哪个地方。您可以同时指定多个输出目的地。

    2.配置日志信息输出目的地Appender,其语法为:

    log4j.appender.appenderName = fully.qualified.name.of.appender.class  
    log4j.appender.appenderName.option1 = value1  
    …  
    log4j.appender.appenderName.option = valueN4j.appender.appenderName = fully.qualified.name.of.appender.class  
    log4j.appender.appenderName.option1 = value1  
    …  
    log4j.appender.appenderName.option = valueN

    其中,Log4j提供的appender有以下几种:

    org.apache.log4j.ConsoleAppender(控制台),  
    org.apache.log4j.FileAppender(文件),  
    org.apache.log4j.DailyRollingFileAppender(每天产生一个日志文件),  
    org.apache.log4j.RollingFileAppender(文件大小到达指定尺寸的时候产生一个新的文件),  
    org.apache.log4j.WriterAppender(将日志信息以流格式发送到任意指定的地方).apache.log4j.ConsoleAppender(控制台),  
    org.apache.log4j.FileAppender(文件),  
    org.apache.log4j.DailyRollingFileAppender(每天产生一个日志文件),  
    org.apache.log4j.RollingFileAppender(文件大小到达指定尺寸的时候产生一个新的文件),  
    org.apache.log4j.WriterAppender(将日志信息以流格式发送到任意指定的地方)

    3.配置日志信息的格式(布局),其语法为:

    log4j.appender.appenderName.layout = fully.qualified.name.of.layout.class  
    log4j.appender.appenderName.layout.option1 = value1  
    …  
    log4j.appender.appenderName.layout.option = valueN4j.appender.appenderName.layout = fully.qualified.name.of.layout.class  
    log4j.appender.appenderName.layout.option1 = value1  
    …  
    log4j.appender.appenderName.layout.option = valueN

    其中,Log4j提供的layout有以e几种:

    org.apache.log4j.HTMLLayout(以HTML表格形式布局),  
    org.apache.log4j.PatternLayout(可以灵活地指定布局模式),  
    org.apache.log4j.SimpleLayout(包含日志信息的级别和信息字符串),  
    org.apache.log4j.TTCCLayout(包含日志产生的时间、线程、类别等等信息).apache.log4j.HTMLLayout(以HTML表格形式布局),  
    org.apache.log4j.PatternLayout(可以灵活地指定布局模式),  
    org.apache.log4j.SimpleLayout(包含日志信息的级别和信息字符串),  
    org.apache.log4j.TTCCLayout(包含日志产生的时间、线程、类别等等信息)

    Log4J采用类似C语言中的printf函数的打印格式格式化日志信息,打印参数如下: %m 输出代码中指定的消息

    %p 输出优先级,即DEBUG,INFO,WARN,ERROR,FATAL  
    %r 输出自应用启动到输出该log信息耗费的毫秒数  
    %c 输出所属的类目,通常就是所在类的全名  
    %t 输出产生该日志事件的线程名  
    %n 输出一个回车换行符,Windows平台为“rn”,Unix平台为“n”  
    %d 输出日志时间点的日期或时间,默认格式为ISO8601,也可以在其后指定格式,比如:%d{yyy MMM dd HH:mm:ss,SSS},输出类似:20021018221028921  
    %l 输出日志事件的发生位置,包括类目名、发生的线程,以及在代码中的行数。举例:Testlog4.main(TestLog4.java:10)log信息耗费的毫秒数  
    %c 输出所属的类目,通常就是所在类的全名  
    %t 输出产生该日志事件的线程名  
    %n 输出一个回车换行符,Windows平台为“rn”,Unix平台为“n”  
    %d 输出日志时间点的日期或时间,默认格式为ISO8601,也可以在其后指定格式,比如:%d{yyy MMM dd HH:mm:ss,SSS},输出类似:20021018221028921  
    %l 输出日志事件的发生位置,包括类目名、发生的线程,以及在代码中的行数。举例:Testlog4.main(TestLog4.java:10)

    2.2、在代码中使用Log4j

    1.得到记录器

    使用Log4j,第一步就是获取日志记录器,这个记录器将负责控制日志信息。其语法为:

    public static Logger getLogger( String name)

    通过指定的名字获得记录器,如果必要的话,则为这个名字创建一个新的记录器。Name一般取本类的名字,比如:

    static Logger logger = Logger.getLogger ( ServerWithLog4j.class.getName () )

    2.读取配置文件

    当获得了日志记录器之后,第二步将配置Log4j环境,其语法为:

    BasicConfigurator.configure (): 自动快速地使用缺省Log4j环境。  
    PropertyConfigurator.configure ( String configFilename) :读取使用Java的特性文件编写的配置文件。  
    DOMConfigurator.configure ( String filename ) :读取XML形式的配置文件。.configure (): 自动快速地使用缺省Log4j环境。  
    PropertyConfigurator.configure ( String configFilename) :读取使用Java的特性文件编写的配置文件。  
    DOMConfigurator.configure ( String filename ) :读取XML形式的配置文件。

    3.插入记录信息(格式化日志信息)

    当上两个必要步骤执行完毕,您就可以轻松地使用不同优先级别的日志记录语句插入到您想记录日志的任何地方,其语法如下:

    Logger.debug ( Object message ) ;  
    Logger.info ( Object message ) ;  
    Logger.warn ( Object message ) ;  
    Logger.error ( Object message ) ;.debug ( Object message ) ;  
    Logger.info ( Object message ) ;  
    Logger.warn ( Object message ) ;  
    Logger.error ( Object message ) ;

    2.3、日志级别

    每个Logger都被了一个日志级别(log level),用来控制日志信息的输出。日志级别从高到低分为:
    A:off 最高等级,用于关闭所有日志记录。
    B:fatal 指出每个严重的错误事件将会导致应用程序的退出。
    C:error 指出虽然发生错误事件,但仍然不影响系统的继续运行。
    D:warm 表明会出现潜在的错误情形。
    E:info 一般和在粗粒度级别上,强调应用程序的运行全程。
    F:debug 一般用于细粒度级别上,对调试应用程序非常有帮助。
    G:all 最低等级,用于打开所有日志记录。

    上面这些级别是定义在org.apache.log4j.Level类中。Log4j只建议使用4个级别,优先级从高到低分别是error,warn,info和debug。通过使用日志级别,可以控制应用程序中相应级别日志信息的输出。例如,如果使用b了info级别,则应用程序中所有低于info级别的日志信息(如debug)将不会被打印出来。

    三、Web项目中使用Log4j实例

    上面代码描述了Log4j的简单应用,其实使用Log4j也就是这样简单方便。当然除了上面的配置方法,还有其它,比如做一个J2EE应用,在J2EE应用使用Log4j,必须先在启动服务时加载Log4j的配置文件进行初始化,可以在web.xml中进行。

    1、web应用的log4j使用基本上都采用:新建一个servlet,这个servlet在init函数中为log4j执行配置。一般就是读入配置文件。所以需要在web.xml中为这个servlet配置,同时设定load-on-startup为1。

    2、这个servlet配置log4j就是读出配置文件,然后调用configure函数。这里有两个问题:一、需要知道文件在哪里;二、需要正确的文件类型

    3、配置文件位置在web.xml中配置一个param即可,路径一般是相对于web的root目录

    4、文件类型一般有两种,一个是Java的property文件,另一种是xml文件

    配置文件的大致内容:log4j可以指定输出的log级别的最低等级,以及log的输出配置格式,每个log可以指定多个输出方式

    (1)创建Web工程,整个工程最后目录如下

    (2)web.xml配置如下:

    <?xml version="1.0" encoding="UTF-8"?>  
    <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
        xmlns="http://java.sun.com/xml/ns/javaee"  
        xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"  
        id="WebApp_ID" version="3.0">  
        <display-name>LogLearning</display-name>  
    
        <servlet>  
            <servlet-name>Log4JTestServlet</servlet-name>  
            <servlet-class>com.mucfc.Log4JTestServlet</servlet-class>  
        </servlet>  
    
        <!--用来启动 log4jConfigLocation的servlet -->  
        <servlet>  
            <servlet-name>Log4JInitServlet</servlet-name>  
            <servlet-class>com.mucfc.Log4JInitServlet</servlet-class>  
            <init-param>  
                <param-name>log4j-properties-location</param-name>  
                <param-value>/WEB-INF/classes/log4j.properties</param-value>  
            </init-param>  
            <load-on-startup>1</load-on-startup>  
        </servlet>  
    
        <servlet-mapping>  
            <servlet-name>Log4JTestServlet</servlet-name>  
            <url-pattern>/test</url-pattern>  
        </servlet-mapping>  
    
    </web-app>xml version="1.0" encoding="UTF-8"?>  
    <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
        xmlns="http://java.sun.com/xml/ns/javaee"  
        xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"  
        id="WebApp_ID" version="3.0">  
        <display-name>LogLearning</display-name>  
    
        <servlet>  
            <servlet-name>Log4JTestServlet</servlet-name>  
            <servlet-class>com.mucfc.Log4JTestServlet</servlet-class>  
        </servlet>  
    
        <!--用来启动 log4jConfigLocation的servlet -->  
        <servlet>  
            <servlet-name>Log4JInitServlet</servlet-name>  
            <servlet-class>com.mucfc.Log4JInitServlet</servlet-class>  
            <init-param>  
                <param-name>log4j-properties-location</param-name>  
                <param-value>/WEB-INF/classes/log4j.properties</param-value>  
            </init-param>  
            <load-on-startup>1</load-on-startup>  
        </servlet>  
    
        <servlet-mapping>  
            <servlet-name>Log4JTestServlet</servlet-name>  
            <url-pattern>/test</url-pattern>  
        </servlet-mapping>  
    
    </web-app>

    (3)配置文件log4j.properties

     ### set log levels ###  
    log4j.rootLogger = debug,stdout,D,E  
    
    log4j.appender.stdout = org.apache.log4j.ConsoleAppender  
    log4j.appender.stdout.Target = System.out  
    log4j.appender.stdout.layout = org.apache.log4j.PatternLayout  
    log4j.appender.stdout.layout.ConversionPattern = [%-5p] %d{yyyy-MM-dd HH:mm:ss,SSS} method:%l%n%m%n  
    
    log4j.appender.D = org.apache.log4j.DailyRollingFileAppender  
    log4j.appender.D.File = F://logs/log.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.E = org.apache.log4j.DailyRollingFileAppender  
    log4j.appender.E.File =F://logs/error.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### set log levels ###  
    log4j.rootLogger = debug,stdout,D,E  
    
    log4j.appender.stdout = org.apache.log4j.ConsoleAppender  
    log4j.appender.stdout.Target = System.out  
    log4j.appender.stdout.layout = org.apache.log4j.PatternLayout  
    log4j.appender.stdout.layout.ConversionPattern = [%-5p] %d{yyyy-MM-dd HH:mm:ss,SSS} method:%l%n%m%n  
    
    log4j.appender.D = org.apache.log4j.DailyRollingFileAppender  
    log4j.appender.D.File = F://logs/log.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.E = org.apache.log4j.DailyRollingFileAppender  
    log4j.appender.E.File =F://logs/error.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

    (4)web容器一来就初始化的servlet

    Log4JInitServlet.java

    package com.mucfc;  
    
    import java.io.File;  
    import java.io.IOException;  
    
    import javax.servlet.ServletConfig;  
    import javax.servlet.ServletContext;  
    import javax.servlet.ServletException;  
    import javax.servlet.annotation.WebServlet;  
    import javax.servlet.http.HttpServlet;  
    import javax.servlet.http.HttpServletRequest;  
    import javax.servlet.http.HttpServletResponse;  
    
    import org.apache.log4j.BasicConfigurator;  
    import org.apache.log4j.PropertyConfigurator;  
    
    /** 
     * Servlet implementation class Log4JInitServlet 
     */  
    @WebServlet("/Log4JInitServlet")  
    public class Log4JInitServlet extends HttpServlet {  
        private static final long serialVersionUID = 1L;  
    
        /** 
         * @see HttpServlet#HttpServlet() 
         */  
        public Log4JInitServlet() {  
            super();  
            // TODO Auto-generated constructor stub  
        }  
    
        /** 
         * @see Servlet#init(ServletConfig) 
         */  
        public void init(ServletConfig config) throws ServletException {  
            System.out.println("Log4JInitServlet 正在初始化 log4j日志设置信息");  
            String log4jLocation = config.getInitParameter("log4j-properties-location");  
    
            ServletContext sc = config.getServletContext();  
    
            if (log4jLocation == null) {  
                System.err.println("*** 没有 log4j-properties-location 初始化的文件, 所以使用 BasicConfigurator初始化");  
                BasicConfigurator.configure();  
            } else {  
                String webAppPath = sc.getRealPath("/");  
                String log4jProp = webAppPath + log4jLocation;  
                File yoMamaYesThisSaysYoMama = new File(log4jProp);  
                if (yoMamaYesThisSaysYoMama.exists()) {  
                    System.out.println("使用: " + log4jProp+"初始化日志设置信息");  
                    PropertyConfigurator.configure(log4jProp);  
                } else {  
                    System.err.println("*** " + log4jProp + " 文件没有找到, 所以使用 BasicConfigurator初始化");  
                    BasicConfigurator.configure();  
                }  
            }  
            super.init(config);  
        }  
    
        /** 
         * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response) 
         */  
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {  
            // TODO Auto-generated method stub  
        }  
    
        /** 
         * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response) 
         */  
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {  
            // TODO Auto-generated method stub  
        }  
    
    }import java.io.File;  
    import java.io.IOException;  
    
    import javax.servlet.ServletConfig;  
    import javax.servlet.ServletContext;  
    import javax.servlet.ServletException;  
    import javax.servlet.annotation.WebServlet;  
    import javax.servlet.http.HttpServlet;  
    import javax.servlet.http.HttpServletRequest;  
    import javax.servlet.http.HttpServletResponse;  
    
    import org.apache.log4j.BasicConfigurator;  
    import org.apache.log4j.PropertyConfigurator;  
    
    /** 
     * Servlet implementation class Log4JInitServlet 
     */  
    @WebServlet("/Log4JInitServlet")  
    public class Log4JInitServlet extends HttpServlet {  
        private static final long serialVersionUID = 1L;  
    
        /** 
         * @see HttpServlet#HttpServlet() 
         */  
        public Log4JInitServlet() {  
            super();  
            // TODO Auto-generated constructor stub  
        }  
    
        /** 
         * @see Servlet#init(ServletConfig) 
         */  
        public void init(ServletConfig config) throws ServletException {  
            System.out.println("Log4JInitServlet 正在初始化 log4j日志设置信息");  
            String log4jLocation = config.getInitParameter("log4j-properties-location");  
    
            ServletContext sc = config.getServletContext();  
    
            if (log4jLocation == null) {  
                System.err.println("*** 没有 log4j-properties-location 初始化的文件, 所以使用 BasicConfigurator初始化");  
                BasicConfigurator.configure();  
            } else {  
                String webAppPath = sc.getRealPath("/");  
                String log4jProp = webAppPath + log4jLocation;  
                File yoMamaYesThisSaysYoMama = new File(log4jProp);  
                if (yoMamaYesThisSaysYoMama.exists()) {  
                    System.out.println("使用: " + log4jProp+"初始化日志设置信息");  
                    PropertyConfigurator.configure(log4jProp);  
                } else {  
                    System.err.println("*** " + log4jProp + " 文件没有找到, 所以使用 BasicConfigurator初始化");  
                    BasicConfigurator.configure();  
                }  
            }  
            super.init(config);  
        }  
    
        /** 
         * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response) 
         */  
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {  
            // TODO Auto-generated method stub  
        }  
    
        /** 
         * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response) 
         */  
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {  
            // TODO Auto-generated method stub  
        }  
    
    }

    调用日志Log4JTestServlet,java

    package com.mucfc;  
    
    import java.io.IOException;  
    
    import javax.servlet.ServletConfig;  
    import javax.servlet.ServletException;  
    import javax.servlet.annotation.WebServlet;  
    import javax.servlet.http.HttpServlet;  
    import javax.servlet.http.HttpServletRequest;  
    import javax.servlet.http.HttpServletResponse;  
    
    import org.apache.log4j.Logger;  
    
    /** 
     * Servlet implementation class Log4JTestServlet 
     */  
    @WebServlet("/Log4JTestServlet")  
    public class Log4JTestServlet extends HttpServlet {  
        private static final long serialVersionUID = 1L;  
        private static Logger logger = Logger.getLogger(Log4JTestServlet.class);    
    
        /** 
         * @see HttpServlet#HttpServlet() 
         */  
        public Log4JTestServlet() {  
            super();  
            // TODO Auto-generated constructor stub  
        }  
    
        /** 
         * @see Servlet#init(ServletConfig) 
         */  
        public void init(ServletConfig config) throws ServletException {  
            // TODO Auto-generated method stub  
        }  
    
        /** 
         * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response) 
         */  
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {  
            // 记录debug级别的信息    
            logger.debug("This is debug message.");    
            // 记录info级别的信息    
            logger.info("This is info message.");    
            // 记录error级别的信息    
            logger.error("This is error message.");    
        }  
    
        /** 
         * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response) 
         */  
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {  
            doGet(request,response);  
        }  
    
    } com.mucfc;  
    
    import java.io.IOException;  
    
    import javax.servlet.ServletConfig;  
    import javax.servlet.ServletException;  
    import javax.servlet.annotation.WebServlet;  
    import javax.servlet.http.HttpServlet;  
    import javax.servlet.http.HttpServletRequest;  
    import javax.servlet.http.HttpServletResponse;  
    
    import org.apache.log4j.Logger;  
    
    /** 
     * Servlet implementation class Log4JTestServlet 
     */  
    @WebServlet("/Log4JTestServlet")  
    public class Log4JTestServlet extends HttpServlet {  
        private static final long serialVersionUID = 1L;  
        private static Logger logger = Logger.getLogger(Log4JTestServlet.class);    
    
        /** 
         * @see HttpServlet#HttpServlet() 
         */  
        public Log4JTestServlet() {  
            super();  
            // TODO Auto-generated constructor stub  
        }  
    
        /** 
         * @see Servlet#init(ServletConfig) 
         */  
        public void init(ServletConfig config) throws ServletException {  
            // TODO Auto-generated method stub  
        }  
    
        /** 
         * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response) 
         */  
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {  
            // 记录debug级别的信息    
            logger.debug("This is debug message.");    
            // 记录info级别的信息    
            logger.info("This is info message.");    
            // 记录error级别的信息    
            logger.error("This is error message.");    
        }  
    
        /** 
         * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response) 
         */  
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {  
            doGet(request,response);  
        }  
    
    }

    接下来就是运行了,来看看结果:

    输出结果:

    四、Spring中使用Log4j

    这里要实现web项目中利用Spring来使用Log4j

    (1)接上面的工程,然后再导入Spring的包

    (2)web.xml增加

    <!-- 设置根目录 -->  
       <context-param>    
           <param-name>webAppRootKey</param-name>    
           <param-value>webapp.root</param-value>    
       </context-param>    
    
       <context-param>  
        <param-name>log4jConfigLocation</param-name>  
        <param-value>/WEB-INF/classes/log4j.properties</param-value>  
    </context-param>  
    <!-- 3000表示 开一条watchdog线程每60秒扫描一下配置文件的变化;这样便于日志存放位置的改变 -->  
    <context-param>    
            <param-name>log4jRefreshInterval</param-name>    
            <param-value>3000</param-value>    
       </context-param>   
    <listener>  
        <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>  
    </listener>  
       <context-param>    
           <param-name>webAppRootKey</param-name>    
           <param-value>webapp.root</param-value>    
       </context-param>    
    
       <context-param>  
        <param-name>log4jConfigLocation</param-name>  
        <param-value>/WEB-INF/classes/log4j.properties</param-value>  
    </context-param>  
    <!-- 3000表示 开一条watchdog线程每60秒扫描一下配置文件的变化;这样便于日志存放位置的改变 -->  
    <context-param>    
            <param-name>log4jRefreshInterval</param-name>    
            <param-value>3000</param-value>    
       </context-param>   
    <listener>  
        <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>  
    </listener>

    整个内容如下:

    <?xml version="1.0" encoding="UTF-8"?>  
    <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
        xmlns="http://java.sun.com/xml/ns/javaee"  
        xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"  
        id="WebApp_ID" version="3.0">  
        <display-name>LogLearning</display-name>  
    
        <servlet>  
            <servlet-name>Log4JTestServlet</servlet-name>  
            <servlet-class>com.mucfc.Log4JTestServlet</servlet-class>  
        </servlet>  
    
        <!--用来启动 log4jConfigLocation的servlet -->  
    <!--     <servlet>  
            <servlet-name>Log4JInitServlet</servlet-name>  
            <servlet-class>com.mucfc.Log4JInitServlet</servlet-class>  
            <init-param>  
                <param-name>log4j-properties-location</param-name>  
                <param-value>/WEB-INF/classes/log4j.properties</param-value>  
            </init-param>  
            <load-on-startup>1</load-on-startup>  
        </servlet>-->  
    
        <servlet-mapping>  
            <servlet-name>Log4JTestServlet</servlet-name>  
            <url-pattern>/test</url-pattern>  
        </servlet-mapping>   
    
            <!-- Spring 容器加载 -->  
        <listener>  
            <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
        </listener>  
        <context-param>  
            <param-name>contextConfigLocation</param-name>  
            <param-value>classpath:applicationContext.xml</param-value>  
        </context-param>   
    
        <!-- 设置根目录 -->  
        <context-param>    
            <param-name>webAppRootKey</param-name>    
            <param-value>webapp.root</param-value>    
        </context-param>    
    
        <context-param>  
            <param-name>log4jConfigLocation</param-name>  
            <param-value>/WEB-INF/classes/log4j.properties</param-value>  
        </context-param>  
        <!-- 3000表示 开一条watchdog线程每60秒扫描一下配置文件的变化;这样便于日志存放位置的改变 -->  
        <context-param>    
             <param-name>log4jRefreshInterval</param-name>    
             <param-value>3000</param-value>    
        </context-param>   
        <listener>  
            <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>  
        </listener>   
    
    </web-app>xml version="1.0" encoding="UTF-8"?>  
    <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
        xmlns="http://java.sun.com/xml/ns/javaee"  
        xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"  
        id="WebApp_ID" version="3.0">  
        <display-name>LogLearning</display-name>  
    
        <servlet>  
            <servlet-name>Log4JTestServlet</servlet-name>  
            <servlet-class>com.mucfc.Log4JTestServlet</servlet-class>  
        </servlet>  
    
        <!--用来启动 log4jConfigLocation的servlet -->  
    <!--     <servlet>  
            <servlet-name>Log4JInitServlet</servlet-name>  
            <servlet-class>com.mucfc.Log4JInitServlet</servlet-class>  
            <init-param>  
                <param-name>log4j-properties-location</param-name>  
                <param-value>/WEB-INF/classes/log4j.properties</param-value>  
            </init-param>  
            <load-on-startup>1</load-on-startup>  
        </servlet>-->  
    
        <servlet-mapping>  
            <servlet-name>Log4JTestServlet</servlet-name>  
            <url-pattern>/test</url-pattern>  
        </servlet-mapping>   
    
            <!-- Spring 容器加载 -->  
        <listener>  
            <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
        </listener>  
        <context-param>  
            <param-name>contextConfigLocation</param-name>  
            <param-value>classpath:applicationContext.xml</param-value>  
        </context-param>   
    
        <!-- 设置根目录 -->  
        <context-param>    
            <param-name>webAppRootKey</param-name>    
            <param-value>webapp.root</param-value>    
        </context-param>    
    
        <context-param>  
            <param-name>log4jConfigLocation</param-name>  
            <param-value>/WEB-INF/classes/log4j.properties</param-value>  
        </context-param>  
        <!-- 3000表示 开一条watchdog线程每60秒扫描一下配置文件的变化;这样便于日志存放位置的改变 -->  
        <context-param>    
             <param-name>log4jRefreshInterval</param-name>    
             <param-value>3000</param-value>    
        </context-param>   
        <listener>  
            <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>  
        </listener>   
    
    </web-app>

    这里Log4JInitServlet.java就相当于没用到了。

    (2)applicationContext.xml

    没有内容:

    <?xml version="1.0" encoding="UTF-8"?>  
    <beans xmlns="http://www.springframework.org/schema/beans"  
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"  
        xmlns:aop="http://www.springframework.org/schema/aop"  
        xsi:schemaLocation="    
    
    http://www.springframework.org/schema/beans
    
    
    http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
    
    
    http://www.springframework.org/schema/aop
    
    
    http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
    
    
    http://www.springframework.org/schema/context
    
               http://www.springframework.org/schema/context/spring-context-3.2.xsd">  
    </beans>xml version="1.0" encoding="UTF-8"?>  
    <beans xmlns="http://www.springframework.org/schema/beans"  
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"  
        xmlns:aop="http://www.springframework.org/schema/aop"  
        xsi:schemaLocation="    
    
    http://www.springframework.org/schema/beans
    
    
    http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
    
    
    http://www.springframework.org/schema/aop
    
    
    http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
    
    
    http://www.springframework.org/schema/context
    
               http://www.springframework.org/schema/context/spring-context-3.2.xsd">  
    </beans>

    (3)这样日志就跟随Spring窗口启动而启动了

    程序一运行,就会自动把日志打印

    log.log

    error.log为空,因为它只打印error级别以上的信息

    浏览器输入http://localhost:8080/LogLearning2/test

    然后打开文件

     

     

    展开全文
  • log4j2 实际使用详解

    万次阅读 多人点赞 2017-05-12 19:31:07
    slf4j + log4j2 实际使用 二、日志框架比较(slf4j、log4j、logback、log4j2 ) 日志接口(slf4j) slf4j是对所有日志框架制定的一种规范、标准、接口,并不是一个框架的具体的实现,因为接口并不能独立使

    分享一个朋友的人工智能教程(请以“右键”->"在新标签页中打开连接”的方式访问)。比较通俗易懂,风趣幽默,感兴趣的朋友可以去看看。

    一、目录简介

    • 基础部分
      • 日志框架简单比较(slf4j、log4j、logback、log4j2 )
      • log4j2基础示例
      • log4j2配置文件
    • 实战部分
      • slf4j + log4j2 实际使用

    二、日志框架比较(slf4j、log4j、logback、log4j2 )

    • 日志接口(slf4j)
      slf4j是对所有日志框架制定的一种规范、标准、接口,并不是一个框架的具体的实现,因为接口并不能独立使用,需要和具体的日志框架实现配合使用(如log4j、logback)

    • 日志实现(log4j、logback、log4j2)

      • log4j是apache实现的一个开源日志组件
      • logback同样是由log4j的作者设计完成的,拥有更好的特性,用来取代log4j的一个日志框架,是slf4j的原生实现
      • Log4j2是log4j 1.x和logback的改进版,据说采用了一些新技术(无锁异步、等等),使得日志的吞吐量、性能比log4j 1.x提高10倍,并解决了一些死锁的bug,而且配置更加简单灵活,官网地址: http://logging.apache.org/log4j/2.x/manual/configuration.html
    • 为什么需要日志接口,直接使用具体的实现不就行了吗?

      接口用于定制规范,可以有多个实现,使用时是面向接口的(导入的包都是slf4j的包而不是具体某个日志框架中的包),即直接和接口交互,不直接使用实现,所以可以任意的更换实现而不用更改代码中的日志相关代码。

      比如:slf4j定义了一套日志接口,项目中使用的日志框架是logback,开发中调用的所有接口都是slf4j的,不直接使用logback,调用是 自己的工程调用slf4j的接口,slf4j的接口去调用logback的实现,可以看到整个过程应用程序并没有直接使用logback,当项目需要更换更加优秀的日志框架时(如log4j2)只需要引入Log4j2的jar和Log4j2对应的配置文件即可,完全不用更改Java代码中的日志相关的代码logger.info(“xxx”),也不用修改日志相关的类的导入的包(import org.slf4j.Logger;
      import org.slf4j.LoggerFactory;)

      使用日志接口便于更换为其他日志框架。

      log4j、logback、log4j2都是一种日志具体实现框架,所以既可以单独使用也可以结合slf4j一起搭配使用)


    三、log4j2基础示例

    1. 创建maven web 项目, 结构如下
      这里写图片描述

    2. 配置pom.xml,引入log4j2必要的依赖(log4j-api、log4j-core)

    <properties>
      	<junit.version>3.8.1</junit.version>
      	<log4j.version>2.5</log4j.version>
    </properties>
    
    <!-- 使用aliyun镜像 -->
    <repositories>
      <repository>
          <id>aliyun</id>
          <name>aliyun</name>
          <url>http://maven.aliyun.com/nexus/content/groups/public</url>
      </repository>
    </repositories>
    
    <dependencies>
    	<dependency>  
            <groupId>org.apache.logging.log4j</groupId>  
            <artifactId>log4j-api</artifactId>  
            <version>${log4j.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>org.apache.logging.log4j</groupId>  
            <artifactId>log4j-core</artifactId>  
            <version>${log4j.version}</version>  
        </dependency>  
    </dependencies>
    

    3、 使用Main方法简单测试
    这里写图片描述

    测试说明:

    1. 工程中只引入的jar并没有引入任何配置文件,在测试的时候可以看到有ERROR输出:“ERROR StatusLogger No log4j2 configuration file found. Using default configuration: logging only errors to the console.”

    2. 输出logger时可以看到只有error和fatal级别的被输出来,是因为没有配置文件就使用默认的,默认级别是error,所以只有error和fatal输出来

    3. 引入的包是log4j本身的包(import org.apache.logging.log4j.LogManager)


    四:log2j 配置文件详解

    配置文件的格式和位置

    配置文件的格式:log2j配置文件可以是xml格式的,也可以是json格式的,
    配置文件的位置:log4j2默认会在classpath目录下寻找log4j2.xml、log4j.json、log4j.jsn等名称的文件,如果都没有找到,则会按默认配置输出,也就是输出到控制台,也可以对配置文件自定义位置(需要在web.xml中配置),一般放置在src/main/resources根目录下即可
    这里写图片描述

    纯Java方式:

    public static void main(String[] args) throws IOException {  
        File file = new File("D:/log4j2.xml");  
        BufferedInputStream in = new BufferedInputStream(new FileInputStream(file));  
        final ConfigurationSource source = new ConfigurationSource(in);  
        Configurator.initialize(null, source);  
          
        Logger logger = LogManager.getLogger("myLogger");  
    } 
    

    Web工程方式:

    <context-param>  
        <param-name>log4jConfiguration</param-name>  
        <param-value>/WEB-INF/conf/log4j2.xml</param-value>  
    </context-param>  
      
    <listener>  
        <listener-class>org.apache.logging.log4j.web.Log4jServletContextListener</listener-class>  
    </listener> 
    

    示例一:简单配置(使用根控制器输出到控制台上)

    log4j2.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="WARN">  
        <Appenders>  
            <Console name="Console" target="SYSTEM_OUT">  
                <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n" />  
            </Console>  
        </Appenders>  
        
        <Loggers>  
            <Root level="info">  
                <AppenderRef ref="Console" />  
            </Root>  
        </Loggers>  
    </Configuration>
    

    示例结果:

    这里写图片描述

    结果解释:
    日志管理器获取的是根日志器LogManager.getLogger(LogManager.ROOT_LOGGER_NAME);
    对应的log4j2.xml中的Loggers节点下的Root,因为该根日志器的level=“info”,所以输出的info级别以上的日志


    示例二:File Logger

    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="WARN">  
        <Appenders>  
            <Console name="Console" target="SYSTEM_OUT">  
                <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n" />  
            </Console>
            
            <File name="FileAppender" fileName="D:/logs/app.log">  
                <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n" />  
            </File>  
            
            <!-- 发现Async 好像PatternLayout的输出格式配置的和输出的格式不一样,不用异步就完全一样  -->
            <Async name="AsyncAppender">
    	    <AppenderRef ref="FileAppender"/>
        	</Async>
        </Appenders>  
        
        <Loggers>  
        	<Logger name="AsyncFileLogger" level="trace" additivity="true">  
    	        <AppenderRef ref="AsyncAppender" />  
    		</Logger>
            <Root level="info">  
                <AppenderRef ref="Console" />  
            </Root>  
        </Loggers>  
    </Configuration>
    
    import org.apache.logging.log4j.LogManager;
    import org.apache.logging.log4j.Logger;
    
    public class Log4j2Test {
    
    	public static void main(String[] args) {
    		Logger logger = LogManager.getLogger("AsyncFileLogger"); // Logger的名称
    		
    		logger.trace("trace level");
    		logger.debug("debug level");
    		logger.info("info level");
    		logger.warn("warn level");
    		logger.error("error level");
    		logger.fatal("fatal level");
    	}
    }
    
    

    AsyncFileLogger的additivity的值如果为false的话,就不会在控制台上输出或者为该Logger再增加一个输出源Consloe

    <Logger name="AsyncFileLogger" level="trace" additivity="false">  
    	<AppenderRef ref="AsyncAppender" />  
    	<AppenderRef ref="Console" />  
    </Logger>
    

    示例三: RollingRandomAccessFile

    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="WARN"> 
    	<properties>
    		<property name="LOG_HOME">D:/logs</property>
    		<property name="FILE_NAME">mylog</property>
    	</properties>
    	
    	 
        <Appenders>  
            <Console name="Console" target="SYSTEM_OUT">  
                <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n" />  
            </Console>
            
            <RollingRandomAccessFile name="RollingRandomAccessFile" fileName="${LOG_HOME}/${FILE_NAME}.log" filePattern="${LOG_HOME}/$${date:yyyy-MM}/${FILE_NAME}-%d{yyyy-MM-dd HH-mm}-%i.log">
            	<PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
            	<Policies>
            		<TimeBasedTriggeringPolicy interval="1"/>
            		<SizeBasedTriggeringPolicy size="10 MB"/>
            	</Policies>
            	<DefaultRolloverStrategy max="20"/>
            </RollingRandomAccessFile>
            
            <Async name="AsyncAppender">
            	<AppenderRef ref="RollingRandomAccessFile"/>
        	</Async>
        </Appenders>  
        
        <Loggers>  
        	<Logger name="RollingRandomAccessFileLogger" level="info" additivity="false">  
    	        <AppenderRef ref="AsyncAppender" />  
    	        <AppenderRef ref="Console" />  
    	    </Logger>
        </Loggers>  
    </Configuration>
    
    import org.apache.logging.log4j.LogManager;
    import org.apache.logging.log4j.Logger;
    
    public class Log4j2Test {
    
    	public static void main(String[] args) {
    		
    	    Logger logger = LogManager.getLogger("RollingRandomAccessFileLogger");  
    	    for(int i = 0; i < 50000; i++) {  
    	        logger.trace("trace level");  
    	        logger.debug("debug level");  
    	        logger.info("info level");  
    	        logger.warn("warn level");  
    	        logger.error("error level");  
    	        logger.fatal("fatal level");  
    	    }  
    	    
    	    try {  
    	        Thread.sleep(1000 * 61);  
    	    } catch (InterruptedException e) {}  
    	    
    	    logger.trace("trace level");  
    	    logger.debug("debug level");  
    	    logger.info("info level");  
    	    logger.warn("warn level");  
    	    logger.error("error level");  
    	    logger.fatal("fatal level"); 
    	}
    }
    
    

    这里写图片描述

    RollingRandomAccessFile 会根据命名规则当文件满足一定大小时就会另起一个新的文件


    五:log4j2配置文件详解

    log4j2.xml文件的配置大致如下:

    • Configuration
      • properties
      • Appenders
        • Console
          • PatternLayout
        • File
        • RollingRandomAccessFile
        • Async
      • Loggers
        • Logger
        • Root
          • AppenderRef

    • Configuration:为根节点,有status和monitorInterval等多个属性

      • status的值有 “trace”, “debug”, “info”, “warn”, “error” and “fatal”,用于控制log4j2日志框架本身的日志级别,如果将stratus设置为较低的级别就会看到很多关于log4j2本身的日志,如加载log4j2配置文件的路径等信息
      • monitorInterval,含义是每隔多少秒重新读取配置文件,可以不重启应用的情况下修改配置
    • Appenders:输出源,用于定义日志输出的地方
      log4j2支持的输出源有很多,有控制台Console、文件File、RollingRandomAccessFile、MongoDB、Flume 等

      • Console:控制台输出源是将日志打印到控制台上,开发的时候一般都会配置,以便调试

      • File:文件输出源,用于将日志写入到指定的文件,需要配置输入到哪个位置(例如:D:/logs/mylog.log)

      • RollingRandomAccessFile: 该输出源也是写入到文件,不同的是比File更加强大,可以指定当文件达到一定大小(如20MB)时,另起一个文件继续写入日志,另起一个文件就涉及到新文件的名字命名规则,因此需要配置文件命名规则
        这种方式更加实用,因为你不可能一直往一个文件中写,如果一直写,文件过大,打开就会卡死,也不便于查找日志。

        • fileName 指定当前日志文件的位置和文件名称
        • filePattern 指定当发生Rolling时,文件的转移和重命名规则
        • SizeBasedTriggeringPolicy 指定当文件体积大于size指定的值时,触发Rolling
        • DefaultRolloverStrategy 指定最多保存的文件个数
        • TimeBasedTriggeringPolicy 这个配置需要和filePattern结合使用,注意filePattern中配置的文件重命名规则是${FILE_NAME}-%d{yyyy-MM-dd HH-mm}-%i,最小的时间粒度是mm,即分钟
        • TimeBasedTriggeringPolicy指定的size是1,结合起来就是每1分钟生成一个新文件。如果改成%d{yyyy-MM-dd HH},最小粒度为小时,则每一个小时生成一个文件
      • NoSql:MongoDb, 输出到MongDb数据库中

      • Flume:输出到Apache Flume(Flume是Cloudera提供的一个高可用的,高可靠的,分布式的海量日志采集、聚合和传输的系统,Flume支持在日志系统中定制各类数据发送方,用于收集数据;同时,Flume提供对数据进行简单处理,并写到各种数据接受方(可定制)的能力。)

      • Async:异步,需要通过AppenderRef来指定要对哪种输出源进行异步(一般用于配置RollingRandomAccessFile)

      PatternLayout:控制台或文件输出源(Console、File、RollingRandomAccessFile)都必须包含一个PatternLayout节点,用于指定输出文件的格式(如 日志输出的时间 文件 方法 行数 等格式),例如 pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"

        %d{HH:mm:ss.SSS} 表示输出到毫秒的时间
        %t 输出当前线程名称
        %-5level 输出日志级别,-5表示左对齐并且固定输出5个字符,如果不足在右边补0
        %logger 输出logger名称,因为Root Logger没有名称,所以没有输出
        %msg 日志文本
        %n 换行
      
        其他常用的占位符有:
        %F 输出所在的类文件名,如Log4j2Test.java
        %L 输出行号
        %M 输出所在方法名
        %l 输出语句所在的行数, 包括类名、方法名、文件名、行数
      
    • Loggers:日志器
      日志器分根日志器Root和自定义日志器,当根据日志名字获取不到指定的日志器时就使用Root作为默认的日志器,自定义时需要指定每个Logger的名称name(对于命名可以以包名作为日志的名字,不同的包配置不同的级别等),日志级别level,相加性additivity(是否继承下面配置的日志器), 对于一般的日志器(如Console、File、RollingRandomAccessFile)一般需要配置一个或多个输出源AppenderRef;

      每个logger可以指定一个level(TRACE, DEBUG, INFO, WARN, ERROR, ALL or OFF),不指定时level默认为ERROR

      additivity指定是否同时输出log到父类的appender,缺省为true。

    <Logger name="rollingRandomAccessFileLogger" level="trace" additivity="true">  
    	<AppenderRef ref="RollingRandomAccessFile" />  
    </Logger>
    
    • properties: 属性
      使用来定义常量,以便在其他配置的时候引用,该配置是可选的,例如定义日志的存放位置
      D:/logs

    【实战部分】

    1. 引入slf4j和log4j需要的依赖
    <properties>
      	<junit.version>3.8.1</junit.version>
      	<log4j.version>2.5</log4j.version>
      </properties>
      
      <dependencies>
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>${junit.version}</version>
          <scope>test</scope>
        </dependency>
        
        <!-- slf4j + log4j2 begin -->
        <dependency>
    	    <groupId>org.slf4j</groupId>
    	    <artifactId>slf4j-api</artifactId>
    	    <version>1.7.10</version>
    	</dependency>
    	
    	<dependency> <!-- 桥接:告诉Slf4j使用Log4j2 -->
    	    <groupId>org.apache.logging.log4j</groupId>
    	    <artifactId>log4j-slf4j-impl</artifactId>
    	    <version>2.2</version>
    	</dependency>
    	<dependency> <!-- 桥接:告诉commons logging使用Log4j2 -->
    	    <groupId>org.apache.logging.log4j</groupId>
    	    <artifactId>log4j-jcl</artifactId>
    	    <version>2.2</version>
    	</dependency>
        
        <dependency>  
            <groupId>org.apache.logging.log4j</groupId>  
            <artifactId>log4j-api</artifactId>  
            <version>${log4j.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>org.apache.logging.log4j</groupId>  
            <artifactId>log4j-core</artifactId>  
            <version>${log4j.version}</version>  
        </dependency>  
        <!-- log4j end-->
      </dependencies>
      
      <!-- 使用aliyun镜像 -->
      <repositories>
        <repository>
            <id>aliyun</id>
            <name>aliyun</name>
            <url>http://maven.aliyun.com/nexus/content/groups/public</url>
        </repository>
      </repositories>
    

    2、配置log2.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="WARN"> 
    	<properties>
    		<property name="LOG_HOME">D:/logs</property>
    		<property name="FILE_NAME">mylog</property>
    		<property name="log.sql.level">info</property>
    	</properties>
    	
    	 
        <Appenders>  
            <Console name="Console" target="SYSTEM_OUT">  
                <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %l - %msg%n" />  
            </Console>
            
            <RollingRandomAccessFile name="RollingRandomAccessFile" fileName="${LOG_HOME}/${FILE_NAME}.log" filePattern="${LOG_HOME}/$${date:yyyy-MM}/${FILE_NAME}-%d{yyyy-MM-dd HH-mm}-%i.log">
            	<PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %l - %msg%n"/>
            	<Policies>
            		<TimeBasedTriggeringPolicy interval="1"/>
            		<SizeBasedTriggeringPolicy size="10 MB"/>
            	</Policies>
            	<DefaultRolloverStrategy max="20"/>
            </RollingRandomAccessFile>
        </Appenders>  
        
        <Loggers>  
        	<Root level="info">  
        		<AppenderRef ref="Console" />  
    	        <AppenderRef ref="RollingRandomAccessFile" />  
    	    </Root>
    	    
    	    <Logger name="com.mengdee.dao" level="${log.sql.level}" additivity="false">
                 <AppenderRef ref="Console" />
            </Logger>
        </Loggers>  
    </Configuration>
    

    3、 Java

    package com.mengdee.manage;
    
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    public class Log4j2Test {
    
    	// Logger和LoggerFactory导入的是org.slf4j包
    	private final static Logger logger = LoggerFactory.getLogger(Log4j2Test.class);
    	public static void main(String[] args) {
    		long beginTime = System.currentTimeMillis();
    		
    		for(int i = 0; i < 100000; i++) {  
    			logger.trace("trace level");  
    		    logger.debug("debug level");  
    		    logger.info("info level");  
    		    logger.warn("warn level");  
    		    logger.error("error level");
    		}
    		
    		try {  
    	        Thread.sleep(1000 * 61);  
    	    } catch (InterruptedException e) {}  
    	      
    	    
    	    logger.info("请求处理结束,耗时:{}毫秒", (System.currentTimeMillis() - beginTime));    //第一种用法
    	    logger.info("请求处理结束,耗时:" + (System.currentTimeMillis() - beginTime)  + "毫秒");    //第二种用法
    
    	}
    }
    

    4、运行结果
    这里写图片描述

    这里写图片描述

    这里写图片描述

    持续完善中。。。

    分享一个朋友的人工智能教程(请以“右键”->"在新标签页中打开连接”的方式访问)。比较通俗易懂,风趣幽默,感兴趣的朋友可以去看看。

    我的微信公众号

    这里写图片描述

    展开全文
  • log4j 配置日志输出(log4j.properties)

    万次阅读 多人点赞 2018-05-27 11:19:27
    2018年5月27日一、入门log4j实例1.1 下载解压log4j.jar

    2018年5月27日

    欢迎扫二维码关注公众号,获取技干术货。

    一、入门log4j实例

    1.1 下载解压log4j.jar(地址:http://mirrors.hust.edu.cn/apache/logging/log4j/2.11.0/

    1.2 新建工程,导入jar包

    1.3 Log4jTest.java:

    package test6;
    
    import org.apache.log4j.Logger;
    /**
     * @author mmb
     * @function test log4j
     * */
    public class Log4jTest {
    	
    	private static Logger logger = Logger.getLogger(Log4jTest.class);  
    	
    	public static void main(String [] args){
    		
    		//BasicConfigurator.configure(); //自动快速地使用缺省Log4j环境。
    		
    		logger.info("aaaa");
    		
    		logger.debug("bbbb");
    		
    		logger.error("cccc");
    		
    	}
    }
    

    1.4 log4j.properties

     ### 设置###
    log4j.rootLogger = debug,stdout,D,E
    
    ### 输出信息到控制抬 ###
    log4j.appender.stdout = org.apache.log4j.ConsoleAppender
    log4j.appender.stdout.Target = System.out
    log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
    log4j.appender.stdout.layout.ConversionPattern = [%-5p] %d{yyyy-MM-dd HH:mm:ss,SSS} method:%l%n%m%n
    
    ### 输出DEBUG 级别以上的日志到=E://logs/error.log ###
    log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
    log4j.appender.D.File = E://logs/log.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
    
    ### 输出ERROR 级别以上的日志到=E://logs/error.log ###
    log4j.appender.E = org.apache.log4j.DailyRollingFileAppender
    log4j.appender.E.File =E://logs/error.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

    1.5 输出

     

    二、log4j 详细配置

    参考blog:https://blog.csdn.net/azheng270/article/details/2173430/

     

    展开全文
  • Log4j2-Log4j 2介绍及使用

    万次阅读 2017-07-15 11:08:39
    Log4j 2 官网https://logging.apache.org/log4j/2.x/Log4j 2简介Log4j的1.x版本已经被广泛使用于很多应用程序中。然而,它这些年的发展已经放缓。它变得越来越难以维护,因为它需要严格遵循很老的Java版本,并在2015...

    Log4j 2 官网

    https://logging.apache.org/log4j/2.x/


    Log4j 2简介

    Log4j的1.x版本已经被广泛使用于很多应用程序中。然而,它这些年的发展已经放缓。它变得越来越难以维护,因为它需要严格遵循很老的Java版本,并在2015年8月寿终正寝。它的替代品,SLF4J和Logback对框架做了很多必要的改进。

    那么为什么还要费心去做Log4j 2呢?几个原因如下:

    • Log4j 2被设计为可以作为审计框架使用。Log4j 1.x和Logback都会在重新配置的时候失去事件,而Log4j2不会。在Logback中,Appender当中的异常对应用从来都是不可见的。但Log4j2的Appender可以设置为允许将异常渗透给应用程序。
    • Log4j 2包含基于LMAX Disruptor库的下一代异步日志器。在多线程情况下,异步日志器具有比Log4j 1.x和Logback高出10倍的吞吐性能以及更低的延迟。
    • Log4j 2在稳定记录状态下,对单机应用是无垃圾的,对Web应用是低垃圾的。这不仅降低了垃圾回收器的压力,还可以提供更好的响应性能。
    • Log4j 2使用插件系统使得它非常容易通过新的Appender、Filter、Layout、Lookup和Pattern Converter来扩展框架,且不需要对Log4j做任何修改。
    • 由于插件系统的配置更简单了,配置项不需要声明类名称。
    • 支持自定义日志级别。自定义日志级别可以在代码或配置中定义。
    • 支持Lambda表达式。运行在Java 8上的客户端代码可以使用Lambda表达式来实现仅在对应的日志级别启用时延迟构造日志消息。由于不需要明确地层层把关,这带来了更简洁的代码。
    • 支持Message对象。Message允许支持感兴趣或复杂的结构体在日志系统中传输,且可以被高效地操作。用户可以自由地创建他们自己的Message类型,并编写自定义的Layout、Filter和Lookup来操作它们。
    • Log4j 1.x支持Appender上的Filter。Logback引入了TurboFilter来在事件被Logger处理之前对它们进行过滤。Log4j 2支持的Filter可以设置为在被Logger接管之前即处理事件,如同它在Logger或Appender中被处理。
    • 很多Logback的Appender不接受一个Layout,且只能发送固定格式的数据。而大多数Log4j 2的Appender接受Layout,允许数据以任意一种所需的格式传输。
    • Log4j 1.x和Logback中的Layout返回一个String。这导致了在Logback Encoder中讨论的问题。Log4j 2用更简单的方法,Layout总是返回一个字节数组。优点是这意味着它们可以用于任何Appender,而不仅仅是写入到OutputStream中的那些。
    • Syslog Appender既支持TCP也支持UDP,同样支持BSD系统日志以及RFC 5424格式。
    • Log4j 2利用了Java 5的并发优势,并在尽可能最低的程度上进行锁定。Log4j 1.x中已知存在死锁问题。其中很多已经在Logback中修复,但很多Logback的class文件仍然需要在更高的编译级别中同步。
    • 这是一个被所有ASF项目集体支持使用的Apache软件基金会项目。如果你想要贡献或修改,只要参照贡献中的方法。

    架构

    这里写图片描述

    应用程序要使用Log4j 2的API,需要从LogManager中获取一个有明确名称的Logger。

    LogManager将会定位到一个合适的LoggerContext并且从中获取Logger。

    如果Logger必须被创建,那么它会和包含这些信息的LogConfig相关联:
    a)与Logger相同的名称;
    b)父包的名称;
    c)根LoggerConfig。LoggerConfig对象根据配置中的Logger声明而创建。

    LoggerConfig与实际处理LogEvent事件的Appender关联。


    日志级别

    这里写图片描述

    在表格中,垂直列为LogEvent的级别,水平列为从合适的LoggerConfig中分配到的级别。二者的交点处标识了LogEvent是否会被通过并传递给下一步处理,是(YES)或否(NO)。


    Filter

    Log4j提供Filter并可应用于:控制被传递到任何LoggerConfig之前、控制被传递到达一个LoggerConfig但在调用任何Appender之前、控制被传递到一个LoggerConfig单在调用一个指定的Appender和每一个Appender之前。

    与防火墙过滤的方式类似,每一个Filter都将返回三个结果之一:Accept(接受)、Deny(拒绝)或Neutral(中立)。

    • 响应Accept意味着其他的Filter都不应该再被调用,而事件应该被处理。
    • 响应Deny意味着事件应该被立即忽略,且将控制讲给调用处。
    • 响应Neutral代表事件应该被传递给其他的Filter。如果没有其他Filter,则事件将被处理。

    尽管一个事件可能被Filter接受,但事件仍然可能不被记录。这种情况会发生于事件被LoggerConfig之前的Filter接受,但被LoggerConfig的Filter拒绝或者被所有的Appender拒绝。


    Appender 将日志请求打印到多个目标

    http://logging.apache.org/log4j/2.x/manual/appenders.html

    Log4j允许将日志请求打印到多个目标。用Log4j的说法,一个输出的目标位置被称为Appender。目前,Appender存在几种:控制台、文件、远程Socket服务器、Apache Flume、JMS、远程UNIX系统日志后台以及好几种数据库API。

    一个Logger上可以装配多个Appender。


    Layout 自定义输出格式

    用户不仅希望自定义输出的目的位置,也希望自定义输出格式。

    这可以通过将一个Layout与Appender关联来实现。Layout负责根据用户的希望来格式化LogEvent,然而是Appender负责将格式化的内容输出到目的位置。

    PatternLayout,Log4j中的一部分,让用户根据C语言printf函数的方式来具体化输出格式。

    例如,使用转换模式“%r [%t] %-5p %c - %m%n”的PatternLayout将会输出类似于下面的内容:

    176 [main] INFO  org.foo.Bar - Located nearest gas station.

    第一个字段是程序启动以来锁经过的毫秒时间。
    第二个字段是发出日志请求的线程。
    第三个字段是日志声明的级别。
    第四个字段是与日志请求相关联的Logger名称。

    在“-”之后的文本是日志的消息内容。

    Log4j带有很多不同的Layout以支持诸如JSON、XML、HTML和Syslog


    转到Log4j 2 API

    大多数情况下,从Log4j 1.x API转换到Log4j 2相当简单。很多日志声明都不需要修改,但以下这些变更是必要的

    这里写图片描述

    控制台Appender的简单配置

    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration>
      <Appenders>
        <Console name="STDOUT" target="SYSTEM_OUT">
          <PatternLayout pattern="%d %-5p [%t] %C{2} (%F:%L) - %m%n"/>
        </Console>
      </Appenders>
      <Loggers>
        <Logger name="org.apache.log4j.xml" level="info"/>
        <Root level="debug">
          <AppenderRef ref="STDOUT"/>
        </Root>
      </Loggers>
    </Configuration>

    文件Appender的简单配置

    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration>
      <Appenders>
        <File name="A1" fileName="A1.log" append="false">
          <PatternLayout pattern="%t %-5p %c{2} - %m%n"/>
        </File>
        <Console name="STDOUT" target="SYSTEM_OUT">
          <PatternLayout pattern="%d %-5p [%t] %C{2} (%F:%L) - %m%n"/>
        </Console>
      </Appenders>
      <Loggers>
        <Logger name="org.apache.log4j.xml" level="debug">
          <AppenderRef ref="A1"/>
        </Logger>
        <Root level="debug">
          <AppenderRef ref="STDOUT"/>
        </Root>
      </Loggers>
    </Configuration>

    SocketAppender

    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration>
      <Appenders>
        <Socket name="A1" host="localHost" port="5000">
          <SerializedLayout/>
        </Socket>
        <Console name="STDOUT" target="SYSTEM_OUT">
          <PatternLayout pattern="%d %-5p [%t] %C{2} (%F:%L) - %m%n"/>
        </Console>
      </Appenders>
      <Loggers>
        <Logger name="org.apache.log4j.xml" level="debug">
          <AppenderRef ref="A1"/>
        </Logger>
        <Root level="debug">
          <AppenderRef ref="STDOUT"/>
        </Root>
      </Loggers>
    </Configuration>

    AsyncAppender

    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="debug">
      <Appenders>
        <File name="TEMP" fileName="temp">
          <PatternLayout pattern="%d %-5p [%t] %C{2} (%F:%L) - %m%n"/>
        </File>
        <Async name="ASYNC">
          <AppenderRef ref="TEMP"/>
        </Async>
      </Appenders>
      <Loggers>
        <Root level="debug">
          <AppenderRef ref="ASYNC"/>
        </Root>
      </Loggers>
    </Configuration>

    控制台和文件的AsyncAppender

    注意AsyncAppender应该在它引用Appender的后面被配置,这会让它正确地关闭。

    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="debug">
      <Appenders>
        <Console name="CONSOLE" target="SYSTEM_OUT">
          <PatternLayout pattern="%d %-5p [%t] %C{2} (%F:%L) - %m%n"/>
        </Console>
        <File name="TEMP" fileName="temp">
          <PatternLayout pattern="%d %-5p [%t] %C{2} (%F:%L) - %m%n"/>
        </File>
        <Async name="ASYNC">
          <AppenderRef ref="TEMP"/>
          <AppenderRef ref="CONSOLE"/>
        </Async>
      </Appenders>
      <Loggers>
        <Root level="debug">
          <AppenderRef ref="ASYNC"/>
        </Root>
      </Loggers>
    </Configuration>

    配置Log4j 2

    Log4j 2的配置可以通过以下4种方式之一完成:

    1. 通过以XML、JSON、YAML或属性格式编写的配置文件。
    2. 以编程方式,通过创建ConfigurationFactory和配置实现。
    3. 通过调用配置接口中公开的API,以编程方式将组件添加到默认配置。
    4. 以编程方式,通过调用内部Logger类上的方法

    举例,具体请根据实际需要修改

    <?xml version="1.0" encoding="UTF-8"?>
    <!-- log4j2使用说明:
    使用方式如下:
    private static final Logger logger = LogManager.getLogger(实际类名.class.getName());
    
    2、日志说明:
    (1)请根据实际情况配置各项参数
    (2)需要注意日志文件备份数和日志文件大小,注意预留目录空间
    (3)实际部署的时候backupFilePatch变量需要修改成linux目录
     -->
    <configuration status="debug">
        <Properties>
            <Property name="fileName">loginModule.log</Property>
            <Property name="backupFilePatch">D:/workspace/workspace-jee/HelloSpring/hello-spring4/log/</Property>
          </Properties>
        <!--先定义所有的appender-->
        <appenders>
            <!--这个输出控制台的配置-->
            <Console name="Console" target="SYSTEM_OUT">
                 <!--控制台只输出level及以上级别的信息(onMatch),其他的直接拒绝(onMismatch)-->
                <ThresholdFilter level="trace" onMatch="ACCEPT" onMismatch="DENY" />
                <!-- 输出日志的格式-->
                <PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %class{36} %L %M - %msg%xEx%n" />
            </Console>
    
            <!--这个会打印出所有的信息,每次大小超过size,则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩,作为存档-->
            <RollingFile name="RollingFile" fileName="${backupFilePatch}${fileName}"
                filePattern="${backupFilePatch}$${date:yyyy-MM}/app-%d{yyyyMMddHHmmssSSS}.log.gz">
                <PatternLayout
                    pattern="%d{yyyy.MM.dd 'at' HH:mm:ss.SSS z} %-5level %class{36} %L %M - %msg%xEx%n" />
    
                <!-- 日志文件大小 -->
                <SizeBasedTriggeringPolicy size="20MB" />
                <!-- 最多保留文件数 -->
                <DefaultRolloverStrategy max="20"/>
            </RollingFile>
        </appenders>
    
        <!--然后定义logger,只有定义了logger并引入的appender,appender才会生效-->
        <loggers>
            <!--建立一个默认的root的logger-->
            <Logger name="org.apache.log4j.xml" level="trace"
                additivity="true">
                <AppenderRef ref="RollingFile" />
            </Logger>
            <Root level="error">
                <AppenderRef ref="Console" />
            </Root>
        </loggers>
    </configuration>

    使用Log4j 2

    maven 的引用

    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-api</artifactId>
        <version>${log4j2.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-core</artifactId>
        <version>${log4j2.version}</version>
    </dependency>
    <!-- web容器中需要添加log4j-web -->
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-web</artifactId>
        <version>${log4j2.version}</version>
    </dependency>
    
    
    <properties>
    
            <log4j2.version>2.8.2</log4j2.version>
    </properties>
    import com.foo.Bar;
    
    // 导入Log4j的类
    import org.apache.logging.log4j.Logger;
    import org.apache.logging.log4j.LogManager;
    
    public class MyApp {
    
        // 定义一个静态的日志器变量,引用名为MyApp的实例
        private static final Logger logger = LogManager.getLogger(MyApp.class);
    
        public static void main(final String... args) {
    
            // 设置一个简单的配置,日志显示在控制台中
    
            logger.trace("Entering application.");
            Bar bar = new Bar();
            if (!bar.doIt()) {
                logger.error("Didn't do it.");
            }
            logger.trace("Exiting application.");
        }
    }
    import org.apache.logging.log4j.Logger;
    import org.apache.logging.log4j.LogManager;
    
    public class Bar {
      static final Logger logger = LogManager.getLogger(Bar.class.getName());
    
      public boolean doIt() {
        logger.entry();
        logger.error("Did it again!");
        return logger.exit(false);
      }
    }

    如果Log4j找不到配置文件,它将提供默认配置。DefaultConfiguration类中提供的默认配置将设置:

    • 一个附加到根记录器的ConsoleAppender。
    • 一个设置为“%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} -
      %msg%n”的PatternLayout,被附加到ConsoleAppender上。

    注意,默认情况下Log4j将根日志记录器分配给Level.ERROR。

    MyApp的输出类似如下:

    17:13:01.540 [main] ERROR com.foo.Bar - Did it again!
    17:13:01.540 [main] ERROR MyApp - Didn't do it.

    如前所述,Log4j将首先尝试从配置文件配置自身。与默认配置相同的配置如下所示:

    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="WARN">
      <Appenders>
        <Console name="Console" target="SYSTEM_OUT">
          <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
        </Console>
      </Appenders>
      <Loggers>
        <Root level="error">
          <AppenderRef ref="Console"/>
        </Root>
      </Loggers>
    </Configuration>

    一旦上述文件作为log4j2.xml放入到类路径中,你将得到与上面列出的相同结果。将根级别更改为trace将得到类似于以下的结果:

    17:13:01.540 [main] TRACE MyApp - Entering application.
    17:13:01.540 [main] TRACE com.foo.Bar - entry
    17:13:01.540 [main] ERROR com.foo.Bar - Did it again!
    17:13:01.540 [main] TRACE com.foo.Bar - exit with (false)
    17:13:01.540 [main] ERROR MyApp - Didn't do it.
    17:13:01.540 [main] TRACE MyApp - Exiting application.

    请注意,使用默认配置时,将禁用状态日志的记录。


    展开全文
  • log4jlog4j2性能对比及log4j升级至log4j2方案

    千次阅读 多人点赞 2019-06-16 11:03:53
    1.前言 之前某个服务在压测环境中出现了问题,分析之后得知是log4jLogger对象争用厉害,很多线程阻塞在此。...关于log4jlog4j2的性能对比文章有很多,本文不过多描述,给出几张结论图及原文链接,作为参考...
  • java中的日志使用--slf4j,log4j,logback

    万次阅读 2018-10-15 09:58:23
    之前的各个项目都是配置好的,maven配置的时候,会看到各种类型的Log包:slf4j、log4j、commons-log、logback等等,看着就烦,今天仔细了解了一下,有点收获,记录一下 起因 使用JAVA的kafka api写main方法进行...
  • Log4j的基本使用log4j.properties

    千次阅读 2020-03-21 16:59:19
    log4j.properties log4j.rootCategory=DEBUG,CONSOLE,LOGFILE log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout log4j.appender.CONSOLE.la...
  • Log4J使用

    千次阅读 2014-03-27 10:48:12
    日志的记录对于一个商业...下面我们来探讨下如何使用Log4J: 首先,在官网上下载Jar包 :http://logging.apache.org/log4j/1.2/download.html Log4J的配置(下面举一个例子): ### set log levels ### log4j.ro
  • Log4j详细使用教程

    万次阅读 多人点赞 2015-05-18 11:07:38
    日志是应用软件中不可缺少的部分,Apache的开源项目Log4j是一个功能强大的日志组件,提供方便的日志记录。在apache网站:jakarta.apache.org/log4j 可以免费下载到Log4j最新版本的软件包。
  • 如何配置使用 Log4j

    万次阅读 2013-12-14 14:47:58
    最近在用Java 写一个FTP上传下载文件...下面介绍一下Log4j使用,具体概念到官网查阅: ----------------------------------------------------------------------------- 1、下载: http://archive.apache.org/dist/l
  • Log4j2使用总结

    万次阅读 2013-09-08 22:32:59
    Log4j 2 包含了基于LMAX 分离库的下一代的异步日志系统,在多线程环境下,异步日志系统比 Log4j 1.x 和Logback 提高了10倍性能提升(吞吐量和延迟率 )。
  • log4j使用教程详解(怎么使用log4j2)

    万次阅读 2016-04-01 10:22:02
    1. 去官方下载log4j 2,导入jar包,基本上你只需要导入下面两个jar包就可以了(xx是乱七八糟的...我们知道,要在某个类中使用log4j记录日志,只需要申明下面的成员变量(其实不一定要是成员变量,只是为了方便调用而已)
  • Log4j框架配置文件log4j.properties配置使用详解

    万次阅读 多人点赞 2018-06-05 19:12:19
    Log4j支持两种配置文件格式,一种是XML格式的文件,一种是properties(key=value)文件,其中properties格式的配置文件最为常用,其有一个固定的文件名log4j.properties,下面我们介绍使用properties文件做为配置...
  • 在java中使用log4j输出日志,正常日志都可以输出到日志文件中,但是像一些没有被捕获的异常信息就没有到日志文件中,而是输出到了tomcat的catalina.out这个文件中,有没有什么办法让异常信息也输出到日志文件中,...
  • log4jlog4j2的配合使用、slf4j

    千次阅读 2017-05-18 11:15:35
    log4j2比log4j快很多倍,配置logger和appender的level时粒度更细,这是为啥要使用log4j2的根本原因 通常我都是用log4j2来进行日志输出管理的,但还是由很多第三方的jar项目依赖于slf4j日志管理。可以通过添加slf4j-...
  • spring中log4j使用

    千次阅读 2007-10-30 11:19:00
    在Web应用中一般使用一个专门的Servlet来完成Log4J的配置,并保证在web.xml的配置中,这个Servlet位于其它Servlet之前,以便在Servlet和jsp中调用。下面是这个servlet,代码如下:import org.apache.log4j.*;import ...
  • SLF4J和Log4j使用详解(log4j.XML格式)

    千次阅读 2017-12-13 11:08:03
    log4j.xml配置详解(原文地址) slf4j介绍以及实现原理窥探 SLF4J原理简介(图文并茂) ...使用Slf4j集成Log4j2构建项目日志系统的完美解决方案   slf4j-simple-x.x.x.jar直接绑定System.err,所以是不会...
  • Log4j实践之使用log4j发送报警邮件

    千次阅读 2016-05-11 16:59:38
    配置文件 log4j.rootLogger=DEBUG,CONSOLE,DailyRollingFile,MAIL log4j.addivity.org.apache=true #ERROR,WARN,INFO,DEBUG ...log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender log4j.appender.T
  • 显示是已经加了log4j2.xml的,但是还是提示有问题 感觉和这个sfl4j 版本有问题。我用不同版本,也会显示不同的错误日志信息 ``` 2018-07-03 10:47:58,479 RMI TCP Connection(2)-127.0.0.1 ERROR Unable to locate...
  • 经过查看LogManager.java// if the user has not specified the log4j.configuration // property, we search first for the file "log4j.xml" and then // "log4j.properties" 明确了,当用户没有设置log4j....

空空如也

1 2 3 4 5 ... 20
收藏数 62,859
精华内容 25,143
关键字:

log4j