Comment initialiser correctement log4j?

Après avoir ajouté log4j à mon application, j'obtiens la sortie suivante chaque fois que j'exécute mon application:

log4j: AVERTISSEMENT Aucun appender n'a pu être trouvé pour l'enregistreur (slideselector.facedata.FaceDataParser).
log4j: WARN Veuillez initialiser correctement le système log4j.

Il semble que cela signifie qu'il manque un fichier de configuration. Où doit se trouver ce fichier de configuration et qu'est-ce qu'un bon contenu de départ?

J'utilise plain java pour développer une application de bureau. Donc pas de serveur web etc ...

Log4jrecherche par défaut un fichier appelé log4j.propertiesou log4j.xmlsur le chemin de classe.

Vous pouvez contrôler le fichier qu'il utilise pour s'initialiser lui-même 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 ....

Causera log4jà la recherche d'un fichier appelé customName sur le chemin de classe.

Si vous rencontrez des problèmes, je trouve utile d'activer le log4j.debug:

-Dlog4j.debug

Il imprimera sur System.out de nombreuses informations utiles sur le fichier qu'il a utilisé pour s'initialiser lui-même, les enregistreurs / appendeurs 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 de l'intro 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 "vrais" projets, vous voudrez peut-être une solution rapide et sale, par exemple si vous testez simplement une nouvelle bibliothèque.

Si c'est le cas, un appel à la méthode statique

org.apache.log4j.BasicConfigurator.configure();

configurera la journalisation de base sur la console et les messages d'erreur auront disparu.

Si vous vous débarrassez de tout (par exemple si vous êtes en test)

org.apache.log4j.BasicConfigurator.configure(new NullAppender());

Selon la page FAQ Apache Log4j :

Pourquoi un avertissement s'affiche-t-il à propos de «Aucun appender trouvé pour l'enregistreur» et «Veuillez configurer correctement log4j»?

Cela se produit lorsque la configuration par défaut des fichiers log4j.propertieset log4j.xmlne peut pas être trouvé et l'application N'a pas de configuration explicite. log4jutilise Thread.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é pour placer log4j.properties ou log4j.xmlnécessite de comprendre la stratégie de recherche du chargeur de classe utilisé. log4jne fournit pas de configuration par défaut car la sortie vers la console ou vers le système de fichiers peut être interdite dans certains environnements.

Fondamentalement, l'avertissement Aucun appender n'a été trouvé pour l'enregistreur signifie que vous utilisez le log4jsystème de journalisation, mais vous n'avez ajouté aucun appender (tel que FileAppender, ConsoleAppender, SocketAppender, SyslogAppender, etc.) dans votre fichier de configuration ou le fichier de configuration est manquant.

Il existe trois façons de configurer log4j: avec un fichier de propriétés ( log4j.properties), avec un fichier XML et via du code Java ( rootLogger.addAppender(new NullAppender());).

log4j.properties

