使用Log4j进行日志操作 详解

最新推荐文章于 2022-02-03 21:16:26 发布
最新推荐文章于 2022-02-03 21:16:26 发布
阅读量339 收藏
点赞数
分类专栏： log4j

转载：https://www.ibm.com/developerworks/cn/java/l-log4j/

概述

1.1. 背景

在应用程序中添加日志记录总的来说基于三个目的：监视代码中变量的变化情况，周期性的记录到文件中供其他应用进行统计分析工作；跟踪代码运行时轨迹，作为日后审计的依据；担当集成开发环境中的调试器的作用，向文件或控制台打印代码的调试信息。

最普通的做法就是在代码中嵌入许多的打印语句，这些打印语句可以输出到控制台或文件中，比较好的做法就是构造一个日志操作类来封装此类操作，而不是让一系列的打印语句充斥了代码的主体。

1.2. Log4j简介

在强调可重用组件开发的今天，除了自己从头到尾开发一个可重用的日志操作类外，Apache为我们提供了一个强有力的日志操作包-Log4j。

Log4j是Apache的一个开放源代码项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件、甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护进程等；我们也可以控制每一条日志的输出格式；通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。最令人感兴趣的就是，这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。

此外，通过Log4j其他语言接口，您可以在C、C++、.Net、PL/SQL程序中使用Log4j，其语法和用法与在Java程序中一样，使得多语言分布式系统得到一个统一一致的日志组件模块。而且，通过使用各种第三方扩展，您可以很方便地将Log4j集成到J2EE、JINI甚至是SNMP应用中。

本文介绍的Log4j版本是1.2.3。作者试图通过一个简单的客户/服务器Java程序例子对比使用与不使用Log4j 1.2.3的差别，并详细讲解了在实践中最常使用Log4j的方法和步骤。在强调可重用组件开发的今天，相信Log4j将会给广大的设计开发人员带来方便。加入到Log4j的队伍来吧！

一个简单的例子

我们先来看一个简单的例子，它是一个用Java实现的客户/服务器网络程序。刚开始我们不使用Log4j，而是使用了一系列的打印语句，然后我们将使用Log4j来实现它的日志功能。这样，大家就可以清楚地比较出前后两个代码的差别。

2.1. 不使用Log4j

2.1.1. 客户程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
package log4j ;
import java.io.* ;
import java.net.* ;
/**
  *
  * < p > Client Without Log4j </ p >
  * < p > Description: a sample with log4j</ p >
  * @version 1.0
  */
public class ClientWithoutLog4j {
     /**
      *
      * @param args
      */
     public static void main ( String args [] ) {
         String welcome = null;
         String response = null;
         BufferedReader reader = null;
         PrintWriter writer = null;
         InputStream in = null;
         OutputStream out = null;
         Socket client = null;
         try {
             client = new Socket ( "localhost", 8001 ) ;
             System.out.println ( "info: Client socket: " + client ) ;
             in = client.getInputStream () ;
             out = client.getOutputStream () ;
         } catch ( IOException e ) {
             System.out.println ( "error: IOException : " + e ) ;
             System.exit ( 0 ) ;
         }
         try{
             reader = new BufferedReader( new InputStreamReader ( in ) ) ;
             writer = new PrintWriter ( new OutputStreamWriter ( out ), true ) ;
             welcome = reader.readLine () ;
             System.out.println ( "debug: Server says: '" + welcome + "'" ) ;
             System.out.println ( "debug: HELLO" ) ;
             writer.println ( "HELLO" ) ;
             response = reader.readLine () ;
             System.out.println ( "debug: Server responds: '" + response + "'") ;
             System.out.println ( "debug: HELP" ) ;
             writer.println ( "HELP" ) ;
             response = reader.readLine () ;
             System.out.println ( "debug: Server responds: '" + response + "'" ) ;
             System.out.println ( "debug: QUIT" ) ;
             writer.println ( "QUIT" ) ;
         } catch ( IOException e ) {
             System.out.println ( "warn: IOException in client.in.readln()" ) ;
             System.out.println ( e ) ;
         }
         try{
             Thread.sleep ( 2000 ) ;
         } catch ( Exception ignored ) {}
     }
}

2.1.2. 服务器程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
package log4j ;
import java.util.* ;
import java.io.* ;
import java.net.* ;
/**
  *
  * < p > Server Without Log4j </ p >
  * < p > Description: a sample with log4j</ p >
  * @version 1.0
  */
