log4j教程_Log4j教程

最新推荐文章于 2024-02-28 19:48:47 发布

cunchi4221

最新推荐文章于 2024-02-28 19:48:47 发布

阅读量199

点赞数

文章标签： java spring linux maven tomcat

原文链接：https://www.journaldev.com/10689/log4j-tutorial

版权

log4j教程

Welcome to log4j tutorial. Log4j is most used logging framework in java applications. In this log4j tutorial, we will go through log4j basics, it’s configuration and then see it in action in java standalone application and then in java web application.

欢迎使用log4j教程。 Log4j是Java应用程序中最常用的日志记录框架。在本log4j教程中 ，我们将介绍log4j的基础知识，它的配置，然后在Java独立应用程序中然后在Java Web应用程序中查看它的实际作用。

Log4j教程 (Log4j Tutorial)

Before we start with log4j examples, first step is to get log4j jars. There are many ways to download log4j jars.

在开始使用log4j示例之前，第一步是获取log4j jar。有多种下载log4j jar的方法。

My favourite is to get all the dependencies through Maven. You can add below dependencies in your pom.xml file to get log4j jar.
```
<dependency>
	<groupId>log4j</groupId>
	<artifactId>log4j</artifactId>
	<version>1.2.17</version>
</dependency>
```
我最喜欢的是通过Maven获取所有依赖项。您可以在pom.xml文件中添加以下依赖项以获取log4j jar。
If you are using gradle, then add dependency as: 'log4j:log4j:1.2.17'
如果使用gradle ，则将依赖项添加为： 'log4j:log4j:1.2.17'
If you are not using any build tools, you can download the log4j jar from Apache Log4j Official page and include into your project classpath.
如果不使用任何构建工具，则可以从Apache Log4j Official页面下载log4j jar，并将其包含在项目类路径中。

Log4j配置 (Log4j Configuration)

Log4j supports both properties based as well as XML based configuration. Here I will use XML based configuration, you can see log4j properties based configuration in the linked post.

Log4j支持基于属性和基于XML的配置。在这里，我将使用基于XML的配置，您可以在链接的文章中看到基于log4j属性的配置。

log4j.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<log4j:configuration xmlns:log4j="https://jakarta.apache.org/log4j/"
	debug="false">

	<!-- console appender -->
	<appender name="console" class="org.apache.log4j.ConsoleAppender">
		<param name="Target" value="System.out" />
		<layout class="org.apache.log4j.PatternLayout">
			<param name="ConversionPattern" value="%-5p %c{1} - %m%n" />
		</layout>
	</appender>
	
	<!-- rolling file appender -->
	<appender name="file" class="org.apache.log4j.RollingFileAppender">
		<param name="File" value="logs/main.log" />
		<param name="Append" value="true" />
		<param name="ImmediateFlush" value="true" />
		<param name="MaxFileSize" value="10MB" />
		<param name="MaxBackupIndex" value="5" />

		<layout class="org.apache.log4j.PatternLayout">
			<param name="ConversionPattern" value="%d %d{Z} [%t] %-5p (%F:%L) - %m%n" />
		</layout>
	</appender>


	<logger name="com.journaldev.log4j" additivity="false">
		<level value="DEBUG" />
		<appender-ref ref="file" />
		<appender-ref ref="console" />
	</logger>

	<logger name="com.journaldev.log4j.logic" additivity="false">
		<level value="INFO" />
		<appender-ref ref="file" />
	</logger>

	<root>
		<priority value="DEBUG" />
		<appender-ref ref="file" />
		<appender-ref ref="console" />
	</root>

</log4j:configuration>

The most important part of log4j configuration files are:

log4j配置文件的最重要部分是：

Appenders: Here we define the logging strategy, such as which type of appender class to use, for example org.apache.log4j.ConsoleAppender or org.apache.log4j.RollingFileAppender. org.apache.log4j.PatternLayout is used to define the logging pattern. %d %d{Z} [%t] %-5p (%F:%L) - %m%n will append time, thread, logging level, class name with line number. We can define any number of appenders in our log4j configuration file.
Appenders ：这里我们定义了日志记录策略，例如使用哪种类型的appender类，例如org.apache.log4j.ConsoleAppender或org.apache.log4j.RollingFileAppender 。 org.apache.log4j.PatternLayout用于定义日志记录模式。 %d %d{Z} [%t] %-5p (%F:%L) - %m%n将附加时间，线程，日志记录级别，带有行号的类名。我们可以在log4j配置文件中定义任意数量的附加程序。
logger: It’s used to provide mapping between java packages/classes with appenders and logging levels. As you can see, multiple appenders can be used with a single logger. If multiple logger matches with the java class package, more specific one is used.
logger ：用于提供带有附加程序的Java包/类和日志记录级别之间的映射。如您所见，单个记录器可以使用多个追加程序。如果多个记录器与java类包匹配，则使用更具体的记录器。
root: This is used when there is no logger defined for java packages. For example, if have some classes in com.journaldev.beans package then it won’t match with any logger. So root logger will be used for logging configurations.
root ：当没有为Java包定义记录器时使用。例如，如果com.journaldev.beans包中有一些类，则它将与任何记录器都不匹配。因此，根记录器将用于记录配置。

