SLF4J - Guida rapida

SLF4J sta per Simple Logging Facade per Java. Fornisce una semplice astrazione di tutti i framework di registrazione in Java. Pertanto, consente a un utente di lavorare con qualsiasi framework di registrazione come Log4j, Logback eJUL(java.util.logging) utilizzando una singola dipendenza. È possibile migrare al framework di registrazione richiesto in fase di esecuzione / distribuzione.

Ceki Gülcü ha creato SLF4J come alternativa al framework di registrazione dei comuni di Jakarta.

Vantaggi di SLF4J

Di seguito sono riportati i vantaggi di SLF4J:

• Utilizzando il framework SLF4J, è possibile migrare al framework di registrazione desiderato al momento della distribuzione.

• Slf4J fornisce collegamenti a tutti i framework di registrazione più diffusi come log4j, JUL, Simple logging e, NOP. Pertanto, è possibile passare a uno qualsiasi di questi framework popolari al momento della distribuzione.

• SLF4J fornisce il supporto ai messaggi di registrazione parametrizzati indipendentemente dal collegamento utilizzato.

• Poiché SLF4J disaccoppia l'applicazione e il framework di registrazione, è possibile scrivere facilmente applicazioni indipendentemente dai framework di registrazione. Non è necessario preoccuparsi del framework di registrazione utilizzato per scrivere un'applicazione.

• SLF4J fornisce un semplice strumento Java noto come migrator. Utilizzando questo strumento, è possibile migrare progetti esistenti, che utilizzano funzioni di frame di registrazione come Jakarta Commons Logging (JCL) o, log4j o, Java.util.logging (JUL) a SLF4J.

Accesso alla programmazione, si riferisce alla registrazione di attività / eventi. Di solito, gli sviluppatori dell'applicazione dovrebbero occuparsi della registrazione.

Per semplificare il lavoro di registrazione, Java fornisce vari framework: log4J, java.util.logging (JUL), tiny log, logback, ecc.

Panoramica del framework di registrazione

Un framework di registrazione di solito contiene tre elementi:

Logger

Cattura il messaggio insieme ai metadati.

Formatter

Formatta i messaggi catturati dal logger.

Gestore

L'handler o l'appender infine invia i messaggi stampando sulla console o archiviandoli nel database o inviando tramite e-mail.

Alcuni framework combinano gli elementi logger e appender per velocizzare le operazioni.

Oggetto logger

Per registrare un messaggio, l'applicazione invia un oggetto logger (a volte insieme alle eventuali eccezioni) con nome e livello di sicurezza.

Livello di gravità

I messaggi registrati saranno di vari livelli. La tabella seguente elenca i livelli generali di registrazione.

Suor n	Livello di gravità e descrizione
1	Fatal Problema grave che causa la chiusura dell'applicazione.
2	ERROR Errori di runtime.
3	WARNING Nella maggior parte dei casi, gli errori sono dovuti all'uso di API deprecate.
4	INFO Eventi che si verificano in fase di esecuzione.
5	DEBUG Informazioni sul flusso del sistema.
6	TRACE Informazioni più dettagliate sul flusso del sistema.

Cos'è log4j?

log4j è un servizio affidabile, veloce e flessibile logging framework (APIs) written in Java, distribuito con licenza software Apache.

log4j è altamente configurabile tramite file di configurazione esterni in fase di esecuzione. Visualizza il processo di registrazione in termini di livelli di priorità e offre meccanismi per dirigere le informazioni di registrazione verso una grande varietà di destinazioni, come un database, file, console, UNIX Syslog, ecc. (Per maggiori dettagli su log4j fare riferimento al nostro Tutorial ).

Confronto SLF4J e Log4j

A differenza di log4j, SLF4J (Simple Logging Facade per Java) non è un'implementazione del framework di registrazione, è un file abstraction for all those logging frameworks in Java similar to log4J. Pertanto, non è possibile confrontare entrambi. Tuttavia, è sempre difficile preferire uno tra i due.

Se hai una scelta, l'astrazione della registrazione è sempre preferibile rispetto al framework di registrazione. Se si utilizza un'astrazione di registrazione, in particolare SLF4J, è possibile migrare a qualsiasi framework di registrazione necessaria al momento della distribuzione senza optare per una singola dipendenza.

Osservare il diagramma seguente per avere una migliore comprensione.