public class ServerWithoutLog4j {
     final static int SERVER_PORT = 8001 ; // this server's port
     /**
      *
      * @param args
      */
     public static void main ( String args [] ) {
         String clientRequest = null;
         BufferedReader reader = null;
         PrintWriter writer = null;
         ServerSocket server = null;
         Socket socket = null;
         InputStream in = null;
         OutputStream out = null;
         try {
             server = new ServerSocket ( SERVER_PORT ) ;
             System.out.println ( "info: ServerSocket before accept: " + server ) ;
             System.out.println ( "info: Java server without log4j, on-line!" ) ;
             // wait for client's connection
             socket = server.accept () ;
             System.out.println ( "info: ServerSocket after accept: " + server )  ;
             in = socket.getInputStream () ;
             out = socket.getOutputStream () ;
         } catch ( IOException e ) {
             System.out.println( "error: Server constructor IOException: " + e ) ;
             System.exit ( 0 ) ;
         }
         reader = new BufferedReader ( new InputStreamReader ( in ) ) ;
         writer = new PrintWriter ( new OutputStreamWriter ( out ) , true ) ;
         // send welcome string to client
         writer.println ( "Java server without log4j, " + new Date () ) ;
         while ( true ) {
             try {
                 // read from client
                 clientRequest = reader.readLine () ;
                 System.out.println ( "debug: Client says: " + clientRequest ) ;
                 if ( clientRequest.startsWith ( "HELP" ) ) {
                     System.out.println ( "debug: OK!" ) ;
                     writer.println ( "Vocabulary: HELP QUIT" ) ;
                 }
                 else {
                     if ( clientRequest.startsWith ( "QUIT" ) ) {
                         System.out.println ( "debug: OK!" ) ;
                         System.exit ( 0 ) ;
                     }
                     else{
                         System.out.println ( "warn: Command '" +
                         clientRequest + "' not understood." ) ;
                         writer.println ( "Command '" + clientRequest
                         + "' not understood." ) ;
                     }
                 }
             } catch ( IOException e ) {
                 System.out.println ( "error: IOException in Server " + e ) ;
                 System.exit ( 0 ) ;
             }
         }
     }
}

2.2. 迁移到Log4j

2.2.1. 客户程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
package log4j ;
import java.io.* ;
import java.net.* ;
// add for log4j: import some package
import org.apache.log4j.PropertyConfigurator ;
import org.apache.log4j.Logger ;
import org.apache.log4j.Level ;
/**
  *
  * < p > Client With Log4j </ p >
  * < p > Description: a sample with log4j</ p >
  * @version 1.0
  */
public class ClientWithLog4j {
     /*
     add for log4j: class Logger is the central class in the log4j package.
     we can do most logging operations by Logger except configuration.
     getLogger(...): retrieve a logger by name, if not then create for it.
     */
     static Logger logger = Logger.getLogger
     ( ClientWithLog4j.class.getName () ) ;
     /**
      *
      * @param args : configuration file name
      */
     public static void main ( String args [] ) {
         String welcome = null ;
         String response = null ;
         BufferedReader reader = null ;
         PrintWriter writer = null ;
         InputStream in = null ;
         OutputStream out = null ;
         Socket client = null ;
         /*
         add for log4j: class BasicConfigurator can quickly configure the package.
         print the information to console.
         */
         PropertyConfigurator.configure ( "ClientWithLog4j.properties" ) ;
         // add for log4j: set the level
//        logger.setLevel ( ( Level ) Level.DEBUG ) ;
         try{
             client = new Socket( "localhost" , 8001 ) ;
             // add for log4j: log a message with the info level
             logger.info ( "Client socket: " + client ) ;
             in = client.getInputStream () ;
             out = client.getOutputStream () ;
         } catch ( IOException e ) {
             // add for log4j: log a message with the error level
             logger.error ( "IOException : " + e ) ;
             System.exit ( 0 ) ;
         }
         try{
             reader = new BufferedReader ( new InputStreamReader ( in ) ) ;
             writer = new PrintWriter ( new OutputStreamWriter ( out ), true ) ;
             welcome = reader.readLine () ;
             // add for log4j: log a message with the debug level
             logger.debug ( "Server says: '" + welcome + "'" ) ;
             // add for log4j: log a message with the debug level
             logger.debug ( "HELLO" ) ;
             writer.println ( "HELLO" ) ;
             response = reader.readLine () ;
             // add for log4j: log a message with the debug level
             logger.debug ( "Server responds: '" + response + "'" ) ;
             // add for log4j: log a message with the debug level
             logger.debug ( "HELP" ) ;
             writer.println ( "HELP" ) ;
             response = reader.readLine () ;
             // add for log4j: log a message with the debug level
             logger.debug ( "Server responds: '" + response + "'") ;
             // add for log4j: log a message with the debug level
             logger.debug ( "QUIT" ) ;
             writer.println ( "QUIT" ) ;
         } catch ( IOException e ) {
             // add for log4j: log a message with the warn level
             logger.warn ( "IOException in client.in.readln()" ) ;
             System.out.println ( e ) ;
         }
         try {
             Thread.sleep ( 2000 ) ;
         } catch ( Exception ignored ) {}
     }
}

