Cadre de journalisation pour l'application Java

Question

J'ai créé une petite application Web dans Java. Et maintenant je veux ajouter des fonctionnalités de journalisation. Mais je ne veux pas utiliser n'importe quel framework de journalisation disponible comme Log4j ou autre chose, mais je veux créer mon propre framework de journalisation qui peut aussi être réutilisable à l'avenir. Donc, besoin de quelques push ups initiaux pour la même chose, et c'est le bon endroit pour cela.

Merci.

Answer 1

Mon conseil serait de ne pas le faire. Utilisez des cadres de journalisation testés et testés tels que log4j. Pourquoi voulez-vous réinventer la roue?

Nous avons passé beaucoup de temps sur les frameworks existants - en les faisant fonctionner rapidement, dans différents environnements, etc. Voulez-vous vraiment perdre du temps à répliquer cet effort en utilisant les mêmes fonctionnalités que vos utilisateurs? se soucient de?

N'oubliez pas que de nombreux frameworks (tels que log4j, ou même le java.util.logging intégré) sont extensibles avec vos propres formateurs, handlers, etc. Vous devriez vraiment savoir ce que vous voulez faire pas couvert par les cadres existants et voir si vous pouvez construire juste ce bit plutôt que de créer un autre cadre de journalisation. Si vous avez besoin d'écrire du code supplémentaire, vous pouvez alors poser des questions sur ces besoins spécifiques, plutôt que sur votre question actuelle plutôt générale.

Answer 2

Il existe déjà trop de frameworks de journalisation Java. Pourquoi ne pas simplement envelopper le java.util.logging?

http://java.sun.com/j2se/1.4.2/docs/guide/util/logging/overview.html

Answer 3

Si vous voulez vraiment faire votre propre franmework de l'exploitation forestière (et je suggère fortement vous ne), puis notez certaines exigences d'abord. Que devrait-il faire? Quelles caractéristiques-il, etc.

Les exemples sont la possibilité d'écrire aux sorties mulitple - fichiers, consoles, prises, ports série etc

écriture aussi multithread - vous ne voulez pas plusieurs threads d'écriture dans un journal à la temps, sinon vous allez vous retrouver avec des ordures.

Niveaux de journalisation - combien?

vous pouvez alors commencer à écrire du code .... seulement, comme l'a suggéré, je ne vois pas pourquoi vous ne l'utilisez l'un des nombreux disponibles gratuitement framewroks déconnectant là ,,,

Answer 4

Ce sont là quelques pièges que vous peut tomber dedans tout en essayant de créer votre propre cadre de journalisation:

• Problèmes de simultanéité: La structure de journalisation peut être accédée en même temps par différents threads. Vous devez vous assurer qu'aucun conflit ne survient et que les messages sont enregistrés dans le bon ordre.
• Instanciation: L'infrastructure doit être instanciée une fois et être disponible pour le reste de l'application. Vous avez besoin d'une classe 'Singleton', que vous devez implémenter avec soin. L'utilisation de méthodes statiques est une voie à suivre.
• Vous devez disposer d'un mécanisme de configuration à l'aide de fichiers xml ou d'annotations.
• Votre infrastructure doit coopérer avec des bibliothèques tierces. Je crois que c'est le vrai bouchon pour vous. Vous pouvez avoir votre cadre de journalisation pour votre code, mais les bibliothèques que vous utilisez en nécessitent une autre.

Answer 5

C'est une bonne chose à faire seulement parce que vous comprendrez pourquoi vous devriez utiliser l'un des nombreux et excellents frameworks de journalisation. Après avoir joué avec cela pendant une semaine, revenez en arrière et utilisez log4j.

Cependant, jusque-là, et pour commencer, voici un que j'ai préparé plus tôt parce que je voulais me faire une idée de la complexité. Ceci est incomplet pour vos besoins et je vous recommande de l'utiliser simplement pour décider ce que vous voulez faire plutôt que de baser votre implémentation dessus. Il devrait vous donner une idée raisonnable de ce qui est nécessaire et il fournit la connexion à un seul thread de base ...

/* 
* Created on Jun 11, 2005 
*/ 
package com.hupa.util; 

import java.io.*; 
import java.util.Date; 

/** 
* @author simonpalmer 
*/ 
public class MessageWriter implements ILog 
{ 
    public class e_LogLevel 
    { 
     public static final int e_log_error = 1; 
     public static final int e_log_warn = 2; 
     public static final int e_log_info = 4; 
     public static final int e_log_debug = 8; 
    } 
    public int m_iLogLevel = e_LogLevel.e_log_error; 
    public String m_strLogFile = new String(); 
    public String m_strLogPath = new String(); 
    public boolean m_bConsoleOut = true; 
    PrintStream m_ps; 
    public boolean m_bLogOpen = false; 
    private static Date dt = new Date(); 

