O registro é um recurso importante que deve ser considerado pelos desenvolvedores para rastrear os erros. , sendo uma das linguagens de programação mais populares, vem com uma abordagem personalizável para registro, fornecendo uma API de registro básica. Portanto, neste artigo sobre Logger em Java, irei discutir como pode usar este recurso para habilitar o registro extensível em Java.
Os seguintes tópicos serão abordados neste artigo:
Antes, nos aprofundamos no registro em java, vamos entender a necessidade do registro.
Necessidade de registro
Ao construir aplicativos, frequentemente enfrentamos erros que precisam ser depurados. Assim, com a ajuda de logs, podemos facilmente obter informações sobre o que está acontecendo no aplicativo com um registro de erros e circunstâncias incomuns. Agora, você pode pensar que por que não usar a instrução System.out.print () em . Bem, o problema com essas instruções é que as mensagens de log serão impressas apenas no console. Assim, uma vez que você feche o console, automaticamente, todos os logs serão perdidos. Portanto, os logs não serão armazenados permanentemente e serão exibidos um a um, pois é um ambiente de thread único.
Para evitar tais problemas, o login em Java é simplificado com a ajuda doAPI fornecida através dojava.util.loggingpacote, e oorg.apache.log4j. *pacote.
Componentes de registro
Os componentes de log Java ajudam o desenvolvedor a criar logs, passar os logs para o respectivo destino e manter um formato adequado. A seguir estão os três componentes:
- Madeireiros - Responsável por capturar registros de log e repassá-los ao Anexador correspondente.
- Anexadores ou manipuladores - Eles são responsáveis por registrar eventos de log em um destino. Anexadores formatam eventos com a ajuda de Layouts, antes de enviar saídas.
- Layouts ou formatadores - Responsável por determinar como os dados aparecem quando aparecem na entrada de log.
Você pode consultar a imagem abaixo para ver o funcionamento de todos os três componentes:
Quando um aplicativo faz uma chamada de registro, o componente Logger registra o evento em um LogRecord e o encaminha para o Appender apropriado. Em seguida, ele formatou o registro usando o Layout de acordo com o formato exigido. Além disso, você também pode usar mais de um Filtros para especificar quais Anexadores devem ser usados para eventos.
typecast double para int java
Agora, vamos entender o que é um logger em Java em profundidade.
O que é Logger em Java?
Loggers em Java são objetos que acionam eventos de log, são criados e chamados no código da aplicação, onde geram Eventos de Log antes de passá-los para o próximo componente que é um Appender. Você pode usar vários registradores em uma única classe para responder a vários eventos ou usar registradores em uma hierarquia. Eles são normalmente nomeados usando o namespace hierárquico separado por pontos. Além disso, todos os nomes do Logger devem ser baseados na classe ou no nome do pacote do componente registrado.
Além disso, cada Logger mantém um registro do ancestral mais próximo existente no Histórico namespace e também tem um 'Nível' associado a ele. Bem, discutirei os Loggers na última parte deste artigo, mas antes disso, deixe-me mostrar como criar um Logger em Java.
Criar novo Logger
O processo de criação de um novo Logger em Java é bastante simples. Você tem que usarLogger.getLogger ()método. ogetLogger () identifica o nome do Logger e leva string como parâmetro. Então, se um Logger já existe, esse Logger é retornado, caso contrário, um novo Logger é criado.
Sintaxe:
static Logger logger = Logger.getLogger (SampleClass.class.getName ())
Aqui, SampleClass é o nome da classe para a qual estamos obtendo o objeto Logger.
Exemplo:
public class Customer {private static final Logger LOGGER = Logger.getLogger (Customer.class) public void getCustomerDetails () {}}Agora que eu disse a você como criar um Logger em Java, vamos ver os diferentes níveis disponíveis no log.
Níveis de registro
Os níveis de log são usados para categorizar os logs por sua gravidade ou pelo impacto na estabilidade do aplicativo. oorg.apache.log4j. *pacote e ojava.util.loggingambos fornecem diferentes níveis de registro. Vamos dar uma olhada em cada um deles um por um.
org.apache.log4j. *pacote fornece os seguintes níveis em ordem decrescente:
o que é mutável em java
- FATAL
- ERRO
- ADVERTIR
- INFO
- DEPURAR
java.util.loggingpacote fornece os seguintes níveis em ordem decrescente:
- GRAVE (NÍVEL MAIS ALTO)
- ATENÇÃO
- INFO
- CONFIG
- BEM
- FINER
- FINEST (NÍVEL MAIS BAIXO)
Além disso, o pacote acima também oferece dois níveis adicionaisTODOSeFORAusado para registrar todas as mensagens e desabilitar o registro, respectivamente.
Exemplo de registro em Java usando oorg.apache.log4j. *pacote:
import org.apache.log4j.Logger public class Cliente {static Logger logger = Logger.getLogger (Customer.class) public static void main (String [] args) {logger.error ('ERROR') logger.warn ('AVISO' ) logger.fatal ('FATAL') logger.debug ('DEBUG') logger.info ('INFO') System.out.println ('Resultado final')}}Então, se sua saída forlogger root como WARN-level em nosso log4j.properties arquivo, então todas as mensagens de erro com uma prioridade mais alta do que WARN serão impressas como abaixo:
Você também pode definir o nível usando o método setLevel () dojava.util.loggingpacote como abaixo:
logger.setLevel (Level.WARNING)
Exemplo de registro em Java usando ojava.util.loggingpacote:
pacote edureka import java.io.IOException import java.util.logging.Level import java.util.logging.Logger import java.util.logging. * class EdurekaLogger {private final static Logger LOGGER = Logger.getLogger (Logger.GLOBAL_LOGGER_NAME) public void sampleLog () {LOGGER.log (Level.WARNING, 'Bem-vindo à Edureka!')}} public class Cliente {public static void main (String [] args) {EdurekaLogger obj = new EdurekaLogger () obj.sampleLog () LogManager slg = LogManager.getLogManager () Logger log = slg.getLogger (Logger.GLOBAL_LOGGER_NAME) log.log (Level.WARNING, 'Olá! Bem-vindo de Edureka')}}Para habilitar o registro em seu aplicativo usando oorg.apache.log4j. *pacote ou ojava.util.loggingpacote, você deve configurar o arquivo de propriedades. A seguir neste artigo sobre Logger em Java, vamos discutir o arquivo de propriedades de ambos.
Arquivo de propriedades do Log4j e pacote Java Util
Arquivo de propriedades Log4j de amostra:
# Habilite a opção do logger Root log4j.rootLogger = INFO, file, stdout # Anexar appenders para imprimir o arquivo log4j.appender.file = org.apache.log4j.RollingFileAppender log4j.appender.file.File = E: loglogging.log log4j.appender. file.MaxFileSize = 10 MB log4j.appender.file.MaxBackupIndex = 5 log4j.appender.file.layout = org.apache.log4j.PatternLayout log4j.appender.file.layout.ConversionPattern =% d {aaaa-MM-dd HH: : ss}% -5p% c {1}:% L -% m% n # Anexar appenders para imprimir no console log4j.appender.stdout = org.apache.log4j.ConsoleAppender log4j.appender.stdout.Target = System.out log4j.appender.stdout.layout = org.apache.log4j.PatternLayout log4j.appender.stdout.layout.ConversionPattern =% d {aaaa-MM-dd HH: mm: ss}% -5p% c {1}:% L -% m% n- O arquivo de propriedades Log4j é criado dentro da pasta src do projeto.
- log4j.appender.file = org.apache.log4j.RollingFileAppender -> Imprime todos os registros em um arquivo
- log4j.appender.stdout = org.apache.log4j.ConsoleAppender -> Imprime todos os registros no console
- log4j.appender.file.File = D: loglogging.log -> Especifica a localização do arquivo de log
- log4j.appender.file.MaxFileSize = 10 MB -> Tamanho máximo do arquivo de log para 10 MB
- log4j.appender.file.MaxBackupIndex = 5 -> Limita o número de arquivos de backup a 5
- log4j.appender.file.layout = org.apache.log4j.PatternLayout -> Especifica o padrão em que os logs serão impressos no arquivo de log.
- log4j.appender.file.layout.ConversionPattern =% d {aaaa-MM-dd HH: mm: ss}% -5p% c {1}:% L -% m% n -> Define o padrão de conversão padrão.
Amostra Arquivo de propriedades do pacote Java Util
handlers = java.util.logging.ConsoleHandler .level = AVISO # A saída será armazenada no diretório padrão java.util.logging.FileHandler.pattern =% h / java% u.log java.util.logging.FileHandler.limit = 60000 java.util.logging.FileHandler.count = 1 java.util.logging.FileHandler.formatter = java.util.logging.XMLFormatter # O nível de logs será limitado a AVISO e acima. java.util.logging.ConsoleHandler.level = AVISO java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter
Aqui,
- java.util.logging.FileHandler.pattern =% h / java% u.log -> Os arquivos de log seriam gravados emC: TEMPjava1.log
- java.util.logging.FileHandler.limit = 50000 ->A quantidade máxima que o logger grava em qualquer arquivo em bytes.
- java.util.logging.FileHandler.count = 1 -> Especifica o número de arquivos de saída
- java.util.logging.FileHandler.formatter = java.util.logging.XMLFormatter -> Menciona o formatador usado para formatação. Aqui é usado o formatador XML.
- java.util.logging.ConsoleHandler.level = AVISO -> Define o nível de registro padrão para AVISO
- java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter ->Especifica oFormatadorpara ser usado por todosConsoleHandler'S. Aqui, SimpleFormatter é usado.
Eventos de registro
Para registrar eventos em , você deve ter certeza de atribuir um nível para arquivar facilmente os eventos. Para atribuir um nível e mencionar uma mensagem, você pode usar os métodos abaixo:
Método 1:
logger.log (Level.INFO, “Exibir mensagem”)
Aqui, o nível é INFO e a mensagem a ser impressa é 'Exibir mensagem'.
Método 2:
logger.info (“Exibir mensagem”)
Para certificar-se de que o Logger em Java registra apenas eventos que estão no nível INFO ou acima, você pode usar o setLevel () método discutido acima.
Agora que discuti como usar o Logger em Java, vamos discutir o próximo componente da arquitetura Log4j, ou seja, Anexos.
Appender ou Handlers
Appender ou Handlers são responsáveis por registrar eventos de log em um destino. Cada logger tem acesso a vários manipuladores e recebe a mensagem de log do logger. Em seguida, os Anexadores usam Formatadores ou Layouts para formatar os eventos e enviá-los ao destino correspondente.
Um Appender pode ser desligado usando o método setLevel (Level.OFF). Os dois manipuladores mais padrão nojava.util.loggingpacote são os seguintes:
- FileHandler: Grave a mensagem de log no arquivo
- ConsoleHandler: Grava a mensagem de registro no console
Pois, para seu melhor entendimento, expliquei alguns Anexos na seção de propriedades.
Layout ou formatadores
O layout dos Formatadores é usado para formatar e converter dados em um evento de log.As estruturas de registro fornecem layouts para HTML, XML, Syslog, JSON, texto simples e outros registros.
- SimpleFormatter : Gera mensagens de texto com informações básicas.
- XMLFormatter : Gera mensagem XML para o log
Para seu melhor entendimento, expliquei alguns Layouts na seção de propriedades.Com isso, chegamos ao final deste blog sobre “Logger em Java”. Espero que vocês tenham entendido o que foi ensinado neste artigo.
Confira o pela Edureka, uma empresa de aprendizagem online confiável com uma rede de mais de 250.000 alunos satisfeitos espalhados por todo o mundo. O curso de certificação e treinamento Java J2EE e SOA da Edureka é projetado para estudantes e profissionais que desejam ser um desenvolvedor Java. O curso foi elaborado para dar a você uma vantagem inicial na programação Java e treiná-lo para os conceitos básicos e avançados de Java, juntamente com várias estruturas Java como Hibernate e Spring.
Tem alguma questão para nós? Mencione isso na seção de comentários deste blog “Logger in Java” e entraremos em contato com você o mais breve possível.