LineNumberReader - bessere Lösung möglich? - Log4J

[S2PID]

Hallo,
ich möchte in meiner Software alle Exceptions die auftreten abfangen, abspeichern und in einem seperaten Fenster anzeigen.
Meine Idee war nun jedes mal wenn eine Exception irgendwo auftritt das ganze in einem txt file abzuspeichern (mit Zeitstempel)
Nun hab ich mir ein Internes Fenster angelegt mit einer JList. Ebenso einen Thread der diese Liste aktuell halten soll
Der Thread ruft nun alle 100ms diese Methode auf um meine Liste mit den Fehlermeldungen aktuell zu halten.
Kann man das grundsätlich besser lösen? weil ich finde wenn der Thread nun alle 100ms (gut ich kann gerne noch auf (500-1000ms hochgehen) das komplette File von vorne bis hinten durchläuft und schaut ob es was neues gibt doch etwas performancelastig, oder täusche ich mich da? Kann man vielleicht direkt an eine Zeile springen und von da das lesen beginnen? Ich weiß ja theoretisch das er die Zeilen welche schon im Fenster(JList) angezeigt werden auch in meinem File nicht mehr lesen muss.

	private DefaultListModel exceptionListModel = new DefaultListModel();

	public void exceptionsauslesen(){
		File readfile = new File("log\\exceptions.txt");
		String line;
		int anzexceptionslist = exceptionListModel.getSize();
		try
		{
			if (!readfile.exists())
			{
				readfile.createNewFile();
			}
			LineNumberReader exceptionsreader = new LineNumberReader(new BufferedReader(new FileReader(readfile)));
			while((line = exceptionsreader.readLine()) != null){
				if(exceptionsreader.getLineNumber() > anzexceptionslist){
					exceptionListModel.addElement(line);
				}			
			}
		}
		catch (Exception e)
		{
			System.err.println("Fehler: " + e.getMessage());
		}
	}

Edit: ich hab mal den Threadtitel mit - log4j versehen. Da das eigentliche Problem zu einem ganz anderen wurde.

 

[Wildcard]

Warum überhaupt erst die Datei?
Wenn du Exceptions in einer GUI darstellen möchtest, solltest du sie in einen OutputStream oder so schreiben, den du dann in eine JTextArea, JList, oder was auch immer münden lässt. Dafür musst du nichts in eine Datei schreiben und auch nicht pollen.
Schau dir vielleicht auch mal ein Logging Framework wie Log4J, oder das bereits enthaltene java.util.logging an. Sowas bastelt man sich heute nicht mehr selbst.

 

[S2PID]

Vielen Dank für den Tipp.

Natürlich macht das so viel mehr Sinn Also ich habe mich nun seit heute Nachmittag mit Log4J auseinander gesetzt.
Es läuft auch schon soweit das alles in eine .log Datei ausgegeben wird.

Weiter oben erwähnte ich nicht, das die Fehlermeldungen alle in meinem Hauptprogramm in einem InternalFrame angezeigt werden sollen. Also das InternalFrame hab ich schon erstellt und mit einer JList versorgt.

Nun sollen dort alle Meldungen auch erscheinen, das versteh ich noch nicht so ganz wie das ablaufen soll. Theoretisch ändert sich doch gar nichts daran das ich das logfile wie weiter oben beschrieben auch auslesen muss oder ?
Falls es anders (besser) geht, würde ich mich sehr über ein Beispiel freuen.

 

[Wildcard]

Du kannst die Log4J Ausgabe doch auch in einen Outputstream schicken.
Das kann dann einen eigene Implementierung von OutputStream sein, die zeilenweise Zeug in die JList stopft.

 

[S2PID]

Also ich hab das nun mal versucht hinzubasteln

komm aber irgendwie nicht ganz klar mit der log4j ausgabe.


nachdem meine gui initialisiert wurde leite ich den stream um. und setz nen listener drauf:

				System.setOut(new PrintStream(stream));
				System.setErr(new PrintStream(stream));
				/** WriteListener an den Stream haengen */
				stream.addWriteListener(new WriteListener()
				{
					/** Event Handler reagiert auf WriteEvent */
					public void TextWasWritten(WriteEvent event)
					{
						/** Buffer erzeugen und Meldung anhaengen */
						StringBuffer buffer = new StringBuffer();
						// buffer.append(new String(stream.toByteArray()));
						buffer.append(new String(stream.toString()));
						/** Buffer ausgeben und Stream zuruecksetzen */
						// textArea.append(buffer.toString());
						exceptionChild.exceptionListModel.addElement(buffer.toString());
						stream.reset();
					}
				});

hier der listener:

package de.analyzer.daten;

import java.io.ByteArrayOutputStream;
import java.util.Vector;


/**
* Eigener Ausgabestrom, der so erweitert wurde,
* dass Listener bei ihm registriert werden koennen.
* Werden Daten in den Stream geschrieben, loest
* dieser ein WriteEvent aus und informiert alle
* registrierten Listener ueber das Ereignis.
*
* @author NetPanther
*/
public class OutputStream extends ByteArrayOutputStream
{
  /** Vector fuer registrierte Listener */
  Vector<WriteListener> listeners;
 
 
  /**
   * Neuen Listener registrieren.
   *  
   * @param listener zu registierender Listener
   */
  public void addWriteListener(WriteListener listener)
  {
     if (listeners == null)
     {
        listeners = new Vector<WriteListener>();
     }
     listeners.add(listener);
  }
 
  /**
   * Registrierten Listener wieder abmelden.
   *
   * @param listener abzumeldender Listener
   */
  public void removeWriteListener(WriteListener listener)
  {
     if (listeners != null)
     {
        listeners.remove(listener);
     }  
  }
 
  /**
   * WriteEvent abfeuern und alle registrierten
   * Listener ueber das Ereignis informieren.
   *
   * @param object Objekt
   */
  private void fireWriteEvent(Object object)
  {
     WriteEvent event = new WriteEvent(object);
     
     for (WriteListener listener: listeners)
     {
        listener.TextWasWritten(event);
     }
  }
 
  /**
   * Funktion ueberschreiben, die aufgerufen
   * wird, wenn Daten in den Stream geschrieben
   * werden sollen. In diesem Fall moechten wir
   * naemlich das WriteEvent abfeuern und alle
   * registrierten Listener informieren.
   *
   * @param array Byte-Array mit Daten, die
   * in den Stream geschrieben werden sollen
   * @param offset Offset, von dem aus Daten
   * geschrieben werden sollen
   * @param length Laenge der zu schreibenden
   * Daten
   */
  public void write(byte[] array, int offset, int length)
  {
     super.write(array, offset, length);
     
     /** WriteEvent abfeuern */
     fireWriteEvent(this);
  }
}

package de.analyzer.daten;

import java.util.EventObject;

public class WriteEvent extends EventObject
{
	  /**
	   * Konstruktor schleift Parameter an
	   * den parent-Konstruktor durch.
	   *
	   * @param source Objekt
	   */
	  public WriteEvent(Object source)
	  {
	     super(source);
	  }
}

package de.analyzer.daten;

public interface WriteListener
{
	  /**
	   * Event Handler, der darauf reagiert,
	   * wenn ein WriteEvent ausgeloest wurde.
	   */
	  public void TextWasWritten(WriteEvent event);
}

Das funktioniert auch soweit prima, wenn ich irgendwo in meiner software testausgaben auf die konsole machen lasse. z.b. über System.out.print("") erscheinen die wunderbar in meiner JList.

Problem sind nun die log4j ausgaben, die erscheinen NUR in der Konsole nicht in meinem stream
Ich weiß einfach nicht warum. Das nächste das nicht funktioniert ist das setzen des Levels der Log4j ausgabe.

hier mein log4j.xml file:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd" >
<log4j:configuration>
	<appender name="stdout" class="org.apache.log4j.ConsoleAppender">
		<layout class="org.apache.log4j.PatternLayout">
			<param name="ConversionPattern" value="%d{ABSOLUTE} %5p %c{1}:%L - %m%n"/>
		</layout>
	</appender>
	<root>
		<priority value="debug"></priority>
		<appender-ref ref="stdout"/>
	</root>
</log4j:configuration>

das ganze liegt zusammen mit einem log4j.dtd file in meinem /src ordner

im programm selbst setz ich den logger mit:

private static org.apache.log4j.Logger	logger			= Logger.getLogger(Analyzer.class);

und nachdem dann alles initialisiert wurde ruf ich zum testen:

		logger.info("Hinweis");
		logger.debug("Debug-Meldung");
		logger.warn("Warnung");
		logger.error("Fehler");
		logger.fatal("fataler Fehler");

auf, die konsolen ausgabe ist dann:

13:51:27,062  INFO Analyzer:77 - Hinweis
13:51:27,064 DEBUG Analyzer:78 - Debug-Meldung
13:51:27,064  WARN Analyzer:79 - Warnung
13:51:27,065 ERROR Analyzer:80 - Fehler
13:51:27,066 FATAL Analyzer:81 - fataler Fehler

Normalerweise dürfte gar nichts mehr in der Konsole sein. Ich verstehs nicht

 

[S2PID]

ich hab noch einges ausprobiert. Funktionieren tut es zwar noch nicht, aber ich denke ich kann den Fehler weiter einschränken

Wenn ich mit dem Loggin von Sun arbeite, also in meiner mainklasse

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

importiere anstatt log4j

und dann

static Logger logger = Logger.getLogger("Analyzer");

den logger so deklariere haut das hin mit testausgaben, die erscheinen dann nicht mehr in der Konsole sondern brav in meiner JList.
Lustigerweise habe ich zum testen in einer anderen Klasse log4j eingebunden, und das funktioniert nun auch. das logmeldungen von dort in der Jlist erscheinen.

Binde ich allerdings in meiner main wieder log4j ein, ist alles beim alten und nichts erscheint in meiner JList sondern wieder alles auf der Konsole

Ich hätte schon gerne Log4j verwendet, aber wenn das nicht hinhaut (ich nehm an ich bin einfach nur zu blöd das einzustellen ) dann verwende ich den logger von Sun. Also Hilfe wäre mir lieb

 

[Wildcard]

Vermutlich hast du den logger initialisiert, bevor du den OutputStream umgeleitet hast :wink:

 

[S2PID]

Okay, bitte gebt mir ne große massive Wand wo ich meinen Kopf davor schlagen kann.
Und dafür grad nen Haufen Zeit verblödelt

... danke!

 

[S2PID]

Also erscheint nun alles da wo es hingehört.

ABER nicht so wie es soll, anscheinent ignoriert log4j mein xml und/oder properties file
Wenn ich in meinem xml/properties file paar Sachen, wie z.b. das Level einstelle juckt ihn das gar nicht

Laut Anleitung die ich durchgearbeitet habe sollte das xml/properties file im /src Order liegen, und das tut es auch. Und dann sollte jeder logger mit den einstellungen da arbeiten, das tuts aber nicht

	private static org.apache.log4j.Logger	logger;
private static OutputStream				stream			= new OutputStream();

        ......

	public static void main(String[] args)
	{
		System.setOut(new PrintStream(stream));
		System.setErr(new PrintStream(stream));

		SwingUtilities.invokeLater(new Runnable()
		{
			public void run()
			{

				Analyzer inst = new Analyzer();
				inst.setLocationRelativeTo(null);
				inst.setVisible(true);
			}
		});
	}

	public Analyzer()
	{
		super();
		logger = Logger.getLogger(Analyzer.class);
		initGUI();
		
		/* einige Testausgaben erzeugen */
		logger.trace("Trace");
		logger.debug("Debug");
		logger.info("Info");
		logger.warn("Warn");
		logger.error("Error");
		logger.fatal("Fatal");


                .....

meine log4j.properties

### direct log messages to stdout ###
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{ABSOLUTE} %5p %c{1}:%L -- %m%n
log4j.rootLogger=warn, stdout

ausgegeben wird aber alles ab Debug
Selbiges mit dem xml file, damit gehts auch nicht. Benutzen würde ich gerne das xml file

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd" >
<log4j:configuration>
	<appender name="stdout" class="org.apache.log4j.ConsoleAppender">
		<layout class="org.apache.log4j.PatternLayout">
			<param name="ConversionPattern" value="%d{ABSOLUTE} %5p %c{1}:%L - %m%n"/>
		</layout>
	</appender>
	<root>
		<priority value="warn"></priority>
		<appender-ref ref="stdout"/>
	</root>
</log4j:configuration>

 

[S2PID]

Habs hinbekommen

hab das log4j.xml file vom src ordner in den projektordner gepackt und in meiner anwendung ruf ich anfangs noch:

DOMConfigurator.configureAndWatch("log4j.xml", 60*1000);

auf.

Ich hatte da irgendwo so ein Beispiel her, da ging das ohne, bei mir nicht. Nunja egal nun gehts ja ich wüßte trotzdem gerne warum.
Und evtl kann mir einer sagen was dieses "60*1000" bedeudet. Hab in der entsprechenden Methode nachgesehen, da steht was von Delay, ganz schlau werd ich daraus aber nicht