In questo capitolo, spiegheremo come impostare l'ambiente SLF4J nell'IDE di Eclipse. Prima di procedere con l'installazione, assicurati di avere già Eclipse installato nel tuo sistema. In caso contrario, scarica e installa Eclipse.

Per ulteriori informazioni su Eclipse, fare riferimento al nostro Tutorial Eclipse

Passaggio 1: scarica il file JAR delle dipendenze

Apri la homepage ufficiale del sito web di SLF4J e vai alla pagina di download.

Ora scarica l'ultima versione stabile di slf4j-X.X.tar.gzo slf4j-XXzip , a seconda del sistema operativo (se file .zip di Windows o file tar.gz di Linux).

All'interno della cartella scaricata, troverai slf4j-api-XXjar . Questo è il file Jar richiesto.

Passaggio 2: creare un progetto e impostare il percorso di compilazione

Apri eclipse e crea un progetto di esempio. Fare clic con il tasto destro sul progetto, selezionare l'opzioneBuild Path → Configure Build Path… come mostrato di seguito.

Nel Java Build Path cornice in Libraries scheda, fare clic su Add External JARs…

Seleziona il slf4j-api.x.x.jar file scaricato e fare clic su Apply and Close.

Attacchi SLF4J

Inoltre slf4j-api.x.x.jar file, SLF4Jfornisce molti altri file Jar come mostrato di seguito. Questi sono chiamatiSLF4J bindings.

Dove ogni associazione è per il rispettivo framework di registrazione.

La tabella seguente elenca i collegamenti SLF4J e i relativi framework.

Suor n	File jar e framework di registrazione
1	slf4j-nop-x.x.jar Nessuna operazione, elimina tutte le registrazioni.
2	slf4j-simple-x.x.jar Semplice implementazione in cui vengono stampati i messaggi per informazioni e superiori e, rimanendo tutti gli output su System.err.
3	slf4j-jcl-x.x.jar Jakarta Commons Logging framework.
4	slf4j-jdk14-x.x.jar Java.util.logging framework (JUL).
5	slf4j-log4j12-x.x.jar Log4J frame work. Inoltre, devi averelog4j.jar.

Per far funzionare SLF4J insieme a slf4l-api-xxjar, è necessario aggiungere il rispettivo file Jar (binding) del framework di logger desiderato nel classpath del progetto (set build path).

Per passare da un framework all'altro, è necessario sostituire il rispettivo binding. Se non viene trovato alcun limite, il valore predefinito è la modalità nessuna operazione.

Pom.xml per SLF4J

Se stai creando il progetto Maven, apri il file pom.xml e incolla il seguente contenuto in esso e aggiorna il progetto.

<project xmlns = "http://maven.apache.org/POM/4.0.0"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>Sample</groupId>
   <artifactId>Sample</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <build>
      <sourceDirectory>src</sourceDirectory>
      <plugins>
         <plugin>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.7.0</version>
            <configuration>
               <source>1.8</source>
               <target>1.8</target>
            </configuration>
         </plugin>
      </plugins>
   </build>
   <dependencies>
      <dependency>
         <groupId>org.slf4j</groupId>
         <artifactId>slf4j-api</artifactId>
         <version>1.7.25</version>
      </dependency>
   </dependencies>
</project>

In questo capitolo discuteremo delle classi e dei metodi che useremo nei capitoli successivi di questo tutorial.

Interfaccia logger

L'interfaccia logger di org.slf4jpackage è il punto di ingresso dell'API SLF4J. Di seguito sono elencati i metodi importanti di questa interfaccia.

Sr.No.	Metodi e descrizione
1	void debug(String msg) Questo metodo registra un messaggio a livello di DEBUG.
2	void error(String msg) Questo metodo registra un messaggio a livello di ERRORE.
3	void info(String msg) Questo metodo registra un messaggio a livello di INFO.
4	void trace(String msg) Questo metodo registra un messaggio a livello di TRACE.
5	void warn(String msg) Questo metodo registra un messaggio a livello WARN.

LoggerFactory Class

La classe LoggerFactory di org.slf4j package è una classe di utilità, che viene utilizzata per generare logger per varie API di registrazione come log4j, JUL, NOP e simple logger.

Sr.No.	Metodo e descrizione
1	Logger getLogger(String name) Questo metodo accetta un valore stringa che rappresenta un nome e restituisce un Logger oggetto con il nome specificato.

Classe Profiler

