Login
Cerca all'interno di JavaPortal
Help
Home Page Documentazione Forum Progetti Partner Pubblica!
Documentazione > Tutorial > Un' introduzione alla Java Logging API
Hide
Best Practices
EJB
Frameworks
Howto
J2EE
J2ME and Wireless
J2SE
JSP e Servlet
Java Application Server
Java IDE/Tools
Java Media
Java Security
Java Sys Admin
Java e XML
Java e SQL
OpenSource Java
Patterns
Repository
Tesi
UML
Web Services
Slide
White Paper di jws.it
project management
Eventi
Groovy

Hai una tesi in Java?
Tesine preparate
per esami?
Pubblica tutto su
JavaPortal!

Scrivi al nostro staff


Javaday Roma 2009: Ecco le slide


Un giorno le macchine riusciranno...
a risolvere tutti i problemi, ma mai nessuna di esse potra' porne uno. Einstein


MYSQL - Schema beer_store


Rss Feed
Home Page
Articoli
News
Forum
Classi

  Visualizza Commenti (0) Aggiungi Commento    
Add to Shortcuts
 
Vota l'articolo
Un' introduzione alla Java Logging API
By Giuseppe Capodieci
26 luglio 2005

  Un' introduzione alla Java Logging API
Program Classi e Interfacce per il logging
Program Interazioni tra le classi di logging
Program Configurazione
Program ..e in pratica?
Program Conclusioni

Prima di cominciare a parlare della java logging API vediamo cosa vuol dire loggare: Il logging è il processo di notificare ad una entità dei particolari eventi. Un entità può essere lo standard error, un file su disco, un database o un'altro computer remoto, mentre un evento può essere una informazione di debug, durante lo sviluppo di un software, una eccezione a runtime su un'applicazione già in produzione oppure una o più azioni compiute da un utente che utilizza un software o che accede ad una pagina web.
L'API di logging è parte della J2SE dalla versione 1.4 e permette a programmi java, servlet, applet, EJB ecc. di tenere traccia di messaggi che risultano di particolare interesse ad un utente di un software, anziché ad un amministratore di sistema o ad un programmatore, permettendo di effettuare una selezione di questi messaggi proprio in base al contesto e allo scopo per cui si sta usando. Quindi ad un programmatore servirà poter seguire in modo molto dettagliato la sequenza di operazioni di un software che sta sviluppando, mentre ad un amministratore di sistema servirà poter tenere traccia delle operazioni legate all'attività di una rete e alla segnalazione di problemi, mentre ad utente finale per individuare eventuali errori di configurazione.
Tutto questo è possibile ottenerlo semplicemente sfruttando le features che questa API mette a disposizione.



Classi e Interfacce per il logging top

Le funzionalità di logging sono tutte definite nel package java.util.logging che contiene le seguenti classi e interfacce:

  • ConsoleHandler
  • FileHander
  • Filter
  • Formatter
  • Handler
  • Level
  • Logger
  • LoggingPermission
  • LogManager
  • LogRecord
  • MemoryHandler
  • SimpleFormatter
  • SocketHandler
  • StreamHandler
  • XMLFormatter

Tra queste ricoprono un'importanza maggiore le seguenti classi:

  • Logger : La classe principale che mette a disposizione un'insieme di metodi usati per generare messaggi di log.

Ai logger viene normalmente associato un nome di tipo gerarchico utilizzando il nome del package o della classe che si vuole loggare oppure semplicemente un nome arbitrario (una stringa). Un oggetto di tipo Logger si ottiene chiamando uno dei metodi factory getLogger che creano una nuova istanza di Logger se questa non esiste, oppure restituisce l'istanza appropriata, se questa esiste già.

  • LogRecord : Usata per passare le richieste di logging tra il framework e i vari log handlers.
  • Handler : Esporta gli oggetti istanza di LogRecord alle varie destinazioni come lo standard error (console), la      memoria, files, socket ecc. Il package mette a disposizione diversi Handler per questo scopo ed è possibile      anche svilupparne altri.

 

