Bons exemples en utilisant java.util.journalisation [fermé]

java.util.logging vous empêche d'avoir à transporter un fichier jar de plus avec votre application, et cela fonctionne bien avec un bon formateur.

En général, en haut de chaque classe, vous devez avoir:

private static final Logger LOGGER = Logger.getLogger( ClassName.class.getName() );

Ensuite, vous pouvez simplement utiliser diverses fonctionnalités de la classe Logger .

Utiliser Level.FINE pour tout ce qui est débogage, au plus haut niveau de flux d'exécution:

LOGGER.log( Level.FINE, "processing {0} entries in loop", list.size() );

Utiliser Level.FINER / Level.FINEST à l'intérieur de boucles et dans des endroits où vous n'avez peut-être pas toujours besoin de voir autant de détails lors du débogage des problèmes de flux de base:

LOGGER.log( Level.FINER, "processing[{0}]: {1}", new Object[]{ i, list.get(i) } );

Utilisez les versions paramétrées des installations de journalisation pour éviter de générer des tonnes de déchets de concaténation de chaînes que GC devra suivre. Object[] comme ci-dessus est bon marché, sur l'allocation de pile généralement.

Avec la gestion des exceptions, enregistrez toujours les détails complets des exceptions:

try {
    ...something that can throw an ignorable exception
} catch( Exception ex ) {
    LOGGER.log( Level.SEVERE, ex.toString(), ex );
}

Je passe toujours ex.toString(), comme le message ici, parce que puis, quand je "grep -n" pour "Exception" dans des fichiers journaux, je peux voir le message trop. Sinon, il va être sur la prochaine ligne de sortie générée par le vidage de la pile, et vous devez avoir une expression régulière plus avancée pour correspondre à cette ligne, ce qui vous donne souvent plus de sortie que vous n'avez besoin de regarder à travers.

Devrait déclarer logger comme ceci:

private final static Logger LOGGER = Logger.getLogger(MyClass.class.getName());

Donc, si vous refactorisez votre nom de classe, il suit.

J'ai écrit un article sur java logger avec des exemples ici.

Il existe de nombreux exemples et aussi de différents types pour la journalisation. Jetez un oeil à la java.util.journalisation du paquet.

Exemple de code:

import java.util.logging.Logger;

public class Main {

  private static Logger LOGGER = Logger.getLogger("InfoLogging");

  public static void main(String[] args) {
    LOGGER.info("Logging an INFO-level message");
  }
}

Sans coder en dur le nom de la classe:

import java.util.logging.Logger;

public class Main {
  private static final Logger LOGGER = Logger.getLogger(
    Thread.currentThread().getStackTrace()[0].getClassName() );

  public static void main(String[] args) {
    LOGGER.info("Logging an INFO-level message");
  }
}

SLF4J est une meilleure façade de journalisation que Apache Commons Logging (ACL). Il a des ponts vers d'autres frameworks de journalisation, faisant des appels directs à ACL, Log4J ou Java Util Logging passent par SLF4J, de sorte que vous pouvez diriger toutes les sorties vers un fichier journal si vous le souhaitez, avec un seul fichier de configuration de journal. Pourquoi votre application utiliserait-elle plusieurs frameworks de journalisation? Parce que les bibliothèques tierces que vous utilisez, en particulier les plus anciennes, le font probablement.

SLF4J prend en charge diverses implémentations de journalisation. Il peut affichez tout sur standard-out, utilisez Log4J ou Logback (recommandé sur Log4J).

Http://www.slf4j.org/

Http://logback.qos.ch/

Je voudrais utiliser minlog, personnellement. C'est extrêmement simple, car la classe de journalisation est de quelques centaines de lignes de code.

Je suggère que vous utilisiez l'utilitaire de journalisation commons d'Apache. Il est hautement évolutif et prend en charge des fichiers journaux séparés pour différents enregistreurs. Voir ici.