2.2.2. 服务器程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
package log4j;
import java.util.* ;
import java.io.* ;
import java.net.* ;
// add for log4j: import some package
import org.apache.log4j.PropertyConfigurator ;
import org.apache.log4j.Logger ;
import org.apache.log4j.Level ;
/**
  *
  * < p > Server With Log4j </ p >
  * < p > Description: a sample with log4j</ p >
  * @version 1.0
  */
public class ServerWithLog4j {
     final static int SERVER_PORT = 8001 ; // this server's port
     /*
     add for log4j: class Logger is the central class in the log4j package.
     we can do most logging operations by Logger except configuration.
     getLogger(...): retrieve a logger by name, if not then create for it.
     */
     static Logger logger = Logger.getLogger
     ( ServerWithLog4j.class.getName () ) ;
     /**
      *
      * @param args
      */
     public static void main ( String args[]) {
         String clientRequest = null ;
         BufferedReader reader = null ;
         PrintWriter writer = null ;
         ServerSocket server = null ;
         Socket socket = null ;
         InputStream in = null ;
         OutputStream out = null ;
         /*
         add for log4j: class BasicConfigurator can quickly configure the package.
         print the information to console.
         */
         PropertyConfigurator.configure ( "ServerWithLog4j.properties" ) ;
         // add for log4j: set the level
//        logger.setLevel ( ( Level ) Level.DEBUG ) ;
         try{
             server = new ServerSocket ( SERVER_PORT ) ;
             // add for log4j: log a message with the info level
             logger.info ( "ServerSocket before accept: " + server ) ;
             // add for log4j: log a message with the info level
             logger.info ( "Java server with log4j, on-line!" ) ;
             // wait for client's connection
             socket = server.accept() ;
             // add for log4j: log a message with the info level
             logger.info ( "ServerSocket after accept: " + server ) ;
             in = socket.getInputStream() ;
             out = socket.getOutputStream() ;
         } catch ( IOException e ) {
             // add for log4j: log a message with the error level
             logger.error ( "Server constructor IOException: " + e ) ;
             System.exit ( 0 ) ;
         }
         reader = new BufferedReader ( new InputStreamReader ( in ) ) ;
         writer = new PrintWriter ( new OutputStreamWriter ( out ), true ) ;
         // send welcome string to client
         writer.println ( "Java server with log4j, " + new Date () ) ;
         while ( true ) {
             try {
                 // read from client
                 clientRequest = reader.readLine () ;
                 // add for log4j: log a message with the debug level
                 logger.debug ( "Client says: " + clientRequest ) ;
                 if ( clientRequest.startsWith ( "HELP" ) ) {
                     // add for log4j: log a message with the debug level
                     logger.debug ( "OK!" ) ;
                     writer.println ( "Vocabulary: HELP QUIT" ) ;
                 }
                 else {
                     if ( clientRequest.startsWith ( "QUIT" ) ) {
                         // add for log4j: log a message with the debug level
                         logger.debug ( "OK!" ) ;
                         System.exit ( 0 ) ;
                     }
                     else {
                         // add for log4j: log a message with the warn level
                         logger.warn ( "Command '"
                         + clientRequest + "' not understood." ) ;
                         writer.println ( "Command '"
                         + clientRequest + "' not understood." ) ;
                     }
                 }
             } catch ( IOException e ) {
                 // add for log4j: log a message with the error level
                 logger.error( "IOException in Server " + e ) ;
                 System.exit ( 0 ) ;
             }
         }
     }
}

2.2.3. 配置文件

2.2.3.1. 客户程序配置文件

1
2
3
4
log4j.rootLogger=INFO, A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%-4r %-5p [%t] %37c %3x - %m%n

2.2.3.2. 服务器程序配置文件

1
2
3
4
log4j.rootLogger=INFO, A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%-4r %-5p [%t] %37c %3x - %m%n

2.3. 比较

