log4j2 project log component instance code

During the project operation, functional debugging and user behavior are often required. Some people are used to using it, but this is not recommended. It is only convenient to use but not easy to maintain and has no scalability. Compared with log4j, log4j can control the destination, output format and level of log information, etc., so that we can control the log generation process more carefully.

Log4j2 is an upgrade to Log4j1, with significant improvements in performance and functionality, including enhanced throughput in multithreads, support for placeholders, automatic configuration file reloading, etc.

1. Introduction

1. Download the jar package

<dependencies>
 <dependency>
 <groupId>.log4j</groupId>
 <artifactId>log4j-api</artifactId>
 <version>2.10.0</version>
 </dependency>
 <dependency>
 <groupId>.log4j</groupId>
 <artifactId>log4j-core</artifactId>
 <version>2.10.0</version>
 </dependency>
</dependencies>

2. Configuration file

Log4j contains four configuration factory implementations: JSON, YAML, properties, and XML. This article introduces the commonly used method XML.

Log4j has the ability to automatically configure itself during initialization. When Log4j starts, it will locate all names-compliant files under the classpath, in priority order: > > >

3. A simple example

xml configuration:

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

Java code:

private static final Logger logger = ();
 @Test
 public void testLog4j(){
 ("hello world!");
 }
}

Console information

22:17:47.146 [main] INFO MyApp - hello world!

2. Module introduction

<Configuration>

<Appenders>

Log4j allows log requests to be printed to multiple destinations. In the log4j language, the output destination is called Appender. Currently, appenders exist in consoles, files, remote socket servers, Apache Flume, JMS, remote UNIX Syslog daemons and various database apis. The following introduces several more commonly used appenders. If you need to know more, you can check it on the official website.

1、ConsoleAppender

Output to console, <Console>

2、FileAppender

Output to file, <File>

3、JDBCAppender

JDBCAppender uses standard JDBC to write log events into relational database tables. It can be configured to obtain a JDBC connection using a JNDI data source or a custom factory method. Regardless of the method, it must be supported by the connection pool.

Otherwise, logging performance will be greatly affected.

If the configured JDBC driver supports batch statements and configures the buffer size to a positive number, the log event will be batched.

（1）<JDBC>

(2) Use <DataSource> to obtain JDBC connection, only jndi is listed here:

(3) Use <Column> to specify which columns in the table to be written and how to write them. It has no SQL injection vulnerability.

Example:

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="error">
 <Appenders>
 <JDBC name="databaseAppender" tableName="dbo.application_log">
  <DataSource jndiName="java:/comp/env/jdbc/LoggingDataSource" />
  <Column name="eventDate" isEventTimestamp="true" />
  <Column name="level" pattern="%level" />
  <Column name="logger" pattern="%logger" />
  <Column name="message" pattern="%message" />
  <Column name="exception" pattern="%ex{full}" />
 </JDBC>
 </Appenders>
 <Loggers>
 <Root level="warn">
  <AppenderRef ref="databaseAppender"/>
 </Root>
 </Loggers>
</Configuration>

<PatternLayout>

(1) Date, %d/%date

Of course you can also customize the format, such as %d{yyyy-MM-dd HH:mm:ss}

(2) Logger, %c/%logger

{?} - When ? is a positive integer, it means taking n parts from the right, and a negative integer means removing n parts from the left. So why %c{-10} is the complete name, I don't know. Welcome to leave a message

(3) Log information, %m/%msg/%message

(4) Log level, %level

<Filter>

log4j2 comes with a variety of filters for direct use, and we can also define filters ourselves:

import .;
import .;
import .;
import .;
import .;
import .;
import .;
import .;
import .;
import .;
@Plugin(name = "MyFilter", category = "Core", elementType = "filter", printObject = true)
public final class MyFilter extends AbstractFilter {
 private final Level level;
 private MyFilter(Level level, Result onMatch, Result onMismatch) {
  super(onMatch, onMismatch);
   = level;
 }
 public Result filter(Logger logger, Level level, Marker marker, String msg, Object[] params) {
  return filter(level);
 }
 public Result filter(Logger logger, Level level, Marker marker, Object msg, Throwable t) {
  return filter(level);
 }
 public Result filter(Logger logger, Level level, Marker marker, Message msg, Throwable t) {
  return filter(level);
 }
 @Override
 public Result filter(LogEvent event) {
  return filter(());
 }
 private Result filter(Level level) {
  /*
   * Business logic
   * */
  
  return () ? onMatch : onMismatch;
 }
 @Override
 public String toString() {
  return ();
 }
 @PluginFactory
 public static MyFilter createFilter(@PluginAttribute(value = "level", defaultString = "ERROR") Level level,
            @PluginAttribute(value = "onMatch", defaultString = "NEUTRAL") Result onMatch,
            @PluginAttribute(value = "onMismatch", defaultString = "DENY") Result onMismatch) {
  return new MyFilter(level, onMatch, onMismatch);
 }
}

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="warn" monitorInterval="5" packages="your packages" verbose="false" strict="true">
 <Appenders>
 <Console name="Console" target="SYSTEM_OUT" ignoreExceptions="true">
  <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss} %level %logger{10} - %msg"/>
  <MyFilter level="info" onMatch="ACCEPT"/>
 </Console>
 </Appenders>
 <Loggers>
 <Root level="info">
  <AppenderRef ref="Console"/>
 </Root>
 </Loggers>
</Configuration>

Replenish:

In practical applications, it is sometimes necessary to record user access information, such as request parameters, user ID, etc. In log4j1, we will use MDC and NDC to store the application context information, while log4j2 uses ThreadContext to implement the functions of both MDC and NDC.

(1) NDC uses a stack-like mechanism to store context information, and threads are independent.

Use %x to output in PatternLayout, note that x is lowercase.

Example:

("hello world!");

<Column name="tip" pattern="%x" />

(2) MDC uses a map-like mechanism to store information, and threads are independent.

Use %X{userId} in PatternLayout to output, note that X is capitalized.

Example:

("userId","1");

<Column name="userId" pattern="%X{userId}" />

Note that after using it, call clearAll() to clear the context map and stack.

api：/log4j//

Official website address:/log4j//

The above example code of the log4j2 project log component is all the content I share with you. I hope you can give you a reference and I hope you can support me more.