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

This article shows you what the 15 good suggestions for printing Java logs are, concise and easy to understand, which will definitely brighten your eyes. I hope you can get something through the detailed introduction of this article.

1. Select the appropriate log level

There are five common log levels, which are error, warn, info, debug, and trace. In daily development, we need to choose the appropriate log level, not to print info with backhand.

Error: error log, which refers to serious errors that affect normal business and require operation and maintenance to configure and monitor

Warn: warning logs, general errors, have little impact on the business, but require developer attention

Info: information log, recording key information for troubleshooting problems, such as call time, input parameters, etc.

Debug: runtime data in critical logic for developing DEBUG

Trace: the most detailed information, which is usually only recorded in the log file.

two。 The log should print out the input and output parameters of the method

We don't need to print a lot of logs, we just need to print valid logs that can quickly locate the problem. An effective log is a sharp weapon to throw away the pot!

What are the effective and critical logs? For example, when the method comes in, print the input parameters. And then, when the method returns, it prints out the parameters and returns the value. If you enter the parameter, it is usually the key information such as userId or bizSeq. The positive examples are as follows:

Public String testLogMethod (Document doc, Mode mode) {log.debug ("method enter param: {}", userId); String id = "666"; log.debug ("method exit param: {}", id); return id;} 3. Select the appropriate log format

An ideal log format should include the most basic information, such as the current timestamp (general millisecond accuracy), log level, thread name, and so on. You can configure it in the logback log as follows:

% d {HH:mm:ss.SSS}%-5level [% thread] [% logger {0}]% m% n

If our log format is not even recorded at the current time, then we don't even know the time of the request?

4. Encounter if...else... When waiting for conditions, try to print the log on the first line of each branch.

When you run into if...else... Or under the condition of switch, you can print the log on the first line of the branch, so that when troubleshooting the problem, you can use the log to determine which branch you entered, and the code logic is clearer and more convenient for troubleshooting.

Positive example:

If (user.isVip ()) {log.info ("the user is a member, Id: {}, start processing member logic", user,getUserId ()); / / member logic} else {log.info ("this user is a non-member, Id: {}, start processing non-member logic", user,getUserId ()) / / non-member logic} 5. When the log level is low, determine the log switch.

For the relatively low log level of trace/debug, the log level switch must be determined.

Positive example:

User user = new User (666L, "website", "); if (log.isDebugEnabled ()) {log.debug (" userId is: {} ", user.getId ());}

Because the following log code is currently available:

Logger.debug ("Processing trade with id:" + id + "and symbol:" + symbol)

If the configured log level is warn, the above logs will not be printed, but string concatenation will be performed, and if symbol is an object, the toString () method will be executed, which wastes system resources and performs the above operations, but the log will not be printed. Therefore, it is recommended to add a log switch to judge.

6. Instead of using API in the logging system (Log4j, Logback), you can use API in the logging framework SLF4J.

SLF4J is the log framework of facade mode, which helps to maintain and unify the log processing of each class, and it is very convenient to change the underlying log framework without modifying the code.

Positive example:

Import org.slf4j.Logger; import org.slf4j.LoggerFactory;private static final Logger logger = LoggerFactory.getLogger (TianLuoBoy.class); 7. It is recommended that you use parameter placeholder {} instead of + splicing.

Counterexample:

Logger.info ("Processing trade with id:" + id + "and symbol:" + symbol)

In the above example, the use of the + operator for string concatenation has some performance loss.

The positive examples are as follows:

Logger.info ("Processing trade with id: {} and symbol: {}", id, symbol)

We use curly braces {} as placeholders in the log, which is more elegant and concise than using the + operator. And, compared to the counterexample, using placeholders is just a replacement action, which can effectively improve performance.

8. It is recommended to output logs asynchronously.

Logs will eventually be output to files or other output streams, and IO performance will be required. If asynchronous, IO performance can be significantly improved.

Unless there are special requirements, it is recommended to output logs asynchronously. Take logback as an example. To configure asynchrony, it is easy to use AsyncAppender.

9. Do not use e.printStackTrace ()

Counterexample:

Try {/ / Business Code processing} catch (Exception e) {e.printStackTrace ();}

Positive example:

Try {/ / Business Code processing} catch (Exception e) {log.error ("your program has an exception", e);}

Reason:

The stack log printed by e.printStackTrace () is interlaced with the business code log, and it is usually not convenient to troubleshoot the exception log.

The string generated by the e.printStackTrace () statement records stack information. If the information is too long and too much, and the memory block where the string constant pool is located has no space, that is, the memory is full, then the user's request is stuck.

10. Do not type only half of the exception log, but output all error messages.

Counterexample 1:

Try {/ / Business Code handles} catch (Exception e) {/ / error LOG.error ('your program has an exception');}

The exception e is not printed out, so I have no idea what type of exception has occurred.

Counterexample 2:

Try {/ / Business Code handles} catch (Exception e) {/ / error LOG.error ('your program has an exception', e.getMessage ());}

E.getMessage () does not record detailed stack exception information, but only records the basic description of the error, which is not conducive to troubleshooting.

Positive example:

Try {/ / Business Code handles} catch (Exception e) {/ / error LOG.error ('your program has an exception', e);} 11. Disable enabling debug in online environment

It is important to disable debug in online environments.

Because there are a lot of debug logs in general systems, and debug logs are widely used in various frameworks, enabling debug online may soon fill up the disk and affect the normal operation of the business system.

twelve。 Don't record the exception and throw it again

The counterexamples are as follows:

Log.error ("IO exception", e); throw new MyException (e)

If this is done, the stack information is usually printed twice. This is because where the MyException exception is caught, it will be printed again.

Such log records, or package and then throw out, do not use at the same time! Otherwise, your journal will look confusing.

13. Avoid repeatedly printing logs

Avoid repeatedly printing logs, as it will waste disk space. If you already have a line of logs that clearly express your meaning, avoid redundant printing. The counterexample is as follows:

If (user.isVip ()) {log.info ("the user is a member, Id: {}", user,getUserId ()); / / redundant, you can merge log.info with the previous log ("start processing member logic, id: {}", user,getUserId ()); / / member logic} else {/ / non-member logic}

If you are using the log4j log framework, be sure to set additivity=false in log4j.xml because you can avoid repeatedly printing logs

Positive example:

14. Log file separation

We can separate different types of logs, such as access.log, or error-level error.log, and print them into a single file.

Of course, it can also be printed to different log files according to different business modules, so that it will be more convenient for us to troubleshoot problems and do data statistics.

15. Core function module, it is recommended to print a more complete log

In our daily development, if the core or logic is complex code, it is recommended to add detailed comments, as well as a more detailed log.

How detailed is the log? Brainstorm, if your core program which step is wrong, through the log can be located, that is fine.

The above are the 15 good suggestions for printing Java logs. Have you learned any knowledge or skills? If you want to learn more skills or enrich your knowledge reserve, you are welcome to follow the industry information channel.

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.