À propos du niveau de journalisation de java.util.logging.Logger

Qu'est-ce que java.util.logging.Logger?

API standard Java. Enregistre les informations d'erreur en fonction du contenu.

comment utiliser

Tout d'abord, l'utilisation de base. Les apparences principales sont les trois suivantes.

1. Logger-Un objet qui génère des journaux.
2. Handler - Objet qui contrôle la destination de sortie du journal.
3. Formatter-Un objet qui contrôle le format du journal.

Commencez par créer une instance Logger.

Logger logger = Logger.getLogger("nom de l'enregistreur")

Ensuite, créez une instance Handler et enregistrez-la avec le logger. Vous pouvez enregistrer plusieurs gestionnaires. Cette fois, créez un gestionnaire avec C: \ sample \ sample.log comme destination de sortie. Si vous souhaitez générer une sortie dans un fichier, utilisez la classe d'implémentation d'interface Handler FileHandler.

Handler handler = new FileHandler("C:\\sample\\sample.log");
logger.addHandler(handler);

Enfin, créez une instance du formateur et enregistrez-la dans le gestionnaire. Cette fois, nous utiliserons SimpleFormatter pour le formater sous une forme facile à lire pour les humains. SimpleFormatter est une classe d'implémentation de l'interface Formatter.

Formatter formatter =  new SimpleFormatter();
handler.setFormatter(formatter);

Maintenant, vous êtes prêt à partir. Transmettez le message à l'enregistreur et sortez le journal.

Niveau de journal

Spécifiez le niveau de journalisation lors de la sortie du journal. Vous pouvez définir les niveaux de demande suivants:

Par exemple, si Level.CONFIG est défini, la sortie du journal sera "Configuration", "Information", "Warning", "Critical" et en dessous du niveau défini. Level.ALL, comme son nom l'indique, affiche tout.

Confirmation par mise en œuvre

Vérifiez la sortie réelle du journal par l'implémentation suivante.

Log

public class Log {

	public static Logger getLog(String name) {
		//Générer un enregistreur
		Logger logger = Logger.getLogger(name);

		try {
			//Génération de gestionnaire (vrai):l'écriture,false:Écraser)
			Handler handler = new FileHandler("/log/sample.log", false);
			//Spécification du format de journal par SimpleFormat
			handler.setFormatter(new SimpleFormatter());
			//Spécifiez le niveau de journalisation/Paramètres du gestionnaire
		    logger.addHandler(handler);
		    logger.setLevel(Level.ALL);

		    //Paramètres de sortie standard
		    ConsoleHandler consoleHandler = new ConsoleHandler();
			consoleHandler.setLevel(Level.CONFIG);
			logger.addHandler(consoleHandler);

		    //Paramètres de l'enregistreur parental(true:Envoyer à l'enregistreur parent,false:Envoyer à l'enregistreur parentしない)
			logger.setUseParentHandlers(false);
			//Sortie de journal
			logger.finest("FNST");
			logger.finer("FNR");
			logger.fine("FN");
			logger.config("CFG");
			logger.info("INF");
			logger.warning("WNG");
			logger.severe("SVR");

			throw new IOException();

		}  catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
			logger.log(Level.CONFIG, "Erreur est survenue", e);
			logger.warning("WNG:Erreur est survenue");
		}
		return logger;
	}
}

Cette classe sera une classe qui encapsule java.util.logging.Logger``` Vérifiez le comportement du journal en appelant la méthode getLog () avec le nom de la classe comme argument

1. Utilisez getLogger () pour générer un enregistreur et définir le niveau de journalisation

Générer un enregistreur en utilisant la méthode getLogger de java.util.logging.Logger``` Spécifiez le niveau de journalisation avec la méthode setLevel

2. Configuration de la sortie sous forme de fichier (FileHandler)