比较这两个应用可以看出，采用Log4j进行日志操作的整个过程相当简单明了，与直接使用System.out.println语句进行日志信息输出的方式相比，基本上没有增加代码量，同时能够清楚地理解每一条日志信息的重要程度。通过控制配置文件，我们还可以灵活地修改日志信息的格式，输出目的地等等方面，而单纯依靠System.out.println语句，显然需要做更多的工作。

下面我们将以前面使用Log4j的应用作为例子，详细讲解使用Log4j的主要步骤。

Log4j基本使用方法

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

3.1.定义配置文件

其实您也可以完全不使用配置文件，而是在代码中配置Log4j环境。但是，使用配置文件将使您的应用程序更加灵活。

Log4j支持两种配置文件格式，一种是XML格式的文件，一种是Java特性文件（键=值）。下面我们介绍使用Java特性文件做为配置文件的方法：

  1. 配置根Logger，其语法为：

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

    其中，level 是日志记录的优先级，分为OFF、FATAL、ERROR、WARN、INFO、DEBUG、ALL或者您定义的级别。Log4j建议只使用四个级别，优先级从高到低分别是ERROR、WARN、INFO、DEBUG。通过在这里定义的级别，您可以控制到应用程序中相应级别的日志信息的开关。比如在这里定义了INFO级别，则应用程序中所有DEBUG级别的日志信息将不被打印出来。 
    appenderName就是指定日志信息输出到哪个地方。您可以同时指定多个输出目的地。
  2. 配置日志信息输出目的地Appender，其语法为
    1
    2
    3
    4
    log4j.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（将日志信息以流格式发送到任意指定的地方）
  3. 配置日志信息的格式（布局），其语法为：
    1
    2
    3
    4
    log4j.appender.appenderName.layout = fully.qualified.name.of.layout.class
    log4j.appender.appenderName.layout.option1 = value1
    …
    log4j.appender.appenderName.layout.option = valueN

    其中，Log4j提供的layout有以下几种： 
    org.apache.log4j.HTMLLayout（以HTML表格形式布局）， 
    org.apache.log4j.PatternLayout（可以灵活地指定布局模式）， 
    org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串）， 
    org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）

3.2.在代码中使用Log4j

下面将讲述在程序代码中怎样使用Log4j。

3.2.1.得到记录器

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

public static Logger getLogger( String name)，

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

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

3.2.2.读取配置文件

当获得了日志记录器之后，第二步将配置Log4j环境，其语法为： 
BasicConfigurator.configure ()： 自动快速地使用缺省Log4j环境。 
PropertyConfigurator.configure ( String configFilename) ：读取使用Java的特性文件编写的配置文件。 
DOMConfigurator.configure ( String filename ) ：读取XML形式的配置文件。

3.2.3.插入记录信息（格式化日志信息）

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

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

生活因我绚丽
关注
专栏目录
11-使用log4j收集日志
明明Vers的博客
01-30 225
1、引入log4j jar包 <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.17</version> </dependency> 2、src目录下新建log4j.properties配置文件 ### set log levels ### log4j.
log4j2动态修改日志级别及拓展性使用详解
08-26
log4j2动态修改日志级别及拓展性使用详解 log4j2是一个流行的Java日志记录库，提供了许多强大的功能，包括动态修改日志级别和拓展性使用。下面将详细介绍log4j2动态修改日志级别及拓展性使用。 一、log4j2动态修改...
使用Log4J进行日志操作
Howie Lee的博客
03-21 468
Log4J简介Log4J是Apache的一个开放源代码项目，它是一个日志操作包，通过使用Log4J，可以指定日志信息输出的目的地，如控制台、文件、ＣＵＩ组件、NT的事件记录器；还可以控制每一条日志输出格式。此外，通过定义日志信息的级别，能够非常细致地控制日志的输出，最令人感兴趣的是，这些功能可以通过一个配置文件来灵活进行配置，而不需要修改应程序代码。 在应用程序中输出日志有３个目的：  监
使用Log4j进行日志操作
wgogo的专栏
04-16 824
        在应用程序中添加日志记录总的来说基于三个目的：监视代码中变量的变化情况，周期性的记录到文件中供其他应用进行统计分析工作；跟踪代码运行时轨迹，作为日后审计的依据；担当集成开发环境中的调试器的作用，向文件或控制台打印代码的调试信息。 在应用程序中添加日志记录总的来说基于三个目的：监视代码中变量的变化情况，周期性的记录到文件中供其他应用进行统计分析工作；跟踪代码运行时轨迹，作为日后审计的
