[Log4J][Héritage] Création d’une classe de log personnalisée

**jproto** · 13/09/2006, 12h12

Bonjour,

J’ai dû rater une subtilité grosse comme une poutre, mais je dois admettre que cela me laisse dubitatif.
J’ai créé une classe destiné, à terme, à ma faciliter la gestion des logs (basés sur Log4J).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
import org.apache.log4j.*;
 
public class Log extends Logger {
 
    static final Logger logger = Logger.getLogger("MonLog");
 
    /** Creates a new instance of Log */
    protected Log(String name) {
        super(name);
        BasicConfigurator.configure();
        logger.setLevel(Level.INFO);
    }
 
/* …
Je compte placer ici mes fonctions perso 
*/
}

Comme vous le constatez, cette classe hérite de org.apache.log4j.Logger.

Lorsque j’utilise cette classe

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
    public static void main(String args[]) {
        Log log = new Log("MonLog");
        log.info("Mon texte à afficher");
    }

Je me retrouve avec une exception :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
Exception in thread "main" java.lang.NullPointerException
        at org.apache.log4j.Category.info(Category.java:753)
        at TstMain.main(TstMain.java:21)
Java Result: 1

Alors que si je complète ma classe Log avec une méthode info() qui se contente de faire appel à son homologue dans Logger :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import org.apache.log4j.*;
 
public class Log extends Logger {
 
    static final Logger logger = Logger.getLogger("MonLog");
 
    /** Creates a new instance of Log */
    protected Log(String name) {
        super(name);
        BasicConfigurator.configure();
        logger.setLevel(Level.INFO);
    }
 
  public void info(Object message) {
      logger.info(message);
  }
 
/* …
Je compte placer ici mes fonctions perso 
*/
 
}

Cela fonctionne très bien.

Bref, il y a-t-il une subtilité dans la classe Logger que je n’aurais pas perçu ?
Celle-ci héritant de la classe Category (qui implémente la méthode info()), je trouve normal de pouvoir acceder à la méthode depuis un objet Logger. Cependant, je ne vois pas pourquoi mon objet Log (héritant lui-même de Logger) ne peux pas exploiter la méthode info() sans avoir à la redéfinir.

Quelqu’un est-il plus inspiré que moi ?

Chris

**jproto** · 15/09/2006, 15h35

