Protokollfunktionen (Logger) verwenden

Sie können die Java™-Protokollierung verwenden, um Nachrichten zu protokollieren und Traces hinzuzufügen.

Informationen zu diesem Vorgang

Java stellt ein Paket für die Protokoll- und Traceerstellung (java.util.logging) bereit, das Sie für die Instrumentierung Ihrer Anwendungen verwenden können. In diesem Artikel wird beschrieben, wie Sie das Protokollierungs- und Tracedurchführungspaket am besten verwenden.

Vorgehensweise

  1. Verwenden Sie die Stufe WsLevel.DETAIL und höher für Nachrichten und niedrigere Stufen für den Trace. Die Erweiterungs-API von WebSphere Application Server (Paket com.ibm.websphere.logging) enthält die Klasse WsLevel.
    Verwenden Sie für Nachrichten Folgendes:
    WsLevel.FATAL 
    Level.SEVERE 
    Level.WARNING 
    WsLevel.AUDIT 
    Level.INFO 
    Level.CONFIG 
    WsLevel.DETAIL
    Verwenden Sie für Traces Folgendes:
    Level.FINE 
    Level.FINER 
    Level.FINEST
  2. Verwenden Sie an Stelle der Methode "log" oder "logrb" die Methode "logp". Die Methode "logp" akzeptiert Parameter für den Klassennamen und den Methodennamen. Die Methoden "log" und "logrb" versuchen im Allgemeinen, diese Informationen abzuleiten. Aufgrund der damit verbundenen Leistungseinbußen verbietet sich jedoch die Verwendung dieser Methoden. Im Allgemeinen wirkt sich die Methode "logp" weniger auf die Leistung aus als die Methode "log" bzw. "logrb".
  3. Vermeiden Sie die Verwendung der Methode "logrb". Diese Methode führt zu einer ineffizienten Zwischenspeicherung von Ressourcenpaketen und zu Leistungseinbußen.
  4. Verwenden Sie die Methode "isLoggable", um für einen Protokollierungsaufruf das Erstellen von Daten zu vermeiden, die nicht protokolliert werden. Beispiele:
    if (logger.isLoggable(Level.FINEST)) {
     		String s = dumpComponentState();	// eine kostenintensive Berechnungsmethode
     		logger.logp(Level.FINEST, className, methodName, "componentX state dump:\n{0}", s);
     }

Lokalisierte Nachrichten

Das folgende Beispiel gilt für lokalisierte Nachrichten:
// Anmerkung: Vermeiden Sie aus Gründen der Konsistenz mit WebSphere Application Server für Nachrichten // generell die Stufen FINE, FINER, FINEST

String componentName = "com.ibm.websphere.componentX";
String resourceBundleName = "com.ibm.websphere.componentX.Messages";
Logger logger = Logger.getLogger(componentName, resourceBundleName);

// Einfache Methoden, die aufgrund der fehlenden Klassen-/Methodennamen nicht generell zu empfehlen sind
//   - Es können keine Substitutionsparameter für Nachrichten angegeben werden.
//   - Es können keine Klassen- und Methodennamen angegeben werden.
if (logger.isLoggable(Level.SEVERE))
		logger.severe("MSG_KEY_01");

if (logger.isLoggable(Level.WARNING))
		logger.warning("MSG_KEY_01");

if (logger.isLoggable(Level.INFO))
		logger.info("MSG_KEY_01");

if (logger.isLoggable(Level.CONFIG))
		logger.config("MSG_KEY_01");


// Protokollmethoden werden aufgrund der fehlenden Klassen- und Methodennamen
// nicht verwendet
//   - Es können WAS-spezifische Stufen verwendet werden.
//   - Es können Substitutionsparameter für Nachrichten verwendet werden.
//   - Es können keine Klassen- und Methodennamen angegeben werden.
if (logger.isLoggable(WsLevel.FATAL))
		logger.log(WsLevel.FATAL, "MSG_KEY_01", "Parameter 1");

if (logger.isLoggable(Level.SEVERE))
		logger.log(Level.SEVERE, "MSG_KEY_01", "Parameter 1");