Définissez l'emplacement, le format et le niveau du fichier journal. Utilisez FileHandler pour définir le premier argument: chemin du fichier, deuxième argument: écraser / ajouter true est écrasé et false est ajouté. Cette fois, je veux voir le comportement quand il est exécuté une fois, alors réglez-le sur true Définir le format de journal pour le gestionnaire généré Par défaut, le journal est sorti au format XML, mais il est difficile à voir, alors définissez-le pour une sortie en japonais avec SimpleFormatter (). Vous pouvez définir le niveau de journalisation dans le gestionnaire et configurer l'enregistreur pour qu'il ne génère que les messages au-dessus d'un certain niveau de journal. Cette fois, en définissant ALL, toutes les sorties du journal seront décrites dans le fichier.

3. Définissez la sortie standard (ConsoleHandler)

En configurant ConsoleHandler, le contenu du journal peut également être vérifié sur la console. La méthode de paramétrage peut être effectuée à l'aide de la méthode addHandler () comme FileHandler. Définissez également le niveau de journalisation pour la sortie standard afin que les journaux de CONFIG ou supérieurs soient générés.

4. Paramètres de l'enregistreur parental

False est défini, mais s'il est défini sur true, la sortie standard inférieure au niveau requis s'affiche deux fois ou le niveau ne correspond pas. Ce qui s'affiche deux fois, c'est que le journal créé est envoyé à l'enregistreur parent, de sorte que le journal enregistré dans l'enregistreur parent sera sorti.

5. Paramètres du journal

Chaque niveau de journal est émis pour la confirmation du journal.

6. Vérifiez le journal lorsqu'une erreur se produit

J'ai soulevé une IOException et l'ai liée au journal lorsque la dernière erreur s'est produite.

Créez une classe maiin et appelez-la pour vérifier son comportement.

Résultat d'exécution

Sample.log

9 21, 2020 2:18:27 h 00.abstractDemo.log.Log getLog
Le plus détaillé: FNST
9 21, 2020 2:18:27 h 00.abstractDemo.log.Log getLog
Détails: FNR
9 21, 2020 2:18:27 h 00.abstractDemo.log.Log getLog
d'habitude: FN
9 21, 2020 2:18:27 h 00.abstractDemo.log.Log getLog
Constitution: CFG
9 21, 2020 2:18:27 h 00.abstractDemo.log.Log getLog
information: INF
9 21, 2020 2:18:27 h 00.abstractDemo.log.Log getLog
avertissement: WNG
9 21, 2020 2:18:27 h 00.abstractDemo.log.Log getLog
Sérieux: SVR
9 21, 2020 2:18:27 h 00.abstractDemo.log.Log getLog
Constitution:Erreur est survenue
java.io.IOException
	at app.abstractDemo.log.Log.getLog(Log.java:43)
	at app.abstractDemo.MainActivity.main(MainActivity.java:10)

9 21, 2020 2:18:27 h 00.abstractDemo.log.Log getLog
avertissement: WNG:Erreur est survenue

Grâce à SimpleFormatter (), j'ai pu confirmer que le journal a été modifié pour être sorti en japonais au lieu du format XML. Tous les journaux sont générés car le niveau de journalisation de l'enregistreur est défini sur TOUS.

Sortie standard

9 21, 2020 2:18:27 h 00.abstractDemo.log.Log getLog
Constitution: CFG
9 21, 2020 2:18:27 h 00.abstractDemo.log.Log getLog
information: INF
9 21, 2020 2:18:27 h 00.abstractDemo.log.Log getLog
avertissement: WNG
9 21, 2020 2:18:27 h 00.abstractDemo.log.Log getLog
Sérieux: SVR
java.io.IOException
	at app.abstractDemo.log.Log.getLog(Log.java:43)
	at app.abstractDemo.MainActivity.main(MainActivity.java:10)
9 21, 2020 2:18:27 h 00.abstractDemo.log.Log getLog
Constitution:Erreur est survenue
java.io.IOException
	at app.abstractDemo.log.Log.getLog(Log.java:43)
	at app.abstractDemo.MainActivity.main(MainActivity.java:10)

