log4j日志输出规范

合集下载

Log4j2的日志配置文件，log4j2.xml文件的配置（实现控制台输出，各级别分别文件。。。

Log4j2的⽇志配置⽂件，log4j2.xml⽂件的配置（实现控制台输出，各级别分别⽂件。

<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "/2002/xmlspec/dtd/2.10/xmlspec.dtd"><!-- status : 这个⽤于设置log4j2⾃⾝内部的信息输出,可以不设置,当设置成trace时,会看到log4j2内部各种详细输出 monitorInterval: Log4j能够⾃动检测修改配置⽂件和重新配置本⾝, 设置间隔秒数。

注：本配置⽂件的⽬标是将不同级别的⽇志输出到不同⽂件，最⼤2MB⼀个⽂件，⽂件数据达到最⼤值时，旧数据会被压缩并放进指定⽂件夹 --><Configuration status="WARN" monitorInterval="600"><Properties><Property name="LOG_HOME">${sys:catalina.home}/WebAppLogs/HHServices</Property></Properties><Appenders><!-- DENY，⽇志将⽴即被抛弃不再经过其他过滤器； NEUTRAL，有序列表⾥的下个过滤器过接着处理⽇志； ACCEPT，⽇志会被⽴即处理，不再经过剩余过滤器。

android log4j 用法

android log4j 用法Android Log4j 用法：详细步骤解析Log4j是一个功能强大且广泛用于Java程序的日志记录工具。

它提供了灵活的日志配置选项，允许开发人员根据应用程序的需求自定义日志输出。

在Android开发中，我们可以使用Log4j来记录应用程序的日志，以便更好地进行调试和故障排除。

本文将一步一步介绍如何在Android项目中使用Log4j，并对其用法进行详细解析。

第一步：引入Log4j库要使用Log4j，我们首先需要将其库文件添加到Android项目的依赖项中。

可以从Apache官方网站上下载Log4j的最新版本。

下载完成后，将其包含在项目的libs文件夹中。

接下来，在项目的build.gradle文件中添加以下依赖项：dependencies {implementation files('libs/log4j.jar')}这样，Log4j库就会被添加到项目中。

第二步：创建配置文件Log4j需要一个配置文件来定义日志输出的格式和目标。

我们可以在项目的res目录下创建一个名为log4j.properties的文件，并按照如下内容进行配置：# 设置根日志级别为DEBUGlog4j.rootLogger=DEBUG,stdout# 配置控制台输出log4j.appender.stdout=org.apache.log4j.ConsoleAppenderlog4j.appender.stdout.Target=System.outyout=org.apache.log4j.PatternLayoutyout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %p %t %c - %m%n# 配置文件输出log4j.appender.file=org.apache.log4j.RollingFileAppenderlog4j.appender.file.File=/sdcard/app.loglog4j.appender.file.MaxFileSize=5MBlog4j.appender.file.MaxBackupIndex=4yout=org.apache.log4j.PatternLayoutyout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %p %t %c - %m%n在上述配置文件中，我们首先设置了根日志级别为DEBUG，这意味着只有DEBUG级别及以上的日志才会被输出。

JAVA中使用log4j及slf4j进行日志输出的方法详解

JAVA中使⽤log4j及slf4j进⾏⽇志输出的⽅法详解 JAVA中输出⽇志⽐较常⽤的是log4j，这⾥讲下log4j的配置和使⽤⽅法，以及slf4j的使⽤⽅法。

⼀、下载log4j的架包，并导⼊项⽬中，如下：⼆、创建log4j.properties配置⽂件1、log4j配置⽂件的位置：（1）如果是java project项⽬，则在项⽬的根⽬录下创建log4j.properties⽽不是在src⽬录下。

（2）如果是java web项⽬，则在src⽬录下创建log4j.properties配置⽂件，因为这个时候tomcat会去默认的加载这个配置⽂件，⽽不需要我们⼿动的加载log4j的配置⽂件。

log4j.properties配置内容如下：1 log4j.rootLogger=info,logTest2 log4j.appender.logTest=org.apache.log4j.DailyRollingFileAppender3 log4j.appender.logTest.File=/logs/LogTest/logTest.log4 log4j.appender.logTest.DatePattern='.'yyyy-MM-dd'.log'5 yout=org.apache.log4j.PatternLayout6 yout.ConversionPattern=[LogTestInfo] [%d][%c][%-5p]%m%n2、log4j配置项的说明：（1）第⼀⾏中rootLogger配置的是整个项⽬的⽇志输出，也可以只针对某⼀个模块进⾏⽇志输出，⽐如第⼀⾏配置成.logTest.project=info,logTest，则⽇志只输出项⽬路径com/logTest/project下的。

info为⽇志级别，可分为OFF、FATAL、ERROR、WARN、INFO、DEBUG、ALL。

log4j日志输出格式自定义

log4j⽇志输出格式⾃定义yout.ConversionPattern
类的⾃定义
1. #⾃定义样式
2. #%c 输出所属的类⽬，通常就是所在类的全名
3. #%C 输出Logger所在类的名称，通常就是所在类的全名
4. #%d 输出⽇志时间点的⽇期或时间，默认格式为ISO8601，也可以在其后指定格式，⽐如：
%d{yyy MMM dd HH:mm:ss , SSS}，%d{ABSOLUTE}，%d{DATE}
5. #%F 输出所在类的类名称，只有类名。

6. #%l 输出语句所在的⾏数，包括类名+⽅法名+⽂件名+⾏数
7. #%L 输出语句所在的⾏数，只输出数字
8. #%m 输出代码中指定的讯息，如log(message)中的message
9. #%M 输出⽅法名
10. #%p 输出⽇志级别，即DEBUG，INFO，WARN，ERROR，FATAL
11. #%r 输出⾃应⽤启动到输出该log信息耗费的毫秒数
12. #%t 输出产⽣该⽇志事件的线程名
13. #%n 输出⼀个回车换⾏符，Windows平台为“/r/n”，Unix平台为“/n”
14. #%% ⽤来输出百分号“%”
例如：
[%p] [%d{yyyy-MM-dd HH:mm:ss}][%t][%F-%L]%m%n
[%p] [%d{yyyy-MM-dd HH:mm:ss}][%l]%m%n。