Fig. 1 Classi e Interfacce per il logging 

  • Level : Definisce un'insieme di livelli di log standard che permettono di controllare l'output del log.Configurando il livello di log vengono loggati alcuni tipi di messaggi mentre altri vengono ignorati. I livelli predefiniti, in ordine decrescente, sono i seguenti:

SEVERE

Il valore più alto; usato per messaggi di una certa importanza (es. errori fatali). Questo livello è utile principalmente agli utenti finali o ad un system administrator.

WARNING

Si usa per i messaggi di avvertimento, per segnalare potenziali problemi. Di interesse per utenti finali e system manager

INFO

Usato per messaggi di informazione a runtime. Questo livello è utile principalmente agli utenti finali o ad un system administrator.

CONFIG

Usato per informazioni relative alla configurazione di un'applicazione. Utile agli sviluppatori in fase di debug di una particolare configurazione di un software.

FINE

Usato per informazioni di dettaglio durante il debug o il test di un'applicazione. Questo livello, insieme ai successivi FINER e FINEST, sono di interesse per lo sviluppatore che vuole tenere traccia, più o meno dettagliatamente ,dell'output del software che sta sviluppando.

FINER

Come sopra ma con ulteriore dettaglio

FINEST

Il valore più basso; altissimo dettaglio.


Settando un determinato livello di logging si abilitano anche i livelli di log più alti. In aggiunta ai livelli descritti in tabella, c'è il livello ALL che abilita il log di tutti i messaggi e il livello OFF che disabilita il log. E' inoltre possibile creare livelli di log personalizzati.
Ad ogni chiamata di un metodo di log del Logger, che può essere il generico log con i due parametri relativi al livello di priorità e al messaggio, oppure uno dei metodi con livello di priorità già impostato tipo severe, warning, o altri; avviene un check del livello di log : Se il livello di priorità associato al metodo è minore del livello di log settato, non viene loggato nulla.

  • Filter : Permette di aggiungere un controllo dell'output più fine rispetto a quello già svolto dai livelli di log.
  • Formatter : Serve per formattare gli oggetti LogRecord cioè di definire il formato di output del log. Il package include due formatter SimpleFormatter e XMLFormatter da cui si ottiene come output un testo piano e un XML rispettivamente. Altri formatter possono essere sviluppati per ottenere output personalizzati.



Interazioni tra le classi di logging top

Fig. 2  Interazioni tra le classi di logging

La figura sopra mostra il modello a oggetti (in notazione UML) delle classi coinvolte nella gestione del log in un'applicazione. Osserviamo, per primo, la classe LogManager, una classe in Singleton instance (unica istanza) che fa da factory e cache per i loggers. Mediante i metodi getLogManager si ottiene il manager e con addLogger si aggiungono loggers alla cache per poi reperirli mediante il già descritto metodo getLogger. L'uso di un LogManager è comunque opzionale.
Abbiamo poi la classe principale e cioè Logger mediante la quale le applicazioni effettuano le operazioni di log. Questa classe alloca un oggetto di tipo LogRecord che viene passato agli Handler per la pubblicazione. Sia i Loggers che gli Handlers possono usare i livelli di logging (Level) e opzionalmente i Filter se si è interessati a filtrare particolari LogRecord. Quando è necessario pubblicare un LogRecord in una destinazione esterna si può, opzionalmente, utilizzare un Formatter per formattare i messaggi in un modo appropriato alla destinazione.



Configurazione top
L' API è strutturata in modo che i parametri di configurazione di default vengono letti da un file di properties che si trova nella directory lib del JRE (logging.properties). Questi settings possono essere cambiati a runtime utilizzando dei metodi appropriati o modificando il file di properties; la classe LogManager mette a disposizione dei metodi che consentono di rileggere il file di configurazione.
La configurazione di default prevede due Handler globali, uno su file nella home directory dell'utente corrente e un altro su schermo (Console). Il livello di defualt di questi logger è INFO.
Per modificare queste impostazioni a runtime si può intervenire in vari modi:
  • Creando nuovi Handler come ad esempio FileHandlers, MemoryHandlers, e PrintHandlers
  • Creando nuovi Logger da associare a specifici Handler
  • Utilizzando il metodo setLevel di Logger o LogManager per cambiare il livello dei Loggers