9 21, 2020 2:18:27 h 00.abstractDemo.log.Log getLog
avertissement: WNG:Erreur est survenue

Étant donné que le niveau de journalisation de consoleHandler est défini dans CONFIG, il a été confirmé que les journaux supérieurs à CONFIG sont générés.

filtre

J'ai présenté comment définir le niveau de journalisation dans l'enregistreur et le contrôler afin que seuls les messages au-dessus d'un certain niveau de journal soient sortis, mais si vous souhaitez un contrôle plus détaillé, utilisez la classe Filter.

Filter filter = new Filter() {
    @Override
    public boolean isLoggable(LogRecord record) {
        return record.getMessage().contains("Nombre de dossiers traités=");
    }
};
logger.setFilter(filter);

Si le filtre est défini comme ci-dessus, seuls les journaux qui incluent "nombre de processus =" seront affichés dans le message. Ajoutez l'enregistrement suivant à l'implémentation et vérifiez le processus

Log

	        //Définir un filtre sur l'enregistreur
	        Filter filter1 = new Filter() {
	            @Override
	            public boolean isLoggable(LogRecord record) {
	                return record.getMessage().contains("Nombre de dossiers traités=");
	            }
	        };
	        logger.setFilter(filter1);
	        logger.info("Exemple de message");                          //Pas de sortie
	        logger.info("Exemple de message,Nombre de dossiers traités=1");               //Production

	        //Définir un filtre sur le gestionnaire
	        Filter filter2 = (record) -> record.getMessage().contains("Nombre de mises à jour=");
	        handler.setFilter(filter2);
	        logger.info("Exemple de message");                          //Pas de sortie
	        logger.info("Exemple de message,Nombre de dossiers traités=1");               //Pas de sortie
	        logger.info("Exemple de message,Nombre de dossiers traités=1,Nombre de mises à jour=1");    //Production

	        //Définir le niveau de journalisation dans le gestionnaire
	        handler.setLevel(Level.WARNING);
	        logger.info("Exemple de message");                          //Pas de sortie
	        logger.info("Exemple de message,Nombre de dossiers traités=1");               //Pas de sortie
	        logger.info("Exemple de message,Nombre de dossiers traités=1,Nombre de mises à jour=1");    //Pas de sortie
	        logger.warning("Message d'alerte,Nombre de dossiers traités=1,Nombre de mises à jour=1");   //Production

Il est supposé que seul le journal écrit comme commenté par le filtre et le niveau de journal sera généré.

Résultat d'exécution

sample.log

9 21, 2020 12:14:03 après-midi.abstractDemo.log.Log getLog
information:Exemple de message,Nombre de dossiers traités=1
9 21, 2020 12:14:03 après-midi.abstractDemo.log.Log getLog
information:Exemple de message,Nombre de dossiers traités=1,Nombre de mises à jour=1
9 21, 2020 12:14:03 après-midi.abstractDemo.log.Log getLog
avertissement: avertissementメッセージ,Nombre de dossiers traités=1,Nombre de mises à jour=1

Trois journaux sont générés comme prévu.

Sortie standard

9 21, 2020 12:14:03 après-midi.abstractDemo.log.Log getLog
information:Exemple de message,Nombre de dossiers traités=1
9 21, 2020 12:14:03 après-midi.abstractDemo.log.Log getLog
information:Exemple de message,Nombre de dossiers traités=1
9 21, 2020 12:14:03 après-midi.abstractDemo.log.Log getLog
information:Exemple de message,Nombre de dossiers traités=1,Nombre de mises à jour=1
9 21, 2020 12:14:03 après-midi.abstractDemo.log.Log getLog
information:Exemple de message,Nombre de dossiers traités=1
9 21, 2020 12:14:03 après-midi.abstractDemo.log.Log getLog
information:Exemple de message,Nombre de dossiers traités=1,Nombre de mises à jour=1
9 21, 2020 12:14:03 après-midi.abstractDemo.log.Log getLog
avertissement: avertissementメッセージ,Nombre de dossiers traités=1,Nombre de mises à jour=1