Je constate que ma question n’a pas inspiré grand monde sur cette partie du forum, je vais donc tenter ma chance sur une partie plus générale de Java [http://www.developpez.net/forums/sho....php?t=210799].

**benratti** · 15/09/2006, 16h29

En lisant ton code, j'ai plus l'impression que tu as rajouter une couche au dessus de ton logger plutot que tu as fais de l'heritage.

Ce qui me fait penser à ca, c'est cette ligne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

static final Logger logger = Logger.getLogger("MonLog");

**jproto** · 15/09/2006, 16h55

En fait, il s’agit d’une bidouille inopportune (au moins dans le cadre de cet exemple).
A la base, je souhaitais tenter un petit mixte des deux.
Mais tu as raison, je m’y suis mal pris, et j’ai ainsi initialisé le mauvais contexte.
Je vais revoir ma copie.

Merci pour tes lumières.

Chris.

**stepmaniac** · 13/11/2006, 15h31

Tu peux t'y prendre comme tu as fais, mais il suffit à la place de :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
public void info(Object message) {
      logger.info(message);
}

de faire ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
public void info(Object message) {
      logger.log(this.getClass().getName(), Level.INFO, message, null);
}

Cf la javadoc sur la méthode log(String callerFQCN, Priority level, Object message, Throwable t) pour les explications...

**jproto** · 13/11/2006, 15h45

Envoyé par stepmaniac

Tu peux t'y prendre comme tu as fais, mais il suffit à la place de :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
public void info(Object message) {
      logger.info(message);
}

de faire ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
public void info(Object message) {
      logger.log(this.getClass().getName(), Level.INFO, message, null);
}

Cf la javadoc sur la méthode log(String callerFQCN, Priority level, Object message, Throwable t) pour les explications...

Je te remercie stepmaniac, en fait, je suis parti sur une solution plus simple de délégation.

Mais je dois admettre ma grande faute : d'une part, je n'en avais pas fait mention, mais en plus, je n'avais pas taggé la discution comme [Résolu].
Je m'en vais y remédier.

A+,
Chris.

**stepmaniac** · 13/11/2006, 15h50

Ta solution par délégation m'intéresse jproto. Car en fait je n'ai trouvé que cette façon de faire....

Donc si tu as un bout de code qui montre une autre solution, je suis prenneur

**jproto** · 13/11/2006, 16h34

A vrai dire, je viens de te répondre de mémoire. Et maintenant que tu m’as obligé à mettre le nez dans mon code, je me rends bien compte que la délégation n’a pas retenue mon attention suffisamment longtemps.

Bref, je te livre tout de même tel quel le contenu MA solution. Si tu peux en tirer quelque chose, c’est parfait, sinon, personne ne t’oblige à l’exploiter.

Pour faire au plus clair, voici le contenu de ma solution :

Une classe LogFactory qui me permet de gérer de façon unique l’initialisation de mes loggers. C’est elle qu’il faudra que je fasse évoluer afin d’externaliser le paramétrage.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
/*
 * LogFactory.java
 */
package SimpleLog;
 
import org.apache.log4j.*;
 
 
/**
 * Cette classe est une Factory Method de création des Logger. (cf. Design Patterns)
 * @author Chris
 */
public class LogFactory {
    /**
     * Cette fonction retourne un Logger initialisé. <BR>
     * Elle est à exploiter pour l’ensemble des Logger à créer, car elle prend en charge leur initialisation selon les divers niveaux de log. <BR>
     * <BR>
     * Le logger de l’application principale doit toujours s’appeler "root" : <BR>
     * private Logger logger = LogFactory.makeNewLoggerInstance("root"); <BR>
     * <BR>
     * Le logger des classes fille doit toujours s’appeler avec le nom de la classe : <BR>
     * private Logger logger = LogFactory.makeNewLoggerInstance("TestFille"); <BR>
     * @param name Nom du Logger ("root" ou Nom_de_la_classe)
     * @return Le Logger initialisé
     */
    public static Logger makeNewLoggerInstance (String name) {
        Logger logger;
 
        // TODO Gérer les divers initialisations via fichier de configuration
        // TODO avec conf par défaut si pas de fichier.
        if(name.equals("root")) {
            logger = Logger.getRootLogger();
            initLogger(logger);
        } else {
            logger = Logger.getLogger(name);
        }
 
        return logger;
    }
 
    private static void initLogger (Logger logger) {
        // Niveau des logs.
        logger.setLevel(Level.DEBUG);
 
        // Connection du log à la console
        PatternLayout consoleLayout = new PatternLayout("%d %-5p %c - %m%n");
        BasicConfigurator.configure(new ConsoleAppender(consoleLayout));
    }
}

Une classe VisuLog qui me permet d’intégrer dans mes interfaces graphiques un affichage des logs.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
/*
 * VisuLog.java
 *
 */
 
package SimpleLog;
 
import javax.swing.JFrame;
import javax.swing.text.AbstractDocument;
import javax.swing.text.StyledDocument;
import org.apache.log4j.*;
 
/**
 * Composant graphique hérité de JPanel permettant d'afficher sous la forme d'un JTextPane l'ensemble des logs de niveau supérieur à INFO. <BR>
 * <BR>
 * Il est destiné à être exploité directement via Matisse et se connecte au logger via un VisualAppender. <BR>
 * Syntaxe : <BR>
 * VisuLog vl; <BR>
 * logger.addAppender(new VisualAppender(vl)); <BR>
 * @author Chris
 */
public class VisuLog extends javax.swing.JPanel {
 
    /** Document rattaché au panel */
    protected AbstractDocument doc;
 
 
    /**
     * Constructeur de VisuLog
     */
    public VisuLog() {
        initComponents();
 
        // Initialisation du TextPane
        log.setCaretPosition(0);
        StyledDocument styledDoc = log.getStyledDocument();
        if (styledDoc instanceof AbstractDocument) {
            doc = (AbstractDocument)styledDoc;
        } else {
            System.err.println("log's document isn't an AbstractDocument!");
            System.exit(-1);
        }
    }
 
    /** This method is called from within the constructor to
     * initialize the form.
     * WARNING: Do NOT modify this code. The content of this method is
     * always regenerated by the Form Editor.
     */
    // <editor-fold defaultstate="collapsed" desc=" Generated Code ">//GEN-BEGIN:initComponents
    private void initComponents() {
        scrollLog = new javax.swing.JScrollPane();
        log = new SimpleGUI.SJTextPane();
 
        log.setEditable(false);
        scrollLog.setViewportView(log);
 
        org.jdesktop.layout.GroupLayout layout = new org.jdesktop.layout.GroupLayout(this);
        this.setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING)
            .add(scrollLog, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 747, Short.MAX_VALUE)
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING)
            .add(scrollLog, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 305, Short.MAX_VALUE)
        );
    }// </editor-fold>//GEN-END:initComponents
 
 
    // Variables declaration - do not modify//GEN-BEGIN:variables
    private SimpleGUI.SJTextPane log;
    private javax.swing.JScrollPane scrollLog;
    // End of variables declaration//GEN-END:variables
 
}

