September, 2022 - AsenView

Using SLF4J and Logback

September 7, 2022September 7, 2022asenview

The good friends Commons Logging and Log4j are introduced earlier. One of them is responsible for the log API, and the other is responsible for implementing the bottom layer of the log. It is very easy to develop when used together.

Some children’s shoes may also have heard of SLF4J and Logback. These two things also look like logs, what are they?

In fact, SLF4J is similar to Commons Logging and is also a log interface, while Logback is similar to Log4j and is a log implementation.

Why with Commons Logging and Log4j, SLF4J and Logback pop up again? This is because Java has a very long history of open source. Not only is OpenJDK itself open source, but almost all of the third-party libraries we use are open source. A particular feature of the rich open source ecosystem is that for the same function, several competing open source libraries can be found.

Because of dissatisfaction with the interface of Commons Logging, some people engaged in SLF4J. Because of dissatisfaction with the performance of Log4j, some people engaged in Logback.

Let’s first take a look at how SLF4J improves the Commons Logging interface. In Commons Logging, we want to print the log, sometimes we have to write:

int score = 99;
p.setScore(score);
log.info("Set score " + score + " for Person " + p.getName() + " ok.");

int score = 99;

p.setScore(score);

log.info("Set score " + score + " for Person " + p.getName() + " ok.");

Spelling strings is a very troublesome thing, so the log interface of SLF4J has been improved as follows:

int score = 99;
p.setScore(score);
logger.info("Set score {} for Person {} ok.", score, p.getName());

int score = 99;

p.setScore(score);

logger.info("Set score {} for Person {} ok.", score, p.getName());

We can guess by guessing. The log interface of SLF4J passes in a string with placeholders, and the placeholders are automatically replaced with the following variables, so it looks more natural.

How to use SLF4J? Its interface is actually almost identical to Commons Logging:

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

class Main {
    final Logger logger = LoggerFactory.getLogger(getClass());
}

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

class Main {

final Logger logger = LoggerFactory.getLogger(getClass());

}

Compare the interfaces of Commons Logging and SLF4J:

Commons Logging	SLF4J
org.apache.commons.logging.Log	org.slf4j.Logger
org.apache.commons.logging.LogFactory	org.slf4j.LoggerFactory

The difference is that Log becomes Logger, and LogFactory becomes LoggerFactory.

Using SLF4J and Logback is similar to using Commons Logging and Log4j as mentioned earlier. First download SLF4J and Logback respectively , and then put the following jar packages on the classpath:

slf4j-api-1.7.x.jar
logback-classic-1.2.x.jar
logback-core-1.2.x.jar

Then use SLF4J’s Logger and LoggerFactory. Similar to Log4j, we still need a Logback configuration file, logback.xmlput it on the classpath, and configure it as follows:

&lt;?xml version="1.0" encoding="UTF-8"?&gt;
&lt;configuration&gt;

	&lt;appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender"&gt;
		&lt;encoder&gt;
			&lt;pattern&gt;%d{HH:mm:ss.SSS} &#91;%thread] %-5level %logger{36} - %msg%n&lt;/pattern&gt;
		&lt;/encoder&gt;
	&lt;/appender&gt;

	&lt;appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender"&gt;
		&lt;encoder&gt;
			&lt;pattern&gt;%d{HH:mm:ss.SSS} &#91;%thread] %-5level %logger{36} - %msg%n&lt;/pattern&gt;
			&lt;charset&gt;utf-8&lt;/charset&gt;
		&lt;/encoder&gt;
		&lt;file&gt;log/output.log&lt;/file&gt;
		&lt;rollingPolicy class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy"&gt;
			&lt;fileNamePattern&gt;log/output.log.%i&lt;/fileNamePattern&gt;
		&lt;/rollingPolicy&gt;
		&lt;triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy"&gt;
			&lt;MaxFileSize&gt;1MB&lt;/MaxFileSize&gt;
		&lt;/triggeringPolicy&gt;
	&lt;/appender&gt;

	&lt;root level="INFO"&gt;
		&lt;appender-ref ref="CONSOLE" /&gt;
		&lt;appender-ref ref="FILE" /&gt;
	&lt;/root&gt;
