OOP java.util.logging.Logger: Wie kann ich mehre Klassen in ein Logfile schreiben lassen?

[backarc]

Wie kann ich von mehreren Klassen aus einen Logger nutzen?

Aktuell habe ich in jeder Klasse eine eigene Logger-Instanz.
Deshalb erstellt mein Programm eine ganze Menge log-Dateien. Ist natürlich schön fürs debuggen, aber schöner wäre eine Log-Datei.
Ich möchte so weit wie möglich auf externe Bibliotheken verzichten um in jedem Fall auf Windows und MacOS lauffähig zu sein, deshalb nutze ich java.util.logging.Logger.

Jetzt mag ich einfach zu blöde sein, oder nicht genügend von Java verstehen - aber ich bekomme das irgendwie nicht hin.
Sinnvolle Beispiele finde ich nicht - entweder das macht niemand, niemand nutzt Logger (eventuell mit log4J?) oder ich nutze die falschen Suchbegriffe.



Was ich bisher versucht habe, ist eine Klasse zu bauen.
1) Die von Logger abgelitten ist. Hat nicht funktioniert, finde keinen Weg das "legal" hinzubekommen.
2) Die eine Instanz von Logger enthält. Wenn ich dann eine Instanz der Klasse in anderen Klassen nutze schreibt er mir dann leider keine Daten in die Logs.
3) Einfach so denselben Dateinamen nutzen - geht nicht, Java macht einen Filelock auf das Logfile.


Jetzt die Frage(n):
Kann man das hinbekommen?
Wenn ja wie?
Gibt es Tutorials oder andere Quellen (gerne auch in Englisch) die das Beschreiben?

Danke für Eure Hilfe im voraus!

Gruss,

backarc

 

[turtle]

Kann man das hinbekommen?
Ja
Wenn ja wie?
Gibt es Tutorials oder andere Quellen (gerne auch in Englisch) die das Beschreiben?
:rtfm:Java TM Logging Overview

Ich schlage auch vor, die Datei logging.properties in Deinem JDK anzuschauen. Zusammen mit der Overview sollte dann vieles klarer sein.

 

[jueki]

Mit dieser Logging-Klasse habe ich keine erfahrung, aber ich habe das Problem über eine eigene Klasse mit einer statischen Funktion gelöst:

public class myGlobals
{

	/**
	 * Funktion schreibt eine Reportmeldung in eine festgelegte Textdatei
	 * und hängt einen Zeilenumbruch an.
	 * @param message [String] Abzuspeichernde Reportmeldung
	 */
	public static void reportln(String message)
	{
		try
		{
			FileWriter f = new FileWriter("../../report.txt", true); // Datei zum Anhängen öffnen
			message += "\n";
			f.write(message);
			f.close();
		}
		catch (Exception ex)
		{
			String error = "cant write Reportmessage '"
						 + message
						 + "'";
			System.out.println(error);
		}
	}
// ....
}

In irgendeiner anderen Klasse rufe ich die Funktion dann so auf:

myGlobals.reportln("blablabla");

Daneben habe ich mir noch eine statische Funktion geschrieben, die die Datei löscht, neu anlegt und das aktuelle Datum und einigen anderen Unsinn an den Anfang schreibt. Diese Funktion wird beim Programmstart aufgerufen. Klappt eigentlich ganz prima, könnte aber bei Threads probleme machen.

jueki

 

[turtle]

Ich beschreibe mal kurz meine Nutzung von java.util.logging.

In einer Klasse A

public class A {
	private static final Logger logger = Logger.getLogger(A.class.getName()); 

	public static void main(String[] args) {
		logger.info("A gestartet");
		new B();
		logger.info("A beendet");
	}
}

In einer anderen Klasse B

public class B {
	private static final Logger logger = Logger.getLogger(B.class.getName()); 

	public B() {
		logger.info("B konstruiert");
	}
}

