Jak poprawnie zainicjować log4j?

Po dodaniu log4j do mojej aplikacji za każdym razem, gdy uruchamiam aplikację, otrzymuję następujące dane wyjściowe:

log4j: WARN Nie można znaleźć dodatków dla programu rejestrującego (slideselector.facedata.FaceDataParser).
log4j: OSTRZEŻENIE Proszę poprawnie zainicjować system log4j.

Wygląda na to, że oznacza to brak pliku konfiguracyjnego. Gdzie powinien znajdować się ten plik konfiguracyjny i jaka jest dobra zawartość początkowa?

Używam zwykłego języka Java do tworzenia aplikacji komputerowych. Więc nie ma serwera itp.

Log4jdomyślnie szuka pliku o nazwie log4j.propertieslub log4j.xmlw ścieżce klasy.

Możesz kontrolować, który plik używa do inicjowania się, ustawiając właściwości systemowe zgodnie z opisem tutaj (poszukaj sekcji „Domyślna procedura inicjalizacji”).

Na przykład:

java -Dlog4j.configuration=customName ....

Powoduje log4jposzukiwanie pliku o nazwie customName na ścieżce klasy.

W przypadku problemów uważam, że pomocne jest włączenie log4j.debug:

-Dlog4j.debug

Wydrukuje do System.out wiele przydatnych informacji o tym, którego pliku użył do zainicjowania się, które loggery / moduły dodające zostały skonfigurowane i jak itp

Plik konfiguracyjny może być plikiem właściwości Java lub plikiem XML. Oto przykład formatu pliku właściwości pobranego ze strony dokumentacji wprowadzenia do 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

Prawidłowe skonfigurowanie log4j jest idealne dla „prawdziwych” projektów, możesz chcieć szybkiego i brudnego rozwiązania, np. Jeśli tylko testujesz nową bibliotekę.

Jeśli tak, wywołanie metody statycznej

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

skonfiguruje podstawowe logowanie do konsoli, a komunikaty o błędach znikną.

Jeśli po prostu pozbędziesz się wszystkiego (np. Jeśli jesteś w trakcie testów)

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

Zgodnie ze stroną FAQ Apache Log4j :

Dlaczego widzę ostrzeżenie dotyczące „Nie znaleziono programów dołączających do programu rejestrującego” i „Proszę poprawnie skonfigurować log4j”?

Dzieje się tak, gdy nie można znaleźć domyślnych plikówlog4j.propertieslog4j.xml konfiguracyjnych , a aplikacja nie wykonuje jawnej konfiguracji. log4jsłuży Thread.getContextClassLoader().getResource()do lokalizowania domyślnych plików konfiguracyjnych i nie sprawdza bezpośrednio systemu plików. Znanie odpowiedniej lokalizacji do umieszczenia pliku log4j.properties lub log4j.xmlwymaga zrozumienia strategii wyszukiwania używanego modułu ładującego klasy. log4jnie zapewnia domyślnej konfiguracji, ponieważ dane wyjściowe do konsoli lub systemu plików mogą być zabronione w niektórych środowiskach.

Zasadniczo ostrzeżenie Nie można znaleźć dodatków do programu rejestrującego, co oznacza, że ​​używaszlog4j programów dołączających systemu rejestrującego, ale nie dodałeś żadnych programów dołączających (takich jak FileAppender, ConsoleAppender, SocketAppender, SyslogAppender itp.) Do pliku konfiguracyjnego lub plik konfiguracyjny to brakujący.

Istnieją trzy sposoby konfiguracji log4j: za pomocą pliku właściwości ( log4j.properties), pliku XML i za pomocą kodu Java ( rootLogger.addAppender(new NullAppender());).

log4j.properties

Jeśli masz plik właściwości (np. Podczas instalacji Solr), musisz umieścić ten plik w ścieżce klasy katalogu .

ścieżka klasy

Oto kilka sugestii poleceń w systemie Linux, jak określić wartość ścieżki klasy:

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

lub z Java: System.getProperty("java.class.path") .

Log4j XML

Poniżej znajduje się podstawowy plik konfiguracyjny XML dla log4j w formacie 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>

Kocur