&lt;/configuration&gt;

<?xml version="1.0" encoding="UTF-8"?>

<pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>

</encoder>

</appender>

<pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>

</encoder>

<file>log/output.log</file>

<fileNamePattern>log/output.log.%i</fileNamePattern>

</rollingPolicy>

</triggeringPolicy>

</appender>

<appender-ref ref="CONSOLE" />

<appender-ref ref="FILE" />

</root>

</configuration>

Run it to get output similar to the following:

13:15:25.328 &#91;main] INFO  com.itranswarp.learnjava.Main - Start process...

1 2	13:15:25.328 [main] INFO com.itranswarp.learnjava.Main - Start process...

Judging from the current trend, more and more open source projects have shifted from Commons Logging plus Log4j to SLF4J plus Logback.

practise

According to the configuration file, observe the log files written by Logback.

slf4j+logback

summary

SLF4J and Logback can replace Commons Logging and Log4j;

Always use SLF4J’s interface to write logs. Using Logback only requires configuration and no code modification.

Java NullPointerException

September 3, 2022September 3, 2022asenview

Of all the RuntimeExceptionexceptions, Java programmers are probably most familiar with NullPointerException.

NullPointerException is the null pointer exception, commonly known as NPE. This exception is usually thrown by the JVM if an object is null called, its methods are called or its fields are accessed , for example:NullPointerException

// NullPointerException
----
public class Main {
    public static void main(String&#91;] args) {
        String s = null;
        System.out.println(s.toLowerCase());
    }
}

// NullPointerException

----

public class Main {

public static void main(String[] args) {

String s = null;

System.out.println(s.toLowerCase());

}

The concept of pointers is actually derived from the C language, and there are no pointers in the Java language. The variables we define are actually references, Null Pointer is more precisely Null Reference, but the difference between the two is not much.

Handling NullPointerException

If encountered NullPointerException, how should we deal with it? First of all, it must be clear that it NullPointerExceptionis a code logic error. When encountered NullPointerException, follow the principle of early exposure and early repair. It is strictly prohibited to use catchto hide such coding errors:

// 错误示例: 捕获NullPointerException
try {
    transferMoney(from, to, amount);
} catch (NullPointerException e) {
}

// 错误示例: 捕获NullPointerException

try {

transferMoney(from, to, amount);

} catch (NullPointerException e) {

}

Good coding practices can greatly reduce NullPointerExceptionthe occurrence of, for example:

Member variables are initialized when they are defined:

public class Person {
    private String name = "";
}

public class Person {

private String name = "";

}

A lot can be avoided by using an empty string ""instead of the default , and when writing business logic, it is much safer to use an empty string for unfilled .nullNullPointerException""null

Returns an empty string "", an empty array instead of null:

public String&#91;] readLinesFromFile(String file) {
    if (getFileSize(file) == 0) {
        // 返回空数组而不是null:
        return new String&#91;0];
    }
    ...
}

public String[] readLinesFromFile(String file) {

if (getFileSize(file) == 0) {

// 返回空数组而不是null:

return new String[0];

}

...

}

This saves the caller from having to check whether the result is null.

If the caller must make nulljudgments, such as returning to nullindicate that the file does not exist, then consider returning Optional<T>:

public Optional&lt;String&gt; readFromFile(String file) {
    if (!fileExist(file)) {
        return Optional.empty();
    }
    ...
}

public Optional<String> readFromFile(String file) {

if (!fileExist(file)) {

return Optional.empty();

}

...

}

In this way, the caller must pass the Optional.isPresent()judgment whether there is a result.

Locating NullPointerException

If generated NullPointerException, for example, a.b.c.x()when called, the NullPointerExceptionreason may be:

