Come inizializzare log4j correttamente?


280

Dopo aver aggiunto log4j alla mia applicazione, ottengo il seguente output ogni volta che eseguo la mia applicazione:

log4j: WARN Impossibile trovare appendici per il logger (slideselector.facedata.FaceDataParser).
log4j: WARN Inizializzare correttamente il sistema log4j.

Sembra che questo significhi che manca un file di configurazione. Dove dovrebbe trovarsi questo file di configurazione e qual è un buon contenuto iniziale?

Sto usando Java semplice per lo sviluppo di un'applicazione desktop. Quindi nessun server web ecc ...


49
per tutti i ragazzi maven come me: metti log4j.properties in src / main / resources !!
Karussell,

La documentazione di log4j contiene un esempio molto semplice di un file log4j.xml .
Ken Bloom,

È molto utile consultare il breve manuale di Log4j: logging.apache.org/log4j/1.2/manual.html
Sa'ad,

Risposte:


278

Log4jper impostazione predefinita cerca un file chiamato log4j.propertieso log4j.xmlsul percorso di classe.

È possibile controllare quale file utilizza per inizializzarsi impostando le proprietà di sistema come descritto qui (Cercare la sezione "Procedura di inizializzazione predefinita").

Per esempio:

java -Dlog4j.configuration=customName ....

Farà sì che log4jper cercare un file chiamato customName nel classpath.

In caso di problemi, trovo utile attivare il log4j.debug:

-Dlog4j.debug

Stamperà su System.out molte informazioni utili su quale file ha usato per inizializzare se stesso, quali logger / appenders sono stati configurati e come ecc.

Il file di configurazione può essere un file delle proprietà java o un file xml. Ecco un esempio del formato del file delle proprietà tratto dalla pagina della documentazione di introduzione 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

43
Quindi per caricare il file di configurazione da un file che non si trova su un percorso di classe devi farlo come segue: -Dlog4j.configuration = file: / c: /my/folder/log4j.properties che in realtà è un URL.
bbcooper

15
un piccolo suggerimento che forse qualcuno troverà utile: puoi anche attivare il debugger log4j abilitando la proprietà corrispondente nel codice - System.setProperty ("log4j.debug", "");
XXL

Dove metti java -Dlog4j.configuration=customName? Ho provato Progetto / Preferenze / Esegui / Impostazioni debug, ho selezionato alcune configurazioni, ho fatto clic su Modifica, scheda Argomenti, argomenti VM. CustomName include un'estensione .xml?
Noumenon,

2
Dopo aver provato molte varianti, ha funzionato: -Dlog4j.configuration = file: /// C: /mydir/subdir/log4j.properties L'esempio sopra: -Dlog4j.configuration = file: / c: /my/folder/log4j.properties fallito.
user1062589

1
Vorrei davvero che i manuali enfatizzassero di più che -Dlog4j.debugpossano aiutare a eseguire il debug della configurazione.
Sridhar Sarnobat,

239

Mentre la corretta configurazione di log4j è ottima per i progetti "reali", potresti voler una soluzione rapida, ad esempio se stai solo testando una nuova libreria.

In tal caso, una chiamata al metodo statico

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

imposterà la registrazione di base sulla console e i messaggi di errore spariranno.


Ciao a3. 14_Infinito dove dovrei usare questo? non capisco. anche io ho indicato più risposte per questo problema. per favore aiutatemi
Ravi Potnuru,

5
Tieni presente che per impostazione predefinita sarà la registrazione a livello di debug, che potrebbe non essere desiderabile. Puoi cambiarlo in questo modo:Logger.getRootLogger().setLevel(Level.INFO);
forresthopkinsa,

Non solo gli avvisi sono scomparsi, ma ho ottenuto alcune utili informazioni di debug nella finestra della console
Baked Inhalf

2
così ironico ... lo usiamo nello stato di produzione
come

25

Se ti sbarazzi di tutto (ad esempio se sei nei test)

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

20

Come nella pagina FAQ di Apache Log4j :

Perché viene visualizzato un avviso "Nessuna appendice trovata per il logger" e "Configurare log4j correttamente"?

Ciò si verifica quando la configurazione di default dei file log4j.propertiese log4j.xmlnon può essere trovato e le esegue applicazioni alcuna configurazione esplicita. log4jutilizza Thread.getContextClassLoader().getResource()per individuare i file di configurazione predefiniti e non controlla direttamente il file system. Conoscere la posizione appropriata per posizionare log4j.properties o log4j.xmlrichiede la comprensione della strategia di ricerca del programma di caricamento classi in uso. log4jnon fornisce una configurazione predefinita poiché l'output sulla console o sul file system potrebbe essere vietato in alcuni ambienti.

Fondamentalmente l'avvertimento Impossibile trovare appendici per il logger significa che stai utilizzando il log4jsistema di registrazione, ma non hai aggiunto appendici (come FileAppender, ConsoleAppender, SocketAppender, SyslogAppender, ecc.) Al tuo file di configurazione o il file di configurazione è mancante.