Une classe VisualAppender qui gère l’alimentation des objets VisuLog.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
/*
 * VisualAppender.java
 */
package SimpleLog;
 
import org.apache.log4j.*;
 
import javax.swing.text.BadLocationException;
import javax.swing.text.SimpleAttributeSet;
 
 
/**
 * Appender de type Log4J permettant de connecter un composant VisuLog à un objet Logger. <BR>
 * <BR>
 * Il permet de filter les éléments à afficher (logs de niveau supérieur à INFO), et <BR>
 * de les metre en forme selon leur niveau. <BR>
 * @author Chris
 * @see VisuLog.java
 */
public class VisualAppender extends AppenderSkeleton {
    /** Panel dans lequel les logs doivent être affichés */
    VisuLog vl;
 
    /**
     * Constructeur de VisualAppender
     * @param vl Composant VisuLog à connecter à l'objet Logger.
     */
    public VisualAppender(VisuLog vl) {
        super();
        this.vl = vl;
    }
 
    /**
     * Méthode héritée de org.apache.log4j.AppenderSkeleton dont l'appel par le Logger est automatique.
     * Elle permet de filtrer et de mettre en forme les logs destinés à être affichés via le composant VisuLog.
     * @param event Evénement (log) transmis par le Logger à éventuellement afficher (et metttre en forme) dans le composant VisuLog.
     */
    protected void append(org.apache.log4j.spi.LoggingEvent event) {
        if (event.getLevel().toInt() >= Level.INFO_INT) {
            String Txt = event.getMessage().toString();
 
            // TODO Gérer les couleurs selon le niveau du message
            try {
                this.vl.doc.insertString(this.vl.doc.getLength(), Txt + "\n",
                    new SimpleAttributeSet());
            } catch (BadLocationException ex) {
                ex.printStackTrace();
            }
        }
    }
 
    /**
     * Indique au Logger si la présence d'un Layout est obligatoire.
     * Ici, nous retournons FALSE car nous gérons nous même la mise en forme via la méthode append().
     * @return La présence d'un Layout obligatoire ou pas.
     */
    public boolean requiresLayout() {
        return false;
    }
 
    /**
     * Héritage direct est obligatoire de AppenderSkeleton
     */
    public void close() {
    }
}

Une classe TestVisuLog qui est un exemple de mise en œuvre simple des logs via la classe Logger dans la classe d'application principale

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
118
119
120
121
122
123
124
125
126
127
128
 
/*
 * TestVisuLog.java
 *
 */
 
package SimpleLog;
 
import SimpleGUI.SJFrame;
import org.apache.log4j.*;
 
 
/**
 * Exemple de mise en œuvre simple des traces via la classe Logger dans la classe d'application principale. <BR>
 * (Pour la mise en œuvre dans une classe fille : cf. TestFille.java) <BR>
 * <BR>
 * 1. Ajouter l'import <BR>
 * <BR>
 * import org.apache.log4j.*; <BR>
 * import SimpleLog.*; <BR>
 * <BR>
 * 2. Déclarer un logger <BR>
 * <BR>
 * private Logger logger = LogFactory.makeNewLoggerInstance("root"); <BR>
 * <BR>
 * ! : Le logger de l’application principale doit toujours s’appeler « root ». C’est une convention garantissant une initialisation minimale. <BR>
 * <BR>
 * 3. Connecter éventuellement le logger à un composant visuel. <BR>
 * <BR>
 *    // Connection du log au composant VisuLog <BR>
 *    logger.addAppender(new VisualAppender(visuLog1)); <BR>
 * <BR>
 * Ceci peut être réalisé dans le constructeur de la classe, mais APRES après la méthode initComponents(). <BR>
 * <BR>
 * 4. Faire appel au logger de le source selon les divers niveau de messages : <BR>
 *         logger.debug("sJButton1ActionPerformed - Appel => "+evt.toString()); <BR>
 *         logger.info("Bouton - Coucou"); <BR>
 *         logger.warn("Attention : Message important"); <BR>
 *         logger.error("Tant pis ! un message d'erreur !"); <BR>
 * @author Chris
 */
public class TestVisuLog extends SimpleGUI.SJFrame {
 
    /** Logger */
    private Logger logger = LogFactory.makeNewLoggerInstance("root");
 
 
    /**
     * Constructeur de TestVisuLog
     */
    public TestVisuLog() {
        initComponents();
 
        // Connection du log au composant VisuLog
        logger.addAppender(new VisualAppender(visuLog1));
    }
 
