Registro de Java

¡Hola! Al escribir las lecciones, enfatizo particularmente si hay un tema específico que será absolutamente esencial en el trabajo real. Entonces, ¡ESCUCHA! El tema que trataremos hoy definitivamente será útil en todos sus proyectos desde el primer día de empleo. Vamos a hablar sobre el registro de Java. Este tema no es nada complicado (incluso diría que fácil). Pero tendrás suficientes cosas obvias por las que estresarte en tu primer trabajo, así que es mejor que lo entiendas bien ahora :) Bueno, comencemos.

¿Qué es iniciar sesión en Java?

El registro es el acto de registrar datos sobre el funcionamiento de un programa. El lugar donde registramos estos datos se llama "registro". Inmediatamente surgen dos preguntas: ¿qué datos se escriben y dónde? Comencemos con el "dónde". Puede escribir datos sobre el trabajo de un programa en muchos lugares diferentes. Por ejemplo, durante sus estudios, a menudo System.out.println()para enviar datos a la consola. De hecho, esto es registro, aunque en su forma más simple. Por supuesto, esto no es muy conveniente para los usuarios o un equipo de soporte de productos: obviamente, no querrán instalar un IDE y monitorear la consola :) Hay un formato más habitual para registrar información: archivos de texto. Los humanos se sienten mucho más cómodos leyendo datos en este formato, y ciertamente es mucho más conveniente para almacenar datos. Ahora la segunda pregunta: ¿qué datos del programa deben registrarse? ¡Eso depende completamente de ti! El sistema de registro de Java es muy flexible. Puede configurarlo para registrar todo lo que hace su programa. Por un lado, esto es bueno. Pero por otro lado, imagina lo grandes que serían los logs de Facebook o Twitter si escribieran todo en ellos. Estas grandes empresas probablemente tengan la capacidad de almacenar esa cantidad de datos. Pero imagine lo difícil que sería encontrar información sobre un error crítico en 500 gigabytes de registros de texto. Eso sería peor que buscar una aguja en un pajar. En consecuencia, Java se puede configurar para registrar solo datos de error. ¡O incluso errores críticos! Dicho esto, no es del todo exacto hablar del sistema de registro nativo de Java. El hecho es que los programadores necesitaban iniciar sesión antes de agregar esta funcionalidad al lenguaje. Cuando Java introdujo su propia biblioteca de registro, todos ya usaban la biblioteca log4j. La historia de iniciar sesión en Java es realmente muy larga e informativa. En resumen, Java tiene su propia biblioteca de registro, pero casi nadie la usa :) Más tarde, cuando aparecieron varias bibliotecas de registro diferentes y comenzaron a ser utilizadas por los programadores, surgieron problemas de compatibilidad. Para evitar que la gente reinvente la rueda en una docena de bibliotecas diferentes con diferentes interfaces, se creó el marco abstracto SLF4J ("Service Logging Facade For Java"). Se llama abstracto, porque incluso si usa y llama a los métodos de las clases SLF4J, bajo el capó en realidad usan todos los marcos de registro que vinieron antes: log4j, el estándar java.util.logging y otros. Si en algún momento necesita alguna característica específica de Log4j que falta en otras bibliotecas, pero no desea vincular directamente su proyecto a esta biblioteca, simplemente use SLF4J. Y luego deja que llame a los métodos de Log4j. Si cambia de opinión y decide que ya no necesita las funciones de Log4j, solo necesita volver a configurar el "aquí , y la biblioteca Log4j aquí . Luego, descomprima el archivo y use IntelliJ IDEA para agregar los archivos JAR al classpath. Elementos del menú: Archivo -> Estructura del proyecto -> Bibliotecas Seleccione los archivos JAR necesarios y agréguelos al proyecto (los archivos que descargamos contienen muchos archivos JAR; mire las imágenes para ver los que necesita) Tenga en cuenta que esta instrucción para esos estudiantes que no saben cómo usar Maven. Si sabe cómo usar Maven, generalmente es mejor (mucho más fácil) intentar comenzar allí. Si usa Maven , agregue esta dependencia:

    	<dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j-impl</artifactId>
            <version>2.14.0</version>
    	</dependency>

¡Excelente! Descubrimos la configuración :) Veamos cómo funciona SLF4J. ¿Cómo nos aseguramos de que el trabajo del programa se grabe en alguna parte? Para hacer esto, necesitamos dos cosas: registrador y appender. Comencemos con el primero. Un registrador es un objeto que proporciona un control total del registro. Crear un registrador es muy fácil: hacemos esto usando los métodos estáticos LoggerFactory.getLogger() . El parámetro del método es la clase cuya operación se registrará. Ejecutemos nuestro código:

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

public class MyTestClass {

   public static final Logger LOGGER = LoggerFactory.getLogger(MyTestClass.class);

   public static void main(String[] args) {

       LOGGER.info("Test log entry!!!");
       LOGGER.error("An error occurred!");
   }
}

Salida de la consola:

ERROR StatusLogger No Log4j 2 configuration file found. Using default configuration (logging only errors to the console), or user programmatically provided configurations. Set system property 'log4j2.debug' to show Log4j 2 internal initialization logging. See https://logging.apache.org/log4j/2.x/manual/configuration.html for instructions on how to configure Log4j 2 15:49:08.907 [main] ERROR MyTestClass - An error occurred!

