Logger in Java – Java Logging Voorbeeld

Handleidingen

Vandaag zullen we kijken naar Logger in Java. Java Logger biedt logging in Java-programmering.

Logger in Java

Java Logging API werd geïntroduceerd in 1.4 en je kunt de java logging API gebruiken om applicatieberichten te loggen. In deze Java logging zelfstudie zullen we de basisfuncties van Java Logger leren. We zullen ook kijken naar een Java Logger-voorbeeld van verschillende logniveaus, Logging Handlers, Formatters, Filters, Log Manager en loggingconfiguraties.

Java Logger

java.util.logging.Logger is de klasse die wordt gebruikt om applicatieberichten te loggen in de java logging API. We kunnen een Java Logger maken met een zeer eenvoudige eenregelige code als;

Logger logger = Logger.getLogger(MyClass.class.getName());

Java Logging Niveaus

java.util.logging.Level definieert de verschillende niveaus van Java logging. Er zijn zeven niveaus van logging in Java.

  1. SEVERE (hoogste)
  2. WAARSCHUWING
  3. INFO
  4. CONFIG
  5. FINE
  6. FINER
  7. FINEST

Er zijn twee andere logniveaus, UIT die alle logging uitschakelt en ALLES die alle berichten logt. We kunnen het logniveau van de logger instellen met de volgende code:

logger.setLevel(Level.FINE);

De logs worden gegenereerd voor alle niveaus gelijk aan of groter dan het logniveau van de logger. Bijvoorbeeld, als het logniveau is ingesteld op INFO, worden logs gegenereerd voor INFO, WAARSCHUWING en SEVERE logberichten.

Java Logging Handlers

We kunnen meerdere handlers toevoegen aan een Java logger en telkens wanneer we een bericht loggen, zal elke handler het dienovereenkomstig verwerken. Er zijn twee standaardhandlers die worden geleverd door de Java Logging API.

  1. ConsoleHandler: Deze handler schrijft alle logberichten naar de console
  2. FileHandler: Deze handler schrijft alle logberichten naar een bestand in XML-indeling.

We kunnen ook onze eigen aangepaste handlers maken om specifieke taken uit te voeren. Om onze eigen Handler-klasse te maken, moeten we de klasse java.util.logging.Handler uitbreiden of een van de subklassen ervan zoals StreamHandler, SocketHandler enzovoort. Hier is een voorbeeld van een aangepaste Java logging handler:

package com.journaldev.log;

import java.util.logging.LogRecord;
import java.util.logging.StreamHandler;

public class MyHandler extends StreamHandler {

    @Override
    public void publish(LogRecord record) {
        //eigen logica toevoegen om te publiceren
        super.publish(record);
    }


    @Override
    public void flush() {
        super.flush();
    }


    @Override
    public void close() throws SecurityException {
        super.close();
    }

}

Java Logging Formatters

Formatters worden gebruikt om de logberichten op te maken. Er zijn twee beschikbare formatters in de Java logging API.

  1. SimpleFormatter: Deze formatter genereert tekstberichten met basisinformatie. ConsoleHandler gebruikt deze formatterklasse om logberichten naar de console af te drukken.
  2. XMLFormatter: Deze formatter genereert XML-berichten voor de logboeken; FileHandler gebruikt XMLFormatter als standaardformatter.

We kunnen onze eigen aangepaste Formatter-klasse maken door de klasse java.util.logging.Formatter uit te breiden en deze aan een van de handlers te koppelen. Hier is een voorbeeld van een eenvoudige aangepaste formatterklasse.

package com.journaldev.log;

import java.util.Date;
import java.util.logging.Formatter;
import java.util.logging.LogRecord;

public class MyFormatter extends Formatter {

    @Override
    public String format(LogRecord record) {
        return record.getThreadID()+"::"+record.getSourceClassName()+"::"
                +record.getSourceMethodName()+"::"
                +new Date(record.getMillis())+"::"
                +record.getMessage()+"\n";
    }

}

Logger in Java – Java Log Manager

java.util.logging.LogManager is de klasse die de loggingconfiguratie leest, logger-instanties maakt en onderhoudt. We kunnen deze klasse gebruiken om onze eigen toepassingsspecifieke configuratie in te stellen.

LogManager.getLogManager().readConfiguration(new FileInputStream("mylogging.properties"));

Hier is een voorbeeld van een configuratiebestand voor de Java Logging API. Als we geen configuratie opgeven, wordt deze gelezen uit het bestand lib/logging.properties in de JRE-thuismap.mylogging.properties