Questa classe appartiene al pacchetto org.slf4jquesto viene utilizzato per scopi di profilazione ed è noto come profiler dei poveri. In questo modo, il programmatore può scoprire il tempo impiegato per eseguire attività prolungate.

Di seguito sono riportati i metodi importanti di questa classe.

Sr.No.	Metodi e descrizione
1	void start(String name) Questo metodo avvierà un nuovo cronometro bambino (denominato) e arresta i cronometri bambino precedenti (o strumenti del tempo).
2	TimeInstrument stop() Questo metodo interromperà il cronometro figlio recente e il cronometro globale e restituirà lo strumento temporale corrente.
3	void setLogger(Logger logger) Questo metodo accetta un oggetto Logger e associa il logger specificato al Profiler corrente.
4	void log() Registra il contenuto dello strumento temporale corrente associato a un logger.
5	void print() Stampa il contenuto dello strumento del tempo corrente.

In questo capitolo vedremo un semplice programma logger di base che utilizza SLF4J. Seguire i passaggi descritti di seguito per scrivere un semplice logger.

Passaggio 1: creare un oggetto dell'interfaccia slf4j.Logger

Dal momento che il slf4j.Logger è il punto di ingresso dell'API SLF4J, innanzitutto è necessario ottenere / creare il suo oggetto

Il getLogger() metodo del LoggerFactory class accetta un valore stringa che rappresenta un nome e restituisce un Logger oggetto con il nome specificato.

Logger logger = LoggerFactory.getLogger("SampleLogger");

Passaggio 2: registra il messaggio richiesto

Il info() metodo del slf4j.Logger l'interfaccia accetta un valore stringa che rappresenta il messaggio richiesto e lo registra a livello di informazioni.

logger.info("Hi This is my first SLF4J program");

Esempio

Di seguito è riportato il programma che dimostra come scrivere un logger di esempio in Java utilizzando SLF4J.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SLF4JExample {
   public static void main(String[] args) {
      //Creating the Logger object
      Logger logger = LoggerFactory.getLogger("SampleLogger");

      //Logging the information
      logger.info("Hi This is my first SLF4J program");
   }
}

Produzione

Quando si esegue inizialmente il seguente programma, si otterrà il seguente output invece del messaggio desiderato.

SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further
details.

Poiché non abbiamo impostato il classpath su alcun binding che rappresenti un framework di registrazione, come menzionato in precedenza in questo tutorial, SLF4J ha impostato per impostazione predefinita un'implementazione senza operazioni. Quindi, per vedere il messaggio è necessario aggiungere l'associazione desiderata nel classpath del progetto. Dato che stiamo usando eclipse, impostabuild path per il rispettivo file JAR o, aggiungi la sua dipendenza nel file pom.xml.

Ad esempio, se dobbiamo utilizzare JUL (Java.util.logging framework), dobbiamo impostare il percorso di compilazione per il file jar slf4j-jdk14-x.x.jar. E se vogliamo utilizzare il framework di registrazione log4J, dobbiamo impostare il percorso di compilazione o aggiungere dipendenze per i file jarslf4j-log4j12-x.x.jar e log4j.jar.

Dopo aver aggiunto l'associazione che rappresenta uno qualsiasi dei framework di registrazione ad eccezione di slf4j-nopx.x.jar al progetto (classpath), otterrai il seguente output.

Dec 06, 2018 5:29:44 PM SLF4JExample main
INFO: Hi Welcome to Tutorialspoint

In questo capitolo, discuteremo i vari messaggi di errore o avvertenza che riceviamo mentre lavoriamo con SLF4J e le cause / i significati di questi messaggi.

Impossibile caricare la classe "org.slf4j.impl.StaticLoggerBinder".

Questo è un avviso che viene generato quando non sono presenti bind SLF4J nel classpath.

Di seguito è riportato l'avvertimento completo:

SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further
details.

Per risolvere questo problema, è necessario aggiungere uno dei collegamenti del framework di registrazione. Questo è spiegato nelHello world capitolo di questo tutorial.

Note - Ciò si verifica nelle versioni di SLF4J comprese tra 1.6.0 e 1.8.0-beta2.

Nessun provider SLF4J trovato

In slf4j-1.8.0-beta2, l'avviso di cui sopra è più chiaro “No SLF4J providers were found”.

Di seguito è riportato l'avvertimento completo:

SLF4J: No SLF4J providers were found.
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#noProviders for further details.

