[java.util.logging]Bonne utilisation de logging?

Version imprimable

Bonjour,
voilà, j'ai monté un objet de log pour mes exceptions. Je me demande si j'utilise bien le logging ou si au contraire je suis en train de monter une gouffre à performance...
Si quelqu'un à des conseils je suis preneur!

Code de mon objet:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
package utile;
 
import java.util.logging.FileHandler;
import java.util.logging.Level;
import java.util.logging.LogManager;
import java.util.logging.Logger;
import java.util.logging.SimpleFormatter;
 
public class LogError {
	LogManager	lm=null;
	Logger		logger=null;
	FileHandler	fh=null;
 
	/**
         * Constructeur de l'objet de suivi des log d'erreure
         */
	public LogError(String objet){
		try {
			lm = LogManager.getLogManager();
			fh = new FileHandler(objet+"_Exception.txt",true);
			logger = Logger.getLogger(objet);
			lm.addLogger(logger);
			logger.setLevel(Level.ALL);
			logger.addHandler(fh);
			fh.setFormatter(new SimpleFormatter());
		} catch (Exception e) {
		}
	}
	public void severe(Exception exception){
		logger.log(Level.SEVERE, exception.toString());
	}
}

Exemple d'utilisation:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
package controleur;
 
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
 
import java.util.Properties;
 
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;
 
import utile.ConnectBDD;
import utile.LogError;
 
public class Serveur {
	private 		Properties 	configServeur=null;
	private 		ConnectBDD	connectionBDD=null;
	private 		LogError	logException=null;
	/**
         * Fonction main de lancement
         * @param arg
         */
	public static void main (String[] arg){
		new Serveur();
	}
	/**
         * Constructeur de la classe Serveur
         */
	public Serveur(){
		logException=new LogError(this.getClass().getName());
		configServeur=this.lirePara("configserveur.pro");
		connectionBDD=new ConnectBDD(configServeur);
	}
 
	/**
         * Fonction pour lire le fichier de parametrage configserveur.pro
         * @param fichier le fichier de parametrage
         * @return les parametres de l'application
         */
	public Properties lirePara(String fichier)
	{
		Properties prop=null;
		FileReader file=null;
		prop=new Properties();
		try	{
			file=new FileReader(fichier);
			prop.load(file);
			file.close();
		}catch(FileNotFoundException fnfe){
			logException.severe(fnfe);
		}catch(IOException ioe){
			logException.severe(ioe);
		}
		return prop;
	}
	/**
         * Fonction pour choisir le LookAndFeel de l'application
         * @param nb le numero du LookAndFeel
         */
	public void setLookAndFeels(int nb){
		UIManager.LookAndFeelInfo[] info = UIManager.getInstalledLookAndFeels();
		try {
			UIManager.setLookAndFeel(info[nb].getClassName());
		} catch (InstantiationException ie) {
			logException.severe(ie);
		} catch (ClassNotFoundException cnfe) {
			logException.severe(cnfe);
		} catch (UnsupportedLookAndFeelException ulafe) {
			logException.severe(ulafe);
		} catch (IllegalAccessException iae) {
			logException.severe(iae);
		}
	}
}

merci d'avance!