if (logger.isLoggable(Level.WARNING))
		logger.log(Level.WARNING, "MSG_KEY_01", "Parameter 1");

if (logger.isLoggable(WsLevel.AUDIT))
		logger.log(WsLevel.AUDIT, "MSG_KEY_01", "Parameter 1");

if (logger.isLoggable(Level.INFO))
		logger.log(Level.INFO, "MSG_KEY_01", "Parameter 1");

if (logger.isLoggable(Level.CONFIG))
		logger.log(Level.CONFIG, "MSG_KEY_01", "Parameter 1");

if (logger.isLoggable(WsLevel.DETAIL))
		logger.log(WsLevel.DETAIL, "MSG_KEY_01", "Parameter 1");


// logp-Methoden sind die bevorzugte Protokollierungsmethode
//   - Es können WAS-spezifische Stufen verwendet werden.
//   - Es können Substitutionsparameter für Nachrichten verwendet werden.
//   - Es können Klassen- und Methodennamen verwendet werden.
if (logger.isLoggable(WsLevel.FATAL))
		logger.logp(WsLevel.FATAL, className, methodName, "MSG_KEY_01", "Parameter 1");

if (logger.isLoggable(Level.SEVERE))
		logger.logp(Level.SEVERE, className, methodName, "MSG_KEY_01", "Parameter 1");

if (logger.isLoggable(Level.WARNING))
		logger.logp(Level.WARNING, className, methodName, "MSG_KEY_01", "Parameter 1");

if (logger.isLoggable(WsLevel.AUDIT))
		logger.logp(WsLevel.AUDIT, className, methodName, "MSG_KEY_01", "Parameter 1");

if (logger.isLoggable(Level.INFO))
		logger.logp(Level.INFO, className, methodName, "MSG_KEY_01", "Parameter 1");

if (logger.isLoggable(Level.CONFIG))
		logger.logp(Level.CONFIG, className, methodName, "MSG_KEY_01", "Parameter 1");

if (logger.isLoggable(WsLevel.DETAIL))
		logger.logp(WsLevel.DETAIL, className, methodName, "MSG_KEY_01", "Parameter 1");


// logrb-Methoden werden im Allgemeinen aufgrund der verringerten Leistung
// beim dynamischen Wechseln von Ressourcenpaketen nicht verwendet
//   - Es können WAS-spezifische Stufen verwendet werden.
//   - Es können Substitutionsparameter für Nachrichten verwendet werden.
//   - Es können Klassen- und Methodennamen verwendet werden.
String resourceBundleNameSpecial = "com.ibm.websphere.componentX.MessagesSpecial";

if (logger.isLoggable(WsLevel.FATAL))
		logger.logrb(WsLevel.FATAL, className, methodName, resourceBundleNameSpecial, "MSG_KEY_01", "Parameter 1");

if (logger.isLoggable(Level.SEVERE))
		logger.logrb(Level.SEVERE, className, methodName, resourceBundleNameSpecial, "MSG_KEY_01", "Parameter 1");

if (logger.isLoggable(Level.WARNING))
		logger.logrb(Level.WARNING, className, methodName, resourceBundleNameSpecial, "MSG_KEY_01", "Parameter 1");

if (logger.isLoggable(WsLevel.AUDIT))
		logger.logrb(WsLevel.AUDIT, className, methodName, resourceBundleNameSpecial, "MSG_KEY_01", "Parameter 1");

if (logger.isLoggable(Level.INFO))
		logger.logrb(Level.INFO, className, methodName, resourceBundleNameSpecial, "MSG_KEY_01", "Parameter 1");

if (logger.isLoggable(Level.CONFIG))
		logger.logrb(Level.CONFIG, className, methodName, resourceBundleNameSpecial, "MSG_KEY_01", "Parameter 1");

if (logger.isLoggable(WsLevel.DETAIL))
		logger.logrb(WsLevel.DETAIL, className, methodName, resourceBundleNameSpecial, "MSG_KEY_01", "Parameter 1");