Classpath contiene collegamenti SLF4J destinati alle versioni slf4j-api precedenti alla 1.8

Se stai usando la versione 1.8 di SLF4J e hai i collegamenti delle versioni precedenti nel classpath ma non i collegamenti della 1.8, vedrai un avviso come mostrato di seguito.

SLF4J: No SLF4J providers were found.
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#noProviders for further details.
SLF4J: Class path contains SLF4J bindings targeting slf4j-api versions prior to
1.8.
SLF4J: Ignoring binding found at
[jar:file:/C:/Users/Tutorialspoint/Desktop/Latest%20Tutorials/SLF4J%20Tutorial/
slf4j-1.7.25/slf4j-jdk14-1.7.25.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: See http://www.slf4j.org/codes.html#ignoredBindings for an explanation.

NoClassDefFoundError: org / apache / commons / logging / LogFactory

Se stai lavorando con slf4j-jcl e se hai solo slf4j-jcl.jar nel tuo classpath, otterrai un'eccezione come quella fornita di seguito.

Exception in thread "main" java.lang.NoClassDefFoundError:
org/apache/commons/logging/LogFactory
   at org.slf4j.impl.JCLLoggerFactory.getLogger(JCLLoggerFactory.java:77)
   at org.slf4j.LoggerFactory.getLogger(LoggerFactory.java:358)
   at SLF4JExample.main(SLF4JExample.java:8)
Caused by: java.lang.ClassNotFoundException:
org.apache.commons.logging.LogFactory
   at java.net.URLClassLoader.findClass(Unknown Source)
   at java.lang.ClassLoader.loadClass(Unknown Source)
   at sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source)
   at java.lang.ClassLoader.loadClass(Unknown Source)
   ... 3 more

Per risolvere questo problema, è necessario aggiungere commons-logging.jar al tuo classpath.

Sono stati rilevati sia jcl-over-slf4j.jar CHE associato slf4j-jcl.jar sul classpath ..

Il legame slf4j-jcl.jar reindirizza le chiamate del logger slf4j a JCL e al file jcl-over-slf4j.jarreindirizza le chiamate del logger JCL a slf4j. Pertanto, non è possibile avere entrambi nel classpath del progetto. Se lo fai, otterrai un'eccezione come quella indicata di seguito.

SLF4J: Detected both jcl-over-slf4j.jar AND bound slf4j-jcl.jar on the class
path, preempting StackOverflowError.
SLF4J: See also http://www.slf4j.org/codes.html#jclDelegationLoop for more
details.
Exception in thread "main" java.lang.ExceptionInInitializerError
   at org.slf4j.impl.StaticLoggerBinder.<init>(StaticLoggerBinder.java:71)
   at org.slf4j.impl.StaticLoggerBinder.<clinit>(StaticLoggerBinder.java:42)
   at org.slf4j.LoggerFactory.bind(LoggerFactory.java:150)
   at org.slf4j.LoggerFactory.performInitialization(LoggerFactory.java:124)
   at org.slf4j.LoggerFactory.getILoggerFactory(LoggerFactory.java:412)
   at org.slf4j.LoggerFactory.getLogger(LoggerFactory.java:357)
   at SLF4JExample.main(SLF4JExample.java:8)
Caused by: java.lang.IllegalStateException: Detected both jcl-over-slf4j.jar
AND bound slf4j-jcl.jar on the class path, preempting StackOverflowError. See
also http://www.slf4j.org/codes.html#jclDelegationLoop for more details.
   at org.slf4j.impl.JCLLoggerFactory.<clinit>(JCLLoggerFactory.java:54)
   ... 7 more

Per risolvere questo problema, elimina uno dei file jar.

Rilevata mancata corrispondenza del nome del logger

È possibile creare un oggetto Logger:

• Passando il nome del logger da creare come argomento al file getLogger() metodo.

• Passaggio di una classe come argomento a questo metodo.

Se stai cercando di creare l'oggetto logger factory passando una classe come argomento e se hai impostato la proprietà di sistema slf4j.detectLoggerNameMismatch a true, quindi il nome della classe che passi come argomento a getLogger() metodo e la classe che usi dovrebbero essere gli stessi altrimenti riceverai il seguente avviso:

"Rilevata mancata corrispondenza del nome del logger.

Considera il seguente esempio.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SLF4JExample {
   public static void main(String[] args) {
      System.setProperty("slf4j.detectLoggerNameMismatch", "true");
      
      //Creating the Logger object
      Logger logger = LoggerFactory.getLogger(Sample.class);

      //Logging the information
      logger.info("Hi Welcome to Tutorilspoint");
   }
}

