Java Academy · Aula

Fachada SLF4J e loggers

Registre no nível adequado.

Fachada SLF4J e loggers é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

O que é SLF4J?

SLF4J (fachada simples de registro para Java) é uma abstração. Você programa usando a API dela, e uma implementação de suporte, como Logback ou Log4j2, realiza o registro de fato.

Assim, as bibliotecas podem registrar informações sem impor uma implementação específica à aplicação.

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");
    }
}

Obtendo um registrador

Crie um registrador por classe com LoggerFactory.getLogger(MyClass.class).

Por convenção, o campo é private static final e recebe o nome log ou logger. A classe se torna o nome do registrador, que aparece na saída.

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);
    }
}

Os cinco níveis

Os registradores SLF4J oferecem um método para cada nível:

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");
    }
}

Escolhendo o nível adequado

Orientações:

ERROR: uma falha real que precisa ser analisada por uma pessoa.
WARN: uma anomalia da qual é possível se recuperar.
INFO: eventos importantes do ciclo de vida.
DEBUG: diagnósticos para desenvolvedores, desativados em produção.
TRACE: rastreamento extremamente detalhado.

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);
    }
}

Nomes e hierarquia dos registradores

Os nomes dos registradores são hierárquicos, de acordo com os pacotes separados por pontos. Um registrador chamado com.example.svc é filho de com.example.

A configuração de um pai se aplica aos filhos, a menos que seja substituída. Assim, você pode definir níveis por pacote.

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");
    }
}

Protegendo chamadas dispendiosas

Para a construção de mensagens dispendiosas, use isDebugEnabled() como proteção, de modo que o trabalho seja executado somente quando o nível estiver ativo.

Com o registro parametrizado (na próxima lição), raramente você precisará fazer isso, mas essa proteção é essencial ao construir as strings 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());
        }
    }
}

Registrando exceções

Para registrar uma exceção com todo o rastreamento da pilha, passe o Throwable como o último argumento.

Não coloque a exceção em um marcador de posição; passe-a depois da mensagem.

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);
        }
    }
}

Um registrador por classe

Declare o registrador uma única vez como um campo estático final. Nunca crie um registrador dentro de um método, pois isso desperdiça trabalho e elimina a vantagem de usar o nome da classe.

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 e a implementação de suporte

SLF4J é apenas a API. Em tempo de execução, ele se vincula à implementação de suporte que estiver no caminho de classes.

Adicione logback-classic: o SLF4J usará o Logback.
Adicione log4j-slf4j2-impl: o SLF4J usará o Log4j2.

Seu código nunca muda.

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");
    }
}

Evite registrar dados confidenciais

Nunca registre senhas, tokens ou números completos de cartões de crédito. Os registros costumam ser enviados para muitos sistemas e mantidos por muito tempo.

Masque ou omita os campos confidenciais antes de registrá-los.

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"));
    }
}

Um serviço realista

Juntando tudo: um pequeno serviço que registra informações nos níveis adequados e possui um caminho para exceções.

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);
        }
    }
}

Verificação rápida

Verifique seus conhecimentos básicos sobre SLF4J.

Recapitulação

Você aprendeu sobre a fachada SLF4J:

Obtenha um private static final Logger por classe.
Use adequadamente os métodos dos cinco níveis.
Os nomes dos registradores são hierárquicos, permitindo o controle por pacote.
Passe um Throwable por último para registrar rastreamentos da pilha; nunca registre segredos.

A seguir, mensagens parametrizadas 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");
    }
}

Perguntas Frequentes

A aula “Fachada SLF4J e loggers” é grátis?

Sim — o texto completo de “Fachada SLF4J e loggers” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Fachada SLF4J e loggers”?

Registre no nível adequado. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Fachada SLF4J e loggers”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Java Academy