Das folgende Beispiel bezieht sich auf Traces oder nicht lokalisierten Inhalt:
// Anmerkung: Vermeiden Sie aus Gründen der Konsistenz mit WebSphere Application
//Server für Traces generell die Stufen FATAL, SEVERE, WARNING,
//AUDIT, INFO, CONFIG und DETAIL

String componentName = "com.ibm.websphere.componentX";
Logger logger = Logger.getLogger(componentName);

// entering/exiting-Methoden, die für nicht triviale Methoden verwendet werden
if (logger.isLoggable(Level.FINER))
		logger.entering(className, methodName);
	
if (logger.isLoggable(Level.FINER))
		logger.entering(className, methodName, "Methodenparameter1");

if (logger.isLoggable(Level.FINER))
		logger.exiting(className, methodName);

if (logger.isLoggable(Level.FINER))
		logger.exiting(className, methodName, "Methodenergebnis");


// Die throwing-Methode wird wegen des Fehlens von Nachrichten nicht verwendet.
// Verwenden Sie stattdessen logp mit dem Parameter throwable
if (logger.isLoggable(Level.FINER))
		logger.throwing(className, methodName, throwable);


// Einfache Methoden werden aufgrund der fehlenden Klassen- und Methodennamen
// nicht verwendet
//   - Es können keine Substitutionsparameter für Nachrichten angegeben werden.
//   - Es können keine Klassen- und Methodennamen angegeben werden.
if (logger.isLoggable(Level.FINE))
		logger.fine("Dies ist mein Trace");

if (logger.isLoggable(Level.FINER))
		logger.finer("Dies ist mein Trace");

if (logger.isLoggable(Level.FINEST))
		logger.finest("Dies ist mein Trace");


// Protokollmethoden werden aufgrund der fehlenden Klassen- und Methodennamen
// nicht verwendet
//   - Es können WAS-spezifische Stufen verwendet werden.
//   - Es können Substitutionsparameter für Nachrichten verwendet werden.
//   - Es können keine Klassen- und Methodennamen angegeben werden.
if (logger.isLoggable(Level.FINE))
		logger.log(Level.FINE, "Dies ist mein Trace", "Parameter 1");

if (logger.isLoggable(Level.FINER))
		logger.log(Level.FINER, "Dies ist mein Trace", "Parameter 1");

if (logger.isLoggable(Level.FINEST))
		logger.log(Level.FINEST, "Dies ist mein Trace", "Parameter 1");


// logp-Methoden sind die empfohlene Protokollierungsmethode
//   - Es können WAS-spezifische Stufen verwendet werden.
//   - Es können Substitutionsparameter für Nachrichten verwendet werden.
//   - Es können Klassen- und Methodennamen verwendet werden.
if (logger.isLoggable(Level.FINE))
		logger.logp(Level.FINE, className, methodName, "Dies ist mein Trace", "Parameter 1");

if (logger.isLoggable(Level.FINER))
		logger.logp(Level.FINER, className, methodName, "Dies ist mein Trace", "Parameter 1");

if (logger.isLoggable(Level.FINEST))
		logger.logp(Level.FINEST, className, methodName, "Dies ist mein Trace", "Parameter 1");


// logrb-Methoden sind für die Traceprotokollierung nicht anwendbar,
// da keine Lokalisierung erfolgt
Es gibt Situationen, in denen Protokollsätze an die eigenen Protokollhandler übergeben werden sollen und eine Verwendung der integrierten Protokollierung nicht erwünscht ist. Wenn Sie einen eigenständigen Protokollhandler verwenden möchten, setzen Sie das Flag "useParentHandlers" in Ihrer Anwendung auf false. Der Mechanismus für das Erstellen eines angepassten Handler ist die Unterstützung der Klasse Handler in IBM® Developer Kit, Java Technology Edition. Falls Sie sich mit den von Developer Kit implementierten Handlern nicht auskennen, können Sie sich in verschiedenen Texten oder in der API-Dokumentation von java.util.logging informieren. Das folgende Beispiel zeigt einen angepassten Handler:
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.util.logging.Handler;
import java.util.logging.LogRecord;

