Java incorporou uma biblioteca de API de log como parte de sua estrutura do JDK 1.4. Hoje, este é um suporte embutido do Java. No entanto, essa biblioteca é personalizável e extensível no sentido de que podemos usar uma ou mais soluções de log alternativas fornecidas por bibliotecas de terceiros. Embora essas soluções de terceiros tenham uma abordagem diferente para criar dados de log, elas compartilham o mesmo objetivo de registrar mensagens do tempo de execução do aplicativo. Este artigo explora os fundamentos do registro em log e mostra como ele pode ser usado em um programa Java.
Java Logging
Um registro geralmente significa manutenção de algum tipo de registro. Do ponto de vista da programação, é um processo de escrever mensagens em um arquivo de log durante a execução do programa. Os logs de mensagens persistentes são encaminhados, normalmente pelo programador, para coletar determinadas informações estatísticas de tempo de execução que, quando analisadas, podem revelar situações imprevistas. Na verdade, pode haver inúmeras razões distintas pelas quais o registro em log é usado e este é apenas um deles. De acordo com a documentação da API Java, existem quatro usos principais do registro:
- Para diagnóstico de problemas por usuários finais e administradores de sistema.
- É conveniente para os engenheiros de serviço de campo diagnosticarem o problema a partir de mensagens registradas e corrigi-lo rapidamente.
- A organização de desenvolvimento pode rastrear a execução interna de um subsistema específico e analisá-lo.
- Os desenvolvedores podem depurar o aplicativo em desenvolvimento obtendo uma visão rápida do problema subjacente das mensagens registradas.
O log da API Java é projetado de maneira barata no sentido de que pode ser deixado como resíduo mesmo em um aplicativo de produção. Isso não cria muita sobrecarga para a eficiência da execução do programa. A API fornece o mecanismo para alterar a produção de mensagens de log dinamicamente para que o impacto do log possa ser minimizado durante as operações que exigem eficiência máxima. A API consiste em várias classes e interfaces que podem ser personalizadas estendendo-as. Toda a API de registro está empacotada em java.util.logging . As classes e interfaces neste pacote fornecem os principais recursos de log em Java.
Níveis de registro
A urgência de fazer login em um programa Java pode ser categorizada em vários níveis. Ao nivelar para cima e para baixo, podemos aumentar ou diminuir o custo de registro em um aplicativo de produção. É assim que controlamos a eficiência da execução de uma aplicação onde é necessário registrar um ou mais de seus eventos. Isto é conseguido através de uma classe chamada Level , que define a importância do registro. O nível de log é ordenado e especificado por estático constantes inteiras, como:
- Nível.TODOS: Todas as mensagens são registradas, independentemente da importância
- Nível.DESATIVADO: O registro está desativado
- Nível.SEVERO: Indica falha grave; deve ser registrado
- Nível.AVISO: Indica mensagens de aviso
- Nível.INFO: Mensagem informativa de tempo de execução
- Nível.CONFIG: Mensagens de configuração estática
- Nível.FINO: Como rastrear mensagens
- Nível.FINER: Mensagens de rastreamento de detalhes
- Nível.FINEST: Mensagens de rastreamento altamente detalhadas
Componentes de registro
Precisamos de um Logger instância para fazer qualquer tipo de log em Java. Esta instância é responsável por registrar dados em um LogRecord . O Registro de Log instâncias são usadas para passar solicitações de log entre estruturas de log e manipuladores de log individuais. Java SE oferece cinco tipos de manipuladores integrados:StreamHandler , ConsoleHandler , FileHandler , SocketHandler e MemoryHandler . Pode-se, no entanto, criar um novo manipulador ou estender um deles como uma personalização. Os manipuladores determinam o que fazer com o registro de log; por exemplo, ele pode ser persistido em um repositório local ou passado para um servidor em uma rede. Java SE também inclui dois formatadores padrão:SimpleFormatter e XMLFormatter . Esses formatadores são usados para formatar um LogRecord em formato legível por humanos e formato XML padrão, respectivamente.
Existe um LogManager classe que acompanha as informações globais de log, como um namespace hierárquico de Loggers nomeados e um conjunto de propriedades de controle de log do arquivo de configuração. Ele é fundamental para fazer login em Java e praticamente controla o que registrar, onde registrar, incluindo outros detalhes de inicialização e assim por diante.
Um exemplo simples de registro
Criando um Logger objeto é muito simples. Aqui está um código muito simples para ilustrar isso.
import java.util.logging.Logger;
public class App {
private static Logger logger =
Logger.getLogger(App.class.getName());
public static void main(String[] args) {
logger.info("This is a log message !!!");
logger.info("The name of the logger is " +
logger.getName() + " nwhich is same as class name: "
+ App.class.getName());
}
}
Registro os objetos geralmente são nomeados usando a String valor de um namespace hierárquico separado por pontos. No caso anterior, é o mesmo que o nome da classe. O nome, no entanto, pode ser um valor String arbitrário, mas normalmente os nomes são baseados no nome do pacote ou no nome da classe do componente registrado. Também é possível criar um registrador “anônimo” que não será armazenado no Logger namespace.
Registrando em um arquivo externo usando formatação XML
No código a seguir, as mensagens de log são redirecionadas para um arquivo usando FileHandler .
| Observação: O arquivo será criado no diretório do projeto. |
O FileHandler pode gravar em um arquivo especificado ou em um conjunto rotativo de arquivos. O conjunto rotativo de arquivos significa que os arquivos mais antigos são nomeados adicionando 0,1,2 e assim por diante no nome do arquivo base. O XMLFormatter é a formatação padrão usada pelo FileHandler .
import java.io.IOException;
import java.util.logging.FileHandler;
import java.util.logging.Level;
import java.util.logging.Logger;
public class App {
private static FileHandler fileHandler;
private static Logger logger =
Logger.getLogger(App.class.getName());
public static void main(String[] args) throws
IOException {
fileHandler = new
FileHandler(App.class.getName() + ".log");
logger.setLevel(Level.ALL);
logger.addHandler(fileHandler);
logger.info("Log message redirected to a file");
logger.info("The name of the logger is " +
logger.getName() +
" nwhich is same as class name: "
+ App.class.getName());
}
}
Registrando em um arquivo externo usando formatação personalizada
Ajustaremos um pouco o código a seguir para personalizar a formatação da mensagem. Isso altera a forma como as mensagens são gravadas no arquivo externo.
| Observação: Observe o conteúdo do arquivo de log sobre como a formatação foi alterada. |
import java.io.IOException;
import java.util.logging.*;
public class App {
private static FileHandler fileHandler;
private static Logger logger =
Logger.getLogger(App.class.getName());
public static void main(String[] args) throws
IOException {
fileHandler = new
FileHandler(App.class.getName() + ".log");
logger.setLevel(Level.ALL);
fileHandler.setFormatter(newCustomFormatter());
logger.addHandler(fileHandler);
logger.fine("Log message redirected to a file");
logger.finer("The name of the logger is " +
logger.getName());
loggerfinest("This is same as class name: " +
App.class.getName());
}
private static class CustomFormatter extends Formatter {
private static final String format =
"[%1$tF %1$tT] [%2$-4s] %3$s %n";
public String format(LogRecord record) {
returnString.format(format,
record.getMillis(),
record.getLevel().getLocalizedName(),
record.getMessage());
}
}
}
Isso é tudo. Experimente o log Java e tente muitas outras possibilidades. Consulte os documentos da API Java sempre que necessário.
Outras estruturas de log em Java
Às vezes, é conveniente usar uma estrutura de log de terceiros e há algumas opções populares para você escolher. Por exemplo, a API de log fornecida pelo SLF4J usa um padrão de fachada simples é uma camada de abstração que permite que o aplicativo seja desacoplado de sua estrutura de log. Log4j é sintaticamente semelhante ao log Java integrado. Ele tem uma configuração padrão para enviar todas as mensagens de log para o console. Logback é um sucessor do Log4j e é uma extensão de seu predecessor. tinyLog é uma estrutura de registro leve que pode ser usada com Java e Android.
Conclusão
O processo de registro é projetado para ser simples e eficiente na entrega do que deve fazer. É possível começar rapidamente com APIs de Logging em Java. O design é extensível e pode ser customizado de acordo com as necessidades finais do desenvolvedor. Este artigo é um vislumbre dos fundamentos do registro em Java. Muitos detalhes intrincados são omitidos para simplificar. Estude a documentação da API Java e outros documentos apropriados para obter mais detalhes sobre isso.
Referências
- Visão geral do registro em Java
- Documentação da API Java