handlers= java.util.logging.ConsoleHandler

.level= FINE

# standaard uitvoerbestand bevindt zich in de thuismap van de gebruiker.
java.util.logging.FileHandler.pattern = %h/java%u.log
java.util.logging.FileHandler.limit = 50000
java.util.logging.FileHandler.count = 1
java.util.logging.FileHandler.formatter = java.util.logging.XMLFormatter

# Beperk de berichten die op de console worden afgedrukt tot INFO en hoger.
java.util.logging.ConsoleHandler.level = INFO
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter

com.journaldev.files = SEVERE

Hier is een eenvoudig Java-programma dat het gebruik van Logger in Java toont.

package com.journaldev.log;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.logging.ConsoleHandler;
import java.util.logging.FileHandler;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogManager;
import java.util.logging.Logger;

public class LoggingExample {

    static Logger logger = Logger.getLogger(LoggingExample.class.getName());
    
    public static void main(String[] args) {
        try {
            LogManager.getLogManager().readConfiguration(new FileInputStream("mylogging.properties"));
        } catch (SecurityException | IOException e1) {
            e1.printStackTrace();
        }
        logger.setLevel(Level.FINE);
        logger.addHandler(new ConsoleHandler());
        // toevoegen van aangepaste handler
        logger.addHandler(new MyHandler());
        try {
            // FileHandler-bestandsnaam met maximale grootte en limiet van aantal logbestanden
            Handler fileHandler = new FileHandler("/Users/pankaj/tmp/logger.log", 2000, 5);
            fileHandler.setFormatter(new MyFormatter());
            // instellen van aangepaste filter voor FileHandler
            fileHandler.setFilter(new MyFilter());
            logger.addHandler(fileHandler);
            
            for(int i=0; i<1000; i++){
                // logberichten
                logger.log(Level.INFO, "Msg"+i);
            }
            logger.log(Level.CONFIG, "Config data");
        } catch (SecurityException | IOException e) {
            e.printStackTrace();
        }
    }

}

Wanneer u het bovenstaande Java-logger-voorbeeldprogramma uitvoert, zult u merken dat het CONFIG-logboek niet in het bestand wordt afgedrukt, dit komt door de MyFilter-klasse.

package com.journaldev.log;

import java.util.logging.Filter;
import java.util.logging.Level;
import java.util.logging.LogRecord;

public class MyFilter implements Filter {

	@Override
	public boolean isLoggable(LogRecord log) {
		// log geen CONFIG-logs in het bestand
		if(log.getLevel() == Level.CONFIG) return false;
		return true;
	}

}

Ook de uitvoerindeling zal hetzelfde zijn als gedefinieerd door de MyFormatter-klasse.

1::com.journaldev.log.LoggingExample::main::Sat Dec 15 01:42:43 PST 2012::Msg977
1::com.journaldev.log.LoggingExample::main::Sat Dec 15 01:42:43 PST 2012::Msg978
1::com.journaldev.log.LoggingExample::main::Sat Dec 15 01:42:43 PST 2012::Msg979
1::com.journaldev.log.LoggingExample::main::Sat Dec 15 01:42:43 PST 2012::Msg980

Als we onze eigen Formatter-klasse niet toevoegen aan FileHandler, wordt het logbericht als volgt afgedrukt.

<record>
  <date>2012-12-14T17:03:13</date>
  <millis>1355533393319</millis>
  <sequence>996</sequence>
  <logger>com.journaldev.log.LoggingExample</logger>
  <level>INFO</level>
  <class>com.journaldev.log.LoggingExample</class>
  <method>main</method>
  <thread>1</thread>
  <message>Msg996</message>
</record>

Console-logberichten hebben het volgende formaat:

Dec 15, 2012 1:42:43 AM com.journaldev.log.LoggingExample main
INFO: Msg997
Dec 15, 2012 1:42:43 AM com.journaldev.log.LoggingExample main
INFO: Msg998
Dec 15, 2012 1:42:43 AM com.journaldev.log.LoggingExample main
INFO: Msg998

Onderstaande afbeelding toont het uiteindelijke voorbeeldproject Java Logger. Dat is alles voor Logger in Java en Java Logger Voorbeeld. U kunt het project downloaden vanaf onderstaande link.

Download voorbeeldproject Java Logger

Referentie: Java Logging API

Source:
https://www.digitalocean.com/community/tutorials/logger-in-java-logging-example