0Pricing
Java Academy · Lección

Fachada y loggers de SLF4J

Registre mensajes en el nivel adecuado

Fachada y loggers de SLF4J es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.

¿Qué es SLF4J?

SLF4J (Simple Logging Facade for Java) es una abstracción. Usted programa contra su API y un backend como Logback o Log4j2 se encarga del registro real.

Esto permite que las bibliotecas registren mensajes sin imponer una implementación específica a la aplicación.

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

public class Main {
    private static final Logger log = LoggerFactory.getLogger(Main.class);
    public static void main(String[] args) {
        log.info("Application started");
    }
}

Obtener un logger

Cree un logger por clase con LoggerFactory.getLogger(MyClass.class).

Por convención, el campo es private static final y se denomina log o logger. La clase se convierte en el nombre del logger, que aparece en la salida.

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

public class OrderService {
    private static final Logger log = LoggerFactory.getLogger(OrderService.class);
    void placeOrder(String id) {
        log.info("Placing order {}", id);
    }
}

Los cinco niveles

Los loggers de SLF4J exponen un método para cada nivel:

  • log.trace(...)
  • log.debug(...)
  • log.info(...)
  • log.warn(...)
  • log.error(...)
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Main {
    private static final Logger log = LoggerFactory.getLogger(Main.class);
    public static void main(String[] args) {
        log.trace("entering main");
        log.debug("args length = {}", args.length);
        log.info("service is up");
        log.warn("cache miss");
        log.error("failed to connect");
    }
}

Elegir el nivel adecuado

Directrices:

  • ERROR: un fallo real que una persona debe revisar.
  • WARN: una anomalía recuperable.
  • INFO: eventos importantes del ciclo de vida.
  • DEBUG: información de diagnóstico para desarrolladores, desactivada en producción.
  • TRACE: trazado extremadamente detallado.
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class PaymentService {
    private static final Logger log = LoggerFactory.getLogger(PaymentService.class);
    void charge(int cents) {
        if (cents <= 0) { log.warn("non-positive charge: {}", cents); return; }
        log.info("charged {} cents", cents);
    }
}

Nombres y jerarquía de los loggers

Los nombres de los loggers son jerárquicos según los paquetes separados por puntos. Un logger denominado com.example.svc es hijo de com.example.

La configuración de un padre se aplica a sus hijos salvo que se sobrescriba, por lo que puede establecer niveles por paquete.

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

public class Main {
    public static void main(String[] args) {
        Logger a = LoggerFactory.getLogger("com.example.app");
        Logger b = LoggerFactory.getLogger("com.example.app.db");
        a.info("parent logger");
        b.debug("child inherits parent's level unless overridden");
    }
}

Proteger las llamadas costosas

Para construir mensajes costosos, utilice isDebugEnabled() como protección, de modo que el trabajo solo se ejecute cuando el nivel esté activo.

Con el registro parametrizado (en la próxima lección), rara vez necesitará hacerlo, pero es esencial cuando construye cadenas manualmente.

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

public class Main {
    private static final Logger log = LoggerFactory.getLogger(Main.class);
    static String heavyDump() { return "...large state..."; }
    public static void main(String[] args) {
        if (log.isDebugEnabled()) {
            log.debug("state: {}", heavyDump());
        }
    }
}

Registrar excepciones

Para registrar una excepción con todo su stack trace, pase el Throwable como último argumento.

No incluya la excepción en un marcador de posición; pásela después del mensaje.

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

public class Main {
    private static final Logger log = LoggerFactory.getLogger(Main.class);
    public static void main(String[] args) {
        try {
            throw new IllegalStateException("boom");
        } catch (Exception e) {
            log.error("Operation failed for id {}", 42, e);
        }
    }
}

Un logger por clase

Declare el logger una sola vez como campo static final. Nunca cree un logger dentro de un método: desperdicia trabajo y pierde la ventaja de usar el nombre de la clase.

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

public class UserRepository {
    // Good: one shared logger named after the class
    private static final Logger log = LoggerFactory.getLogger(UserRepository.class);
    void save(String user) { log.debug("saving {}", user); }
}

SLF4J frente al backend

SLF4J es solo la API. En tiempo de ejecución se vincula al backend que esté disponible en el classpath.

  • Añada logback-classic: SLF4J utiliza Logback.
  • Añada log4j-slf4j2-impl: SLF4J utiliza Log4j2.

Su código nunca cambia.

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

public class Main {
    private static final Logger log = LoggerFactory.getLogger(Main.class);
    public static void main(String[] args) {
        // Same code, different backend depending on classpath
        log.info("backend-agnostic logging");
    }
}

Evitar registrar datos confidenciales

Nunca registre contraseñas, tokens ni números completos de tarjetas de crédito. Los logs suelen enviarse a muchos sistemas y conservarse durante mucho tiempo.

Enmascare u omita los campos confidenciales antes de registrarlos.

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

public class Main {
    private static final Logger log = LoggerFactory.getLogger(Main.class);
    static String mask(String card) { return "****" + card.substring(card.length() - 4); }
    public static void main(String[] args) {
        log.info("charged card {}", mask("4111111111111234"));
    }
}

Un servicio realista

Reuniendo todos los conceptos: un servicio pequeño que registra mensajes en los niveles adecuados y contempla una ruta de excepción.

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

public class EmailService {
    private static final Logger log = LoggerFactory.getLogger(EmailService.class);
    void send(String to) {
        log.debug("preparing email to {}", to);
        try {
            if (to == null) throw new IllegalArgumentException("null recipient");
            log.info("email sent to {}", to);
        } catch (Exception e) {
            log.error("failed to send email", e);
        }
    }
}

Comprobación rápida

Compruebe sus conocimientos básicos de SLF4J.

Repaso

Ha aprendido a utilizar la fachada SLF4J:

  • Obtenga un private static final Logger por clase.
  • Utilice adecuadamente los métodos de los cinco niveles.
  • Los nombres de los loggers son jerárquicos para controlar cada paquete.
  • Pase un Throwable en último lugar para registrar los stack traces; nunca registre secretos.

A continuación, los mensajes parametrizados eficientes.

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

public class Main {
    private static final Logger log = LoggerFactory.getLogger(Main.class);
    public static void main(String[] args) {
        log.info("SLF4J facade recap complete");
    }
}

Preguntas frecuentes

¿La lección «Fachada y loggers de SLF4J» es gratis?

Sí — el texto completo de «Fachada y loggers de SLF4J» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Fachada y loggers de SLF4J»?

Registre mensajes en el nivel adecuado Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Fachada y loggers de SLF4J»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Por qué usar logging estructurado
  2. Fachada y loggers de SLF4J
  3. Logging parametrizado
  4. Configuración de Logback
← Volver a Java Academy