Comment initialiser log4j correctement?
Après avoir ajouté log4j à mon application, j'obtiens la sortie suivante chaque fois que j'exécute mon application:
log4j:WARN No appenders could be found for logger (slideselector.facedata.FaceDataParser). log4j:WARN Please initialize the log4j system properly.
Il semble que cela signifie qu'un fichier de configuration est manquant. Où mettre ce fichier de configuration situé et qu'est ce qu'un bon début de contenu?
J'utilise Java simple pour développer une application de bureau. Donc pas de serveur web, etc...
20 réponses
Log4j recherche par défaut un fichier appelé log4j. properties ou log4j.xml sur le chemin de classe. Vous pouvez contrôler le fichier qu'il utilise pour s'initialiser en définissant les propriétés du système comme décrit ici (recherchez la section" Procédure D'initialisation par défaut").
Par exemple:
java -Dlog4j.configuration=customName ....
Va amener log4j à rechercher un fichier appelé customName sur le classpath.
Si vous rencontrez des problèmes je trouve utile d'activer le log4j.debug:
-Dlog4j.debug
Il va d'impression du Système.beaucoup d'informations utiles sur le fichier utilisé pour s'initialiser, quels enregistreurs / appenders ont été configurés et comment, etc.
Le fichier de configuration peut être un fichier de propriétés java ou un fichier xml. Voici un exemple du format de fichier de propriétés extrait de la page de documentation d'introduction de log4j :
log4j.rootLogger=debug, stdout, R
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
# Pattern to output the caller's file name and line number.
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] (%F:%L) - %m%n
log4j.appender.R=org.apache.log4j.RollingFileAppender
log4j.appender.R.File=example.log
log4j.appender.R.MaxFileSize=100KB
# Keep one backup file
log4j.appender.R.MaxBackupIndex=1
log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern=%p %t %c - %m%n
Bien que la configuration correcte de log4j soit idéale pour les projets "réels", vous voudrez peut-être une solution rapide et sale, par exemple si vous ne faites que tester une nouvelle bibliothèque.
Si c'est le cas, un appel à la méthode statique
org.apache.log4j.BasicConfigurator.configure();
Va configurer la journalisation de base sur la console, et les messages d'erreur seront partis.
Si vous venez de vous débarrasser de tout (par exemple, si vous êtes dans les tests)
org.apache.log4j.BasicConfigurator.configure(new NullAppender());
Selon page FAQ Apache Log4j :
Pourquoi est-ce que je vois un avertissement sur "aucun ajout trouvé pour logger" et "Veuillez configurer log4j correctement"?
Cela se produit lorsque les fichiers de configuration par défaut
log4j.properties
etlog4j.xml
ne peuvent pas être trouvés et que l'application n'effectue aucune configuration explicite.log4j
utiliseThread.getContextClassLoader().getResource()
pour localiser les fichiers de configuration par défaut et ne vérifie pas directement le système de fichiers. Connaître l'emplacement approprié à placer log4j. properties oulog4j.xml
nécessite de comprendre la stratégie de recherche du chargeur de classe utilisé.log4j
ne fournit pas de configuration par défaut car la sortie vers la console ou le système de fichiers peut être interdite dans certains environnements.
Fondamentalement, l'avertissement aucun ajout n'a pu être trouvé pour logger signifie que vous utilisez log4j
système de journalisation, mais vous n'avez pas ajouté D'Appenders (tels que FileAppender, ConsoleAppender, SocketAppender, SyslogAppender, etc.) dans votre fichier de configuration le fichier de configuration ou est manquant.
Il y a trois façons de configurer log4j: avec un fichier de propriétés (log4j.properties
), avec un fichier XML et via le code Java (rootLogger.addAppender(new NullAppender());
).
log4j.properties
Si vous avez un fichier de propriété présent (par exemple lors de L'installation de Solr), vous devez placer ce fichier dans votre répertoire classpath.
Classpath
Voici quelques suggestions de commandes sous Linux pour déterminer votre chemin de classe valeur:
$ echo $CLASSPATH
$ ps wuax | grep -i classpath
$ grep -Ri classpath /etc/tomcat? /var/lib/tomcat?/conf /usr/share/tomcat?
Ou de Java: System.getProperty("java.class.path")
.
Log4j XML
Voici un fichier de configuration XML de base pour log4j au format XML:
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
<appender name="console" class="org.apache.log4j.ConsoleAppender">
<param name="Target" value="System.out"/>
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%-5p %c{1} - %m%n"/>
</layout>
</appender>
<root>
<priority value ="debug" />
<appender-ref ref="console" />
</root>
</log4j:configuration>
Tomcat
Si vous utilisez Tomcat, vous pouvez placer votre log4j.properties
en: /usr/share/tomcat?/lib/
ou /var/lib/tomcat?/webapps/*/WEB-INF/lib/
dossier.
Solr
Pour la référence, le fichier Solr default log4j.properties
ressemble à:
# Logging level
solr.log=logs/
log4j.rootLogger=INFO, file, CONSOLE
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%-4r [%t] %-5p %c %x \u2013 %m%n
#- size rotation with log cleanup.
log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.MaxFileSize=4MB
log4j.appender.file.MaxBackupIndex=9
#- File to log to and log format
log4j.appender.file.File=${solr.log}/solr.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%-5p - %d{yyyy-MM-dd HH:mm:ss.SSS}; %C; %m\n
log4j.logger.org.apache.zookeeper=WARN
log4j.logger.org.apache.hadoop=WARN
# set to INFO to enable infostream log messages
log4j.logger.org.apache.solr.update.LoggingInfoStream=OFF
Pourquoi log4j ne peut-il pas trouver mon fichier de propriétés dans une application J2EE ou WAR?
La réponse courte: le les classes log4j et le fichier de propriétés ne sont pas dans la portée du même classloader.
Log4j utilise uniquement le mécanisme par défaut
Class.forName()
pour charger les classes. Les ressources sont traitées de la même manière. Voir la documentation dejava.lang.ClassLoader
pour plus de détails.Donc, si vous rencontrez des problèmes, essayez de charger la classe ou la ressource vous-même. Si vous ne le trouvez pas, log4j non plus.;)
Voir aussi:
- Brève introduction à log4j à Apache site
- Apache: l'enregistrement de Services: FAQ à Apache site
Trouver un log4j. properties ou log4j.xml en ligne qui a un appender racine, et le mettre sur votre classpath.
### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.SimpleLayout
log4j.rootLogger=debug, stdout
Se connectera à la console. Je préfère la journalisation à un fichier afin que vous puissiez enquêter par la suite.
log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.maxFileSize=100KB
log4j.appender.file.maxBackupIndex=5
log4j.appender.file.File=test.log
log4j.appender.file.threshold=debug
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
log4j.rootLogger=debug,file
Bien que pour les applications de journalisation verbeuses, 100 Ko doivent généralement être augmentés à 1 Mo ou 10 Mo, en particulier pour le débogage.
Personnellement, j'ai configuré plusieurs enregistreurs et défini l'enregistreur racine sur warn ou error level au lieu de debug.
Vous pouvez définir l'emplacement de votre log4j. properties à partir de votre application java en utilisant:
org.apache.log4j.PropertyConfigurator.configure(file/location/log4j.properties)
Plus d'informations sont disponibles ici: https://logging.apache.org/log4j/1.2/manual.html
Une autre façon de le faire sans mettre le fichier de propriété sur le classpath, est de définir la propriété à partir du code java directement. Voici un exemple de code.
public class Log4JSample {
public static void main(String[] args) {
Properties properties=new Properties();
properties.setProperty("log4j.rootLogger","TRACE,stdout,MyFile");
properties.setProperty("log4j.rootCategory","TRACE");
properties.setProperty("log4j.appender.stdout", "org.apache.log4j.ConsoleAppender");
properties.setProperty("log4j.appender.stdout.layout", "org.apache.log4j.PatternLayout");
properties.setProperty("log4j.appender.stdout.layout.ConversionPattern","%d{yyyy/MM/dd HH:mm:ss.SSS} [%5p] %t (%F) - %m%n");
properties.setProperty("log4j.appender.MyFile", "org.apache.log4j.RollingFileAppender");
properties.setProperty("log4j.appender.MyFile.File", "my_example.log");
properties.setProperty("log4j.appender.MyFile.MaxFileSize", "100KB");
properties.setProperty("log4j.appender.MyFile.MaxBackupIndex", "1");
properties.setProperty("log4j.appender.MyFile.layout", "org.apache.log4j.PatternLayout");
properties.setProperty("log4j.appender.MyFile.layout.ConversionPattern","%d{yyyy/MM/dd HH:mm:ss.SSS} [%5p] %t (%F) - %m%n");
PropertyConfigurator.configure(properties);
Logger logger = Logger.getLogger("MyFile");
logger.fatal("This is a FATAL message.");
logger.error("This is an ERROR message.");
logger.warn("This is a WARN message.");
logger.info("This is an INFO message.");
logger.debug("This is a DEBUG message.");
logger.trace("This is a TRACE message.");
}
}
Vous pouvez configurer le niveau du journal en utilisant setLevel () .
, Les niveaux sont utiles pour facilement définir le type d'informations que vous souhaitez afficher.
Par exemple:
Logger.getRootLogger().setLevel(Level.WARN); //will not show debug messages
L'ensemble des niveaux sont:
TRACE,
Débogage,
INFO,
Avertir,
Erreur et
FATALE
import org.apache.log4j.BasicConfigurator;
Appelez cette méthode
BasicConfigurator.configure();
Pour activer -Dlog4j.debug
, je vais à Système, paramètres système Avancés, les variables d'Environnement et définissez la variable système _JAVA_OPTIONS
à -Dlog4j.debug
.
Dans quoi développez-vous? Utilisez-vous Apache Tomcat?
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.target=System.out
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{yyyyMMdd HH:mm:ss.SSS} [[%5p] %c{1} [%t]] %m%n
J'ai des propriétés comme celle-ci dans une application Java.
Mon log4j a été corrigé par le fichier de propriété ci-dessous:
## direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.SimpleLayout
log4j.rootLogger=debug, stdout
log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.maxFileSize=100KB
log4j.appender.file.maxBackupIndex=5
log4j.appender.file.File=./logs/test.log
log4j.appender.file.threshold=debug
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
log4j.rootLogger=debug,file
J'ai créé le fichier log4j.propriétés dans ressources dossier à côté de mise en veille prolongée.cfg.xml fichier et rempli avec le texte ci-dessous:
log4j.rootLogger=INFO, CONSOLE
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ABSOLUTE} %-5p [%c{1}:%L] %m%n
Maintenant, je me suis débarrassé des avertissements et des erreurs
Créez simplement log4j. properties sous le dossier src/main/assembly. Selon si vous voulez que les messages de journal soient affichés dans la console ou dans le fichier, vous modifiez votre fichier. Ce qui suit va afficher vos messages dans la console.
# Root logger option
log4j.rootLogger=INFO, stdout
# Direct log messages to stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n
Comme expliqué précédemment, il existe 2 approches
La première consiste à simplement ajouter cette ligne à votre méthode principale:
BasicConfigurator.configure();
La deuxième approche consiste à ajouter ce fichier log4j. properties standard à votre classpath:
Tout en prenant la deuxième approche, vous devez vous assurer que vous initialisez le fichier correctement.
Par exemple.
Properties props = new Properties();
props.load(new FileInputStream("log4j property file path"));
props.setProperty("log4j.appender.File.File", "Folder where you want to store log files/" + "File Name");
Assurez-vous de créer le dossier requis pour stocker les fichiers journaux.
Essayez de définir l'attribut de débogage dans le nœud log4j:configuration sur true.
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/" debug="true">
Il imprime les informations lorsque le fichier de configuration est lu et utilisé pour configurer l'environnement log4j. Vous pouvez avoir plus de détails pour résoudre votre problème.
API de journalisation - L'API Java Logging facilite l'entretien et la maintenance des logiciels sur les sites clients en produisant des rapports de journal adaptés à l'analyse par les utilisateurs finaux, les administrateurs système, les ingénieurs de service sur le terrain et les équipes de développement de logiciels. Les API de journalisation capturent des informations telles que des défaillances de sécurité, des erreurs de configuration, des goulots d'étranglement des performances et/ou des bogues dans l'application ou la plate-forme. Le package de base comprend la prise en charge de la fourniture de texte brut ou XML enregistrements de journaux formatés en mémoire, flux de sortie, consoles, fichiers et sockets. En outre, les API de journalisation sont capables d'interagir avec les services de journalisation qui existent déjà sur le système d'exploitation hôte.
Paquet java.util.journalisation " fournit les classes et les interfaces des fonctionnalités de journalisation de base de la plate-forme Java.
Log4j 1.x " log4j est un utilitaire de journalisation basé sur Java populaire. Log4j est une source ouverte projet basé sur le travail de nombreux auteurs. Il permet au développeur de contrôler quelles instructions de journal sont sorties à divers emplacements en utilisant des Appenders [console, fichiers, DB et email]. Il est entièrement configurable à l'exécution en utilisant des fichiers de configuration externes.
Log4j a trois composantes principales:
- enregistreurs - [OFF, FATAL, ERROR, WARN, INFO, DEBUG, TRACE]
Annexes
Apache Commons Journalisation: ConsoleAppender, FileAppender, RollingFileAppender, DailyRollingFileAppender, JDBCAppender-
Driver
, SocketAppenderLog4J Appender pour MongoDB: MongoDbAppender -
Driver
- Maquettes, [PatternLayout, EnhancedPatternLayout]
Les fichiers de Configuration peuvent être écrits au format XML ou au format Java properties (key = value).
- log4j_External.propriétés " format des propriétés Java (clé = valeur)
La chaîne entre une ouverture "${" et de clôture "}" est interprété comme une clé. La valeur de la variable substituée peut être définie comme une propriété système ou dans le fichier de configuration lui-même. Définissez des options spécifiques à l'appender. "log4j.appender.appenderName.option = valeur, pour chaque addender nommé, vous pouvez configurer sa mise en page.
log4j.rootLogger=INFO, FILE, FILE_PER_SIZE, FILE_PER_DAY, CONSOLE, MySql
#log.path=./
log.path=E:/Logs
# https://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/PatternLayout.html
# {%-5p - [WARN ,INFO ,ERROR], %5p 0- [ WARN, INFO,ERROR]}
log.patternLayout=org.apache.log4j.PatternLayout
log.pattern=%-5p - %d{yyyy-MM-dd HH:mm:ss.SSS} %C{1}:%12.20M:%L - %m %n
# System.out | System.err
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.Target=System.err
log4j.appender.CONSOLE.layout=${log.patternLayout}
log4j.appender.CONSOLE.layout.ConversionPattern=${log.pattern}
# File Appender
log4j.appender.FILE=org.apache.log4j.FileAppender
log4j.appender.FILE.File=${log.path}/logFile.log
#log4j:ERROR setFile(null,false) call failed. - Defaults setFile(null,true)
#log4j.appender.FILE.Append = false
log4j.appender.FILE.layout=${log.patternLayout}
log4j.appender.FILE.layout.ConversionPattern=${log.pattern}
# BackUP files for every Day.
log4j.appender.FILE_PER_DAY=org.apache.log4j.DailyRollingFileAppender
# [[ Current File ] - logRollingDayFile.log ], { [BackUPs] logRollingDayFile.log_2017-12-10, ... }
log4j.appender.FILE_PER_DAY.File=${log.path}/logRollingDayFile.log
log4j.appender.FILE_PER_DAY.DatePattern='_'yyyy-MM-dd
log4j.appender.FILE_PER_DAY.layout=${log.patternLayout}
log4j.appender.FILE_PER_DAY.layout.ConversionPattern=${log.pattern}
# BackUP files for size rotation with log cleanup.
log4j.appender.FILE_PER_SIZE=org.apache.log4j.RollingFileAppender
# [[ Current File ] - logRollingFile.log ], { [BackUPs] logRollingFile.log.1, logRollingFile.log.2}
log4j.appender.FILE_PER_SIZE.File=${log.path}/logRollingFile.log
log4j.appender.FILE_PER_SIZE.MaxFileSize=100KB
log4j.appender.FILE_PER_SIZE.MaxBackupIndex=2
log4j.appender.FILE_PER_SIZE.layout=${log.patternLayout}
log4j.appender.FILE_PER_SIZE.layout.ConversionPattern=${log.pattern}
# MySql Database - JDBCAppender
log4j.appender.MySql=org.apache.log4j.jdbc.JDBCAppender
log4j.appender.MySql.driver=com.mysql.jdbc.Driver
log4j.appender.MySql.URL=jdbc:mysql://localhost:3306/automationlab
log4j.appender.MySql.user=root
log4j.appender.MySql.password=
log4j.appender.MySql.layout=org.apache.log4j.EnhancedPatternLayout
log4j.appender.MySql.layout.ConversionPattern=INSERT INTO `logdata` VALUES ('%p', '%d{yyyy-MM-dd HH:mm:ss}', '%C', '%M', '%L', '%m');
#log4j.appender.MySql.sql=INSERT INTO `logdata` VALUES ('%p', '%d{yyyy-MM-dd HH:mm:ss}', '%C', '%M', '%L', '%m');
# Direct log events[Messages] to MongoDB Collection - MongoDbAppender
log.mongoDB.hostname=loalhost
log.mongoDB.userName=Yash777
log.mongoDB.password=Yash@123
log.mongoDB.DB=MyLogDB
log.mongoDB.Collection=Logs
log4j.appender.MongoDB=org.log4mongo.MongoDbAppender
log4j.appender.MongoDB.hostname=${log.mongoDB.hostname}
log4j.appender.MongoDB.userName=${log.mongoDB.userName}
log4j.appender.MongoDB.password=${log.mongoDB.password}
log4j.appender.MongoDB.port=27017
log4j.appender.MongoDB.databaseName=${log.mongoDB.DB}
log4j.appender.MongoDB.collectionName=${log.mongoDB.Collection}
log4j.appender.MongoDB.writeConcern=FSYNCED
Structure de la Table MySQL pour le tableau logdata
CREATE TABLE IF NOT EXISTS `logdata` (
`Logger_Level` varchar(5) COLLATE utf8_unicode_ci NOT NULL,
`DataTime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
`ClassName` varchar(30) COLLATE utf8_unicode_ci NOT NULL,
`MethodName` varchar(50) COLLATE utf8_unicode_ci NOT NULL,
`LineNumber` int(10) NOT NULL,
`Message` text COLLATE utf8_unicode_ci NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;
- log4j_External.xml " XML log4j: configuration avec un fichier DTD public
<?xml version="1.0" encoding="iso-8859-1"?>
<!DOCTYPE log4j:configuration PUBLIC
"-//APACHE//DTD LOG4J 1.2//EN" "http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/xml/doc-files/log4j.dtd">
<log4j:configuration debug="false">
<appender name="CONSOLE" class="org.apache.log4j.ConsoleAppender">
<param name="target" value="System.out" />
<param name="threshold" value="debug" />
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%-5p - %d{yyyy-MM-dd HH:mm:ss.SSS} %C{1}:%12.20M:%L - %m %n" />
</layout>
</appender>
<appender name="FILE" class="org.apache.log4j.FileAppender">
<param name="file" value="E:/Logs/logFile.log" />
<param name="append" value="false" />
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%-5p - %d{yyyy-MM-dd HH:mm:ss.SSS} %C{1}:%12.20M:%L - %m %n" />
</layout>
</appender>
<appender name="FILE_PER_SIZE" class="org.apache.log4j.RollingFileAppender">
<param name="file" value="E:/Logs/logRollingFile.log" />
<param name="immediateFlush" value="true"/>
<param name="maxFileSize" value="100KB" />
<param name="maxBackupIndex" value="2"/>
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%-5p - %d{yyyy-MM-dd HH:mm:ss.SSS} %C{1}:%12.20M:%L - %m %n" />
</layout>
</appender>
<appender name="FILE_PER_DAY" class="org.apache.log4j.DailyRollingFileAppender">
<param name="file" value="E:/Logs/logRollingDayFile.log" />
<param name="datePattern" value="'_'yyyy-MM-dd" />
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%-5p - %d{yyyy-MM-dd HH:mm:ss.SSS} %C{1}:%12.20M:%L - %m %n"/>
</layout>
</appender>
<root>
<priority value="info" />
<appender-ref ref="CONSOLE" />
<appender-ref ref="FILE" />
<appender-ref ref="FILE_PER_SIZE" />
<appender-ref ref="FILE_PER_DAY" />
</root>
</log4j:configuration>
- configuration Log4j à partir de L'URL dans le programme Java:
Afin de spécifier une configuration personnalisée avec un fichier externe, la classe utilisée doit implémenter Interface configurateur.
Lorsque les fichiers de configuration par défaut "log4j.properties", "log4j.xml" ne sont pas disponibles
- pour "log4j. properties", vous pouvezPropertyConfigurator.configurer (java.net.URL) méthode.
- Pour "log4j.xml" DOMConfigurator sera utilisé.
public class LogFiles {
// Define a static logger variable so that it references the Logger instance named "LogFiles".
static final Logger log = Logger.getLogger( LogFiles.class );
@SuppressWarnings("deprecation")
public static void main(String[] args) {
System.out.println("CONFIGURATION_FILE « "+LogManager.DEFAULT_CONFIGURATION_FILE);
System.out.println("DEFAULT_XML_CONFIGURATION_FILE = 'log4j.xml' « Default access modifier");
String fileName = //"";
//"log4j_External.xml";
"log4j_External.properties";
String configurationFile = System.getProperty("user.dir")+"/src/" + fileName;
if( fileName.contains(".xml") ) {
DOMConfigurator.configure( configurationFile );
log.info("Extension *.xml");
} else if ( fileName.contains(".properties") ) {
PropertyConfigurator.configure( configurationFile );
log.info("Extension *.properties");
} else {
DailyRollingFileAppender dailyRollingAppender = new DailyRollingFileAppender();
dailyRollingAppender.setFile("E:/Logs/logRollingDayFile.log");
dailyRollingAppender.setDatePattern("'_'yyyy-MM-dd");
PatternLayout layout = new PatternLayout();
layout.setConversionPattern( "%-5p - %d{yyyy-MM-dd HH:mm:ss.SSS} %C{1}:%12.20M:%L - %m %n" );
dailyRollingAppender.setLayout(layout);
dailyRollingAppender.activateOptions();
Logger rootLogger = Logger.getRootLogger();
rootLogger.setLevel(Level.DEBUG);
rootLogger.addAppender(dailyRollingAppender);
log.info("Configuring from Java Class.");
}
log.info("Console.Message.");
method2();
methodException(0);
}
static void method2() {
log.info("method2 - Console.Message.");
}
static void methodException(int b) {
try {
int a = 10/b;
System.out.println("Result : "+ a);
log.info("Result : "+ a);
} catch (Exception ex) { // ArithmeticException: / by zero
log.error(String.format("\n\tException occurred: %s", stackTraceToString(ex)));
}
}
public static String stackTraceToString(Exception ex) {
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
ex.printStackTrace(pw);
return sw.toString();
}
}
Si nous utilisons le wrapper de journalisation Apache commons au-dessus de log4j, alors nous devons avoir les deux jars disponibles dans classpath. En outre, commons-logging.properties
et log4j.properties/xml
devraient être disponibles dans classpath.
Nous pouvons également passer la classe d'implémentation et log4j.properties
name comme {[3] } soit en utilisant -Dorg.apache.commons.logging.Log=<logging implementation class name> -Dlog4j.configuration=<file:location of log4j.properties/xml file>
. La même chose peut être faite via le paramètre JAVA_OPTS
dans le cas d'un serveur app/web.
Cela aidera à externaliser les propriétés qui peuvent être modifiées dans le déploiement.
C'est une autre façon d'utiliser .yaml
Structure Logique:
Configuration:
Properties:
Appenders:
Loggers:
Échantillon:
Configutation:
name: Default
Properties:
Property:
name: log-path
value: "logs"
Appenders:
Console:
name: Console_Appender
target: SYSTEM_OUT
PatternLayout:
pattern: "[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %c{1} - %msg%n"
File:
name: File_Appender
fileName: ${log-path}/logfile.log
PatternLayout:
pattern: "[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %c{1} - %msg%n"
Loggers:
Root:
level: debug
AppenderRef:
- ref: Console_Appender
Logger:
- name: <package>.<subpackage>.<subsubpackage>.<...>
level: debug
AppenderRef:
- ref: File_Appender
level: error
Pour les tests, un moyen rapide, y compris le réglage du niveau du journal:
org.apache.log4j.BasicConfigurator.configure();
org.apache.log4j.Logger.getRootLogger().setLevel(org.apache.log4j.Level.WARN);
// set to Level.DEBUG for full, or Level.OFF..