    /** This method is called from within the constructor to
     * initialize the form.
     * WARNING: Do NOT modify this code. The content of this method is
     * always regenerated by the Form Editor.
     */
    // <editor-fold defaultstate="collapsed" desc=" Generated Code ">//GEN-BEGIN:initComponents
    private void initComponents() {
        visuLog1 = new SimpleLog.VisuLog();
        sJButton1 = new SimpleGUI.SJButton();
 
        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
 
        sJButton1.setText("sJButton1");
        sJButton1.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                sJButton1ActionPerformed(evt);
            }
        });
 
        org.jdesktop.layout.GroupLayout layout = new org.jdesktop.layout.GroupLayout(getContentPane());
        getContentPane().setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING)
            .add(layout.createSequentialGroup()
                .addContainerGap()
                .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING)
                    .add(visuLog1, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 747, Short.MAX_VALUE)
                    .add(sJButton1, org.jdesktop.layout.GroupLayout.PREFERRED_SIZE, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, org.jdesktop.layout.GroupLayout.PREFERRED_SIZE))
                .addContainerGap())
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING)
            .add(layout.createSequentialGroup()
                .addContainerGap()
                .add(visuLog1, org.jdesktop.layout.GroupLayout.PREFERRED_SIZE, 168, org.jdesktop.layout.GroupLayout.PREFERRED_SIZE)
                .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED)
                .add(sJButton1, org.jdesktop.layout.GroupLayout.PREFERRED_SIZE, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, org.jdesktop.layout.GroupLayout.PREFERRED_SIZE)
                .addContainerGap(org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
        );
        pack();
    }// </editor-fold>//GEN-END:initComponents
 
    private void sJButton1ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_sJButton1ActionPerformed
        logger.debug("sJButton1ActionPerformed - Appel => "+evt.toString());
        logger.info("Bouton - Coucou");
        logger.warn("Attention : Message important");
        logger.error("Tant pis ! un message d'erreur !");
 
        // Création d'un objet de la classe fille
        TestFille tst = new TestFille();
    }//GEN-LAST:event_sJButton1ActionPerformed
 
    /**
     * Méthode main()
     * @param args the command line arguments
     */
    public static void main(String args[]) {
 
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                new TestVisuLog().setVisible(true);
            }
        });
    }
 
    // Variables declaration - do not modify//GEN-BEGIN:variables
    private SimpleGUI.SJButton sJButton1;
    private SimpleLog.VisuLog visuLog1;
    // End of variables declaration//GEN-END:variables
 
}

Une classe TestFille qui est un exemple de mise en œuvre simple des logs via la classe Logger dans la classe fille

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
/*
 * TestFille.java
 *
 */
package SimpleLog;
 
import org.apache.log4j.*;
import SimpleLog.LogFactory;
 
 
/**
 *
 * Exemple de mise en œuvre simple des traces via la classe Logger dans la classe fille. <BR>
 * (Pour la mise en œuvre dans une classe d'application principale : cf. TestVisuLog.java) <BR>
 * <BR>
 * 1. Ajouter l'import <BR>
 * <BR>
 * import org.apache.log4j.*; <BR>
 * import SimpleLog.LogFactory; <BR>
 * <BR>
 * 2. Déclarer un logger <BR>
 * <BR>
 *  private Logger logger = LogFactory.makeNewLoggerInstance("TestFille"); <BR>
 * <BR>
 * ! : Par convention, le logger des classes fille doit toujours s’appeler avec le nom de la classe. <BR>
 * <BR>
 * 3. Faire appel au logger de le source selon les divers niveau de messages : <BR>
 * <BR>
 * logger.debug("Constructeur - Coucou"); <BR>
 * logger.info("Appel à une classe fille"); <BR>
 * <BR>
 * @author Chris
 */
public class TestFille {
 
    /** Logger */
    private Logger logger = LogFactory.makeNewLoggerInstance("TestFille");
 
    /**
     * Constructeur de TestFille
     */
    public TestFille() {
        logger.debug("Constructeur - Coucou");
        logger.info("Appel à une classe fille");
    }
}

Voilà. Il ne me reste plus qu’à ajouter que je développe sous NetBeans, et qu’un ensemble de templates me permet de ne jamais avoir à m’occuper de l’intégration des logs.

A+,
Chris.

PS : Toute critique (constructive) est la bien venue.

**stepmaniac** · 13/11/2006, 16h45

ok
merci jproto

a+

[Log4J][Héritage] Création d’une classe de log personnalisée

Logging Java

Discussions similaires

Partager

Partager