Bons exemples utilisant java.util.logging [fermé]

Je souhaite utiliser des journaux dans mon programme. J'ai entendu parler de java.util.logging , mais je ne sais pas par où commencer.

Y a-t-il des exemples de ce que je peux faire avec la journalisation? Comment utiliser la journalisation dans mon propre programme?

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

En général, au sommet de chaque classe , vous devriez avoir:

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

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

Utilisez Level.FINEpour tout ce qui débogue au niveau supérieur du flux d'exécution:

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

Utilisez Level.FINER/ à l' Level.FINESTintérieur des boucles et dans des endroits où vous n'aurez 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 fonctions de journalisation pour éviter de générer des tonnes de déchets de concaténation de chaînes que le 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 de l'exception:

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

Je passe toujours ex.toString()le message ici, car lorsque je " grep -n" pour " Exception" dans les fichiers journaux, je peux aussi voir le message. Sinon, il se trouvera sur la prochaine ligne de sortie générée par le vidage de la pile, et vous devez également disposer d'un RegEx plus avancé pour correspondre à cette ligne, ce qui vous donne souvent plus de sortie que vous n'en avez besoin.

Devrait déclarer l'enregistreur comme ceci:

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

donc si vous refactorisez le nom de votre classe, cela suit.

J'ai écrit un article sur Java Logger avec des exemples ici .

Il existe de nombreux exemples et également de différents types de journalisation. Jetez un œil au package java.util.logging .

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 cadres de journalisation, faisant des appels directs à ACL, Log4J ou Java Util Logging via 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 cadres 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 tout sortir en sortie standard, utiliser Log4J ou Logback (recommandé sur Log4J).

http://www.slf4j.org/

http://logback.qos.ch/

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

Je vous suggère d'utiliser l'utilitaire de journalisation des communs d'Apache. Il est hautement évolutif et prend en charge des fichiers journaux distincts pour différents enregistreurs. Voyez ici .