    /** 
    * Output info level message 
    * @param strMess 
    */ 
    public void info(String strMess) 
    { 
     if ((m_iLogLevel & e_LogLevel.e_log_info) == e_LogLevel.e_log_info) 
     { 
      dt.setTime(System.currentTimeMillis()); 
      String strOut = dt.toString() + " inf: " + strMess; 
      if (m_bConsoleOut) System.out.println(strOut); 
      if (m_bLogOpen) m_ps.println(strOut); 
     } 
    } 
    public boolean bInfo(){return ((m_iLogLevel & e_LogLevel.e_log_info) == e_LogLevel.e_log_info);} 
    /** 
    * Output debug level message 
    * @param strMess 
    */ 
    public void debug(String strMess) 
    { 
     if ((m_iLogLevel & e_LogLevel.e_log_debug) == e_LogLevel.e_log_debug) 
     { 
      dt.setTime(System.currentTimeMillis()); 
      String strOut = dt.toString() + " dbg: " + strMess; 
      if (m_bConsoleOut) System.out.println(strOut); 
      if (m_bLogOpen) m_ps.println(strOut); 
     } 
    } 
    public boolean bDebug(){return ((m_iLogLevel & e_LogLevel.e_log_debug) == e_LogLevel.e_log_debug);} 
    /** 
    * Output warning level message 
    * @param strMess 
    */ 
    public void warn(String strMess) 
    { 
     if ((m_iLogLevel & e_LogLevel.e_log_warn) == e_LogLevel.e_log_warn) 
     { 
      dt.setTime(System.currentTimeMillis()); 
      String strOut = dt.toString() + " warn: " + strMess; 
      if (m_bConsoleOut) System.out.println(strOut); 
      if (m_bLogOpen) m_ps.println(strOut); 
     } 
    } 
    public boolean bWarn(){return ((m_iLogLevel & e_LogLevel.e_log_warn) == e_LogLevel.e_log_warn);} 
    /** 
    * Output error level message 
    * @param strMess 
    */ 
    public void error(String strMess) 
    { 
     if ((m_iLogLevel & e_LogLevel.e_log_error) == e_LogLevel.e_log_error) 
     { 
      dt.setTime(System.currentTimeMillis()); 
      String strOut = dt.toString() + " err: " + strMess; 
      if (m_bConsoleOut) System.out.println(strOut); 
      if (m_bLogOpen) m_ps.println(strOut); 
     } 
    } 
    public boolean bError(){return ((m_iLogLevel & e_LogLevel.e_log_error) == e_LogLevel.e_log_error);} 

    /** 
    * construst the log file name 
    * @return String, full file path and name 
    */ 
    public String GetLogFileName() 
    { 
     return m_strLogPath + m_strLogFile + ".log"; 
    } 

    /** 
    * Open the log file prescribed by the settings 
    * @return boolean, success 
    */ 
    public boolean OpenLog() 
    { 
     try 
     { 
      m_ps = new PrintStream(new FileOutputStream(GetLogFileName())); 
      m_bLogOpen = true; 
     } 
     catch (FileNotFoundException e) 
     { 
      // this means that the folder doesn't exist 
      if (MakeFolder(m_strLogPath)) 
      { 
       m_bLogOpen = true; 
       try 
       { 
        m_ps = new PrintStream(new FileOutputStream(GetLogFileName())); 
       } 
       catch (IOException e1) 
       { 
        e.printStackTrace(); 
        m_bLogOpen = false; 
       } 
      } 
     } 
     return m_bLogOpen; 
    } 

    public static boolean MakeFolder(String strFolder) 
    { 
     try 
     { 
      java.io.File f = new File(strFolder); 
      if (!f.mkdirs()) 
      { 
       return false; 
      } 
     } 
     catch (SecurityException e) 
     { 
      e.printStackTrace(); 
      return false; 
     } 
     return true; 
    } 

    /** 
    * Close the log file 
    * @return boolean, success 
    */ 
    public boolean CloseLog() 
    { 
     if (m_ps != null) 
     { 
      m_ps.flush(); 
      m_ps.close(); 
     } 
     m_bLogOpen = false; 
     return m_bLogOpen; 
    } 

    public void setConsoleOut(boolean b) 
    { 
     m_bConsoleOut = b; 
    } 
    public void setLogLevel(int i) 
    { 
     m_iLogLevel = i; 
    } 

} 

et voici l'interface

public interface ILog 
{ 
    abstract public void debug(String message); 
    abstract public void info(String message); 
    abstract public void warn(String message); 
    abstract public void error(String message); 

    abstract public void setLogLevel(int i); 
    abstract public void setConsoleOut(boolean b); 
    abstract public boolean CloseLog(); 
    abstract public boolean OpenLog(); 

    abstract public boolean bDebug(); 
} 

Answer 6

Vous voulez une petite empreinte mémoire encore de expansibilité? Évitez les optimisations prématurées, alors: essayez log4j ou java.util.logging, mesurez l'empreinte (compilation conditionnelle), et voyez si vous pouvez vraiment battre ça en lançant le vôtre ou en dérivant. En plus de définir les exigences comme le conseille Visage, et en rencontrant les pièges kgiannakakis souligne, les mesures sont votre meilleur ami.