¿Qué vemos aquí? Primero, vemos un mensaje de error. Esto es el resultado del hecho de que ahora nos faltan los ajustes necesarios. En consecuencia, nuestro registrador actualmente solo puede generar mensajes de error (ERROR) y solo a la consola. El método logger.info() no funcionó. ¡Pero logger.error() lo hizo! En la consola, vemos la fecha actual, el método donde ocurrió el error ( main), la palabra "ERROR", y nuestro mensaje! ERROR es el nivel de registro. En general, si una entrada de registro está marcada con la palabra "ERROR", entonces se ha producido un error en este punto del programa. Si la entrada está marcada con la palabra "INFO", entonces el mensaje simplemente representa información actual sobre el funcionamiento normal del programa. La biblioteca SLF4J tiene muchos niveles de registro diferentes que le permiten configurar el registro de manera flexible. Todo es muy fácil de administrar: toda la lógica necesaria ya está en la clase Java Logger . Solo necesita llamar a los métodos relevantes. Si desea registrar un mensaje de rutina, llame al método logger.info() . Para un mensaje de error, use logger.error() . Para una advertencia, use logger.warn()

Ahora hablemos de appender

Un appender es el lugar donde van sus datos. En cierto modo, lo contrario de una fuente de datos, es decir, "punto B". De forma predeterminada, los datos se envían a la consola. Tenga en cuenta que en el ejemplo anterior no tuvimos que configurar nada: el texto apareció en la consola y el registrador de la biblioteca Log4j solo puede enviar mensajes de nivel de ERROR a la consola. Obviamente, es más conveniente para las personas leer y escribir registros en un archivo de texto. Para cambiar el comportamiento predeterminado del registrador, debemos configurar nuestro agregador de archivos. Para comenzar, debe crear un archivo log4j.xml directamente en la carpeta src. Ya está familiarizado con el formato XML: recientemente tuvimos una lección al respecto :) Aquí está el contenido del archivo:

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="INFO">
   <Appenders>
       <File name="MyFileAppender" fileName="C:\Users\Username\Desktop\testlog.txt" immediateFlush="false" append="false">
           <PatternLayout pattern="%d{yyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
       </File>
   </Appenders>
   <Loggers>
       <Root level="INFO">
           <AppenderRef ref="MyFileAppender"/>
       </Root>
   </Loggers>
</Configuration>

Nada particularmente especial o difícil aquí :) Pero aún así, repasemos el contenido.

<Configuration status="INFO">

Este es el llamado StatusLogger. No está relacionado con nuestro registrador y se usa en los procesos internos de Log4j. Si configura status="TRACE" en lugar de status="INFO", toda la información sobre el trabajo interno de Log4j se mostrará en la consola (StatusLogger muestra datos en la consola, incluso si nuestro agregador es un archivo). No lo necesitamos ahora, así que dejémoslo como está.

<Appenders>
   <File name="MyFileAppender" fileName="C:\Users\Evgeny\Desktop\testlog.txt" append="true">
       <PatternLayout pattern="%d{yyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
   </File>
</Appenders>

Aquí creamos nuestro appender. La etiqueta <File> indica que será un agregador de archivos. name="MyFileAppender" establece el nombre del agregador. fileName="C:\Users\Username\Desktop\testlog.txt" indica la ruta al archivo de registro donde se escribirán todos los datos. append="true" indica si los datos deben escribirse al final del archivo. En nuestro caso, esto es precisamente lo que haremos. Si establece el valor en false, el contenido anterior del archivo de registro se eliminará cada vez que se inicie el programa. <PatternLayout pattern="%d{aaaa-MM-dd HH:mm:ss.SSS} [%t] %-5nivel %logger{36} - %msg%n"/>indica la configuración de formato. Aquí podemos usar expresiones regulares para personalizar cómo se formatea el texto en nuestro registro.

<Loggers>
       <Root level="INFO">
           <AppenderRef ref="MyFileAppender"/>
       </Root>
</Loggers>

Aquí indicamos el nivel raíz. Hemos establecido el nivel "INFO", lo que significa que todos los mensajes cuyos niveles sean superiores a INFO (según la tabla que vimos arriba) no se registrarán. Nuestro programa tendrá 3 mensajes: uno INFO, uno WARN y un ERROR. Con la configuración actual, se registrarán los 3 mensajes. Si cambia el nivel raíz a ERROR, solo el último mensaje de la llamada al método LOGGER.error() terminará en el registro. Además, aquí también va una referencia al appender. Para crear dicha referencia, debe crear una etiqueta <ApprenderRef> dentro de la etiqueta <Root> y agregarle el atributo ref='your appender's name' . En caso de que lo hayas olvidado, aquí es donde establecemos el nombre del agregador: <. ¡Y aquí está nuestro código!

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

public class MyTestClass {

   public static final Logger LOGGER = LoggerFactory.getLogger(MyTestClass.class);

   public static void main(String[] args) {

       LOGGER.info("The program is starting!!!");

       try {
           LOGGER.warn("Attention! The program is trying to divide a number by another.
           System.out.println(12/0);
       } catch (ArithmeticException x) {

           LOGGER.error("Error! Division by zero!");
       }
   }
}

Por supuesto, es un poco raro (atrapar una RuntimeException es una idea cuestionable), pero es perfecto para nuestros propósitos :) Ejecutemos nuestro método main() 4 veces seguidas y miremos nuestro archivo testlog.txt. No necesita crearlo con anticipación: la biblioteca lo hará automáticamente. ¡Todo funcionó! :) Ahora tiene un registrador configurado. Puede jugar con algunos de sus programas antiguos, agregando llamadas de registro a cada método. Luego mire el registro resultante :) Considera el tema del registro en profundidad. Sería un desafío leerlo todo de una sola vez. Dicho esto, contiene mucha información útil adicional. Por ejemplo, aprenderá cómo configurar el registrador para que cree un nuevo archivo de texto si nuestro archivo testlog.txt alcanza cierto tamaño :) ¡Y eso concluye nuestra clase! Hoy te familiarizaste con un tema muy importante, y este conocimiento definitivamente te será útil en tu trabajo futuro. ¡Hasta la proxima vez! :)