Wie initialisiere ich log4j richtig?

Nach dem Hinzufügen von log4j zu meiner Anwendung erhalte ich bei jeder Ausführung meiner Anwendung die folgende Ausgabe:

log4j: WARNUNG Für den Logger wurden keine Appender gefunden (Slideselector.facedata.FaceDataParser).
log4j: WARNUNG Bitte initialisieren Sie das log4j-System ordnungsgemäß.

Es scheint, dass dies bedeutet, dass eine Konfigurationsdatei fehlt. Wo sollte sich diese Konfigurationsdatei befinden und was ist ein guter Startinhalt?

Ich verwende einfaches Java für die Entwicklung einer Desktop-Anwendung. Also kein Webserver etc ...

Log4jsucht standardmäßig nach einer Datei mit dem Namen log4j.propertiesoder log4j.xmlim Klassenpfad.

Sie können steuern, welche Datei zum Initialisieren verwendet wird, indem Sie die Systemeigenschaften wie hier beschrieben festlegen (siehe Abschnitt "Standardinitialisierungsverfahren").

Beispielsweise:

java -Dlog4j.configuration=customName ....

Verursacht log4j, dass im Klassenpfad nach einer Datei mit dem Namen customName gesucht wird.

Wenn Sie Probleme haben, finde ich es hilfreich, den log4j.debug zu aktivieren:

-Dlog4j.debug

Es werden auf System.out viele hilfreiche Informationen darüber gedruckt, welche Datei zum Initialisieren verwendet wurde, welche Logger / Appender konfiguriert wurden und wie usw.

Die Konfigurationsdatei kann eine Java-Eigenschaftendatei oder eine XML-Datei sein. Hier ist ein Beispiel für das Eigenschaftendateiformat, das der Dokumentationsseite des log4j-Intro entnommen wurde :

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

Während die ordnungsgemäße Einrichtung von log4j ideal für "echte" Projekte ist, möchten Sie möglicherweise eine schnelle und schmutzige Lösung, z. B. wenn Sie nur eine neue Bibliothek testen.

Wenn ja, ein Aufruf der statischen Methode

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

wird die grundlegende Protokollierung in der Konsole einrichten und die Fehlermeldungen werden gelöscht.

Wenn Sie einfach alles loswerden (zB wenn Sie in Tests sind)

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

Wie pro Apache Log4j FAQ - Seite :

Warum wird eine Warnung zu "Keine Appender für Logger gefunden" und "Bitte konfigurieren Sie log4j richtig" angezeigt?

Dies geschieht , wenn die Konfigurationsstandarddateien log4j.propertiesund kann log4j.xmlnicht gefunden werden und die Anwendung führt keine explizite Konfiguration. log4jwird Thread.getContextClassLoader().getResource()zum Auffinden der Standardkonfigurationsdateien verwendet und überprüft das Dateisystem nicht direkt. Um den geeigneten Speicherort für log4j.properties zu kennen oder log4j.xmldie Suchstrategie des verwendeten Klassenladeprogramms zu verstehen. log4jbietet keine Standardkonfiguration, da die Ausgabe an die Konsole oder an das Dateisystem in einigen Umgebungen möglicherweise verboten ist.

Grundsätzlich bedeutet die Warnung , dass für den Logger keine Appender gefunden wurden , dass Sie verwendenlog4j keine Appender Protokollierungssystem verwenden, aber Sie haben Ihrer Konfigurationsdatei oder der Konfigurationsdatei keine Appender (wie FileAppender, ConsoleAppender, SocketAppender, SyslogAppender usw.) hinzugefügt fehlt.

Es gibt drei Möglichkeiten, log4j zu konfigurieren: mit einer Eigenschaftendatei ( log4j.properties), mit einer XML-Datei und über Java-Code ( rootLogger.addAppender(new NullAppender());).

log4j.properties

Wenn eine Eigenschaftendatei vorhanden ist (z. B. bei der Installation von Solr), müssen Sie diese Datei in Ihrem Klassenpfad platzieren .

Klassenpfad

Hier sind einige Befehlsvorschläge unter Linux, wie Sie Ihren Klassenpfadwert bestimmen können:

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

oder aus Java: System.getProperty("java.class.path") .

Log4j XML

Unten finden Sie eine grundlegende XML-Konfigurationsdatei für log4j im XML-Format:

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

Kater

