Hoe log4j correct initialiseren?

Na het toevoegen van log4j aan mijn applicatie krijg ik de volgende output elke keer dat ik mijn applicatie uitvoer:

log4j:WARN Er zijn geen appenders gevonden voor logger (slideselector.facedata.FaceDataParser).
log4j:WARN Initialiseer het log4j-systeem op de juiste manier.

Het lijkt erop dat dit betekent dat er een configuratiebestand ontbreekt.
Waar moet dit configuratiebestand staan en wat is een goede startinhoud?

Ik gebruik gewone java voor het ontwikkelen van een desktoptoepassing. Dus geen webserver etc…


Antwoord 1, autoriteit 100%

log4jzoekt standaard naar een bestand met de naam log4j.propertiesof log4j.xmlop het klassenpad.

Je kunt bepalen welk bestand het gebruikt om zichzelf te initialiseren door systeemeigenschappen in te stellen zoals hier(Zoek naar de sectie “Standaardinitialisatieprocedure”).

Bijvoorbeeld:

java -Dlog4j.configuration=customName ....

Zorgt ervoor dat log4jzoekt naar een bestand met de naam customName op het klassenpad.

Als je problemen hebt, vind ik het handig om de log4j.debug aan te zetten:

-Dlog4j.debug

Het zal veel nuttige informatie naar System.out afdrukken over welk bestand het heeft gebruikt om zichzelf te initialiseren, welke loggers / appenders zijn geconfigureerd en hoe enz.

Het configuratiebestand kan een Java-eigenschappenbestand of een XML-bestand zijn. Hier is een voorbeeld van de bestandsindeling voor eigenschappen die is overgenomen van de documentatiepagina van de log4j-intro:

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

Antwoord 2, autoriteit 85%

Hoewel het correct instellen van log4j geweldig is voor “echte” projecten, wilt u misschien een snelle en vuile oplossing, b.v. als je gewoon een nieuwe bibliotheek aan het testen bent.

In dat geval een oproep naar de statische methode

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

zet de basisregistratie op de console in en de foutmeldingen zijn verdwenen.


Antwoord 3, autoriteit 9%

Als je gewoon van alles af bent (bijvoorbeeld als je in tests zit)

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

Antwoord 4, autoriteit 7%

Volgens Apache Log4j FAQ-pagina:

Waarom zie ik een waarschuwing over “Geen appenders gevonden voor logger” en “Configureer log4j correct”?

Dit gebeurt wanneer de standaardconfiguratie bestanden log4j.propertiesen log4j.xmlniet kunnen worden gevondenen de toepassing geen expliciete configuratie uitvoert. log4jgebruikt Thread.getContextClassLoader().getResource()om de standaardconfiguratiebestanden te vinden en controleert niet rechtstreeks het bestandssysteem. Om de juiste locatie te kennen om log4j.properties of log4j.xmlte plaatsen, moet u de zoekstrategie van de gebruikte klassenlader begrijpen. log4jbiedt geen standaardconfiguratie omdat uitvoer naar de console of naar het bestandssysteem in sommige omgevingen verboden kan zijn.

In principe betekent de waarschuwing Er zijn geen appenders gevonden voor loggerdat u log4jlogsysteem, maar u heeft geen appenders (zoals FileAppender, ConsoleAppender, SocketAppender, SyslogAppender, enz.) aan uw configuratiebestand toegevoegd of het configuratiebestand ontbreekt.

Er zijn drie manieren om log4j te configureren: met een eigenschappenbestand (log4j.properties), met een XML-bestanden via Java-code (rootLogger.addAppender(new NullAppender());).

log4j.properties

Als je een eigenschappenbestand hebt (bijvoorbeeld bij het installeren van Solr), moet je dit bestand in je classpathmap.

klassenpad

Hier zijn enkele commandosuggesties in Linux om je classpath-waarde te bepalen:

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

of van Java: System.getProperty("java.class.path").

Log4j XML

Hieronder staat een basis XML-configuratiebestand voor log4j in XML-formaat:

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

