# Logging



## JB (26. Okt 2007)

Hallo

ich möchte mit dem Mitgelieferten Klassen usw. von Java loggen.

Jetzt hab ich mal folgendes gemacht.
Zuerst eine Klasse Logging erstellt. 


```
import java.io.IOException;
import java.util.logging.*;

/**
 *
 * @author Bernhard
 */
public  class Logging{
    static Logger logger = Logger.getLogger("edmserver.Logging");
    Handler file_handler;
    Formatter xmllogging;
    /** Creates a new instance of Logging */
    public  Logging() throws IOException {
        // Logger erzeugen
        // File Handler erzeugen
        file_handler = new FileHandler("Logging.xml");
       // Formatter erzeugen
        xmllogging = new XMLFormatter();
        file_handler.setFormatter(xmllogging);
        logger.addHandler(file_handler);
        logger.setLevel(Level.ALL);
        logger.entering("Logging","testmylogger");
        
    }
    public void testmylogger(){
        logger.log(Level.WARNING,"Hallo das ist ein Test des Loggers.");
        
    }
   
}
```

Hauptprogramm:


```
public static void main(String[] args) {
        // TODO code application logic here
           
        try{
            lg=new Logging();
            lg.testmylogger();
        }
        catch(IOException ioexc){
            
        }
```


Danach erstelle ich eine Instanz von der Klasse im Hauptprogramm und führe die Methode testmylogger() aus.

Nun wird aber jedes mal neustart die Loggingdatei neu erstellt, wie kann ich das verhindern, denn ich möchte ja nciht das bei einem neustart die alten logging-Einträge verloren gehen.

Weiteres wäre es auch sehr wichtig, dass diese Logging-Klasse statisch ist und dass ich sie von jeder Stelle im Programm aufrufen kann. Nur lasst er mich nicht compilieren, wenn ich diese Klasse als statisch deklariere.

Danke schon mal für eure Mithilfe

mfg
bernhard


----------



## maki (27. Okt 2007)

Wegen des Problems mit der überschriebenen Datei solltest du mal deine logging properties posten.

Normalerweise hat jede Klasse einen eigenen statischen Logger, einen einzigen für die ganze Anwendung ist etwas wenig 
Ausser dem kann man nur so die Konfigurationsmöglichkeiten ausschöpfen.


----------



## JB (28. Okt 2007)

Wo finde ich die Properties fürs Logging??


----------



## JB (28. Okt 2007)

Hab hier mal die logging.properties gepostet:


```
############################################################
#  	Default Logging Configuration File
#
# You can use a different file by specifying a filename
# with the java.util.logging.config.file system property.  
# For example java -Djava.util.logging.config.file=myfile
############################################################

############################################################
#  	Global properties
############################################################

# "handlers" specifies a comma separated list of log Handler 
# classes.  These handlers will be installed during VM startup.
# Note that these classes must be on the system classpath.
# By default we only configure a ConsoleHandler, which will only
# show messages at the INFO and above levels.
handlers= java.util.logging.ConsoleHandler

# To also add the FileHandler, use the following line instead.
#handlers= java.util.logging.FileHandler, java.util.logging.ConsoleHandler

# Default global logging level.
# This specifies which kinds of events are logged across
# all loggers.  For any given facility this global level
# can be overriden by a facility specific level
# Note that the ConsoleHandler also has a separate level
# setting to limit messages printed to the console.
.level= INFO

############################################################
# Handler specific properties.
# Describes specific configuration info for Handlers.
############################################################

# default file output is in user's home directory.
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

# Limit the message that are printed on the console to INFO and above.
java.util.logging.ConsoleHandler.level = INFO
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter


############################################################
# Facility specific properties.
# Provides extra control for each logger.
############################################################

# For example, set the com.xyz.foo logger to only log SEVERE
# messages:
com.xyz.foo.level = SEVERE
```

Was muss ich daran ändern und muss ich da die globale ändern oder muss ich eine Kopie Davn im Verzeichnis des Programmes, welches Loggen soll erstellen und da dann die Konfigurationen vornehmen. 
Weil wenn ich die globale Datei ändere gilt das ja für alle Java-Programme, welche unter dieser Runtime laufen.


----------



## maki (28. Okt 2007)

Mach dir einen Logger für jede Klasse die Loggen soll:


```
private static Logger log = Logger.getLogger(NameDerZuLoggendenKlasse.class.toString());
```

Dannach kannst du denn Logger benutzen:

```
public void meineMethode(String arg0) {
    if(log.isLoggable(java.util.logging.Level.FINE)){
        log.fine("meineMethode(String arg0="+arg0+")");
    }

}
```
Anleitung lesen kann helfen: http://java.sun.com/j2se/1.4.2/docs/guide/util/logging/overview.html

Wenn ich mich nicht irre, kann bei java.util.Logger eine properties Datei pro Classpath gesetzt werden, einfach die properties zu deinen Klassen ins default package kopieren.

Ansonsten bleibt noch zu sagen, das log4j zu bevorzugen wäre 
Warum eine schlechte Kopie nehmen wenn das Original immer noch besser ist...


----------



## JB (28. Okt 2007)

thx für eure unterstützung,

log4j hab i mir eh auch schon angeschaut, werd des eh auch ausprobieren.


----------



## Guest (28. Okt 2007)

Schreib dir am besten selbst ein Interface und einen Logger und dann die Implementierung für z.B. Log4J und/oder 
andere. Dadurch wird es austauschbar und einheitlich in der Anwendung.


----------



## maki (28. Okt 2007)

> Schreib dir am besten selbst ein Interface und einen Logger und dann die Implementierung für z.B. Log4J und/oder
> andere. Dadurch wird es austauschbar und einheitlich in der Anwendung.


Meinst du so wie commons-logging von jakarta? 

Solange es keine Bibliothek ist die du schreibst, ist es imho am besten gleich auf log4j zu setzen.


----------



## Guest (28. Okt 2007)

maki hat gesagt.:
			
		

> > Schreib dir am besten selbst ein Interface und einen Logger und dann die Implementierung für z.B. Log4J und/oder
> > andere. Dadurch wird es austauschbar und einheitlich in der Anwendung.
> 
> 
> Meinst du so wie commons-logging von jakarta?


So ungefähr, nur ohne die commons-logging.jar


----------



## maki (28. Okt 2007)

> So ungefähr, nur ohne die commons-logging.jar


Jaja, die "gute" alte commons-logging... da ist man mit einem eigenen Logging wrapper wirklich besser dran.

http://www.qos.ch/logging/thinkAgain.jsp


----------



## PollerJava (16. Nov 2007)

JD wie hast du das geschafft, dass inder XML- Datei die alten einträge bleiben nach einem Neustart des Programms?
ich hab mom genau Dein Programm zum testen.

lg


----------