Wenn Sie Tomcat verwenden, können Sie Ihren Ordner log4j.propertiesin: /usr/share/tomcat?/lib/oder /var/lib/tomcat?/webapps/*/WEB-INF/lib/ablegen.

Solr

Als Referenz log4j.propertiessieht die Solr-Standarddatei folgendermaßen aus:

#  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

Warum kann log4j meine Eigenschaftendatei in einer J2EE- oder WAR-Anwendung nicht finden?

Die kurze Antwort: Die log4j-Klassen und die Eigenschaftendatei befinden sich nicht im Bereich desselben Klassenladeprogramms.

Log4j verwendet nur den Standardmechanismus Class.forName()zum Laden von Klassen. Ressourcen werden ähnlich behandelt. java.lang.ClassLoaderWeitere Informationen finden Sie in der Dokumentation .

Wenn Sie also Probleme haben, laden Sie die Klasse oder Ressource selbst. Wenn Sie es nicht finden können, wird log4j auch nicht. ;)

Siehe auch:

• Kurze Einführung in log4j auf der Apache-Site
• Apache: Logging Services: FAQ auf der Apache-Site

Sie können den Speicherort Ihrer log4j.properties in Ihrer Java-App festlegen, indem Sie Folgendes verwenden:

org.apache.log4j.PropertyConfigurator.configure(file/location/log4j.properties)

Weitere Informationen finden Sie hier: https://logging.apache.org/log4j/1.2/manual.html

Suchen Sie online nach log4j.properties oder log4j.xml mit einem Stamm-Appender und fügen Sie ihn in Ihren Klassenpfad ein.

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

wird sich an der Konsole anmelden. Ich ziehe es vor, mich in einer Datei anzumelden, damit Sie danach nachforschen können.

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

Für ausführliche Protokollierungsanwendungen müssen 100 KB normalerweise auf 1 MB oder 10 MB erhöht werden, insbesondere für das Debuggen.

Persönlich habe ich mehrere Logger eingerichtet und den Root-Logger auf Warn- oder Fehlerstufe anstatt auf Debug eingestellt.

Eine andere Möglichkeit, dies zu tun, ohne die Eigenschaftendatei in den Klassenpfad zu stellen, besteht darin, die Eigenschaft direkt aus dem Java-Code festzulegen. Hier ist der Beispielcode.

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.");
}

}}

Sie können die Protokollebene mit setLevel () einrichten .

Die Ebenen sind nützlich, um auf einfache Weise die Art der Informationen festzulegen, die das Programm anzeigen soll.

Beispielsweise:

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

Die möglichen Ebenen sind:

SPUR,

DEBUGGEN,

DIE INFO,

WARNEN,

FEHLER und

TÖDLICH

Gemäß Logging Services-Handbuch

import org.apache.log4j.BasicConfigurator;

Rufen Sie diese Methode auf

BasicConfigurator.configure();

Zum Aktivieren -Dlog4j.debuggehe ich zu System, Erweiterte Systemeinstellungen, Umgebungsvariablen und setze Systemvariable _JAVA_OPTIONSauf -Dlog4j.debug.

In was entwickelst du dich? Verwenden Sie 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

Ich habe solche Eigenschaften in einer meiner Java-Apps.

Mein log4j wurde durch die folgende Eigenschaftendatei behoben:

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

Ich habe Datei erstellt log4j.properties in Ressourcen - Ordner neben hibernate.cfg.xml Datei und füllte es mit Text:

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

Jetzt habe ich Warnungen und Fehler beseitigt

Erstellen Sie einfach log4j.properties im Ordner src / main / assembly. Je nachdem, ob Protokollnachrichten in der Konsole oder in der Datei angezeigt werden sollen, ändern Sie Ihre Datei. Im Folgenden werden Ihre Nachrichten in der Konsole angezeigt.

# 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

Wie bereits erläutert, gibt es zwei Ansätze

Zuerst müssen Sie diese Zeile einfach zu Ihrer Hauptmethode hinzufügen:

BasicConfigurator.configure();

Der zweite Ansatz besteht darin, diese Standarddatei log4j.properties zu Ihrem Klassenpfad hinzuzufügen:

Während Sie den zweiten Ansatz wählen, müssen Sie sicherstellen, dass Sie die Datei ordnungsgemäß initialisieren.

Z.B.

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");

Stellen Sie sicher, dass Sie den erforderlichen Ordner zum Speichern von Protokolldateien erstellen.

Versuchen Sie, das Debug-Attribut in log4j: configuration node auf true zu setzen.

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

Es druckt Informationen aus, während die Konfigurationsdatei gelesen und zum Konfigurieren der log4j-Umgebung verwendet wird. Möglicherweise erhalten Sie weitere Details, um Ihr Problem zu beheben.

Protokollierungs-API - Die Java-Protokollierungs-API erleichtert die Wartung und Instandhaltung von Software beim Kunden, indem Protokollberichte erstellt werden, die für die Analyse durch Endbenutzer, Systemadministratoren, Außendiensttechniker und Softwareentwicklungsteams geeignet sind. Die Protokollierungs-APIs erfassen Informationen wie Sicherheitsfehler, Konfigurationsfehler, Leistungsengpässe und / oder Fehler in der Anwendung oder Plattform. Das Kernpaket enthält Unterstützung für die Bereitstellung von Protokolldatensätzen im Nur-Text- oder XML-Format für Speicher, Ausgabestreams, Konsolen, Dateien und Sockets. Darüber hinaus können die Protokollierungs-APIs mit Protokollierungsdiensten interagieren, die bereits auf dem Host-Betriebssystem vorhanden sind.

Paket ^{java.util.logging} «Bietet die Klassen und Schnittstellen der wichtigsten Protokollierungsfunktionen der Java-Plattform.

Log4j 1.x «log4j ist ein beliebtes Java-basiertes Protokollierungsprogramm. Log4j ist ein Open Source-Projekt, das auf der Arbeit vieler Autoren basiert. Mithilfe von Appenders [Konsole, Dateien, Datenbank und E-Mail] kann der Entwickler steuern, welche Protokollanweisungen an verschiedenen Speicherorten ausgegeben werden. Es kann zur Laufzeit mithilfe externer Konfigurationsdateien vollständig konfiguriert werden.

Log4j besteht aus drei Hauptkomponenten:

• Logger - [AUS, FATAL, FEHLER, WARN, INFO, DEBUG, TRACE]

• Appenders

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

  • Log4J Appender für MongoDB: MongoDbAppender -Driver

• Layouts - [PatternLayout, EnhancedPatternLayout]

Konfigurationsdateien können im XML- oder im Java-Eigenschaftenformat (Schlüssel = Wert) geschrieben werden.

1. log4j_External.properties «Format der Java-Eigenschaften (Schlüssel = Wert)

Die Zeichenfolge zwischen einem öffnenden " $ { " und einem schließenden " } " wird als Schlüssel interpretiert. Der Wert der ersetzten Variablen kann als Systemeigenschaft oder in der Konfigurationsdatei selbst definiert werden. Legen Sie appenderspezifische Optionen fest. «Log4j.appender.appenderName.option = value, Für jeden benannten Appender können Sie sein Layout konfigurieren.

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

MySQL-Tabellenstruktur für Tabelle 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: Konfiguration mit öffentlicher DTD-Datei

<?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. Log4j-Konfiguration über die URL im Java-Programm:

Um eine benutzerdefinierte Konfiguration mit einer externen Datei anzugeben, muss die verwendete Klasse die Konfiguratorschnittstelle implementieren .

Wenn die Standardkonfigurationsdateien "log4j.properties", "log4j.xml" nicht verfügbar sind

• Für "log4j.properties" können Sie die Methode PropertyConfigurator .configure (java.net.URL) eingeben.
• Für "log4j.xml" wird DOMConfigurator verwendet.

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();
    }
}

Das Update für mich war, "log4j.properties" in den Ordner "src" zu legen.

Wenn wir Apache Commons Logging Wrapper über log4j verwenden, müssen beide Jars im Klassenpfad verfügbar sein. Auch commons-logging.propertiesund log4j.properties/xmlsollte im Klassenpfad verfügbar sein.

Wir können auch die Implementierungsklasse und den log4j.propertiesNamen als JAVA_OPTSentweder mit übergeben -Dorg.apache.commons.logging.Log=<logging implementation class name> -Dlog4j.configuration=<file:location of log4j.properties/xml file>. Gleiches kann über die Einstellung JAVA_OPTSbei App / Webserver erfolgen.

Es hilft, Eigenschaften zu externalisieren, die während der Bereitstellung geändert werden können.

Dies ist eine alternative Methode mit .yaml

Logikstruktur:

Configuration:
    Properties:
    Appenders:
    Loggers:

Stichprobe:

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             

Ref: LOG4J 2 KONFIGURATION: VERWENDUNG VON YAML

Zum Testen eine schnelle Methode, einschließlich der Einstellung der Protokollstufe:

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

Maven-Lösung:

Ich bin auf dieselben Probleme wie oben gestoßen und habe für eine Maven-Lösung zwei Abhängigkeiten verwendet. Diese Konfiguration ist nur zum schnellen Testen gedacht, wenn für ein einfaches Projekt ein Logger mit einer Standardkonfiguration verwendet werden soll. Ich kann mir vorstellen, dass Sie später eine Konfigurationsdatei erstellen möchten, wenn Sie weitere Informationen benötigen und / oder Ihre eigenen Protokollierungsstufen optimieren möchten.

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

Ich habe das gerade gemacht und das Problem wurde behoben.

Folgen Sie dem folgenden Blog

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

Aber hier sagt er wie unten

Um dies zu beheben, geben Sie einfach die folgende Datei log4j.resources in den Ordner main / resources Ihres Projekts ein

Anstatt log4j.resources zu erstellen, erstellen Sie log4j.properties. Klicken Sie mit der rechten Maustaste auf Ressource in IntelliJ -> Neu -> Ressourcenpaket - Benennen Sie es einfach als log4j

Wenn dieser Fehler in Intellij IDEA auch nach dem Hinzufügen der Datei log4j.propertiesoder log4j.xmlin Ihrem Ressourcentestordner auftritt, ist der Intellij IDEA möglicherweise noch nichts über die Existenz der Datei bekannt.

Klicken Sie nach dem Hinzufügen der Datei mit der rechten Maustaste auf die Datei und wählen Sie log4j.xml neu kompilieren .