Shulou(Shulou.com)06/03 Report--

This article mainly explains "what are the advantages of the high-performance logging tool Log4j2". The content of the article is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn what are the advantages of the high-performance logging tool Log4j2.

01, where is the top 2 of Log4j

1) in a multithreaded scenario, the throughput of Log4j 2 is 10 times higher than that of Logback, and the latency is reduced by several orders of magnitude. This sounds like a brag, but it was the official brag of Log4j 2 itself.

Log4j 2's asynchronous Logger uses unlocked data structures, while Logback and Log4j's asynchronous Logger uses ArrayBlockingQueue. For blocking queues, multithreaded applications often encounter lock contention when trying to queue log events.

The following figure illustrates the impact of unlocked data structures on throughput in a multithreaded scenario. Log4j 2 scales better as the number of threads expands: applications with more threads can log more. Because of lock contention in other logging libraries, the total throughput remains constant or declining as more threads are recorded. This means that with other logging libraries, each individual thread will be able to reduce logging.

Performance is the biggest highlight of Log4j 2, and some of the other advantages, such as the following, are negligible, and how short the text is represents how unimportant it is.

2) Log4j 2 can reduce the pressure on the garbage collector.

3) Lambda expressions are supported.

4) automatic reloading configuration is supported.

02, Log4j 2 use example

Don't talk too much nonsense, just go straight to work. Theoretical knowledge is useful, but it is not as good as hands-on practice, which is also a "not so good" programming habit that I have developed over the years: finding problems, solving problems, and looking for theoretical basis in practice.

The first step is to add Log4j 2 dependencies to the pom.xml file:

Org.apache.logging.log4j log4j-api 2.5 org.apache.logging.log4j log4j-core 2.5

(this artifactId is still log4j, which is not reflected in 2, but in version, it is somewhat mistaken for log4j.)

Step two, take the simplest test case:

Import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;public class Demo {private static final Logger logger = LogManager.getLogger (Demo.class); public static void main (String [] args) {logger.debug ("log4j2");}}

Run the Demo class, and you can see the following information on the console:

ERROR StatusLogger No log4j2 configuration file found. Using default configuration: logging only errors to the console.

Log4j 2 didn't print "log4j2" on the console and complained that we didn't specify a configuration file for it. At this point, I think it is not as good as Logback, after all, people will export.

This is very unfriendly for beginners, because beginners are often at a loss when they encounter such a situation. Although ERROR is reflected in the log, there is no compilation error or running error in the code, so why don't you output it?

Well, as an old programming bird, I have to tell you, it's best to find out why. How do I do that?

We can copy the keywords in the log message, such as "No log4j2 configuration file found", and then search in Intellij IDEA, and if you download the source code and documentation, you will find this sentence in the ConfigurationFactory class, not surprisingly.

You can make a breakpoint in the method, and then debug it, and you will see the content in the following figure.

From the source code, you can see that Log4j 2 will look for four types of configuration files with the suffixes properties, yaml, json and xml. The prefix is log4j2-test or log4j2.

Once you get this hint, you can move on to the third step.

* * step 3: * * add a log4j2-test.xml file to the resource directory (for easy comparison with Logback), as shown below:

The configuration file format of Log4j 2 is somewhat similar to that of Logback, with a basic structure of

Element, containing 0 or more

Element, followed by 0 or more

Element, followed by at most one

element.

1) configure appender, that is, the output destination of the configuration log.

There is Console. You can see the typical console configuration information above. Let me briefly explain the format of pattern in it:

% d {HH:mm:ss.SSS} indicates the time of output to milliseconds

T outputs the current thread name

%-5level output log level,-5 indicates left alignment and fixed output of 5 characters, if not enough to fill in the blanks on the right

% logger output logger name, up to 36 characters

% msg log text

% n line feeds

By the way, add other commonly used placeholders:

% F the class file name where the output is located, such as Demo.java

% L output line number

% M output is the name of the method

L output the number of lines on which the statement is located, including class name, method name, file name, number of lines

% p output log level