Qui, abbiamo impostato la proprietà slf4j.detectLoggerNameMismatch su true. Il nome della classe che abbiamo usato èSLF4JExample e il nome della classe che abbiamo passato al metodo getLogger () è Sample poiché entrambi non sono uguali, riceveremo il seguente avviso.

SLF4J: Detected logger name mismatch. Given name: "Sample"; computed name:
"SLF4JExample".
SLF4J: See http://www.slf4j.org/codes.html#loggerNameMismatch for an
explanation
Dec 10, 2018 12:43:00 PM SLF4JExample main
INFO: Hi Welcome to Tutorilspoint

Note - Ciò si verifica dopo slf4j 1.7.9

Classpath contiene più bind SLF4J.

Dovresti avere un solo binding nel classpath. Se hai più di un binding, riceverai un avviso che elenca i binding e le loro posizioni.

Supponiamo, se abbiamo gli attacchi slf4j-jdk14.jar e slf4j-nop.jar nel classpath avremo il seguente avviso.

SLF4J: Class path contains multiple SLF4J bindings.
SLF4J: Found binding in
[jar:file:/C:/Users/Tutorialspoint/Desktop/Latest%20Tutorials/SLF4J%20Tutorial/
slf4j-1.7.25/slf4j-nop-1.7.25.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: Found binding in
[jar:file:/C:/Users/Tutorialspoint/Desktop/Latest%20Tutorials/SLF4J%20Tutorial/
slf4j-1.7.25/slf4j-jdk14-1.7.25.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: See http://www.slf4j.org/codes.html#multiple_bindings for an
explanation.
SLF4J: Actual binding is of type [org.slf4j.helpers.NOPLoggerFactory]

Sono stati rilevati sia log4j-over-slf4j.jar CHE associati slf4j-log4j12.jar nel percorso di classe

Per reindirizzare le chiamate del logger log4j a slf4j, è necessario utilizzare log4j-over-slf4j.jar binding e se vuoi reindirizzare le chiamate slf4j a log4j, devi usare slf4j-log4j12.jar rilegatura.

Pertanto, non è possibile avere entrambi nel classpath. Se lo fai, otterrai la seguente eccezione.

SLF4J: Detected both log4j-over-slf4j.jar AND bound slf4j-log4j12.jar on the
class path, preempting StackOverflowError.
SLF4J: See also http://www.slf4j.org/codes.html#log4jDelegationLoop for more
details.
Exception in thread "main" java.lang.ExceptionInInitializerError
   at org.slf4j.impl.StaticLoggerBinder.<init>(StaticLoggerBinder.java:72)
   at org.slf4j.impl.StaticLoggerBinder.<clinit>(StaticLoggerBinder.java:45)
   at org.slf4j.LoggerFactory.bind(LoggerFactory.java:150)
   at org.slf4j.LoggerFactory.performInitialization(LoggerFactory.java:124)
   at org.slf4j.LoggerFactory.getILoggerFactory(LoggerFactory.java:412)
   at org.slf4j.LoggerFactory.getLogger(LoggerFactory.java:357)
   at org.slf4j.LoggerFactory.getLogger(LoggerFactory.java:383)
   at SLF4JExample.main(SLF4JExample.java:8)
Caused by: java.lang.IllegalStateException: Detected both log4j-over-slf4j.jar
AND bound slf4j-log4j12.jar on the class path, preempting StackOverflowError.
See also http://www.slf4j.org/codes.html#log4jDelegationLoop for more details.

Come discusso in precedenza in questo tutorial, SLF4J fornisce il supporto per i messaggi di log parametrizzati.

È possibile utilizzare i parametri nei messaggi e passare loro dei valori successivamente nella stessa istruzione.

Sintassi

Come mostrato di seguito, è necessario utilizzare i segnaposto ({}) nel messaggio (Stringa) ovunque sia necessario e in seguito è possibile passare il valore per il segnaposto in object form, separando il messaggio e il valore con una virgola.

Integer age;
Logger.info("At the age of {} ramu got his first job", age);

Esempio

L'esempio seguente mostra la registrazione parametrizzata (con un singolo parametro) utilizzando SLF4J.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class PlaceHolders {
   public static void main(String[] args) {
      
      //Creating the Logger object
      Logger logger = LoggerFactory.getLogger(PlaceHolders.class);
      Integer age = 23;
      
      //Logging the information
      logger.info("At the age of {} ramu got his first job", age);
   }
}

Produzione

Al momento dell'esecuzione, il programma di cui sopra genera il seguente output:

Dec 10, 2018 3:25:45 PM PlaceHolders main
INFO: At the age of 23 Ramu got his first job

Vantaggio della registrazione parametrizzata

In Java, se dobbiamo stampare i valori in un'istruzione, useremo l'operatore di concatenazione come -

System.out.println("At the age of "+23+" ramu got his first job");

Ciò comporta la conversione del valore intero 23 in stringa e la concatenazione di questo valore con le stringhe che lo circondano.

E se si tratta di un'istruzione di registrazione e se quel particolare livello di registrazione dell'istruzione è disabilitata, tutto questo calcolo sarà inutile.

In tali circostanze, è possibile utilizzare la registrazione parametrizzata. In questo formato, inizialmente SLF4J conferma se la registrazione per un particolare livello è abilitata. In tal caso, sostituisce i segnaposto nei messaggi con i rispettivi valori.

Ad esempio, se abbiamo un'istruzione come

Integer age;
Logger.debug("At the age of {} ramu got his first job", age);

Solo se il debug è abilitato, SLF4J converte l'età in numero intero e lo concatena con le stringhe, altrimenti non fa nulla. Incorrere così nel costo della costruzione dei parametri quando il livello di registrazione è disabilitato.

Variante a due argomenti

È inoltre possibile utilizzare due parametri in un messaggio come:

logger.info("Old weight is {}. new weight is {}.", oldWeight, newWeight);

Esempio

L'esempio seguente mostra l'utilizzo di due segnaposto nella registrazione parametrizzata.

import java.util.Scanner;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class PlaceHolders {
   public static void main(String[] args) {
      Integer oldWeight;
      Integer newWeight;
      Scanner sc = new Scanner(System.in);
      System.out.println("Enter old weight:");
      oldWeight = sc.nextInt();

      System.out.println("Enter new weight:");
      newWeight = sc.nextInt();

      //Creating the Logger object
      Logger logger = LoggerFactory.getLogger(Sample.class);

      //Logging the information
      logger.info("Old weight is {}. new weight is {}.", oldWeight, newWeight);
 
      //Logging the information
      logger.info("After the program weight reduced is: "+(oldWeight-newWeight));
   }
}

Produzione

Al momento dell'esecuzione, il programma di cui sopra genera il seguente output.

Enter old weight:
85
Enter new weight:
74
Dec 10, 2018 4:12:31 PM PlaceHolders main
INFO: Old weight is 85. new weight is 74.
Dec 10, 2018 4:12:31 PM PlaceHolders main
INFO: After the program weight reduced is: 11

Variante di più argomenti

È inoltre possibile utilizzare più di due segnaposto come mostrato nell'esempio seguente:

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class PlaceHolders {
   public static void main(String[] args) {
      Integer age = 24;
      String designation = "Software Engineer";
      String company = "Infosys";

      //Creating the Logger object
      Logger logger = LoggerFactory.getLogger(Sample.class);

      //Logging the information
      logger.info("At the age of {} ramu got his first job as a {} at {}", age, designation, company);
   }
}

Produzione

Al momento dell'esecuzione, il programma di cui sopra genera il seguente output:

Dec 10, 2018 4:23:52 PM PlaceHolders main
INFO: At the age of 24 ramu got his first job as a Software Engineer at Infosys

Se hai un progetto in Jakarta Commons Logging (JCL) o, log4j o, java.util.logging (JUL) e desideri convertire questi progetti in SLF4J, puoi farlo utilizzando lo strumento di migrazione fornito nella distribuzione SLF4J.

Esecuzione di SLF4J Migrator

SLF4J è un semplice file jar singolo (slf4j-migrator.jar) ed è possibile eseguirlo utilizzando il comando java –jar.

Per eseguirlo, nel prompt dei comandi, sfoglia la directory in cui hai questo file jar ed esegui il seguente comando.

java -jar slf4j-migrator-1.8.0-beta2.jar
Starting SLF4J Migrator

Questo avvia il migratore e puoi vedere un'applicazione java standalone come:

Come specificato nella finestra, è necessario verificare il tipo di migrazione che si desidera eseguire e selezionare la directory del progetto e fare clic sul pulsante Migrate Project to SLF4J.

Questo strumento va ai file sorgente che fornisci ed esegue semplici modifiche come cambiare le linee di importazione e le dichiarazioni del logger dall'attuale framework di logging a SLF4j.

Esempio

Ad esempio, supponiamo di avere un campione log4j(2) progetto in eclipse con un singolo file come segue -

import org.apache.log4j.Logger;
import java.io.*;
import java.sql.SQLException;
import java.util.*;

public class Sample {
   /* Get actual class name to be printed on */
   static Logger log = Logger.getLogger(Sample.class.getName());

   public static void main(String[] args)throws IOException,SQLException {
      log.debug("Hello this is a debug message");
      log.info("Hello this is an info message");
   }
}

Per migrare il campione log4j(2) project su slf4j, dobbiamo controllare il pulsante di opzione from log4j to slf4j e seleziona la directory del progetto e clicca Exit migrare.

Il migratore ha modificato il codice sopra come segue. Qui, se osservi, le istruzioni import e logger sono state modificate.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.*;
import java.sql.SQLException;
import java.util.*;

public class Sample {
   static Logger log = LoggerFactory.getLogger(Sample.class.getName());
   public static void main(String[] args)throws IOException,SQLException {
      log.debug("Hello this is a debug message");
      log.info("Hello this is an info message");
   }
}

Dal momento che hai già log4j.jar nel tuo progetto, devi aggiungere slf4j-api.jar e slf4jlog12.jar file al progetto per eseguirlo.

Limitazioni di SLF4JMigrator

Di seguito sono riportati i limiti del migratore SLF4J.

• Migrator non modificherà gli script di build come ant, maven e ivy, devi farlo da solo.

• Migrator non supporta messaggi diversi dal tipo String.

• Migrator non supporta il livello FATAL.

• Durante l'utilizzo di log4j, il migrator non migrerà le chiamate a PropertyConfigurator o DomConfigurator.

La distribuzione SLF4J fornisce slf4j-ext.jar questo contiene API per le funzionalità come la creazione di profili, la registrazione estesa, la registrazione degli eventi e la registrazione con java agent.

Profilazione

A volte il programmatore vuole misurare alcuni attributi come l'uso della memoria, la complessità temporale o l'utilizzo di particolari istruzioni sui programmi per misurare la reale capacità di quel programma. Questo tipo di misurazione sul programma è chiamato profilazione. La creazione di profili utilizza l'analisi dinamica del programma per eseguire tale misurazione.

SLF4J fornisce una classe denominata Profiler nel org.slf4j.profilerpacchetto a scopo di profilazione. Questo è noto come il profiler del povero. In questo modo, il programmatore può scoprire il tempo impiegato per eseguire attività prolungate.

Profiling utilizzando la classe Profiler

Il profiler contiene cronometri e cronometri figlio e possiamo avviarli e interromperli utilizzando i metodi forniti dalla classe profiler.

Per continuare con la profilazione utilizzando la classe profiler, seguire i passaggi indicati di seguito.

Passaggio 1: creare un'istanza della classe del profiler

Creare un'istanza della classe Profiler passando un valore String che rappresenta il nome del profiler. Quando istanziamo una classe Profiler, verrà avviato un cronometro globale.

//Creating a profiler
Profiler profiler = new Profiler("Sample");

Passaggio 2: avvia un cronometro per bambini

Quando invochiamo il start() metodo avvierà un nuovo cronometro figlio (denominato) e arresta i cronometri figlio precedenti (o strumenti del tempo).

Invoca il file start() metodo del Profiler class passando un valore String che rappresenta il nome del cronometro figlio da creare.

//Starting a child stopwatch and stopping the previous one.
profiler.start("Task 1");
obj.demoMethod1();

Dopo aver creato questi cronometri, puoi eseguire le tue attività o, invocare quei metodi, che eseguono le tue attività.

Passaggio 3: avvia un altro cronometro per bambini (se lo desideri)

Se necessario, crea un altro cronometro utilizzando il file start()metodo ed eseguire le attività richieste. Se lo fai, avvierà un nuovo cronometro e interromperà quello precedente (cioè l'attività 1).

//Starting another child stopwatch and stopping the previous one.
profiler.start("Task 2");
obj.demoMethod2();

Passaggio 4: fermare gli orologi

Quando invochiamo il stop() metodo, interromperà il recente cronometro figlio e il cronometro globale e restituirà lo strumento temporale corrente.

// Stopping the current child stopwatch and the global stopwatch.
TimeInstrument tm = profiler.stop();

Passaggio 5: stampare il contenuto dello strumento del tempo.

Stampare il contenuto dello strumento del tempo corrente utilizzando il print() metodo.

//printing the contents of the time instrument
tm.print();

Esempio

L'esempio seguente mostra la creazione di profili utilizzando la classe Profiler di SLF4J. Qui abbiamo preso due attività di esempio, stampando la somma dei quadrati dei numeri da 1 a 10000, stampando la somma dei numeri da 1 a 10000. Stiamo cercando di ottenere il tempo impiegato per queste due attività.

import org.slf4j.profiler.Profiler;
import org.slf4j.profiler.TimeInstrument;

public class ProfilerExample {
   public void demoMethod1(){
      double sum = 0;
      for(int i=0; i< 1000; i++){
         sum = sum+(Math.pow(i, 2));
      }
      System.out.println("Sum of squares of the numbers from 1 to 10000: "+sum);
   }
   public void demoMethod2(){
      int sum = 0;
      for(int i=0; i< 10000; i++){
         sum = sum+i;
      }
      System.out.println("Sum of the numbers from 1 to 10000: "+sum);
   }
   public static void main(String[] args) {
      ProfilerExample obj = new ProfilerExample();

      //Creating a profiler
      Profiler profiler = new Profiler("Sample");

      //Starting a child stop watch and stopping the previous one.
      profiler.start("Task 1");
      obj.demoMethod1();

      //Starting another child stop watch and stopping the previous one.
      profiler.start("Task 2");
      obj.demoMethod2();
 
      //Stopping the current child watch and the global watch.
      TimeInstrument tm = profiler.stop();

      //printing the contents of the time instrument
      tm.print();
   }
}

Produzione

Al momento dell'esecuzione, il programma di cui sopra genera il seguente output:

Sum of squares of the numbers from 1 to 10000: 3.328335E8
Sum of the numbers from 1 to 10000: 49995000
+ Profiler [BASIC]
|-- elapsed time [Task 1] 2291.827 microseconds.
|-- elapsed time [Task 2] 225.802 microseconds.
|-- Total [BASIC] 3221.598 microseconds.

Registrazione delle informazioni del profiler

Invece di stampare il risultato di un profiler per registrare queste informazioni, è necessario:

• Crea un logger usando il LoggerFactory classe.

• Crea un profiler creando un'istanza della classe Profiler.

• Associa il logger al profiler passando l'oggetto logger creato al file setLogger() metodo del Profiler classe.

• Infine, invece di stampare il log le informazioni del profiler utilizzando il file log() metodo.

Esempio

Nell'esempio seguente, a differenza del precedente (invece di stampare), stiamo cercando di registrare il contenuto dello strumento del tempo.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.profiler.Profiler;
import org.slf4j.profiler.TimeInstrument;

public class ProfilerExample_logger {
   public void demoMethod1(){
      double sum = 0;
      for(int i=0; i< 1000; i++){
         sum = sum+(Math.pow(i, 2));
      }
      System.out.println("Sum of squares of the numbers from 1 to 10000: "+sum);
   }
   public void demoMethod2(){
      int sum = 0;
      for(int i=0; i< 10000; i++){
         sum = sum+i;
      }
      System.out.println("Sum of the numbers from 1 to 10000: "+sum);
   }
   public static void main(String[] args) {
      ProfilerExample_logger obj = new ProfilerExample_logger();

      //Creating a logger
      Logger logger = LoggerFactory.getLogger(ProfilerExample_logger.class);

      //Creating a profiler
      Profiler profiler = new Profiler("Sample");

      //Adding logger to the profiler
      profiler.setLogger(logger);

      //Starting a child stop watch and stopping the previous one.
      profiler.start("Task 1");
      obj.demoMethod1();

      //Starting another child stop watch and stopping the previous one.
      profiler.start("Task 2");
      obj.demoMethod2();

      //Stopping the current child watch and the global watch.
      TimeInstrument tm = profiler.stop();

      //Logging the contents of the time instrument
      tm.log();
   }
}

Produzione

Al momento dell'esecuzione, il programma di cui sopra genera il seguente output.

Sum of squares of the numbers from 1 to 10000: 3.328335E8
Sum of the numbers from 1 to 10000: 49995000