Jeśli używasz Tomcat, możesz umieścić go log4j.propertiesw: /usr/share/tomcat?/lib/lub /var/lib/tomcat?/webapps/*/WEB-INF/lib/folderze.

Solr

Dla odniesienia domyślny log4j.propertiesplik Solr wygląda następująco:

#  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

Dlaczego log4j nie może znaleźć mojego pliku właściwości w aplikacji J2EE lub WAR?

Krótka odpowiedź: klasy log4j i plik właściwości nie wchodzą w zakres tego samego modułu ładującego klasy.

Log4j używa tylko domyślnego Class.forName()mechanizmu do ładowania klas. Zasoby są obsługiwane podobnie. Więcej informacji znajduje się w dokumentacji java.lang.ClassLoader.

Jeśli masz problemy, spróbuj samodzielnie załadować klasę lub zasób. Jeśli nie możesz go znaleźć, log4j również nie. ;)

Zobacz też:

• Krótkie wprowadzenie do log4j na stronie Apache
• Apache: Usługi rejestrowania: FAQ na stronie Apache

Możesz ustawić lokalizację pliku log4j.properties z poziomu aplikacji Java, używając:

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

Więcej informacji jest dostępnych tutaj: https://logging.apache.org/log4j/1.2/manual.html

Znajdź plik log4j.properties lub log4j.xml online z aplikacją root i umieść go na ścieżce klasy.

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

zaloguje się do konsoli. Wolę zalogować się do pliku, abyś mógł później to sprawdzić.

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

chociaż w przypadku pełnych aplikacji do rejestrowania 100 KB zwykle należy zwiększyć do 1 MB lub 10 MB, szczególnie w przypadku debugowania.

Osobiście skonfigurowałem wiele programów rejestrujących i ustawiłem program rejestrujący root na ostrzeganie lub poziom błędu zamiast debugowania.

Innym sposobem na zrobienie tego bez umieszczania pliku właściwości na ścieżce klasy jest bezpośrednie ustawienie właściwości z kodu Java. Oto przykładowy kod.

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

}

Możesz skonfigurować poziom dziennika za pomocą setLevel () .

Poziomy są przydatne do łatwego ustawienia rodzaju informacji, które program ma wyświetlać.

Na przykład:

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

Zestaw możliwych poziomów to:

ŚLAD,

ODPLUSKWIĆ,

INFO,

OSTRZEC,

BŁĄD i

FATALNY

Zgodnie z instrukcją Logging Services

import org.apache.log4j.BasicConfigurator;

Nazwij tę metodę

BasicConfigurator.configure();

Aby włączyć -Dlog4j.debug, przejdź do System, Zaawansowane ustawienia systemu, Zmienne środowiskowe i ustaw zmienną systemową _JAVA_OPTIONSna -Dlog4j.debug.

W czym się rozwijasz? Czy używasz 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

Mam takie właściwości w mojej aplikacji Java.

Mój log4j został naprawiony przez poniższy plik właściwości:

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

Utworzyłem plik log4j.properties w folderze zasobów obok pliku hibernacji.cfg.xml i wypełniłem go tekstem poniżej:

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

teraz pozbyłem się ostrzeżeń i błędów

Po prostu utwórz plik log4j.properties w folderze src / main / assembly. W zależności od tego, czy chcesz wyświetlać komunikaty dziennika w konsoli, czy w pliku, który modyfikujesz. Poniżej zostaną wyświetlone wiadomości w konsoli.

# 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

Jak wyjaśniono wcześniej, istnieją 2 podejścia

Pierwszym jest dodanie tej linii do głównej metody:

BasicConfigurator.configure();

Drugim podejściem jest dodanie tego standardowego pliku log4j.properties do ścieżki klasy:

Podczas drugiego podejścia musisz upewnić się, że plik został poprawnie zainicjowany.

Na przykład.

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

Upewnij się, że utworzyłeś wymagany folder do przechowywania plików dziennika.

Spróbuj ustawić atrybut debugowania w węźle log4j: config na true.

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

Drukuje informacje podczas odczytywania pliku konfiguracyjnego i wykorzystywania go do konfiguracji środowiska log4j. Możesz uzyskać więcej informacji, aby rozwiązać problem.

Logging API - Java Logging API ułatwia serwisowanie i konserwację oprogramowania u klientów poprzez tworzenie raportów dziennika odpowiednich do analizy przez użytkowników końcowych, administratorów systemu, inżynierów serwisowych i zespoły programistów. Interfejsy API rejestrowania przechwytują informacje, takie jak awarie bezpieczeństwa, błędy konfiguracji, wąskie gardła wydajności i / lub błędy w aplikacji lub platformie. Pakiet podstawowy obejmuje obsługę dostarczania do pamięci rekordów dziennika w formacie zwykłego tekstu lub XML, strumieni wyjściowych, konsol, plików i gniazd. Ponadto interfejsy API rejestrowania mogą wchodzić w interakcje z usługami rejestrowania, które już istnieją w systemie operacyjnym hosta.

Pakiet ^{java.util.logging} «Zapewnia klasy i interfejsy podstawowych funkcji rejestrowania platformy Java.

Log4j 1.x «log4j to popularne narzędzie do logowania oparte na Javie. Log4j to projekt typu open source oparty na pracy wielu autorów. Pozwala deweloperowi kontrolować, które wyciągi dziennika są wyprowadzane do różnych lokalizacji za pomocą programów dołączających [konsola, pliki, baza danych i poczta e-mail]. Jest w pełni konfigurowalny w czasie wykonywania przy użyciu zewnętrznych plików konfiguracyjnych.

Log4j ma trzy główne elementy:

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

• Osoby dołączające

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

  • Log4J Appender for MongoDB: MongoDbAppender -Driver

• Układy - [PatternLayout, EnhancedPatternLayout]

Pliki konfiguracyjne można zapisać w formacie XML lub we właściwościach Java (klucz = wartość).

1. log4j_External.properties «Format właściwości Java (klucz = wartość)

Ciąg między otwierającym „ $ { ” a zamykającym „ } ” jest interpretowany jako klucz. Wartość podstawionej zmiennej można zdefiniować jako właściwość systemową lub w samym pliku konfiguracyjnym. Ustaw opcje specyficzne dla programu dołączającego. «Log4j.appender.appenderName.option = wartość, Dla każdego nazwanego programu dołączającego możesz skonfigurować jego układ.

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

Struktura tabeli MySQL dla tabeli 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: konfiguracja z publicznym plikiem DTD

<?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. Konfiguracja Log4j z adresu URL w programie Java:

Aby określić niestandardową konfigurację z plikiem zewnętrznym, używana klasa musi implementować interfejs Konfiguratora .

gdy domyślne pliki konfiguracyjne „log4j.properties”, „log4j.xml” są niedostępne

• W przypadku pliku „log4j.properties” można podać metodę PropertyConfigurator .configure (java.net.URL).
• W przypadku pliku „log4j.xml” użyty zostanie konfigurator DOMConfigurator .

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

Dla mnie rozwiązaniem było umieszczenie pliku „log4j.properties” w folderze „src”.

Jeśli korzystamy z apache commons loging wrapper na log4j, to musimy mieć oba słoiki dostępne w ścieżce klasy. Również commons-logging.propertiesi log4j.properties/xmlpowinien być dostępny w ścieżce klasy.

Możemy również przekazać klasę implementacji i log4j.propertiesnazwę jako JAVA_OPTSza pomocą -Dorg.apache.commons.logging.Log=<logging implementation class name> -Dlog4j.configuration=<file:location of log4j.properties/xml file>. To samo można zrobić poprzez ustawienie JAVA_OPTSw przypadku aplikacji / serwera WWW.

Pomoże to w uzewnętrznieniu właściwości, które można zmienić podczas wdrażania.

Jest to alternatywny sposób korzystania z .yaml

Struktura logiczna:

Configuration:
    Properties:
    Appenders:
    Loggers:

Próba:

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             

Patrz: LOG4J 2 KONFIGURACJA: ZA POMOCĄ YAML

Do testowania szybki i brudny sposób, w tym ustawienie poziomu dziennika:

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

Rozwiązanie Maven:

Natknąłem się na wszystkie te same problemy, co powyżej, i dla rozwiązania maven użyłem 2 zależności. Ta konfiguracja jest przeznaczona tylko do szybkiego testowania, jeśli chcesz, aby prosty projekt korzystał z rejestratora ze standardową konfiguracją. Mogę sobie wyobrazić, że chcesz później utworzyć plik konfiguracyjny, jeśli potrzebujesz więcej informacji i / lub ukończyć własne poziomy rejestrowania.

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

Właśnie to zrobiłem i problem został rozwiązany.

Śledziłem poniższy 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- Pomysł

Ale tutaj mówi jak poniżej

Aby to naprawić, wystarczy wprowadzić następujący plik log4j.resources do folderu main / resources projektu

zamiast tworzyć log4j.resources, utwórz log4j.properties. Kliknij prawym przyciskiem myszy Zasób w IntelliJ -> Nowy -> Pakiet zasobów - Po prostu nazwij go log4j

Jeśli masz ten błąd w Intellij IDEA, nawet po dodaniu pliku log4j.propertieslub do log4j.xmlfolderu testowego zasobów, być może Intellij IDEA nie wie jeszcze o istnieniu pliku.

Po dodaniu pliku kliknij go prawym przyciskiem myszy i wybierz polecenie Rekompiluj plik log4j.xml .