Melhor registro para seu aplicativo Java corporativo – CrunchifyBetterLog4jLogging.java

Publicados: 2019-08-29
Better-logging-for-your-enterprise-java-application-log4j

Se você estiver desenvolvendo um aplicativo Java em que precisa usar a funcionalidade do registrador, há várias maneiras de aprimorar o utilitário Logger.

Para garantir que o registro possa ser deixado em um programa de produção, a API do logger Java foi projetada para tornar o registro o mais barato possível. Para permitir que o código produza logs refinados quando necessário, mas não reduza a velocidade do aplicativo em uso normal de produção, a API fornece mecanismos para alterar dinamicamente quais mensagens de log são produzidas, para que o impacto do código de log seja minimizado durante a operação normal.

Agora vamos começar a escrever o utilitário Logger simples, que melhorará a qualidade geral do registro de produção.

Atualize o Log4j para a versão mais recente

CVE-2021-44228: Apache Log4j2 <=2.14.1 Os recursos JNDI usados ​​na configuração, mensagens de log e parâmetros não protegem contra LDAP controlado por invasores e outros terminais relacionados a JNDI.

A partir do log4j 2.16.0, esse comportamento foi desabilitado por padrão.

Passo 1:

Criar arquivo CrunchifyBetterLog4jLogging.java

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
package com . crunchify . tutorial ;
import org . apache . log4j . Logger ;
 
/**
* @author Crunchify.com
*
*/
 
public class CrunchifyBetterLog4jLogging {
 
     private static final String Crunchify_FLAG_DEBUG = " ---------- " ;
     private static final String Crunchify_FLAG_WARN = " ^^^^^^^^^^ " ;
     private static final String Crunchify_FLAG_INFO = " ********** " ;
     private static final String Crunchify_FLAG_ERROR = " ########## " ;
     private static final String Crunchify_FLAG_FATAL = " $$$$$ " ;
 
     // Debug Level
     public static void debug ( Logger logger , String message ) {
         logger . debug ( Crunchify_FLAG_DEBUG + message + Crunchify_FLAG_DEBUG ) ;
     }
 
     // Warning Level
     public static void warn ( Logger logger , String message ) {
         logger . warn ( Crunchify_FLAG_WARN + message + Crunchify_FLAG_WARN ) ;
     }
 
     // Info Level
     public static void info ( Logger logger , String message ) {
         logger . info ( Crunchify_FLAG_INFO + message + Crunchify_FLAG_INFO ) ;
     }
 
     // Error Level
     public static void error ( Logger Logger , String message ) {
         Logger . error ( Crunchify_FLAG_ERROR + message + Crunchify_FLAG_ERROR ) ;
     }
 
     // Fatal Level
     public static void fatal ( Logger Logger , String message ) {
         Logger . fatal ( Crunchify_FLAG_FATAL + message + Crunchify_FLAG_FATAL ) ;
     }
}

Basicamente o que estamos fazendo é, quando em seu programa Java você diz log.info ou log.error ou log.fatal , o código adicionará automaticamente caracteres especiais como você vê acima.

Passo 2

Caso de teste (exemplo de programa Java) – CrunchifyBetterLog4jLoggingTest.java

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package com . crunchify . tutorial ;
 
import org . apache . log4j . Logger ;
public class CrunchifyBetterLog4jLoggingTest {
 
     private static Logger logger = Logger . getLogger ( CrunchifyBetterLog4jLoggingTest . class ) ;
 
     public static void main ( String [ ] args ) {
         int a = 20 ;
         int b = 30 ;
         int c = 3 ;
         int d = 4 ;
         CrunchifyBetterLog4jLoggingTest . SwapVairablesMethod1 ( a , b ) ;
         CrunchifyBetterLog4jLoggingTest . SwapVairablesMethod2 ( c , d ) ;
     }
 
     public static void SwapVairablesMethod1 ( int a , int b ) {
 
         CrunchifyBetterLog4jLogging . debug ( logger , "value of a and b before swapping, a: " + a + " b: " + b ) ;
         // swapping value of two numbers without using temp variable
         a = a + b ; // now a is 50 and b is 20
         b = a - b ; // now a is 50 but b is 20 (original value of a)
         a = a - b ; // now a is 30 and b is 20, numbers are swapped
         CrunchifyBetterLog4jLogging . warn ( logger , "Result Method1 => a: " + a + " b: " + b ) ;
     }
 
     public static void SwapVairablesMethod2 ( int c , int d ) {
 
         CrunchifyBetterLog4jLogging . info ( logger , "value of c and d before swapping, c: " + c + " d: " + d ) ;
 
         // swapping value of two numbers without using temp variable using
         // multiplication and division
         c = c * d ;
         d = c / d ;
         c = c / d ;
         CrunchifyBetterLog4jLogging . error ( logger , "Result Method2 => c: " + c + " d: " + d ) ;
     }
}

Aqui estamos imprimindo diferentes tipos de resultado de registro.

Resultado:

1
2
3
4
2014 - 06 - 21 00 : 23 : 19 , 463 DEBUG [ CrunchifyBetterLog4jLoggingTest ]    @ @ @ @ @ @ @ @ @ @ value of a and b before swapping , a : 20 b : 30 @ @ @ @ @ @ @ @ @ @
2014 - 06 - 21 00 : 23 : 19 , 464 WARN    [ CrunchifyBetterLog4jLoggingTest ]   ^^^^^^^^^^ Result Method1 = > a : 30 b : 20 ^^^^^^^^^^
2014 - 06 - 21 00 : 23 : 19 , 464 INFO    [ CrunchifyBetterLog4jLoggingTest ]   ********** value of c and d before swapping , c : 3 d : 4 **********
2014 - 06 - 21 00 : 23 : 19 , 464 ERROR [ CrunchifyBetterLog4jLoggingTest ]    ########## Result Method2 => c: 4 d: 3 ##########