Étant donné qu'aucun filtre n'est défini dans consoleHandler, seul le paramètre de filtre défini dans le journal est appliqué. Par conséquent, le "nombre de processus =" défini dans filler1 et le niveau de journal "CONFIG" défini dans consoleHandler sont appliqués et sortis.

Contrôle de sortie de journal

Le filtre de niveau de journal défini pour l'enregistreur est vérifié uniquement par l'enregistreur qui est appelé directement. La vérification du filtre de niveau de journal définie dans le gestionnaire est vérifiée par tous les gestionnaires, y compris le gestionnaire de l'enregistreur parent. En gros, la logique de sortie du journal est celle illustrée dans la figure ci-dessous.

Le filtre de niveau de journal défini sur l'enregistreur est vérifié uniquement sur le premier enregistreur qui reçoit l'appel, alors qu'il est vérifié. Tous les gestionnaires vérifient le filtre de niveau de journal défini dans le gestionnaire.

Étant donné que les paramètres de l'enregistreur ne sont définis qu'au moment de l'appel, ils ne sont pas propagés vers l'enregistreur parent et la sortie du journal peut ne pas être comme prévu. Par exemple, enregistreur parent: AVERTISSEMENT, enregistreur enfant: FINE Gestionnaire: TOUS

Lorsqu'il est défini dans, le journal défini dans FINE est émis même si le niveau de journal est défini dans WARNING dans le journal parent. C'est parce que les paramètres du gestionnaire sont hérités et vérifiés, il semble donc que le journal parent n'est pas défini. Les paramètres peuvent être appliqués en modifiant les paramètres suivants. Enregistreur parent / enregistreur enfant: TOUS Manieur: WRANING

Lire le fichier de propriétés

Si vous écrivez les paramètres du journal sur la source, ce sera compliqué et difficile à lire.

La méthode pour lire le fichier de paramètres à partir du programme est la suivante. Cette fois, logging.properties situé dans le même chemin de classe de l'exemple de programme est lu. Le fichier de configuration doit être lu au format java.util.Properties.

LogManager.getLogManager().readConfiguration(SettingFileSample.class.getResourceAsStream("logging.properties"));

Le fichier de configuration d'exemple est le suivant. Veuillez consulter {java.home} \ lib \ logging.properties pour une explication détaillée.

logging.properties

#Le paramètre de niveau de journal du gestionnaire de journalisation racine ConsoleHandler a une erreur standard(System.err)Exportez le journal vers.
handlers=java.util.logging.ConsoleHandler
.level=INFO

#Enregistreur utilisé dans l'exemple de programme"sample.SettingFileSample"paramètres de
sample.SettingFileSample.level=FINE
sample.SettingFileSample.handlers=java.util.logging.FileHandler

#Paramètres de ConsoleHandler
java.util.logging.ConsoleHandler.level=INFO
java.util.logging.ConsoleHandler.formatter=java.util.logging.SimpleFormatter

#Paramètres FileHandler
java.util.logging.FileHandler.pattern=C:/sample/sample.log
java.util.logging.FileHandler.limit=1000
java.util.logging.FileHandler.count=1
java.util.logging.FileHandler.formatter=java.util.logging.SimpleFormatter

L'exemple de programme utilisant le fichier de configuration ci-dessus est décrit ci-dessous.

SettingFileSample

public class SettingFileSample {

    public static void main(String[] arg) throws SecurityException, IOException {
        LogManager.getLogManager().readConfiguration(SettingFileSample.class.getResourceAsStream("logging.properties"));

        Logger logger = Logger.getLogger("sample.SettingFileSample");
        logger.finer("Message FINER");
        logger.fine("Message FINE");
        logger.info("Message INFO");
    }
}

C'est chouette car il n'y a pas de paramètres d'enregistreur ou de gestionnaire.

Article de référence

Comment utiliser java.util.logging