Si un fichier de propriétés est présent (par exemple lors de l'installation de Solr), vous devez placer ce fichier dans votre chemin de classe répertoire .

chemin de classe

Voici quelques suggestions de commandes sous Linux pour déterminer votre valeur de chemin de classe:

$ echo $CLASSPATH
$ ps wuax | grep -i classpath
$ grep -Ri classpath /etc/tomcat? /var/lib/tomcat?/conf /usr/share/tomcat?

ou depuis 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>

Matou

Si vous utilisez Tomcat, vous pouvez placer votre log4j.propertiesdans: /usr/share/tomcat?/lib/ou /var/lib/tomcat?/webapps/*/WEB-INF/lib/dossier.

Solr

Pour référence, le log4j.propertiesfichier par défaut de Solr 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 trouve-t-il pas mon fichier de propriétés dans une application J2EE ou WAR?

La réponse courte: les classes log4j et le fichier de propriétés ne sont pas dans la portée du même chargeur de classe.

Log4j utilise uniquement le Class.forName()mécanisme par défaut pour charger les classes. Les ressources sont gérées de la même manière. Consultez la documentation java.lang.ClassLoaderpour 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 également:

• Brève introduction à log4j sur le site Apache
• Apache: Logging Services: FAQ sur le site Apache

Vous pouvez définir l'emplacement de votre log4j.properties depuis l'intérieur 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

Trouvez un log4j.properties ou log4j.xml en ligne qui a un appender racine et placez-le sur votre chemin de classe.

### 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

va se connecter à la console. Je préfère me connecter à 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 détaillées, 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 le niveau d'avertissement ou d'erreur au lieu de déboguer.

Une autre façon de le faire sans placer le fichier de propriétés sur le chemin de classe consiste à définir directement la propriété à partir du code java. Voici l 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 de journalisation à l'aide de setLevel () .

Les niveaux sont utiles pour définir facilement le type d'informations que vous souhaitez que le programme affiche.

Par exemple:

Logger.getRootLogger().setLevel(Level.WARN); //will not show debug messages

L'ensemble des niveaux possibles sont:

TRACE,

DÉBOGUER,

INFO,

PRÉVENIR,

ERREUR et

FATAL

Selon le manuel Logging Services

import org.apache.log4j.BasicConfigurator;

Appelez cette méthode

BasicConfigurator.configure();

Pour l'activer -Dlog4j.debug, je vais dans Système, Paramètres système avancés, Variables d'environnement et définissez la variable système _JAVA_OPTIONSsur -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 de mes applications Java.

Mon log4j a été corrigé par le fichier de propriétés 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.properties dans le dossier des ressources à côté du fichier hibernate.cfg.xml et l' ai 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 que vous souhaitez afficher les messages de journal dans la console ou dans le fichier, vous modifiez votre fichier. Ce qui suit va montrer 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 chemin de classe:

Lors de la seconde approche, vous devez vous assurer d'initialiser correctement le fichier.

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 log4j: node de configuration sur true.

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/" debug="true">

Il imprime des informations à mesure que le fichier de configuration est lu et utilisé pour configurer l'environnement log4j. Vous obtiendrez peut-être plus de détails pour résoudre votre problème.

API de journalisation - L'API de journalisation Java facilite l'entretien et la maintenance des logiciels sur les sites des 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 les échecs de sécurité, les erreurs de configuration, les goulots d'étranglement des performances et / ou les bogues dans l'application ou la plate-forme. Le package de base inclut la prise en charge de la livraison d'enregistrements de journal au format texte brut ou XML dans la mémoire, les flux de sortie, les consoles, les fichiers et les sockets. De plus, 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.

Package ^{java.util.logging} «Fournit les classes et les interfaces des principales fonctions de journalisation de la plate-forme Java.

Log4j 1.x «log4j est un utilitaire de journalisation Java populaire. Log4j est un projet open source basé sur le travail de nombreux auteurs. Il permet au développeur de contrôler les instructions de journal qui sont sorties vers divers emplacements à l'aide d'Appender [console, fichiers, base de données et e-mail]. Il est entièrement configurable lors de l'exécution à l'aide de fichiers de configuration externes.

Log4j comprend trois composants principaux:

• Enregistreurs - [OFF, FATAL, ERROR, WARN, INFO, DEBUG, TRACE]

• Appenders

  • Journalisation Apache Commons: ConsoleAppender, FileAppender, RollingFileAppender, DailyRollingFileAppender, JDBCAppender- Driver, SocketAppender

  • Log4J Appender pour MongoDB: MongoDbAppender -Driver

• Mises en page - [PatternLayout, EnhancedPatternLayout]

Les fichiers de configuration peuvent être écrits au format XML ou au format des propriétés Java (clé = valeur).

1. log4j_External.properties «Format des propriétés Java (clé = valeur)

La chaîne entre une ouverture " $ { " et une fermeture " } " est interprétée 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 les options spécifiques à l'appender. «Log4j.appender.appenderName.option = valeur, Pour chaque appender 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 table MySQL pour table 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;

2. log4j_External.xml «XML log4j: configuration avec 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>

3. Configuration de 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 l' interface Configurator .

lorsque les fichiers de configuration par défaut "log4j.properties", "log4j.xml" ne sont pas disponibles

• Pour "log4j.properties", vous pouvez alimenter la méthode PropertyConfigurator .configure (java.net.URL).
• 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();
    }
}

La solution pour moi était de mettre "log4j.properties" dans le dossier "src".

Si nous utilisons un wrapper de journalisation apache commons au-dessus de log4j, nous devons avoir les deux pots disponibles dans classpath. Aussi, commons-logging.propertiesetlog4j.properties/xml devrait être disponible dans classpath.

Nous pouvons également transmettre la classe et le log4j.propertiesnom d' implémentation en JAVA_OPTSutilisant l'un ou l'autre -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 réglage JAVA_OPTSen cas d'application / serveur Web.

Cela aidera à externaliser les propriétés qui peuvent être modifiées lors du déploiement.

Il s'agit d'une autre manière 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             

Réf: LOG4J 2 CONFIGURATION: UTILISATION DE YAML

Pour les tests, une méthode rapide comprenant le réglage du niveau de journalisation:

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..

Solution Maven:

Je suis tombé sur les mêmes problèmes que ci-dessus, et pour une solution maven, j'ai utilisé 2 dépendances. Cette configuration est uniquement destinée à des tests rapides si vous souhaitez qu'un projet simple utilise un enregistreur, avec une configuration standard. Je peux imaginer que vous souhaitiez créer un fichier de configuration plus tard si vous avez besoin de plus d'informations et / ou d'affiner vos propres niveaux de journalisation.

    <properties>
        <slf4jVersion>1.7.28</slf4jVersion>
    </properties>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4jVersion}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-jdk14</artifactId>
            <version>${slf4jVersion}</version>
        </dependency>

Je viens de le faire et le problème a été résolu.

Suivi du blog ci-dessous

https://intellij-support.jetbrains.com/hc/en-us/community/posts/206875685-How-to-fix-log4j-WARN-console-messages-when-running-an-Application-inside-IntelliJ- Idée

Mais ici, il dit comme ci-dessous

Pour résoudre ce problème, entrez simplement le fichier log4j.resources suivant dans le dossier principal / resources de votre projet

au lieu de créer log4j.resources, créez log4j.properties. Clic droit sur la ressource dans IntelliJ -> Nouveau -> Bundle de ressources - Il suffit de le nommer log4j

Si vous rencontrez cette erreur sur Intellij IDEA même après avoir ajouté le log4j.propertiesoulog4j.xml fichier dans votre dossier de test des ressources, Intellij IDEA n'est peut-être pas encore au courant de l'existence du fichier.

Donc, après avoir ajouté le fichier, faites un clic droit sur le fichier et choisissez Recompiler log4j.xml .