ayes null;
a.byes null;
a.b.cyes null;

Determining exactly which object was nullpreviously only able to print logs like this:

System.out.println(a);
System.out.println(a.b);
System.out.println(a.b.c);

System.out.println(a);

System.out.println(a.b);

System.out.println(a.b.c);

Starting from Java 14, if generated NullPointerException, the JVM can give detailed information to tell us nullwho the object is. Let’s look at an example:

public class Main {
    public static void main(String&#91;] args) {
        Person p = new Person();
        System.out.println(p.address.city.toLowerCase());
    }
}

class Person {
    String&#91;] name = new String&#91;2];
    Address address = new Address();
}

class Address {
    String city;
    String street;
    String zipcode;
}

public class Main {

public static void main(String[] args) {

Person p = new Person();

System.out.println(p.address.city.toLowerCase());

}

class Person {

String[] name = new String[2];

Address address = new Address();

}

class Address {

String city;

String street;

String zipcode;

}

You can NullPointerExceptionsee similar in the details of ... because "<local1>.address.city" is null, meaning the cityfield is null, so we can quickly locate the problem.

This enhanced NullPointerExceptiondetail is new in Java 14, but is off by default, we can -XX:+ShowCodeDetailsInExceptionMessagesenable it by adding a parameter to the JVM:

java -XX:+ShowCodeDetailsInExceptionMessages Main.java

1 2	java -XX:+ShowCodeDetailsInExceptionMessages Main.java

summary

NullPointerExceptionIt is a common logic error in Java code, which should be exposed and repaired early;

NullPointerExceptionDetailed error information can be viewed by enabling Java 14’s Enhanced Exception Information.

How to use Log4j

September 3, 2022September 3, 2022asenview

Commons Logging was introduced earlier, which can be used as a “log interface”. And the real “logging implementation” can use Log4j.

Log4j is a very popular logging framework, the latest version is 2.x.

Log4j is a component-based log system, and its architecture is roughly as follows:

log.info("User signed in.");
 │
 │   ┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐
 ├──&gt;│ Appender │───&gt;│  Filter  │───&gt;│  Layout  │───&gt;│ Console  │
 │   └──────────┘    └──────────┘    └──────────┘    └──────────┘
 │
 │   ┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐
 ├──&gt;│ Appender │───&gt;│  Filter  │───&gt;│  Layout  │───&gt;│   File   │
 │   └──────────┘    └──────────┘    └──────────┘    └──────────┘
 │
 │   ┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐
 └──&gt;│ Appender │───&gt;│  Filter  │───&gt;│  Layout  │───&gt;│  Socket  │
     └──────────┘    └──────────┘    └──────────┘    └──────────┘

log.info("User signed in.");

│

│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐

├──>│ Appender │───>│ Filter │───>│ Layout │───>│ Console │

│ └──────────┘ └──────────┘ └──────────┘ └──────────┘

│

│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐

├──>│ Appender │───>│ Filter │───>│ Layout │───>│ File │

│ └──────────┘ └──────────┘ └──────────┘ └──────────┘

│

│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐

└──>│ Appender │───>│ Filter │───>│ Layout │───>│ Socket │

└──────────┘ └──────────┘ └──────────┘ └──────────┘

When we use Log4j to output a log, Log4j automatically outputs the same log to different destinations through different Appenders. E.g:

console: output to the screen;
file: output to a file;
socket: output to a remote computer through the network;
jdbc: output to database

In the process of outputting logs, Filter is used to filter which logs need to be output and which logs do not need to be output. For example, only output ERRORlevel logs.

Finally, format the log information through Layout, for example, automatically add information such as date, time, method name, etc.

Although the above structure is complex, when we actually use it, we do not need to care about the API of Log4j, but configure it through the configuration file.

Taking XML configuration as an example, when using Log4j, we can put a log4j2.xmlfile classpathdown to let Log4j read the configuration file and output the log according to our configuration. The following is an example of a configuration file:

&lt;?xml version="1.0" encoding="UTF-8"?>
&lt;Configuration>
&lt;Properties>
        &lt;!-- define log format -->
&lt;Property name="log.pattern">%d{MM-dd HH:mm:ss.SSS} &#91;%t] %-5level %logger{36}%n%msg%n%n&lt;/Property>
        &lt;!-- Define filename variable -->
&lt;Property name="file.err.filename">log/err.log&lt;/Property>
&lt;Property name="file.err.pattern">log/err.%i.log.gz&lt;/Property>
&lt;/Properties>
    &lt;!-- Define the Appender, the destination -->
&lt;Appenders>
        &lt;!-- Define output to screen -->
&lt;Console name="console" target="SYSTEM_OUT">
            &lt;!-- The log format refers to the log.pattern defined above -->
&lt;PatternLayout pattern="${log.pattern}" />
&lt;/Console>
        &lt;!-- Define the output to a file, the file name refers to the file.err.filename defined above -->
&lt;RollingFile name="err" bufferedIO="true" fileName="${file.err.filename}" filePattern="${file.err.pattern}">
&lt;PatternLayout pattern="${log.pattern}" />
&lt;Policies>
                &lt;!-- Automatically cut logs according to file size -->
&lt;SizeBasedTriggeringPolicy size="1 MB" />
&lt;/Policies>
            &lt;!-- keep the last 10 copies -->
&lt;DefaultRolloverStrategy max="10" />
&lt;/RollingFile>
&lt;/Appenders>
&lt;Loggers>
&lt;Root level="info">
            &lt;!-- For info-level logs, output to console -->
&lt;AppenderRef ref="console" level="info" />
            &lt;!-- For error-level logs, output to err, which is the RollingFile defined above -->
&lt;AppenderRef ref="err" level="error" />
&lt;/Root>
&lt;/Loggers>
&lt;/Configuration>

<?xml version="1.0" encoding="UTF-8"?>

<Property name="log.pattern">%d{MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36}%n%msg%n%n</Property>

</Properties>

</Console>

</Policies>

</RollingFile>

</Appenders>

</Root>

</Loggers>

</Configuration>

Although configuring Log4j is tedious, once configured, it is very convenient to use. For the above configuration file, all INFOlevel logs will be automatically output to the screen, and ERRORlevel logs will not only be output to the screen, but also output to the file at the same time. And, once the log file reaches the specified size (1MB), Log4j will automatically cut the new log file and keep up to 10 copies.

It is not enough to have a configuration file, because Log4j is also a third-party library, we need to download Log4j from here , after decompression, put the following 3 jar packages into classpathit:

log4j-api-2.x.jar
log4j-core-2.x.jar
log4j-jcl-2.x.jar

Because Commons Logging will automatically discover and use Log4j, put the downloaded one in the previous commons-logging-1.2.jarsection classpath.

To print the log, you only need to write it in the way of Commons Logging, without changing any code, you can get the log output of Log4j, similar to:

03-03 12:09:45.880 &#91;main] INFO  com.itranswarp.learnjava.Main
Start process...

03-03 12:09:45.880 [main] INFO com.itranswarp.learnjava.Main

Start process...

Best Practices

In the development phase, the Commons Logging interface is always used to write logs, and there is no need to introduce Log4j in the development phase. If you need to write the log to a file, you only need to put the correct configuration file and the jar package related to Log4j classpath, and you can automatically switch the log to use Log4j to write without modifying any code.

practise

According to the configuration file, observe the log file written by Log4j.

commons logging + log4j

summary

Logs are implemented through Commons Logging, and Log4j can be used without modifying the code;

To use Log4j, you only need to put log4j2.xml and related jars into the classpath;

If you want to replace Log4j, you only need to remove log4j2.xml and related jars;

Only when you extend Log4j, you need to refer to the interface of Log4j (for example, the function of encrypting logs and writing them to the database needs to be developed by yourself).