利用log4j写日志
wudiyong22的专栏
08-08 2347
1、下载导入包commons-logging.jar和log4j-1.2.9.jar 2、写配置文件log4j.properties，内容如下： log4j.rootCategory=INFO, LOGFILE     //LOGFILE表示将日志写到文件中，如果是CONSOLE则将日志写到控制台 log4j.logger.org.apache.axis2.enterprise=FA
Java中 log4j日志级别配置详解
08-28
Java 中 Log4j 日志级别配置详解 Log4j 是 Java 中最常用的日志记录工具之一，通过配置 Log4j，可以实现灵活的日志记录和管理。下面将详细介绍 Log4j 的日志级别配置。 1. Log4j 的发展历史 Log4j 的历史可以追溯...
详解Log4j 日志文件存放位置设置
08-27
本文将详细介绍如何使用Log4j设置日志文件的存放位置。 首先，要设置日志文件的存放位置，通常需要在Log4j的配置文件中使用特定的配置项。Log4j支持多种类型Appender，其中DailyRollingFileAppender是一个常用的...
log4j日志配置以及配置文件详解
10-16
这是log4j框架的配置文件，使用Java Properties格式，用于定义日志输出的行为。主要包括以下几个核心部分： 1. **Logger**: 定义日志级别，例如DEBUG、INFO、WARN、ERROR和FATAL。日志级别决定了哪些信息会被记录。...
log4j 详解异步日志的配置和测试
08-31
Log4j 是一款广泛使用的日志记录框架，它允许开发者以高效的方式记录应用程序的运行信息。在大型系统中，日志记录尤其重要，因为它有助于排查错误、监控系统状态以及进行数据挖掘。本文将深入探讨如何配置 Log4j 来...
log4j使用与java中log4j记录日志如何写入数据库
07-12
详细介绍了log4j的使用方法，介绍了java中日志记录如何写入数据库，对于初学者来说很不错的一个文档
log4j2 项目日志组件的实例代码
08-28
下面小编就为大家分享一篇log4j2 项目日志组件的实例代码，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
log4j写日志
流年烟火
10-17 74
好处：便于维护与管理，如果系统崩溃或被黑客攻击，查日志就知道问题在哪里。。   log4j.rootLogger=debug,CONSOLE,FILE debug：代表记录器的级别，小级别显示大的，大级别不显示小的 DEBUG&lt;INFO&lt;WARN&lt;ERROR&lt;FATAL appender:配置输出源 log4j.appender.CONSOLE=or...
第十七章 使用Log4J进行日志操作（书摘）
adaiye的专栏
05-12 1116
    Log4J是Apache的一个开放源代码项目，它是一个日志操作包。通过使用Log4J，可以指定日志信息输出的目的地。如控制台、文件、CGI组件，甚至是套接口服务器、NT的事件记录器和UNIX Syslog守护进程等；还可以控制每一条日志的输出格式。此外，通过定义日志信息的级别，能够非常细致的控制日志的输出。这些功能可以通过一个配置文件来灵活地进行配置，而不需要修改应用程序的代码。    
log4j写日志的方法
杰克船长
07-17 1037
1.下载如下jar,导入到工程中。 log4j.jar,commons-logging-1.1.1.jar,commons-logging-adpters-1.1.1.jar 2.在classpath下新建log4j.properties,内容如下：     log4j.rootLogger=info,ROLLING_FILE       log4j.appender.ROLLING_
log4j日志的使用
热爱编程的菜鸟
02-03 1182
文章目录日志是什么日志级别java使用log4j框架 日志是什么 记录项目运行信息的文本，长期存储，定位异常，数据分析。 日志级别 ALL TRACE:跟踪（不常用） DEBUG：调式（开发者） INFO：信息提示 WARN：警告 ERROR：错误 FATAL：致命的错误 java使用log4j框架 首先在src目录下配置文件，log4j.properties 配置内容 #设置为DEBUG模式 可以输出比DEBUG级别高 log4j.rootLogger=DEBUG,cmd,myfile #c
java 使用log4j写日志文件
热门推荐
08-19 1万+
1.下载包，放在lib目录下 2.在CLASSPATH下建立log4j.properties，内容如下 log4j.rootLogger=info,ROLLING_FILE log4j.appender.ROLLING_FILE = org.apache.log
Log4j日志配置详解：从基础到高级
"这是一个关于Log4j日志框架的简明使用说明，主要涵盖了日志输出平台的选择、配置属性以及布局格式的设定。" 在Java开发中，Log4j是一个广泛使用的日志记录工具，它提供了丰富的功能和灵活性，使得开发者能够方便地...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值