Als u Tomcat gebruikt, kunt u uw log4j.propertiesplaatsen in: /usr/share/tomcat?/lib/of /var/lib/tomcat?/webapps/*/WEB-INF/lib/map.

Zonne

Ter referentie, Solr standaard log4j.propertiesbestand ziet er als volgt uit:

#  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

Waarom kan log4j mijn eigenschappenbestand niet vinden in een J2EE- of WAR-toepassing?

Het korte antwoord: de log4j-klassen en het eigenschappenbestand vallen niet binnen het bereik van dezelfde classloader.

Log4j gebruikt alleen het standaard mechanisme Class.forName()voor het laden van klassen. Middelen worden op dezelfde manier behandeld. Zie de documentatie voor java.lang.ClassLoadervoor meer details.

Dus, als je problemen hebt, probeer dan zelf de klas of bron te laden. Als u het niet kunt vinden, zal log4j dat ook niet doen. 😉


Zie ook:


Antwoord 5, autoriteit 4%

U kunt de locatie van uw log4j.properties vanuit uw java-app instellen met:

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

Meer informatie is hier beschikbaar: https://logging.apache.org/log4j/ 1.2/manual.html


Antwoord 6, autoriteit 4%

Zoek online een log4j.properties of log4j.xml met een root-appender en plaats deze in uw klassenpad.

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

logt in op de console. Ik log liever in op een bestand zodat je het achteraf kunt onderzoeken.

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

hoewel voor uitgebreide logboektoepassingen 100 KB gewoonlijk moet worden verhoogd tot 1 MB of 10 MB, vooral voor foutopsporing.

Persoonlijk stel ik meerdere loggers in en stel de rootlogger in op waarschuwings- of foutniveau in plaats van debuggen.


Antwoord 7, autoriteit 3%

Een andere manier om dit te doen zonder het eigenschappenbestand op het klassenpad te plaatsen, is door de eigenschap rechtstreeks vanuit de java-code in te stellen. Hier is de voorbeeldcode.

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

}


Antwoord 8, autoriteit 2%

Je kunt het logniveau instellen met setLevel().

De niveaus zijn handig om eenvoudig het soort informatie in te stellen dat u wilt dat het programma weergeeft.

Bijvoorbeeld:

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

De reeks mogelijke niveaus is:

TRACE,

DEBUG,

INFO,

WAARSCHUW,

FOUT en

FATAL

Volgens Handleiding Logging Services


Antwoord 9, autoriteit 2%

import org.apache.log4j.BasicConfigurator;

Noem deze methode

BasicConfigurator.configure();

Antwoord 10

Om -Dlog4j.debugin te schakelen, ga ik naar Systeem, Geavanceerde systeeminstellingen, Omgevingsvariabelenen stel ik de systeemvariabele _JAVA_OPTIONSin op -Dlog4j.debug.


Antwoord 11

Ik heb het bestand log4j.propertiesgemaakt in de map resourcesnaast het bestand hibernate.cfg.xmlen vul het met onderstaande tekst:

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

nu ben ik verlost van waarschuwingen en fouten


Antwoord 12

Waar ontwikkel je je in? Gebruik je 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

Ik heb een eigenschap als deze in een Java-app van mij.


Antwoord 13

Mijn log4j is gerepareerd door onderstaand eigenschappenbestand:

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

Antwoord 14

Maak eenvoudig log4j.properties onder de map src/main/assembly. Afhankelijk van of u wilt dat logberichten worden weergegeven in de console of in het bestand, wijzigt u uw bestand. Het volgende zal uw berichten in de console tonen.

# 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

Antwoord 15

Zoals eerder uitgelegd zijn er 2 benaderingen

De eerste is om deze regel toe te voegen aan je hoofdmethode:

BasicConfigurator.configure();

De tweede benadering is om dit standaard log4j.properties-bestand toe te voegen aan je classpath:

Terwijl je een tweede benadering kiest, moet je ervoor zorgen dat je het bestand correct initialiseert.

Bijvoorbeeld

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

Zorg ervoor dat u de vereiste map maakt om logbestanden op te slaan.


Antwoord 16

Probeer het foutopsporingskenmerk in log4j:configuratieknooppunt in te stellen op true.

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

Het drukt informatie af terwijl het configuratiebestand wordt gelezen en gebruikt om de log4j-omgeving te configureren. Mogelijk heeft u meer details om uw probleem op te lossen.


Antwoord 17

Logging-APIDe Java Logging API vereenvoudigt softwareservice en onderhoud op klantlocaties door lograpporten te produceren die geschikt zijn voor analyse door eindgebruikers, systeembeheerders, buitendiensttechnici en softwareontwikkelingsteams. De Logging-API’s leggen informatie vast zoals beveiligingsfouten, configuratiefouten, prestatieknelpunten en/of bugs in de toepassing of het platform. Het kernpakket omvat ondersteuning voor het leveren van logrecords in platte tekst of XML-indeling naar het geheugen, uitvoerstromen, consoles, bestanden en sockets. Bovendien kunnen de logging-API’s communiceren met loggingservices die al bestaan op het hostbesturingssysteem.

Pakket java .util.logging« Biedt de klassen en interfaces van de basisregistratiefaciliteiten van het Java-platform.


Log4j 1.x« log4j is een populair op Java gebaseerd hulpprogramma voor logboekregistratie. Log4j is een open source project gebaseerd op het werk van vele auteurs. Het stelt de ontwikkelaar in staat om te bepalen welke log-statements naar verschillende locaties worden uitgevoerd met behulp van Appenders [console, bestanden, DB en e-mail]. Het is volledig configureerbaar tijdens runtime met behulp van externe configuratiebestanden.

Log4j heeft drie hoofdcomponenten:

  • Loggers– [OFF, FATAL, ERROR, WARN, INFO, DEBUG, TRACE]
  • Bijlagen

  • Lay-outs – [PatternLayout, EnhancedPatternLayout]

Configuratiebestanden kunnen in XML of in Java-eigenschappen (key=value) worden geschreven.

  1. log4j_External.properties « Java-eigenschappen (sleutel=waarde) formaat

De tekenreeks tussen een opening “${” en afsluitende “}” wordt geïnterpreteerd als een sleutel. De waarde van de vervangen variabele kan worden gedefinieerd als een systeemeigenschap of in het configuratiebestand zelf.
Stel apperspecifieke opties in. « log4j.appender.appenderName.option=value, Voor elke benoemde appender kunt u zijn Lay-out configureren.

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
[email protected]
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-tabelstructuur voor tabel 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;
  1. log4j_External.xml « XML log4j:configuratie met openbaar DTD-bestand
<?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>

  1. Log4j-configuratie van de URL in het Java-programma:

Om een aangepaste configuratie met een extern bestand te specificeren, moet de gebruikte klasse de Configurator-interface.

wanneer de standaardconfiguratiebestanden “log4j.properties”, “log4j.xml” niet beschikbaar zijn

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

Antwoord 18

Voor testen, een snel vuile manier, inclusief het instellen van het logniveau:

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

Antwoord 19

De oplossing voor mij was om “log4j.properties” in de map “src” te plaatsen.


Antwoord 20

Als we apache commons logging-wrapper gebruiken bovenop log4j, dan moeten beide potten beschikbaar zijn in classpath. Ook moeten commons-logging.propertiesen log4j.properties/xmlbeschikbaar zijn in classpath.

We kunnen ook de implementatieklasse en log4j.properties-naam doorgeven als JAVA_OPTSmet behulp van -Dorg.apache.commons.logging.Log=<logging implementation class name> -Dlog4j.configuration=<file:location of log4j.properties/xml file>. Hetzelfde kan gedaan worden door JAVA_OPTSin te stellen in het geval van app/webserver.

Het helpt bij het externaliseren van eigenschappen die tijdens de implementatie kunnen worden gewijzigd.


Antwoord 21

Dit is een alternatieve manier om .yaml te gebruiken

Logische structuur:

Configuration:
    Properties:
    Appenders:
    Loggers:

Voorbeeld:

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-CONFIGURATIE: YAML GEBRUIKEN


Antwoord 22

Maven-oplossing:

Ik kwam dezelfde problemen tegen als hierboven, en voor een maven-oplossing heb ik 2 afhankelijkheden gebruikt. Deze configuratie is alleen bedoeld voor snel testen als u een eenvoudig project wilt met een logger, met een standaardconfiguratie. Ik kan me voorstellen dat je later een configuratiebestand wilt maken als je meer informatie nodig hebt en of je eigen logboekniveaus wilt verfijnen.

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

Antwoord 23

Ik heb dit zojuist gedaan en het probleem is verholpen.

Heeft onderstaande blog gevolgd

https://intellij-support.jetbrains.com/hc/en-us/community/posts/206875685-How-to-fix-log4j-WARN -console-berichten-wanneer-een-toepassing-binnen-IntelliJ-idee wordt uitgevoerd

Maar hier zegt hij zoals hieronder

Om dit op te lossen, voert u het volgende log4j.resources-bestand in de hoofdmap/resources-map van uw project in

in plaats van log4j.resources te maken, maak je log4j.properties. Klik met de rechtermuisknop op Bron in IntelliJ -> Nieuw -> Bronnenbundel – Noem het gewoon log4j


Antwoord 24

Als je deze foutmelding krijgt op Intellij IDEA, zelfs nadat je het bestand log4j.propertiesof log4j.xmlaan je testmap voor resources hebt toegevoegd, is Intellij IDEA dat misschien niet nog niet op de hoogte van het bestaan van het bestand.

Dus, nadat u het bestand heeft toegevoegd, klikt u met de rechtermuisknop op het bestand en kiest u Log4j.xml opnieuw compileren.

Other episodes