% c output package name, if followed by {length.} parameter, such as% c {1.}, it will output the first character of registration, for example, the actual registration of com.itwanger will only output c.i

Run the Demo class again, and you can see the printed log information in the console:

04.657 [main] DEBUG com.itwanger.Demo-log4j2

2) configure Loggers, specify the log level of Root, and specify which Appenders is enabled.

3) automatic reload configuration.

Logback supports automatic overload configuration, as does Log4j 2, so it's easy to enable this feature by adding a monitorInterval attribute to the Configuration element.

...

Note that the value should be set to non-zero, which means to check for changes in the configuration file after at least 30 seconds. The minimum interval is 5 seconds.

03. Async example

In addition to Console, there is also Async, which can be written asynchronously with files. Typical configuration information is as follows:

% d% p% c [% t]% m% n

Compared to Logback's configuration file, Log4j 2 is really complicated and not very easy to use, so let's put it bluntly! But I made my own appointment, and I had to finish it with tears. Add this Async to Appenders:

% d% p% c [% t]% m% n

Run the Demo class again, and you can see a debug.log file under the project root path, as shown below:

Example of 2020-10-3009 DEBUG com.itwanger.Demo [main] log4j204, RollingFile

Of course, we have both Log4j and Logback configured with RollingFile,Log4j 2. RollingFile scrolls the log files according to the Triggering (trigger) policy and Rollover (transition) policy. If Rollover is not configured, DefaultRolloverStrategy is used as the default configuration for RollingFile.

The trigger policy includes CronTriggeringPolicy; based on file size, time-based TimeBasedTriggeringPolicy, based on cron expressions (derived from Greek, meaning time, and used to configure the time format for periodically executing tasks).

The transition policy includes the default transition policy DefaultRolloverStrategy and the DirectWriteRolloverStrategy that is written directly. In general, you can use the default transition strategy, which is powerful enough.

Take a look at the first example of a configuration based on SizeBasedTriggeringPolicy and TimeBasedTriggeringPolicy policies, as well as the default DefaultRolloverStrategy policy:

% d% p% c {1.} [% t]% m% n

To verify the scrolling strategy of the file, let's adjust the Demo class to print more logs:

For (int I = 1 * * I < 20; iTunes +) {logger.debug ("Wechat search" {} ", reply keyword" {} ", surprise", "Silent King", "java");}

Run the Demo class again, and you can see that there are three more log files in the root directory:

Combined with the log file name, then look at the configuration of RollingFile, it is easy to understand.

1) fileName is used to specify the file name.

2) the mode used by filePattern to specify the file name, which depends on the transition policy.

Because the transition policy is not explicitly specified in the configuration file, RollingFile enables the default DefaultRolloverStrategy.

Let's first take a look at the properties of DefaultRolloverStrategy:

Let's take a look at the value of filePattern rolling-%d {yyyy-MM-dd} -% i.log, where% d {yyyy-MM-dd} is easy to understand, which is the day of the year; what does% I mean?

The first log file is called rolling.log (the most recent log is placed in this file), the second file name is rolling-1.log, and the second file name is rolling-2.log. Based on this information, can you guess the pattern?

In fact, it has something to do with the max attribute in DefaultRolloverStrategy. The default value currently used is 7, so delete the rolling-1.log when the rolling-8.log is to be generated. You can adjust the log output in Demo for verification.

3) SizeBasedTriggeringPolicy, based on the time policy of log file size, the size is in bytes, and the suffix can be KB,MB or GB, for example, 20 MB.

Let's take a look at an example of log file compression to see the configuration:

% d% p% c {1.} [% t]% m% n

The attribute value of fileName contains a directory gz, which means that all log files will be placed in this directory.

A suffix of gz has been added to the attribute value of filePattern, which indicates that the log file is ready to be compressed and can also be in zip format.

After running Demo, you can see the following files in the gz directory:

Thank you for reading, the above is the content of "what are the advantages of the high-performance logging tool Log4j2". After the study of this article, I believe you have a deeper understanding of the advantages of the high-performance logging tool Log4j2, and the specific use needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.