Once log4j configuration file is ready, we have to configure it in the code before we can actually start logging. Below is the way to do that.

准备好log4j配置文件后，我们必须在代码中对其进行配置，然后才能真正开始记录日志。下面是这样做的方法。

//for XML based configuration
DOMConfigurator.configure("log4j.xml");
//for properties based configuration
PropertyConfigurator.configure("log4j.properties");

Note that if our log4j configuration file name is log4j.xml or log4j.properties, then we can skip this step because log4j tries to automatically load these files from classpath.

请注意，如果我们的log4j配置文件名为log4j.xml或log4j.properties ，则可以跳过此步骤，因为log4j会尝试自动从类路径中加载这些文件。

Java Log4j用法 (Java Log4j usage)

Now let’s see how they can be used in the code. We have created two classes for our above defined loggers.

现在让我们看看如何在代码中使用它们。我们为上面定义的记录器创建了两个类。

package com.journaldev.log4j.main;

import org.apache.log4j.Logger;
import org.apache.log4j.xml.DOMConfigurator;

import com.journaldev.log4j.logic.MathUtils;

public class Log4jExample {

	static{
		init();
	}
	
	private final static Logger logger = Logger.getLogger(Log4jExample.class);
	
	public static void main(String[] args) {

		logger.debug("My Debug Log");
		logger.info("My Info Log");
		logger.warn("My Warn Log");
		logger.error("My error log");
		logger.fatal("My fatal log");
		
		MathUtils.add(4,5);
		MathUtils.add(40,50);
		MathUtils.add(1,5);
		
	}

	/**
	 * method to init log4j configurations
	 */
	private static void init() {
		DOMConfigurator.configure("log4j.xml");
	}

}

We can create a final Logger instance once and then reuse it across the class. Notice that I am configuring log4j in init() method that is called at the time of class loading in static block.

我们可以一次创建一个最终的Logger实例，然后在整个类中重用它。注意，我正在init()方法中配置log4j，该方法在类加载到static block中时被调用。

package com.journaldev.log4j.logic;

import org.apache.log4j.Logger;

public class MathUtils {

	private static final Logger logger = Logger.getLogger(MathUtils.class);
	
	public static int add(int x, int y){
		logger.debug("inputs are:"+x+", "+y);
		return x+y;
	}
}

Now when we run above main method, we will get below logs in main.log file.

现在，当我们在main方法之上运行时，我们将在main.log文件中获得以下日志。

2016-05-12 21:22:44,610 +0530 [main] DEBUG (Log4jExample.java:18) - My Debug Log
2016-05-12 21:22:44,611 +0530 [main] INFO  (Log4jExample.java:19) - My Info Log
2016-05-12 21:22:44,611 +0530 [main] WARN  (Log4jExample.java:20) - My Warn Log
2016-05-12 21:22:44,612 +0530 [main] ERROR (Log4jExample.java:21) - My error log
2016-05-12 21:22:44,612 +0530 [main] FATAL (Log4jExample.java:22) - My fatal log

You will also see logs printing into console.

您还将看到日志打印到控制台中。

DEBUG Log4jExample - My Debug Log
INFO  Log4jExample - My Info Log
WARN  Log4jExample - My Warn Log
ERROR Log4jExample - My error log
FATAL Log4jExample - My fatal log

Notice that there are no logs getting printed from MathUtils class, it’s because it’s logger level is INFO that is higher than DEBUG. Just change it’s logging level to DEBUG like below.

注意，MathUtils类没有打印任何日志，这是因为它的记录器级别是INFO，高于DEBUG。只需将其日志记录级别更改为DEBUG，如下所示。

<logger name="com.journaldev.log4j.logic" additivity="false">
	<level value="DEBUG" />
	<appender-ref ref="file" />
</logger>

Now when you will run the program again, main.log file will have below logs too.

现在，当您再次运行该程序时，main.log文件也将具有以下日志。

2016-05-12 21:23:56,151 +0530 [main] DEBUG (MathUtils.java:10) - inputs are:4, 5
2016-05-12 21:23:56,151 +0530 [main] DEBUG (MathUtils.java:10) - inputs are:40, 50
2016-05-12 21:23:56,153 +0530 [main] DEBUG (MathUtils.java:10) - inputs are:1, 5

That’s it for using log4j in java standalone application. Below image shows the final project structure in eclipse.

在Java独立应用程序中使用log4j就是这样。下图显示了Eclipse中的最终项目结构。

You can download this project from below link.

您可以从下面的链接下载该项目。

Download Log4j Tutorial Project 下载Log4j教程项目

Log4j Java Web应用程序 (Log4j Java Web Application)

Now let’s see how to use log4j in java web application. Create a “Dynamic Web Project” and then convert it to Maven. Below image shows the final structure of the project.

现在，让我们看看如何在Java Web应用程序中使用log4j。创建一个“动态Web项目”，然后将其转换为Maven。下图显示了该项目的最终结构。

Below is the log4j configuration file.

下面是log4j配置文件。