Esistono tre modi per configurare log4j: con un file delle proprietà ( log4j.properties), con un file XML e tramite il codice Java ( rootLogger.addAppender(new NullAppender());).

log4j.properties

Se è presente un file di proprietà (ad esempio durante l'installazione di Solr), è necessario posizionare questo file nella directory del percorso di classe .

classpath

Ecco alcuni suggerimenti di comandi in Linux su come determinare il valore del tuo percorso di classe:

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

o da Java: System.getProperty("java.class.path").

Log4j XML

Di seguito è riportato un file di configurazione XML di base per log4j in formato 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>

micio

Se stai utilizzando Tomcat, puoi inserire la cartella log4j.propertiesin: /usr/share/tomcat?/lib/o /var/lib/tomcat?/webapps/*/WEB-INF/lib/.

Solr

Per riferimento, il log4j.propertiesfile predefinito Solr è simile a:

#  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

Perché log4j non riesce a trovare il mio file delle proprietà in un'applicazione J2EE o WAR?

La risposta breve: le classi log4j e il file delle proprietà non rientrano nell'ambito dello stesso programma di caricamento classi.

Log4j utilizza solo il Class.forName()meccanismo predefinito per caricare le classi. Le risorse sono gestite in modo simile. Consultare la documentazione java.lang.ClassLoaderper ulteriori dettagli.

Quindi, se hai problemi, prova a caricare tu stesso la classe o la risorsa. Se non riesci a trovarlo, nemmeno Log4j. ;)


Guarda anche:


12

Puoi impostare la posizione di log4j.properties dall'interno della tua app Java usando:

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

Maggiori informazioni sono disponibili qui: https://logging.apache.org/log4j/1.2/manual.html


1
Hmmm, classe non trovata. Un'istruzione importè sempre utile poiché il completamento del codice non è poi così affidabile.
Martin,

11

Trova un log4j.properties o log4j.xml online con un appender radice e inseriscilo nel tuo percorso di 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

accederà alla console. Preferisco accedere a un file in modo da poter indagare in seguito.

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

anche se per le applicazioni di registrazione dettagliata di solito è necessario aumentare i 100 KB a 1 MB o 10 MB, soprattutto per il debug.

Personalmente ho impostato più logger e impostato il logger di root su livello di avviso o errore anziché debug.


9

Un altro modo per farlo senza inserire il file delle proprietà nel percorso di classe è impostare direttamente la proprietà dal codice java. Ecco il codice di esempio.

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

}


6

È possibile impostare il livello di registro utilizzando setLevel () .

I livelli sono utili per impostare facilmente il tipo di informazioni che si desidera vengano visualizzate dal programma.

Per esempio:

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

L'insieme dei livelli possibili sono:

TRACCIA,

DEBUG,

INFORMAZIONI,

AVVISARE,

ERRORE e

FATALE

Secondo il manuale dei servizi di registrazione


6
import org.apache.log4j.BasicConfigurator;

Chiama questo metodo

BasicConfigurator.configure();

In particolare, questo scrive a System.out. Il javadoc per il metodo di configurazione no-args dice:Add a ConsoleAppender that uses PatternLayout using the PatternLayout#TTCC_CONVERSION_PATTERN and prints to System.out to the root category.
sunil

3

Per abilitare -Dlog4j.debug, vado su Sistema, Impostazioni di sistema avanzate, Variabili di ambiente e imposto la variabile di sistema _JAVA_OPTIONSsu -Dlog4j.debug.


1

In che cosa stai sviluppando? Stai usando 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

Ho proprietà come questa in una mia app Java.


1

Il mio log4j è stato corretto dal seguente file delle proprietà:

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

Ciao, come posso aggiungere la configurazione per il debug sulla console e l'errore sul file?
JhonArias,

1

Ho creato il file log4j.properties nella cartella delle risorse accanto al file hibernate.cfg.xml e l'ho riempito con il testo seguente:

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

ora mi sono liberato di avvertimenti ed errori


1

Semplicemente, crea log4j.properties nella cartella src / main / assembly. A seconda che si desideri visualizzare i messaggi di registro nella console o nel file, si modifica il file. Quanto segue mostrerà i tuoi messaggi nella 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

1

Come spiegato in precedenza ci sono 2 approcci

Il primo è semplicemente aggiungere questa riga al metodo principale:

BasicConfigurator.configure();

Il secondo approccio consiste nell'aggiungere questo file log4j.properties standard al percorso di classe:

Durante il secondo approccio è necessario assicurarsi di inizializzare correttamente il file.

Per esempio.

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

Assicurarsi di creare la cartella richiesta per archiviare i file di registro.


1

Prova a impostare l'attributo di debug in log4j: nodo di configurazione su true.

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

Stampa le informazioni mentre il file di configurazione viene letto e utilizzato per configurare l'ambiente log4j. Potresti ricevere maggiori dettagli per risolvere il tuo problema.


Qualcuno sa? La stessa opzione è utilizzabile anche dalla configurazione delle proprietà senza ricorrere all'impostazione -Dlog4j.debug = true all'avvio del runtime?
JFK,

1

API di registrazione - L'API di registrazione Java facilita l'assistenza e la manutenzione del software presso i siti dei clienti producendo rapporti di registro adatti per l'analisi da parte di utenti finali, amministratori di sistema, tecnici dell'assistenza sul campo e team di sviluppo software. Le API di registrazione acquisiscono informazioni quali errori di sicurezza, errori di configurazione, colli di bottiglia delle prestazioni e / o bug nell'applicazione o nella piattaforma. Il pacchetto principale include il supporto per la consegna di record di log in formato testo o XML in memoria, flussi di output, console, file e socket. Inoltre, le API di registrazione sono in grado di interagire con i servizi di registrazione già esistenti sul sistema operativo host.

Pacchetto java.util.logging «Fornisce le classi e le interfacce delle principali funzionalità di registrazione della piattaforma Java.


Log4j 1.x «log4j è una popolare utility di registrazione basata su Java. Log4j è un progetto open source basato sul lavoro di molti autori. Consente allo sviluppatore di controllare quali istruzioni di registro vengono emesse in una varietà di posizioni utilizzando Appendici [console, file, DB ed e-mail]. È completamente configurabile in fase di esecuzione utilizzando file di configurazione esterni.

Log4j ha tre componenti principali:

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

  • Layout: [PatternLayout, EnhancedPatternLayout]

I file di configurazione possono essere scritti in XML o nel formato delle proprietà Java (chiave = valore).

  1. log4j_External.properties «Formato delle proprietà Java (chiave = valore)

La stringa tra un'apertura " $ { " e la chiusura " } " viene interpretata come chiave. Il valore della variabile sostituita può essere definito come proprietà di sistema o nel file di configurazione stesso. Imposta le opzioni specifiche dell'appender. «Log4j.appender.appenderName.option = value, Per ogni appender nominato puoi configurarne il layout.

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

Struttura della tabella MySQL per la tabella 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: configurazione con file DTD pubblico
<?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 Configuration dall'URL nel programma Java:

Per specificare una configurazione personalizzata con un file esterno, la classe utilizzata deve implementare l' interfaccia di Configurator .

quando i file di configurazione predefiniti "log4j.properties", "log4j.xml" non sono disponibili

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

1

La soluzione per me era mettere "log4j.properties" nella cartella "src".


0

Se stiamo usando il wrapper per la registrazione dei commons apache sopra log4j, allora dobbiamo avere entrambi i vasetti disponibili in classpath. Inoltre, commons-logging.propertiese log4j.properties/xmldovrebbe essere disponibile in classpath.

Possiamo anche passare la classe di implementazione e log4j.properties nome JAVA_OPTSusando entrambi -Dorg.apache.commons.logging.Log=<logging implementation class name> -Dlog4j.configuration=<file:location of log4j.properties/xml file>. Lo stesso può essere fatto tramite l'impostazione JAVA_OPTSin caso di app / web server.

Aiuterà a esternalizzare le proprietà che possono essere modificate nella distribuzione.


0

Questo è un modo alternativo usando .yaml

Struttura logica:

Configuration:
    Properties:
    Appenders:
    Loggers:

Campione:

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             

Rif: LOG4J 2 CONFIGURAZIONE: USANDO YAML


0

Per i test, un modo rapido e sporco che include l'impostazione del livello di registro:

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

0

Soluzione di Maven:

Mi sono imbattuto in tutti gli stessi problemi di cui sopra e per una soluzione maven ho usato 2 dipendenze. Questa configurazione è pensata per test rapidi solo se si desidera che un progetto semplice utilizzi un logger, con una configurazione standard. Posso immaginare che tu voglia creare un file di configurazione in seguito se hai bisogno di maggiori informazioni e o di perfezionare i tuoi livelli di registrazione.

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

0

Ho appena fatto questo e il problema è stato risolto.

Seguito il blog qui sotto

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

Ma qui dice come sotto

Per risolvere il problema basta inserire il seguente file log4j.resources nella cartella principale / risorse del progetto

invece di creare log4j.resources, crea log4j.properties. Fare clic con il tasto destro su Risorsa in IntelliJ -> Nuovo -> Pacchetto di risorse - Basta nominarlo come log4j


0

Se si verifica questo errore su Intellij IDEA anche dopo aver aggiunto il log4j.propertieslog4j.xml file o sulla cartella di test delle risorse, forse Intellij IDEA non è ancora a conoscenza dell'esistenza del file.

Quindi, dopo aver aggiunto il file, fai clic con il pulsante destro del mouse sul file e scegli Ricompila log4j.xml .

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.