日志输出规范

⽇志输出规范1、log4j⽇志参数说明yout.ConversionPattern=[%p][%l] %d{yyyy-MM-dd HH:mm:ss} %m%n格式输出修改成：yout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} - [%p] - [%l] - [ %m ]%n时间-事件级别-打印⽇志的详细信息-消息内容p log事件的级别。

l log发⽣位置的详细描述，包括⽅法名、⽂件名及⾏号。

d 时间和⽇期的输出格式，例如：%d{yyyy MM dd HH:mm:ss,SS}，可不带后⾯的⽇期格式字符。

m log事件的消息内容n 根据所运⾏的平台输出相应的⾏分隔字符。

2、在⼀个对象中通常只使⽤⼀个Logger对象，Logger应该是static final的，只有在少数需要在构造函数中传递logger的情况下才使⽤private final。

private static final org.slf4j.Logger logger =LoggerFactory.getLogger(TemperatureDetectionController.class);如果使⽤com.leelen.esafe.utils.Logger,则⽇志输出的具体类将不能体现。

之前写法：(TAG + ":" + JSON.toJSONString(cmds));调⽤LoggerUtil的类，并且要⼿动获取类名，拼接字符串才能显⽰具体的类名3.输出Exceptions的全部Throwable信息，因为logger.error(msg)和logger.error(msg,e.getMessage())这样的⽇志输出⽅法会丢失掉最重要的StackTrace信息。