/**
 * MyCustomHandler gibt Inhalt in einer angegebenen Datei aus
 */
public class MyCustomHandler extends Handler {

		FileOutputStream fileOutputStream;
		PrintWriter printWriter;

		public MyCustomHandler(String filename) {
		super();

				// Eingabeparameter prüfen
				if (filename == null || filename == "")
						filename = "mylogfile.txt";
		
		try  {
						// Datei initialisieren 
						fileOutputStream = new FileOutputStream(filename);
						printWriter = new PrintWriter(fileOutputStream);
			 			 setFormatter(new SimpleFormatter());
		}
		catch (Exception e) {
						// Ausnahmebehandlung implementieren
		}
	}

		/* (Nicht in der API-Dokumentation)
	 	 * @see java.util.logging.Handler#publish(java.util.logging.LogRecord)
	 */
		public void publish(LogRecord record) {
				// Sicherstellen, dass dieser Protokollsatz vom Handler protokolliert wird
				if (!isLoggable(record))
			return;
		
				// Formatierte Daten in Datei ausgeben
				printWriter.println(getFormatter().format(record));
	}

		/* (Nicht in der API-Dokumentation)
	 	 * @see java.util.logging.Handler#flush()
	 */
		public void flush() {
				printWriter.flush();
	}

		/* (Nicht in der API-Dokumentation)
	 	 * @see java.util.logging.Handler#close()
	 */
		public void close() throws SecurityException {
				printWriter.close();
	}
}

Ein angepasster Filter ermöglicht eine optionale, sekundäre Steuerung protokollierter Daten über die Protokollstufe hinaus. Der Mechanismus für das Erstellen eines angepassten Filters ist die Unterstützung der Schnittstelle "Filter" in IBM Developer Kit, Java Technology Edition. Falls Sie sich mit den von Developer Kit implementierten Filtern nicht auskennen, können Sie sich in verschiedenen Texten oder in der API-Dokumentation zur API java.util.logging informieren.

Das folgende Beispiel zeigt einen angepassten Filter:

/**
 * This class filters out all log messages starting with SECJ022E, SECJ0373E, or SECJ0350E.
 */
import java.util.logging.Filter;
import java.util.logging.Handler;
import java.util.logging.Logger;
import java.util.logging.LogRecord;

public class MyFilter implements Filter {
		public boolean isLoggable(LogRecord lr) {
				String msg = lr.getMessage();
				if (msg.startsWith("SECJ0222E") || msg.startsWith("SECJ0373E") || msg.startsWith("SECJ0350E")) {
			return false;
		}
		return true;
	}
}

//Dieser Code registriert den oben genannten Protokollfilter mit den Handlern der Stammprotokollfunktion
// (einschließlich der WAS-Systemprotokolle):
...
Logger rootLogger = Logger.getLogger("");
rootLogger.setFilter(new MyFilter());

Ein Formatter (Formatierungsprogramm) formatiert Ereignisse. Handler können einem oder mehreren Formattern zugeordnet sein. Der Mechanismus für das Erstellen eines angepassten Formatter ist die Unterstützung der Schnittstelle Formatter in IBM Developer Kit, Java Technology Edition. Falls Sie sich mit den von Developer Kit implementierten Formattern nicht auskennen, können Sie sich in verschiedenen Texten oder in der API-Dokumentation von java.util.logging informieren.

Das folgende Beispiel zeigt einen benutzerdefinierten Formatter:

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

/**
 * MeinCustomFormatter formatiert den Protokollsatz wie folgt:
 * Datum   Version   lokalisierte Nachricht mit Parametern 
 */
public class MeinCustomFormatter extends Formatter {

		public MeinCustomFormatter() {
		super();
	}

