Protokollfunktionen (Logger) verwenden
Sie können die Java™-Protokollierung verwenden, um Nachrichten zu protokollieren und Traces hinzuzufügen.
Informationen zu diesem Vorgang
Vorgehensweise
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
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");
}
}
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