try {throw new Exception("测试⽇志");}catch (Exception e){(e.getMessage());//错误("输⼊⽇志1",e.getMessage());//错误("输⼊⽇志2",e);//正确}4、不允许记录⽇志后⼜抛出异常，因为这样会多次记录⽇志，只允许记录⼀次⽇志。

日志打印会严重影响到性能

⽇志打印会严重影响到性能以前编程不喜欢对每个功能、重要的⽅法进⾏⽇志的格式化输出，即使要输出，也没按照规范进⾏输出。

前段时间，随着我们平台⽤户量不断增加，出现些问题。

当⽤户遇到问题，就给我们客服打电话。

然后客服毫⽆疑问就来找我们。

当我们接收到这样问题的时候，我们⾸先要定位是什么原因造成的。

当时就是因为⾃⼰⽅法中输出的⽇志很少，⽽且不规范，所以根本找不到具体原因，虽然最后问题解决了，但是花费很多不必要的时间。

那么我们怎样使⽤好⽇志这⼀利器呢？1.写好⽇志：我们先来看⼀下糟糕的⽇志打印：[java]1. @ResponseBody2. @RequestMapping(value = "unbind.do", method = RequestMethod.POST)3. public Object unbind(String bankId, String memberId) {4.5. if (StringUtils.isBlank(bankId) || StringUtils.isBlank(memberId)) {6. return new Result(false, "解绑参数不合法！");7. }8. try {9. authPayTwoService.unbind(bankId, memberId);10. } catch (AppException e) {11. ("认证⽀付2.0(unbind)失败：{}",e);12. return new Result(false, e.getMessage());13. } catch (Exception e) {14. ("认证⽀付2.0(unbind)]失败：{}", e);15. return new Result(false, "解绑银⾏卡失败，请重试");16. }17. return new Result(true, "解绑银⾏卡成功！");18. }上⾯代码是严格不符合规范的，每个公司都有⾃⼰的打印要求。

idea log4j插件用法

1. 什么是Log4j插件Log4j是一个开源的日志记录框架，广泛应用于Java项目中。

Log4j插件是用于在开发过程中方便地使用Log4j框架的工具，能够帮助开发人员快速配置和管理日志记录功能。

2. Log4j插件的安装在使用Log4j插件之前，首先需要在开发环境中安装Log4j插件。

可以通过Maven或手动下载Jar包的方式将Log4j插件导入到项目中，然后在项目配置文件中声明Log4j插件的依赖关系。

3. Log4j插件的配置在项目中成功导入Log4j插件后，需要对插件进行配置。

首先需要创建一个Log4j配置文件（通常命名为log4j.properties或log4j.xml），在配置文件中指定日志记录的格式、输出目标、日志级别等参数。

4. 使用Log4j插件记录日志配置完成后，开发人员可以通过调用Log4j插件提供的API来记录日志。

开发人员可以在代码中插入日志记录语句，指定日志的级别（如DEBUG、INFO、WARN、ERROR等），以及日志的内容。

通过Log4j插件记录的日志可以输出到控制台、文件、数据库等不同的目标。

5. Log4j插件的优点Log4j插件提供了丰富的日志记录功能，可以根据需要灵活地配置日志记录的方式和输出目标。

Log4j插件具有较高的性能和稳定性，适用于各种规模的项目。

另外，Log4j插件支持多种日志级别，开发人员可以根据实际需要精细地控制日志的记录和输出。

6. Log4j插件的注意事项在使用Log4j插件的过程中，需要注意配置文件的正确指定和日志记录语句的合理使用。

对于不同的项目和需求，需要仔细选择适合的日志记录方式和输出目标，以便保证日志记录的准确性和便捷性。

7. 结语Log4j插件是一个优秀的日志记录工具，能够帮助开发人员轻松地实现日志记录的功能。

通过仔细的配置和合理的使用，开发人员可以充分发挥Log4j插件的优势，为项目提供有效的日志管理和追踪功能。

希望本文对大家了解Log4j插件的用法有所帮助。

log4j使用教程详解（怎么使用log4j2）

log4j使⽤教程详解（怎么使⽤log4j2）1. 去官⽅下载log4j 2，导⼊jar包，基本上你只需要导⼊下⾯两个jar包就可以了(xx是乱七⼋糟的版本号)：log4j-core-xx.jarlog4j-api-xx.jar2. 导⼊到你的项⽬中：这个就不说了。

3. 开始使⽤：我们知道，要在某个类中使⽤log4j记录⽇志，只需要申明下⾯的成员变量（其实不⼀定要是成员变量，只是为了⽅便调⽤⽽已）复制代码代码如下:private static Logger logger = LogManager.getLogger(MyApp.class.getName());⾥getLogger有⼀个参数指定的是这个logger的名称，这个名称在配置⽂件⾥⾯可是有需要的，这个待会⼉再说。

声明了Logger对象，我们就可以在代码中使⽤他了。

4. ⽇志的级别：我们现在要调⽤logger的⽅法，不过在这个Logger对象中，有很多⽅法，所以要先了解log4j的⽇志级别，log4j规定了默认的⼏个级别：trace<debug<info<warn<error<fatal等。

这⾥要说明⼀下：1）级别之间是包含的关系，意思是如果你设置⽇志级别是trace，则⼤于等于这个级别的⽇志都会输出。

2）基本上默认的级别没多⼤区别，就是⼀个默认的设定。

你可以通过它的API⾃⼰定义级别。

你也可以随意调⽤这些⽅法，不过你要在配置⽂件⾥⾯好好处理了，否则就起不到⽇志的作⽤了，⽽且也不易读，相当于⼀个规范，你要完全定义⼀套也可以，不⽤没多⼤必要。

3）这不同的级别的含义⼤家都很容易理解，这⾥就简单介绍⼀下：trace：是追踪，就是程序推进以下，你就可以写个trace输出，所以trace应该会特别多，不过没关系，我们可以设置最低⽇志级别不让他输出。

debug：调试么，我⼀般就只⽤这个作为最低级别，trace压根不⽤。

springboot配置log4j2日志，并输出到文件

springboot配置log4j2⽇志，并输出到⽂件1、pom.xml中,如果导⼊了spring-boot-starter-web依赖包，那么必须先将⾃带的⽇志框架去掉，如下<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-jpa</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId><exclusions><exclusion><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-logging</artifactId></exclusion></exclusions></dependency>然后加⼊<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-log4j2</artifactId></dependency>2、在resources下建⼀个log4j2spring.xml<?xml version="1.0" encoding="UTF-8"?><configuration monitorInterval="5"><Properties><property name="LOG_PATTERN" value="%date{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n" /><property name="FILE_PATH" value="/logs" /><property name="FILE_NAME" value="demo" /></Properties><appenders><console name="Console" target="SYSTEM_OUT"><PatternLayout pattern="${LOG_PATTERN}"/><ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/></console><File name="Filelog" fileName="${FILE_PATH}/test.log" append="false"><PatternLayout pattern="${LOG_PATTERN}"/></File><RollingFile name="RollingFileInfo" fileName="${FILE_PATH}/${FILE_NAME}/info.log" filePattern="${FILE_PATH}/${FILE_NAME}-INFO-%d{yyyy-MM-dd}_%i.log.gz"><ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/><PatternLayout pattern="${LOG_PATTERN}"/><Policies><TimeBasedTriggeringPolicy interval="1"/><SizeBasedTriggeringPolicy size="10MB"/></Policies><DefaultRolloverStrategy max="15"/></RollingFile><RollingFile name="RollingFileWarn" fileName="${FILE_PATH}/${FILE_NAME}/warn.log" filePattern="${FILE_PATH}/${FILE_NAME}-WARN-%d{yyyy-MM-dd}_%i.log.gz"><ThresholdFilter level="warn" onMatch="ACCEPT" onMismatch="DENY"/><PatternLayout pattern="${LOG_PATTERN}"/><Policies><TimeBasedTriggeringPolicy interval="1"/><SizeBasedTriggeringPolicy size="10MB"/></Policies><DefaultRolloverStrategy max="15"/></RollingFile><RollingFile name="RollingFileError" fileName="${FILE_PATH}/${FILE_NAME}/error.log" filePattern="${FILE_PATH}/${FILE_NAME}-ERROR-%d{yyyy-MM-dd}_%i.log.gz"><ThresholdFilter level="error" onMatch="ACCEPT" onMismatch="DENY"/><PatternLayout pattern="${LOG_PATTERN}"/><Policies><TimeBasedTriggeringPolicy interval="1"/><SizeBasedTriggeringPolicy size="10MB"/></Policies><DefaultRolloverStrategy max="15"/></RollingFile></appenders><!--Logger节点⽤来单独指定⽇志的形式，⽐如要为指定包下的class指定不同的⽇志级别等。

log4j日志不正常,不输出到控制台问题

log4j⽇志不正常,不输出到控制台问题问题：我的myeclipse 2014由于⼀些原因不打印console⽇志。

解决⽅法:1. 在运⾏的VM的参数⾥⾯增加-Dlog4j.debug 打印出log4j的测试信息。

2. 或者在VM参数⾥⾯强制增加log4j配置⽂件地址： -Dlog4j.configuration=log4j-config_folder/log4j.xml⼀般你应该通过第⼀步找到原因然后根据情况解决如何加参数：1. 如果你是⽤的run/debug右键->run/debug下⾯有⼀个run configurations/debugconfigurations->(x)=Arguments->下⽅有个VMarguments: 把参数加到⾥⾯，选apply和run/debug就可以了。

2. 如果你是⽤的myeclipse，要在Tomcat->Tomcat n.x->JDK->Optional Java VM arguments下增加 -Dlog4j.debug原⽂:/questions/3501355/log4j-output-not-displayed-in-eclipse-consoleFor some reason my Eclipse console no longer displays Log4jINFO and DEBUG statements when I run JUnit tests. In terms ofcode there hasn't been any change, so it must something to dowith the Eclipse configuration.All I do in my Unit test is the following and for some reasonONLY the ERROR statement is displayed in the Eclipseconsole. Why? Where shall I look for clues?public class SampleTest{private static final Logger LOGGER = Logger.getLogger(SampleTest.class);@Beforepublic void init() throws Exception{// Log4J junit configuration.BasicConfigurator.configure();("INFO TEST");LOGGER.debug("DEBUG TEST");LOGGER.error("ERROR TEST");}}Details:log4j-1.2.6.jarjunit-4.6.jar EclipseIDE for Java Developers, Version: Helios Release, Build id:20100617-1415java eclipse junit log4jshare|improve this question edited Aug 17 '10 at10:21leppie68.9k8106203asked Aug 17 '10 at10:11javaExpert1242210add a commentLook in the log4j.properties or log4j.xml file for the log level. It's probably set to ERROR instead ofcommand line with log4j.jar and log4j.properties on your classpath.。

JsonLayoutlog4j2json格式输出日志

JsonLayoutlog4j2json格式输出⽇志如果⽇志输出时，想改变⽇志的输出形式为Json格式，可以在log4j2.xml中使⽤JsonLayout标签，使⽇志输出格式为Json格式。

前提需要Jackson的包，保证项⽬中包含jackson的依赖然后在log4j2.xml中在需要⽇志输出的地⽅，添加<JsonLayout/>例如需要在控制台输出格式为Json格式则：<Console name="Console" target="SYSTEM_OUT"><JsonLayout/></Console>如果需要在⽇志⽂件输出，则为：<RollingFile name="syswareLog" fileName="${LOG_HOME}/logs/sysware.log"filePattern="${LOG_HOME}/logs/$${date:yyyy-MM}/sysware-%d{yyyy-MM-dd}-%i.log"><JsonLayout/><Policies><TimeBasedTriggeringPolicy/><SizeBasedTriggeringPolicy size="100000 kb"/></Policies><DefaultRolloverStrategy max="100"/></RollingFile>设置完成之后，⽇志输出格式如下：{"timeMillis" : 1547108632526,"thread" : "main","level" : "WARN","loggerName" : "com.ctrip.framework.apollo.internals.DefaultMetaServerProvider","message" : "Could not find meta server address, because it is not available in neither (1) JVM system property 'apollo.meta', (2) OS env variable 'APOLLO_META' (3) property 'apollo.meta' from server.properties nor (4) property 'apollo.meta' fro "endOfBatch" : false,"loggerFqcn" : "org.apache.logging.slf4j.Log4jLogger","threadId" : 1,"threadPriority" : 5}但是这个⽇志是格式化后的json,有同事提出需求，想让⼀个json对象输出为⼀⾏，这样⽇志读取的时候，可以以⼀个对象为单位读取，⽽不是⼀⾏。

Log4j2中的同步日志与异步日志

Log4j2中的同步⽇志与异步⽇志1.背景Log4j 2中记录⽇志的⽅式有同步⽇志和异步⽇志两种⽅式，其中异步⽇志⼜可分为使⽤AsyncAppender和使⽤AsyncLogger两种⽅式。

2.Log4j2中的同步⽇志所谓同步⽇志，即当输出⽇志时，必须等待⽇志输出语句执⾏完毕后，才能执⾏后⾯的业务逻辑语句。

下⾯通过⼀个例⼦来了解Log4j2中的同步⽇志，并借此来探究整个⽇志输出过程。

log4j2.xml配置如下：<?xml version="1.0" encoding="UTF-8"?><Configuration status="debug" name="MyApp" packages=""><ThresholdFilter level="ALL"/><Appenders><Console name="Console" target="SYSTEM_OUT"><PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/></Console><RollingFile name="RollingFile" fileName="logs/app.log"filePattern="logs/app-%d{yyyy-MM-dd HH}.log"><ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/><PatternLayout><Pattern>%d %p %c{1.} [%t] %m%n</Pattern></PatternLayout><Policies><SizeBasedTriggeringPolicy size="500MB"/></Policies></RollingFile></Appenders><Loggers><Logger name="com.meituan.Main" level="trace" additivity="false"><ThresholdFilter level="debug"/><appender-ref ref="RollingFile"/></Logger><Root level="debug"><AppenderRef ref="Console"/></Root></Loggers></Configuration>java代码如下：import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;public class Main {public static void main(String args[]) {Logger logger = LogManager.getLogger(Main.class);Person person = new Person("Li", "lei");("hello, {}", person);}private static class Person {private String firstName;private String lastName;public Person(String firstName, String lastName) {this.firstName = firstName;stName = lastName;}public String toString() {return "Person[" + firstName + "," + lastName + "]";}}}使⽤以上的配置，当我们运⾏程序后，以下log将被添加到logs/app.log中。

MAVEN项目使用log4j配置日志输出

MAVEN项⽬使⽤log4j配置⽇志输出当前环境：SPRINGMVC+mybatis+SPRING.在项⽬中pom.xml加⼊log4j包的依赖，更新MAEVN12<properties>3<slf4j.version>1.7.7</slf4j.version>4<log4j.version>1.2.17</log4j.version>5</properties>678<dependency>9<groupId>log4j</groupId>10<artifactId>log4j</artifactId>11<version>${log4j.version}</version>12</dependency>13<dependency>14<groupId>org.slf4j</groupId>15<artifactId>slf4j-api</artifactId>16<version>${slf4j.version}</version>17</dependency>18<dependency>19<groupId>org.slf4j</groupId>20<artifactId>slf4j-log4j12</artifactId>21<version>${slf4j.version}</version>22</dependency>写log4j配置⽂件---logback.properties---1 #定义输出级别2 log4j.rootLogger=DEBUG,Console,File3 #⽇志输出⽅式：控制台输出45 log4j.appender.Console=org.apache.log4j.ConsoleAppender6 log4j.appender.Console.Target=System.out7 log4j.appender.Console.Encoding=GBK89 #可以灵活地指定布局模式10 yout=org.apache.log4j.PatternLayout11 #yout.ConversionPattern = %d{yyyy-MM-dd HH:mm:ss.SSS} -%p (%F\:%L)- %m%n12 #打印格式栗⼦：2017-08-11 15:36 -DEBUG (HttpServletBean.java:174)- Servlet 'mvc' configured successfully13 yout.ConversionPattern = %d{yyyy-MM-dd HH:mm} -%p (%F\:%L)- %m%n1415 ### 打印SQL ###16 #.ibatis=DEBUG17 #mon.jdbc.SimpleDataSource=DEBUG18 #mon.jdbc.ScriptRunner=DEBUG19 #.ibatis.sqlmap.engine.impl.SqlMapClientDelegate=DEBUG20 log4j.logger.java.sql.Connection=DEBUG21 log4j.logger.java.sql.Statement=DEBUG22 log4j.logger.java.sql.PreparedStatement=DEBUG23 #log4j.logger.java.sql.ResultSet=DEBUG最后⼀步，在项⽬/WEB-INF下的web.xml⽂件中加⼊监听配置，顺序需注意，listener必须放在后⾯12<context-param>3<param-name>log4jConfigLocation</param-name>4<param-value>classpath:logback.properties</param-value>5</context-param>67<listener>8<listener-class>9 org.springframework.web.util.Log4jConfigListener10</listener-class>11</listener>。

使用Log4j如何实现分级输出

log4j日志分级输出到不同文件的配置基础：log4j的配置项说明：log4j总共有6中级别，从高到低分别为：OFF、FATAL、ERROR、WARN、INFO、DEBUG、ALL或者您定义的级别。

Log4j建议只使用四个级别，优先级从高到低分别是ERROR、WARN、INFO、DEBUG。

其中：DEBUG Level 指出细粒度信息事件对调试应用程序是非常有帮助的。

INFO level表明消息在粗粒度级别上突出强调应用程序的运行过程。

WARN level表明会出现潜在错误的情形。

ERROR level指出虽然发生错误事件，但仍然不影响系统的继续运行。

FATAL level指出每个严重的错误事件将会导致应用程序的退出。

ALL Level是最低等级的，用于打开所有日志记录。

OFF Level是最高等级的，用于关闭所有日志记录。

# log4j.rootLogger中配置的ERROR，表示一下配置的所有配置的级别的起点为：ERROR。

即只能显示、存储ERROR以及ERROR以上级别的日志# 若在此配置了ERROR,下边配置了INFO级别的日志要存储在指定的文件中，实际是不会存储的# 若配置INFO级别的日志存在文件1中，ERROR级别的文件，存在文件2中，# 若有个ERROR的日志的话，两个文件都是可以存储的；若有个INFO 级别的文件的话，则只有文件1会存储该日志，文件2是不会存储的日志的输出格式配置：# %m 输出代码中指定的消息#%p 输出优先级，即DEBUG，INFO，WARN，ERROR，FATAL #%r 输出自应用启动到输出该log信息耗费的毫秒数#%c 输出所属的类目，通常就是所在类的全名#%t 输出产生该日志事件的线程名#%n 输出一个回车换行符，Windows平台为“\r\n”，Unix平台为“\n”#%d 输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyy MMM dd HH:mm:ss , SSS}，输出类似：2002年10月18日22 ：10 ：28 ，921#%l 输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数。

Log4j每天生成日志文件和按文件大小生成日志文件

一、按照‎一定时间产‎生日志文件‎,配置文件‎如下：‎# Set‎root‎logg‎e r le‎v el t‎o ERR‎O R an‎d its‎only‎appe‎n der ‎t o A1‎.lo‎g4j.r‎o otLo‎g ger=‎E RROR‎,R‎# R i‎s set‎to b‎e a D‎a ilyR‎o llin‎g File‎A ppen‎d er. ‎log4‎j.app‎e nder‎.R=or‎g.apa‎c he.l‎o g4j.‎D aily‎R olli‎n gFil‎e Appe‎n der ‎log‎4j.ap‎p ende‎r.R.F‎i le=b‎a ckup‎.log ‎log4‎j.app‎e nder‎.R.Da‎t ePat‎t ern ‎= '.'‎y yyy-‎M M-dd‎log‎4j.ap‎p ende‎r.R.l‎a yout‎=org.‎a pach‎e.log‎4j.Pa‎t tern‎L ayou‎tlo‎g4j.a‎p pend‎e r.R.‎l ayou‎t.Con‎v ersi‎o nPat‎t ern=‎%-d{y‎y yy-M‎M-dd ‎H H:mm‎:ss} ‎[%c]-‎[%p] ‎%m%n ‎以上配‎置是每天产‎生一个备份‎文件。

其中‎备份文件的‎名字叫ba‎c kup.‎l og。

‎具体的效‎果是这样：‎当天的日志‎信息记录在‎b acku‎p.log‎文件中，前‎一天的记录‎在名称为‎b acku‎p.log‎.yyyy‎-mm-d‎d的文件‎中。

类‎似的，如果‎需要每月产‎生一个文件‎可以修改上‎面的配置：‎将‎l og4j‎.appe‎n der.‎R.Dat‎e Patt‎e rn =‎'.'y‎y yy-M‎M-dd ‎改为‎l og4j‎.appe‎n der.‎R.Dat‎e Patt‎e rn =‎'.'y‎y yy-M‎M二‎、根据日志‎文件大小自‎动产生新日‎志文件‎配置文件内‎容如下：‎# S‎e t ro‎o t lo‎g ger ‎l evel‎to E‎R ROR ‎a nd i‎t s on‎l y ap‎p ende‎r to ‎A1.‎l og4j‎.root‎L ogge‎r=ERR‎O R,R ‎# R‎is s‎e t to‎be a‎Roll‎i ngFi‎l eApp‎e nder‎.lo‎g4j.a‎p pend‎e r.R=‎o rg.a‎p ache‎.log4‎j.Rol‎l ingF‎i leAp‎p ende‎rl‎o g4j.‎a ppen‎d er.R‎.File‎=back‎u p.lo‎g#l‎o g4j.‎a ppen‎d er.R‎.MaxF‎i leSi‎z e=10‎0KB‎# Ke‎e p on‎e bac‎k up f‎i le‎l og4j‎.appe‎n der.‎R.Max‎B acku‎p Inde‎x=1‎l og4j‎.appe‎n der.‎y‎o ut=o‎r g.ap‎a che.‎l og4j‎.Patt‎e rnLa‎y out ‎log4‎j.app‎e nder‎‎y out.‎C onve‎r sion‎P atte‎r n=%-‎d{yyy‎y-MM-‎d d HH‎:mm:s‎s} [%‎c]-[%‎p] %m‎%n‎其中：‎#日志文‎件的大小‎log4‎j.app‎e nder‎.R.Ma‎x File‎S ize=‎100KB‎# 保‎存一个备份‎文件l‎o g4j.‎a ppen‎d er.R‎.MaxB‎a ckup‎I ndex‎=1 ‎。

Logger用法

Apache Log4j配置说明1.Log4j简介Log4j是Apache的一个开源项目，它允许开发者以任意间隔输出日志信息。

Log4j 主要由三大类组件构成：1）Logger-负责输出日志信息，并能够对日志信息进行分类筛选，即决定哪些日志信息应该被输出，哪些该被忽略。

Loggers组件输出日志信息时分为5个级别：DEBUG、INFO、WARN、ERROR、FATAL。

这五个级别的顺序是：DEBUG<INFO<WARN<ERROR<FATAL。

如果设置某个Logger组件的级别是P，则只有级别比P高的日志信息才能输出。

Logger是有继承关系的，最上层是rootLogger，定义的其他Logger都会继承rootLogger。

2）Appender-定义了日志输出目的地，指定日志信息应该被输出到什么地方。

输出的目的地可以是控制台、文件或网络设备。

3）Layout-通过在Appender的后面附加Layout来实现格式化输出。

一个Logger可以有多个Appender，每个Appender对应一个Layout。

2.LoggersLogger的定义格式：log4j.[l oggername]=[level],appenderName,appenderName,…这里level是指Logger的优先级，appenderName是日志信息的输出地，可以同时定义多个输出地。

3.AppendersAppender的定义格式：log4j.appender.appenderName = .of.appender.class// ".of.appender.class" 可以指定下面五个目的地中的一个：Appender类及其作用列表org.apache.log4j.ConsoleAppenderorg.apache.log4j.FileAppenderorg.apache.log4j.DailyRollingFileAppender每天产生一个日志文件org.apache.log4j.RollingFileAppender文件大小到达指定尺寸时产生一个新的文件org.apache.log4j. WriterAppender将日志信息以流格式发送到任意指定的地方1）ConsoleAppender选项-Threshold=WARN:指定日志消息的输出最低层次。

log4j pattern 表达式

log4j pattern 表达式log4j pattern是一种用于日志输出格式化的表达式，它可以帮助开发人员更好地理解和分析日志信息。

在实际的开发中，我们经常需要使用log4j来记录应用程序的运行状态，以便于后期的排查和分析。

通过合理的使用log4j pattern，我们可以将日志信息的关键部分进行提取和展示，从而更好地理解应用程序的行为。

在使用log4j pattern时，我们需要注意以下几点，以确保输出的日志信息符合我们的需求：1. 不要输出http地址在应用程序中，我们可能会调用外部的http接口，这时候日志中可能会包含http请求的URL地址。

然而，在输出日志时，为了保护用户的隐私和敏感信息，我们应该避免将http地址直接输出到日志中。

可以通过使用log4j pattern中的一些特定的格式化符号，如%replace来替换或隐藏URL地址的敏感部分，以确保日志信息的安全性。

2. 不要输出公式在应用程序中，我们可能会进行一些数学计算或运算，这时候日志中可能会包含一些公式或计算式。

然而，在输出日志时，我们应该避免直接将这些公式或计算式输出到日志中，以免造成误解或歧义。

可以通过使用log4j pattern中的一些特定的格式化符号，如%msg来输出计算结果或相关的描述信息，以便于理解和分析。

3. 内容不能重复在日志输出中，我们应该尽量避免重复输出相同的信息。

重复的日志信息会浪费存储空间和读取时间，并且会给后期的日志分析带来困扰。

可以通过使用log4j pattern中的一些特定的格式化符号，如%notEmpty来判断日志信息是否为空，从而避免重复输出相同的信息。

4. 整体格式规范整洁在使用log4j pattern时，我们应该保持整体格式的规范整洁，以便于阅读和理解。

可以通过合理的使用缩进、换行和空格等排版方式，使日志信息的层次结构清晰可见。

同时，可以使用恰当的段落和标题，使文章结构清晰，易于阅读。

日志记录规范标准

平常我的系统开发运行过程中，记录关键信息对于完善和修改提出了明确的建议。

但是在现实的一些应用中的日志记录比拟混乱，导致无法准确快速的定位问题发生的地方和问题发生的时候以与问题发生的场景。

我就依据我平时使用log4j进展日志记录的一点心得与大家分享如何更加规的记录日志信息，如果有不妥的问题请明示我好进展相应的改良，共同进步哈。

1.要记录什么类型日志我们的系统开发常常会涉与到系统致命错误日志，系统可控错误日志，用户操作日志和系统运行日志这四大类日志的记录。

记录致命性错误用于记录会影响整个系统正常运行的错误，比方我们在开发过程中的try...catch...模块中抛出的一些未能预料到的系统错误，而且这种错误会导致系统运行失败的信息进展记录。

系统可控错误日志，这一类的日志发生之后其实不会导致系统运行出现异常的，可能是对某些数据的初始化深入验证出现的问题。

用户操作日志这一类日志量比拟大，同时这一类日志用于跟踪用户的行为分析是非常的重要的应为可以作为用户数据挖掘发现用户的喜好等一些信息。

程序运行信息记录，这一类信息用于记录子过程运行情况。

2.致命错误如何记录如上所述我们明确的错误日志，是用来记录系统费预测性错误，可能导致爆出黄页相应的操作流程无法进展下去。

或那么在一些安装程序中记录导致系统突然退出的相关信息。

在防御式编程中经常使用try....catch...模块包括一个程序的运行过程，catch的最后捕获的一级Exception是我们无法控制也无法预测的系统运行异常，这里我们记录fatal致命性错误，我这里一般记录的是一场发生的堆栈信息。

如下程序块：[html]view plaincopyprint?1.try {2.VerificationUser(user);3.String result= OrderTicket(user,flight);4.orderticket.trace("执行占座成功！占座成功的代码："+result);(user.getName()+"执行了占座操作，占座编码为"+result);6.String ticketNo= GenariteTicket(result);7.genariteTicket.trace("执行出票成功！出票成功票号："+ticketNo);(user.getName()+"执行了生成票功能：票号："+ticketNo);10.catch (Exception e) {11.// fatal12.genariteTicket.fatal(e.getStackTrace());13.throw e;14.}完成这样的日志记录，当程序再次发生异常之后就可以快速定位致命性错误发生的位置和相应的异常信息。

关于log4j2的异步日志输出方式

关于log4j2的异步⽇志输出⽅式⽬录log4j2的异步⽇志输出⽅式第⼀种实现异步⽅式AsyncAppender第⼆种实现异步⽅式AsyncLoggerlog4j2异步注意事项log4j2异步类型⼩提⽰log4j2的异步⽇志输出⽅式使⽤log4j2的同步⽇志进⾏⽇志输出，⽇志输出语句与程序的业务逻辑语句将在同⼀个线程运⾏。

⽽使⽤异步⽇志进⾏输出时，⽇志输出语句与业务逻辑语句并不是在同⼀个线程中运⾏，⽽是有专门的线程⽤于进⾏⽇志输出操作，处理业务逻辑的主线程不⽤等待即可执⾏后续业务逻辑。

Log4j2中的异步⽇志实现⽅式有AsyncAppender和AsyncLogger两种。

其中：AsyncAppender采⽤了ArrayBlockingQueue来保存需要异步输出的⽇志事件；AsyncLogger则使⽤了Disruptor框架来实现⾼吞吐。

第⼀种实现异步⽅式AsyncAppenderAsyncAppender直接在log4j2的xml的配置⽂件中配置，注意下⾯代码的注释位置<?xml version="1.0" encoding="UTF-8"?><Configuration status="warn"><Appenders><RollingFile name="RollingFileError" fileName="${Log_Home}/error.${date:yyyy-MM-dd}.log" immediateFlush="true"filePattern="${Log_Home}/$${date:yyyy-MM}/error-%d{MM-dd-yyyy}-%i.log.gz"><PatternLayout pattern="%d{yyyy-MM-dd 'at' HH:mm:ss z} %-5level %logger{36} : %msg%xEx%n"/><ThresholdFilter level="error" onMatch="ACCEPT" onMismatch="DENY"/><Policies><TimeBasedTriggeringPolicy modulate="true" interval="1"/><SizeBasedTriggeringPolicy size="10MB"/></Policies></RollingFile><Async name="Async"><AppenderRef ref="MyFile"/></Async></Appenders><Loggers><Root level="error"><AppenderRef ref="Async"/></Root></Loggers></Configuration>重点内容全在上⾯代码的注释中，AsyncAppender的配置就在xml⽂件中实现，⽆需单独引⽤包来⽀持.配置AsyncAppender 后，⽇志事件写⼊⽂件的操作将在单独的线程中执⾏。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

Log4j 使用参考规范目录简介 (3)1. 概述 (3)2. 库主件 (3)3. 主要组件 (3)配置 (4)1. 相关配置文件 (4)2. 详细配置说明 (5)3. 输出方式 (5)4. 输出格式 (6)调用 (7)注意问题 (7)参考文档 (8)1. 概述程序开发环境中的日志记录是由嵌入在程序中以输出一些对开发人员有用信息的语句所组成。

例如，跟踪语句（trace），结构转储和常见的System.out.println或printf调试语句。

log4j 提供分级方法在程序中嵌入日志记录语句。

日志信息具有多种输出格式和多个输出级别。

使用一个专门的日志记录包，可以减轻对成千上万的System.out.println 语句的维护成本，因为日志记录可以通过配置脚本在运行时得以控制。

log4j 维护嵌入在程序代码中的日志记录语句。

通过规范日志记录的处理过程，一些人认为应该鼓励更多的使用日志记录并且获得更高程度的效率。

五级输出，依次为DEBUG、INFO、WARN、ERROR、FATAL。

使用者可根据不同的需求，设定不同的输出级别，则得到不同级别的输出结果。

（在正式生产环境中，一般设定为 warn）2. 库主件目前log4j 2.0 版本需要JAVA5（logging services designed for Java 5 and later）；1.3 版不被推荐使用，我们使用的最多的是1.2版。

目前可download 的是1.2.17 版。

下载地址：/dyn/closer.cgi/logging/log4j/库文件一般为名为log4j.jar, 使用时加入lib路径下。

3. 主要组件Log4j有三个主要组件：loggers、appenders和layouts。

这三个组件协同工作，使开发人员能够根据消息类型和级别来记录消息，并且在程序运行期控制消息的输出格式位置。

Logger：记录器；Logger 负责处理日志记录的大部分操作。

Appender：挂载点；Appender 负责控制日志记录操作的输出。

Layout：布局；Layout 负责格式化Appender 的输出。

1. 相关配置文件Log4j 的配置文件可以使用XML 文件和property 文件。

这里我们主要使用log4j.properties 配置文件，其比较直观，便于修改和维护。

下面是一个log4j 配置文件的例子：log4j.rootLogger=warn, logfile, errorLogger, consolelog4j.appender.console=org.apache.log4j.ConsoleAppenderyout=org.apache.log4j.PatternLayoutyout.ConversionPattern=[%d{yyyy-MM-dd HH:mm:ss}].apache=warn.yaic.app=warnlog4j.appender.logfile=org.apache.log4j.DailyRollingFileAppenderlog4j.appender.logfile.File=/app/domains/Appdomain.logs/dysub_log.logyout=org.apache.log4j.PatternLayoutyout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%-3p] %t %C %L: %m%nlog4j.appender.errorLogger=org.apache.log4j.DailyRollingFileAppenderlog4j.appender.errorLogger.File=/app/domains/Appdomain.logs/dysub_error.logyout=org.apache.log4j.PatternLayoutyout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%-3p] %t %C %L: %m%nlog4j.appender.errorLogger.Threshold=errorlog4j.logger.yafaLogger=trace, yafaLogger, consolelog4j.appender.yafaLogger=org.apache.log4j.DailyRollingFileAppenderlog4j.appender.yafaLogger.File=/app/domains/Appdomain.logs/dysub_yafa.logyout=org.apache.log4j.PatternLayoutyout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%-3p] %t %C %L: %m%nlog4j.additivity.yafaLogger = falselog4j.logger.auditLogger=trace, auditLogger, consolelog4j.appender.auditLogger=org.apache.log4j.DailyRollingFileAppenderlog4j.appender.auditLogger.File=/app/domains/Appdomain.logs/dysub_audit.logyout=org.apache.log4j.PatternLayoutyout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss}[%-3p] %t %C %L: %m%nlog4j.additivity.auditLogger = falselog4j.logger.quartzJobLogger=trace, quartzJobLoggerlog4j.appender.quartzJobLogger=org.apache.log4j.DailyRollingFileAppenderlog4j.appender.quartzJobLogger.file=/app/domains/Appdomain.logs/quartzjob.logyout=org.apache.log4j.PatternLayoutyout.conversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%-3p] %t %C %L: %m%nlog4j.additivity.quartzJobLogger = false.ibatis=warnlog4j.logger.java.sql.Connection=warnlog4j.logger.java.sql.Statement=warnlog4j.logger.java.sql.PreparedStatement=warn2. 详细配置说明使用者可设置五级输出，DEBUG、INFO、WARN、ERROR、FATAL，且有级别关系DEBUG<INFO<WARN<ERROR<FATAL, 只输出比设定级别高的log信息。