my-log4j.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<log4j:configuration xmlns:log4j="https://jakarta.apache.org/log4j/"
	debug="false">

	<!-- console appender -->
	<appender name="console" class="org.apache.log4j.ConsoleAppender">
		<param name="Target" value="System.out" />
		<layout class="org.apache.log4j.PatternLayout">
			<param name="ConversionPattern" value="%-5p %c{1} - %m%n" />
		</layout>
	</appender>
	
	<!-- rolling file appender -->
	<appender name="file" class="org.apache.log4j.RollingFileAppender">
		<param name="File" value="${catalina.home}/logs/main.log" />
		<param name="Append" value="true" />
		<param name="ImmediateFlush" value="true" />
		<param name="MaxFileSize" value="10MB" />
		<param name="MaxBackupIndex" value="5" />

		<layout class="org.apache.log4j.PatternLayout">
			<param name="ConversionPattern" value="%d %d{Z} [%t] %-5p (%F:%L) - %m%n" />
		</layout>
	</appender>


	<logger name="com.journaldev.log4j" additivity="false">
		<level value="DEBUG" />
		<appender-ref ref="file" />
		<appender-ref ref="console" />
	</logger>

	<root>
		<priority value="DEBUG" />
		<appender-ref ref="file" />
		<appender-ref ref="console" />
	</root>

</log4j:configuration>

More of less it’s similar to earlier configuration, except that we are injecting catalina.home variable to generate log files into tomcat logs directory.

它与早期配置的相似之处更多，不同之处在于，我们将catalina.home变量注入到tomcat logs目录中生成日志文件。

Since we have to configure log4j before it’s being used, we can load it by defining a ServletContextListener as below.

由于必须在使用log4j之前对其进行配置，因此可以通过定义如下的ServletContextListener来加载它。

package com.journaldev.log4j.servlet;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;

import org.apache.log4j.xml.DOMConfigurator;

@WebListener
public final class Log4jInitListener implements ServletContextListener {

    public Log4jInitListener() {
    }

    public void contextDestroyed(ServletContextEvent paramServletContextEvent)  { 
    }

    public void contextInitialized(ServletContextEvent servletContext)  { 
    	String webAppPath = servletContext.getServletContext().getRealPath("/");
	String log4jFilePath = webAppPath + "WEB-INF/classes/my-log4j.xml";
    	DOMConfigurator.configure(log4jFilePath);
    	System.out.println("initialized log4j configuration from file:"+log4jFilePath);
    }
	
}

Notice the use of ServletContext to get the full path of log4j configuration file. This is something additional we have to do because we don’t know the full path of the log4j file at runtime and we don’t want to hardcode it either.

注意，使用ServletContext来获取log4j配置文件的完整路径。这是我们必须做的其他事情，因为我们在运行时不知道log4j文件的完整路径，也不想对其进行硬编码。

Below is a simple Servlet class using Logger to log some messages.

下面是一个简单的Servlet类，它使用Logger记录一些消息。

package com.journaldev.log4j.servlet;

import java.io.IOException;
import java.io.PrintWriter;

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;

@WebServlet("/MyServlet")
public class MyServlet extends HttpServlet {
	
	private static final long serialVersionUID = 1L;
	
	private static final Logger logger = Logger.getLogger(MyServlet.class);
	
    public MyServlet() {
    }

	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		String name = request.getParameter("name");
		logger.info("Name parameter value = "+name);
		
		PrintWriter out = response.getWriter();
		
		out.append("Served at: ").append(request.getContextPath());
		out.append("\n\nHello "+name);
		out.flush();
	}

}

Just export the project as WAR file and then deploy into Tomcat server, below image shows when we call the servlet in browser.

只需将项目导出为WAR文件，然后部署到Tomcat服务器，下图显示了当我们在浏览器中调用servlet时的图像。

You will get below kind of logs in tomcat logs directory main.log file.

您将在tomcat日志目录main.log文件中获得以下日志类型。

pankaj:logs pankaj$ tail -f main.log 
2016-05-12 21:46:33,038 +0530 [http-nio-8080-exec-2] INFO  (MyServlet.java:29) - Name parameter value = Pankaj

Since we are also logging to console that goes to catalina.out file, you will find below logs in catalina log file.

由于我们还在登录到catalina.out文件的控制台，因此您将在catalina日志文件中找到以下日志。

pankaj:logs pankaj$ tail -f catalina.out 
INFO  MyServlet - Name parameter value = Pankaj

That’s it for a quick tutorial on log4j, you can download Log4j Web Application example project from below link.

就可以使用Log4j的快速教程了，您可以从下面的链接下载Log4j Web应用程序示例项目。

Download Log4j Servlet Example Project 下载Log4j Servlet示例项目

References:

参考文献 ：

翻译自: https://www.journaldev.com/10689/log4j-tutorial

log4j教程

cunchi4221

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
log4j教程_Log4j教程

log4j教程Welcome to log4j tutorial. Log4j is most used logging framework in java applications. In this log4j tutorial, we will go through log4j basics, it’s configuration and then see it in action in ja...
复制链接

扫一扫