01/07/2009, 13h32
dingoth
Plusieurs petits conseils :
- Il existe la possibilité de configurer des loggers directement dans des fichiers. Pour plus d'infos, voir http://java.sun.com/javase/6/docs/ap...ogManager.html
- Créer un objet handler (et donc fichier log) par classe, ainsi qu'un simpleFormatter peut s'avérer coûter et faire pâtir tes performances (essentiellement mémoire et vitesse d'écriture). Je ne peux que te conseiller d'utiliser un ou deux handler maximum par application (donc un ou deux fichiers log), et les lier à chacun de tes objets logger. Ceci est faisable rapidement en utiliser la configuration par fichier citée plus haut.
- Enfin, ton encadrement dans une classe LogError est superflu au vu des points précédents, puisqu'elle ne fait rien d'autre. Elle enlève même des fonctionnalités telles la possibilité de logger des exceptions autres que SEVERE.

En suivant tes conseils, et j'espere que j'ai tout compris, voilà ce que ca donne:

La classe où "j'initialise" le logger:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
 
 
package controleur;
 
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
 
import java.util.Properties;
import java.util.logging.FileHandler;
import java.util.logging.Level;
import java.util.logging.LogManager;
import java.util.logging.Logger;
import java.util.logging.SimpleFormatter;
 
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;
 
import utile.ConnectBDD;
/**
 * Classe de de lancement du serveur
 * @author SBO
 */
public class Serveur {
	private 		Properties 		configServeur=null;
	private 		ConnectBDD		connectionBDD=null;
	private 		LogManager 		lm=null;
	private 		FileHandler 	fhException=null;
	private 		Logger 			loggerException=null;
	private			SimpleFormatter	formatter=null;
 
	/**
         * Fonction main de lancement
         */
	public static void main (String[] args){
		new Serveur();
	}
	/**
         * Constructeur de la classe Serveur
         */
	public Serveur(){
		try {
			this.setLookAndFeels(1);
			lm = LogManager.getLogManager();
			formatter=new SimpleFormatter();
			fhException = new FileHandler("Exception.txt",true);
			fhException.setFormatter(formatter);
			loggerException = Logger.getLogger("Exception");
			lm.addLogger(loggerException);
			loggerException.setLevel(Level.ALL);
			loggerException.addHandler(fhException);
		} catch (SecurityException e) {
		} catch (IOException e) {
		}
		configServeur=this.lirePara("configserveur.pro");
		connectionBDD=new ConnectBDD(this);
 
	}
	/**
         * Fonction pour lire le fichier de parametrage configserveur.pro
         * @param fichier le fichier de parametrage
         * @return les parametres de l'application
         */
	public Properties lirePara(String fichier){
 
		Properties prop=null;
		FileReader file=null;
		try	{
			prop=new Properties();
			file=new FileReader(fichier);
			prop.load(file);
		}catch(FileNotFoundException fnfe){
			loggerException.severe(fnfe.toString());
		}catch(IOException ioe){
			loggerException.severe(ioe.toString());
		}finally{
			try {
				file.close();
			} catch (IOException ioe) {
				loggerException.severe(ioe.toString());
			}
		}
		return prop;
	}
	/**
         * Fonction pour choisir le LookAndFeel de l'application
         * @param nb le numero du LookAndFeel
         */
	public void setLookAndFeels(int nb){
		UIManager.LookAndFeelInfo[] info = UIManager.getInstalledLookAndFeels();
		try {
			UIManager.setLookAndFeel(info[nb].getClassName());
		} catch (InstantiationException ie) {
			loggerException.severe(ie.toString());
		} catch (ClassNotFoundException cnfe) {
			loggerException.severe(cnfe.toString());
		} catch (UnsupportedLookAndFeelException ulafe) {
			loggerException.severe(ulafe.toString());
		} catch (IllegalAccessException iae) {
			loggerException.severe(iae.toString());
		}
	}
	/**
         * Getter sur la config serveur
         * return La configuration du serveur
         */
	public Properties getConfigServeur(){
		return configServeur;
	}
	/**
         * Getter sur le logger d'exception
         * @return le Logger d'exception de l'application
         */
	public Logger getLoggerException(){
		return loggerException;
	}
}

Exemple d'utilisation dans la classe ConnectBDD:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
package utile;
 
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
 
import java.util.logging.Logger;
 
import controleur.Serveur;
/**
 * Classe de connection a la base de donnees
 * @author SBO
 */
public class ConnectBDD {
 
	private 	String 		pilote=null;
	private 	String 		hote=null;
	private 	String 		base=null;
	private 	String 		utilisateur=null;
	private 	String 		mdp=null;
	private 	Connection	connec=null;
	private 	Logger		logException=null;
 
	/**
         * Constructeur de l'objet de connection a la base de donnees
         * @param serveur
         */
	public ConnectBDD(Serveur serveur){
		try	{
			logException=serveur.getLoggerException();
			pilote=serveur.getConfigServeur().getProperty("PiloteBDD");//"com.mysql.jdbc.Driver";
			hote=serveur.getConfigServeur().getProperty("IpBDD");
			base=serveur.getConfigServeur().getProperty("Base");
			utilisateur=serveur.getConfigServeur().getProperty("Utilisateur");
			mdp=serveur.getConfigServeur().getProperty("Mdp");
			Class.forName(pilote);
			connec=DriverManager.getConnection("jdbc:mysql://"+hote+"/"+base,utilisateur,mdp);
		}catch(ClassNotFoundException cnfe){
			logException.severe(cnfe.toString());
		}catch (SQLException sqle){
			logException.severe(sqle.toString());
		}catch (NullPointerException npe){
			logException.severe(npe.toString());
		}
	}
	/**
         * Fonction pour executer des requetes de type Select
         * @param requete - La requete a executee
         * @return Le resultat de l'execution de la requete
         */
	public ResultSet exeSelect(String requete){
		ResultSet 	resultatReq=null;
		Statement	instruction=null;
		try	{
			instruction=connec.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDATABLE);
			resultatReq=instruction.executeQuery(requete);
		}
		catch(SQLException sqle){
			logException.severe(sqle.toString());
		}
		return resultatReq;
	}	
	/**
         * Fonction pour executer des requetes de type Update, Insert, Delete,...
         * @param requete - La requete a executee
         * @return Le nombre de ligne modifiee
         */
	public int exeModif(String requete){
		int 		resultatReq=-1;
		Statement	instruction=null;
		try	{
			instruction=connec.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDATABLE);
			resultatReq=instruction.executeUpdate(requete);
		}
		catch(SQLException sqle){
			logException.severe(sqle.toString());
		}
		return resultatReq;
	}
}

la ca dois déjà être mieux, non?