Das Logging-Verhalten wird über die Datei logging.properties gesteuert, die angibt, wohin und wie geloggt werden soll. Nehmen wie folgende Beispiel-Datei

.level = INFO
handlers= java.util.logging.FileHandler, java.util.logging.ConsoleHandler
java.util.logging.FileHandler.pattern=logs/turtle.log
java.util.logging.FileHandler.formatter=java.util.logging.SimpleFormatter

Dieses gibt an, dass wir auf die Console und in die Datei logs/turtle.log loggen wollen. Und zwar alle Ausgaben ab Info-Level.
Startet man die Applikation mit java -Djava.util.logging.config.file=./logging.properties A werden folgende Ausgaben auf die Console und in die Datei gelogged:

25.07.2011 09:02:00 A main
INFO: A gestartet
25.07.2011 09:02:00 B <init>
INFO: B konstruiert
25.07.2011 09:02:00 A main
INFO: A beendet

 

[FArt]

Der eine oder andere mag das Konzept einer Logging API noch nicht ganz verstanden haben.

Die Logger(-Instanzen) sind von den Appendern (z.B. für Logfiles) komplett getrennt. Über Konfiguration wird festgelegt, welche Logger auf welchen Appendern loggen. Dort kann man dann auch Loglevel, Filter, Format usw. konfigurieren.

Ich empfehle log4j, m.E. die mächtigste Logging API.

 

[backarc]

Moin!

Danke für eure Antworten!
Wenn ich das richtig verstehe war mein Ansatz also grundfalsch - und FArt hat recht mit der Aussage das ich das nicht verstanden habe.
In den Tutorials die ich gefunden habe wird das allerdings auch immer nur für eine Klasse - wie im Beispiel an der Java-Doku die turtle gepostet hat (Ich habe mich an der 1.6er Doku versucht, kaum ein Unterschied).

Für mich bedeutet das also:
Jede Klasse hat eine eigene Instanz von Logger, die ich in der Klasse nicht näher konfiguriere.
Im Projekt-Root gibt es eine Datei "logging.properties" in der ich Klassenübergreifend meinen File-Handler und den Log-Level einstelle.
Richtig?

 

[turtle]

Im Projekt-Root gibt es eine Datei "logging.properties" in der ich Klassenübergreifend meinen File-Handler und den Log-Level einstelle.

Wenn Du java.util.logging einsetzen möchtest, ja.

Aber wie bereits angemerkt, setze ich und viele andere lieber log4j ein. Nutzung im Prinzip gleich. Bei log4j kann zum Beispiel das Log-Format einfacher eingestellt werden und die Konfigurationsdatei heisst log4j.properties.

 

[FArt]

Besser: log4j.xml

 

[backarc]

Danke nochmal für eure Hilfe und die Bestätigung meines Verständnisses
Wie schon gesagt, log4J fällt aus meinem Konzept heraus - ich möchte gerne Java "pur" nutzen solange möglich. Und wenn es noch so weh tut.

Danke & Gruss

backarc

 

[backarc]

Nun kann ich auch eine mögliche Lösung präsentieren - wenn es auch ein wenig gedauert hat.
Und falls es jemanden interessiert der eventuell dieselbe Lösung sucht - heir eine Möglichkeit.
Mit Sicherheit kann man noch am Code arbeiten.

Was ich interessant fand, ist das ich nachdem ich den Tipp mit den logging.properties aus den vorangegangenen Einträgen hatte, einige Artikel gefunden habe die das auch erklärt haben.
Warum ich das vorher nicht gefunden habe kann wahrscheinlich nur google beantworten.
Ich habe also nach
Java Standard: Logging API von Java ? Wikibooks, Sammlung freier Lehr-, Sach- und Fachbücher
und
Java Practices -> Logging messages
das folgende gebastelt:

