Je veux utiliser les journaux dans mon programme. J'ai entendu parler de Java.util.logging , mais je ne sais pas comment commencer.
Existe-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, en haut de chaque classe , vous devriez avoir:
_private static final Logger LOGGER = Logger.getLogger( ClassName.class.getName() );
_
Ensuite, vous pouvez simplement utiliser diverses installations de la classe Enregistreur .
Utilisez Level.FINE
pour tout ce qui est en cours de débogage en haut niveau d'exécution:
_LOGGER.log( Level.FINE, "processing {0} entries in loop", list.size() );
_
Utilisez _Level.FINER
_/_Level.FINEST
_ à l'intérieur des boucles et à des emplacements où vous n'aurez peut-être pas 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 GC devra suivre. _Object[]
_ comme ci-dessus est bon marché, généralement sur l'allocation de pile.
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 le message ex.toString()
comme message ici, car lorsque je "_grep -n
_" pour "Exception
" dans les fichiers journaux, je peux également voir le message. Sinon, il se trouvera sur la prochaine ligne de sortie générée par le vidage de pile et vous devrez disposer d'un RegEx plus avancé pour correspondre à cette ligne également, ce qui vous donnera souvent plus de sortie que nécessaire.
Doit déclarer l'enregistreur comme ceci:
private final static Logger LOGGER = Logger.getLogger(MyClass.class.getName());
donc, si vous modifiez le nom de votre classe, il suit.
J'ai écrit un article sur Java enregistreur avec exemples ici .
Il existe de nombreux exemples et différents types d’enregistrement. Jetez un coup d'œ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 la 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 établit des liaisons avec d'autres infrastructures de journalisation, en appelant directement ACL, Log4J ou Java Util. La journalisation passe par SLF4J, de sorte que vous pouvez diriger toutes les sorties vers un seul fichier journal si vous le souhaitez, avec une seule configuration de journal. fichier. Pourquoi votre application utilise-t-elle plusieurs infrastructures de journalisation? Parce que les bibliothèques tierces que vous utilisez, surtout 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).
J'utiliserais minlog , personnellement. C'est extrêmement simple, car la classe de journalisation est composée de quelques centaines de lignes de code.
Je suggérerais que vous utilisiez l'utilitaire de journalisation commun d'Apache. Il est hautement évolutif et prend en charge des fichiers journaux distincts pour différents enregistreurs. Voir ici .