		public String format(LogRecord record) {
		
				// Zeichenfolgepuffer für formatierten Datensatz erstellen.
		// Mit Datum anfangen.
				StringBuffer sb = new StringBuffer();
		
				// Datum aus dem Protokollsatz abrufen und dem Puffer hinzufügen
				Date date = new Date(record.getMillis());
				sb.append(date.toString());
		sb.append(" ");
		
				// Versionsnamen abrufen und dem Puffer hinzufügen
				sb.append(record.getLevel().getName());
		sb.append(" ");
		 
				// Formatierte Nachricht abrufen (einschließlich Lokalisierung
		// und Substitution von Parametern) und dem Puffer hinzufügen
				sb.append(formatMessage(record));
				sb.append("\n");

		return sb.toString();
	}
}

Mit eigenen Handlern, Filtern und Formattern können Sie die Protokollierungsumgebung, die durch die Konfiguration der Standardprotokollinfrastruktur von WebSphere Application Server bereitgestellt wird, erweitern. Das folgende Beispiel veranschaulicht, wie Sie der untergeordneten Protokollfunktionsstruktur com.myCompany einen neuen Handler für die Verarbeitung von Anforderungen hinzufügen. (Nähere Informationen finden Sie im Artikel Protokollfunktionshierarchie konfigurieren.) Die Methode main in diesem Beispiel zeigt, wie die neu konfigurierte Protokollfunktion verwendet wird.

import java.util.Vector;
import java.util.logging.Filter;
import java.util.logging.Formatter;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.Logger;

public class MyCustomLogging {

		public MyCustomLogging() {
		super();
	}

		public static void initializeLogging() {
		
				// Protokollfunktion abrufen, der ein angepasster Handler zugeordnet werden soll
				String defaultResourceBundleName = "com.myCompany.Messages";
				Logger logger = Logger.getLogger("com.myCompany", defaultResourceBundleName);
		
				// Angepassten Handler konfigurieren (siehe Beispiel MyCustomHandler)
				Handler handler = new MyCustomHandler("MyOutputFile.log");
		
				// Angepassten Filter konfigurieren (siehe Beispiel MyCustomFilter)
				Vector acceptableLevels = new Vector();
				acceptableLevels.add(Level.INFO);
				acceptableLevels.add(Level.SEVERE);
				Filter filter = new MyCustomFilter(acceptableLevels);
		
				// Angepassten Formatter konfigurieren (siehe Beispiel MyCustomFormatter)
				Formatter formatter = new MyCustomFormatter();

				// Filter und Formatter mit dem Handler verbinden
				handler.setFilter(filter);
				handler.setFormatter(formatter);
		
				// Handler mit der Protokollfunktion verbinden
				logger.addHandler(handler);
		
				// Vermeiden, dass Ereignisse, die für com.myCompany protokolliert
  // werden, in den Protokollen in WebSphere Application Server angezeigt werden
				logger.setUseParentHandlers(false);
				
	}

	public static void main(String[] args) {
				initializeLogging();
		
				Logger logger = Logger.getLogger("com.myCompany");
		
				logger.info("This is a test INFO message");
				logger.warning("This is a test WARNING message");
				logger.logp(Level.SEVERE, "MyCustomLogging", "main", "This is a test SEVERE message");
	}
}
Wenn das obige Programm ausgeführt wird, wird die Ausgabe des Programms in die Datei MyOutputFile.log geschrieben. Der Inhalt des Protokolls wird in der erwarteten Protokolldatei, die vom angepassten Handler definiert wird, gespeichert und gemäß den Vorgaben des angepassten Formatter formatiert. Die Warnung wird gemäß der Konfiguration des angepassten Filters gefiltert. Die Ausgabe ist wie folgt:
C:\>type MyOutputFile.log
Sat Sep 04 11:21:19 EDT 2004 INFO This is a test INFO message
Sat Sep 04 11:21:19 EDT 2004 SEVERE This is a test SEVERE message

Symbol, das den Typ des Artikels anzeigt. Taskartikel



Symbol für Zeitmarke Letzte Aktualisierung: 25.05.2016
http://www14.software.ibm.com/webapp/wsbroker/redirect?version=cord&product=was-nd-mp&topic=ttrb_createloginstance
Dateiname:ttrb_createloginstance.html