例如：如果设置级别为DEBUG，则输出所有五级信息；如设置级别为WARN，则只输出WARN，ERROR，FATAL三级信息，DEBUG 和INFO 不输出。

例如：log4j.rootLogger=warn, logfile, errorLogger, console设置apache的输出级别为warn，logfile, errorLogger, console为输出方式log4j.appender.logfile=org.apache.log4j.DailyRollingFileAppenderlog4j.appender.logfile.File=/app/domains/Appdomain.logs/dysub_log.logyout=org.apache.log4j.PatternLayoutyout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%-3p] %t %C %L: %m%n第一行，设置每天产生一个日志文件第二行，设置输出路径为/app/domains/Appdomain.logs/第三行，设置输出的格式为自定义格式（PatternLayout）输出第四行，设置输出格式的模式3. 输出方式Log4j 允许日志请求被输出到多个输出源。

用Log4j 的话说，一个输出源被称做一个Appender。

Appender 包括console（控制台）、files（文件）、GUI components（图形的组件）、remote socket servers（socket 服务）、JMS（java 信息服务）、NT Event Loggers（NT的事件日志）和remote UNIX Syslog daemons（远程UNIX 的后台日志服务）。

它也可以做到异步记录。

一个logger 可以设置超过一个的appender。

设置格式为：log4j.appender.stdout= DailyRollingFileAppender*输出方式：org.apache.log4j.ConsoleAppender（控制台）org.apache.log4j.FileAppender（文件）org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件）org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件）org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）ConversionPattern参数说明%p 输出优先级，即DEBUG，INFO，WARN，ERROR，FATAL%r 输出自应用启动到输出该log信息耗费的毫秒数%c 输出所属的类目，通常就是所在类的全名%t 输出产生该日志事件的线程名%n 输出一个回车换行符，Windows 平台为"\r\n"，Unix 平台为"\n"%d 输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，%l 输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数。

举%L 输出日志事件在代码中的位置，即行号4. 输出格式MDC内部使用了类似map的机制来存储信息，相对应的方法，MDC.put(key, value);在配置PatternLayout的时候使用：%x{key}来输出对应的value例如：String remoteAddr = request.getRemoteAddr();MDC.put("ip", remoteAddr);在log4j.properties文件中作如下的配置即可yout.ConversionPattern=-d{yyyy/MM/dd HH:mm:ss,SSS} [%X{ip}]-[%p]-[%c] %m%n如果在项目中有过滤器，你可以把获取ip 的方法直接定义在过滤器中，然后在配置文件中配置获取ip的显示就可以了根据以上ConversionPattern参数说明，我们规范定义的输出为%d{yyyy-MM-dd HH:mm:ss,SSS} [%X{ip}] -[%p]-[%c] (%L): %m%n输出结果：2016-10-12 {18:15:51,593] [10.1.100.100]{DEBUG} com.test.LookNode (66):This is a debug message...调用在程序中调用比较简单，在将log4j.jar 包引入后，即可使用了。