..e in pratica? top

Dopo aver analizzato le caratteristiche della java jogging API vediamo un esempio pratico di utilizzo:


package mio.package;

import java.io.*;
import java.util.logging.*;

public class MyFirstLogging
{

  public static void main(String[] args) {

  // Si passano come argomenti il path del file di log
  // e il livello di log
  String logPath = args[0];
  String logLevel = args[1];

  // Creiamo un logger usando il metodo statico getLogger()
  // passando il nome del package e della classe

  Logger logger = Logger.getLogger("mio.package.MyFirstLogging");

  // In alternativa si potrebbe creare il logger usando
  // il solo nome del package:
  // Logger logger = Logger.getLogger("mio.package");
  // o il solo nome della classe
  // Logger logger = Logger.getLogger("MyFirstLogging");
  // oppure un nome arbitrario
  // Logger logger = Logger.getLogger("myLog");


  // Creiamo un Handler di tipo FileHandler passando il path
  // del file su cui scrivere i messaggi

  Handler fh = new FileHandler(logPath);

  // Creiamo un Formatter di tipo SimpleFormatter, quindi
  // il file di log è di tipo plain text e lo impostiamo
  // come formatter del nostro handler

  Formatter fmt = new SimpleFormatter();
  fh.setFormatter(fmt);

  // Associamo l'handler creato al nostro logger

  logger.addHandler(fh);

  // Settiamo il LEVEL del nostro logger utilizzando il metodo
  // statico parse che mi restituisce un oggetto di tipo Level
  // da un nome di livello valido

  logger.setLevel(Level.parse(logLevel));

  // Loggiamo diversi messaggi con diverso tipo di priorità
  // Ci sono sette livelli di logging, possiamo scegliere
  // un metodo specifico per il livello desiderato o
  // usare il generico metodo log

  logger.severe("Errore grave ");
  logger.warning("Avvertimento");
  logger.log(Level.WARNING,"Anche questo è un'avvertimento");
  logger.info("Informazione su..");
  logger.config("Un messaggio di configurazione");
  logger.fine("Un messaggio di debug fine");
  logger.finer("Un messaggio di debug più fine ");
  logger.finest("Un messaggio di debug ancora più fine ");
  logger.log(Level.FINEST,"Anche questo è un messaggio finest");
  }
}

Se ad esempio utilizziamo questa classe passando come argomenti C:\log\myfirst.log ALL potremo leggere sul file di log indicato tutti i messaggi.
Se invece passiamo come argomenti C:\log\myfirst.log CONFIG leggeremo nel file di log solo i primi cinque messaggi perché la priorità associata ai messaggi successivi è minore del livello di log impostato (CONFIG).



Conclusioni top

L'API di logging è un giusto compromesso tra potenza e facilità d'uso, come si è visto nell'esempio, è molto semplice utilizzare le classi che il framework mette a disposizione. L'uso dei livelli di log lo rende adatto a qualsiasi situazione e ambiente, partendo dallo sviluppo, come strumento di debug e test, fino ad arrivare alla messa in produzione dove può giocare il ruolo di monitoring dell'attività di un'applicazione.

Riferimenti:

Java Logging API's
http://java.sun.com/j2se/1.4.2/docs/guide/util/logging/index.html

An introduction to the java logging API
http://www.onjava.com/pub/a/onjava/2002/06/19/log.html?page=1

Using J2SETM 1.4 Logging API in Systems Management
http://developer.java.sun.com/developer/technicalArticles/Using/

The Java Logging API
http://www.fawcette.com/javapro/2002_06/magazine/features/shalloway/default.asp

 



Username:
Password:
To sign up for an account, click register... Register
Hide





Powered By



Campagna Anti-IF


Skin


PARTNER
Zio Budda
HostingJava


LICENZA



Eccetto dove diversamente specificato, i contenuti di questo sito sono rilasciati sotto licenza Creative Commons

Sitemap  © 2002-2004 Copyright Information. Privacy . Today is domenica 1 agosto 2010