#this file: see [url=http://de.wikibooks.org/wiki/Java_Standard:_Logging_API_von_Java]Java Standard: Logging API von Java ? Wikibooks, Sammlung freier Lehr-, Sach- und Fachbücher[/url]
# and [url]http://www.java-forum.org/allgemeine-java-themen/122068-java-util-logging-logger-mehre-klassen-logfile-schreiben-lassen.html#post788460[/url]
# Use -Djava.util.logging.config.file=logging.properties

# Der ConsoleHandler gibt die Nachrichten auf std.err aus
#handlers= java.util.logging.ConsoleHandler

# Alternativ können weitere Handler hinzugenommen werden. Hier z.B. der Filehandler
#handlers= java.util.logging.FileHandler, java.util.logging.ConsoleHandler
handlers= java.util.logging.FileHandler, java.util.logging.ConsoleHandler

# Festlegen des Standard Loglevels
.level= FINEST

# Die Nachrichten in eine Datei im Benutzerverzeichnis schreiben
java.util.logging.FileHandler.pattern = ttr_backend.log
java.util.logging.FileHandler.limit = 50000
java.util.logging.FileHandler.count = 1
# Style of output (Simple or XML):
java.util.logging.FileHandler.formatter = java.util.logging.SimpleFormatter
#java.util.logging.FileHandler.formatter = java.util.logging.XMLFormatter

# Zusätzlich zu den normalen Logleveln kann fuer jeden Handler noch ein eigener Filter
# vergeben werden. Das ist nuetzlich wenn beispielsweise alle Nachrichten auf der Konsole ausgeben werden sollen
# aber nur ab INFO in das Logfile geschrieben werden soll.
#java.util.logging.ConsoleHandler.level = ALL
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter


############################################################
# Extraeinstellungen fuer einzelne Logger
############################################################

# Fuer einzelne Logger kann ein eigenes Loglevel festgelegt werden.
trainingstagebuchreader.gui.level = SEVERE
trainingstagebuchreader.gui.ttrGui.level = SEVERE
java.awt.level = SEVERE
sun.level = SEVERE

Und der Aufruf im Programm:

1. Import:

   import java.util.logging.Level;
   import java.util.logging.Logger;

2. Eine Variable anlegen

   private static final Logger logger = Logger.getLogger("Main");

3. Und hier einen Log-Eintrag erzeugen (im Beispiel ein catch-block)

   } catch (TTReaderException ex) {
               logger.log(Level.SEVERE, null, ex);
               System.out.println("Exception when reading login data from " + settingsfile + ex);
           }

Ich hoffe das das irgendwem weiterhilft.
Ich bedanke mich bei allen Helfern!

 

[freez]

ich möchte gerne Java "pur" nutzen solange möglich

kleiner Gag: zieh dir die Sourcen zu log4j in dein Proejkt, dann hast du auch "Java pur" Nein, ernst beiseite:
Das heist
1. du brauchst Performance, die log4j nicht bieten kann? Oder
2. du willst es selber machen, um es einfach zu verstehen? Oder
3. das Jar ist einfach zu groß für dein Projekt. Oder
4. ich weiß keinen weiteren Grund, weshalb man auf diese einfache Art der Nutzung von Logging verzichten sollte.


Was ist deine Wahl?

 

[backarc]

Es geht mir um Punkt 2 (verstehen) und darum ein schlankes Programm zu basteln was überall funktioniert wo Java installiert ist.
Also idealerweise nur das was Java selbst mitliefert.

Das mag blöd sein.
Aber macht eigentlich Spaß

 

[freez]

Es geht mir um Punkt 2 (verstehen) und darum ein schlankes Programm zu basteln was überall funktioniert wo Java installiert ist.

Das ist auch vollkommen ok. Jeder hier hat bestimmt schon mal Code geschrieben, obwohl eine freie Lib es auch kann ... Dabei ist auch schon mal was Besseres / Schnelleres / Anderes raus gekommen, und hatte sogar Erfolg. Also ruhig weiter so!