Logger Classe

Definizione

Spazio dei nomi:

Java.Util.Logging

Assembly:

Mono.Android.dll

Un oggetto Logger viene usato per registrare i messaggi per un sistema o un componente dell'applicazione specifico.

[Android.Runtime.Register("java/util/logging/Logger", DoNotGenerateAcw=true)]
public class Logger : Java.Lang.Object

[<Android.Runtime.Register("java/util/logging/Logger", DoNotGenerateAcw=true)>]
type Logger = class
    inherit Object

Ereditarietà

Object

Object

Logger

Attributi

RegisterAttribute

Commenti

Un oggetto Logger viene usato per registrare i messaggi per un sistema o un componente dell'applicazione specifico. I logger vengono in genere denominati usando uno spazio dei nomi gerarchico delimitato da punti. I nomi dei logger possono essere stringhe arbitrarie, ma in genere devono essere basati sul nome del pacchetto o sul nome della classe del componente registrato, ad esempio java.net o javax.swing. Inoltre, è possibile creare logger "anonimi" che non sono archiviati nello spazio dei nomi Logger.

Gli oggetti Logger possono essere ottenuti tramite chiamate su uno dei metodi factory getLogger. Questi creeranno un nuovo Logger o restituiranno un Logger esistente appropriato. È importante notare che il Logger restituito da uno dei metodi factory getLogger può essere sottoposto a Garbage Collection in qualsiasi momento se non viene mantenuto un riferimento sicuro al Logger.

I messaggi di registrazione verranno inoltrati agli oggetti Handler registrati, che possono inoltrare i messaggi a un'ampia gamma di destinazioni, tra cui console, file, log del sistema operativo e così via.

Ogni Logger tiene traccia di un Logger "padre", che è il predecessore esistente più vicino nello spazio dei nomi Logger.

A ogni logger è associato un "Livello". Questo riflette un livello minimo di attenzione per questo logger. Se il livello di un Logger è impostato su null, il livello effettivo viene ereditato dal relativo elemento padre, che a sua volta può ottenere in modo ricorsivo dal relativo elemento padre e così via verso l'alto l'albero.

Il livello di log può essere configurato in base alle proprietà del file di configurazione della registrazione, come descritto nella descrizione della classe LogManager. Tuttavia, può anche essere modificato dinamicamente dalle chiamate sul metodo Logger.setLevel. Se il livello di un logger viene modificato, la modifica può influire anche sui logger figlio, poiché qualsiasi logger figlio che ha null come livello erediterà il livello effettivo dal relativo elemento padre.

In ogni chiamata di registrazione il Logger esegue inizialmente un controllo economico del livello di richiesta (ad esempio, SEVERE o FINE) rispetto al livello di log effettivo del logger. Se il livello di richiesta è inferiore al livello di log, la chiamata di registrazione viene restituita immediatamente.

Dopo aver superato questo test iniziale (economico), logger allocherà un Oggetto LogRecord per descrivere il messaggio di registrazione. Verrà quindi chiamato un filtro (se presente) per eseguire un controllo più dettagliato sull'eventuale pubblicazione del record. Se viene passato, verrà pubblicato LogRecord nei gestori di output. Per impostazione predefinita, i logger pubblicano anche nei gestori dell'elemento padre, in modo ricorsivo verso l'alto dell'albero.

A ogni Logger può essere associato un oggetto ResourceBundle . Può ResourceBundle essere specificato in base al nome, utilizzando il #getLogger(java.lang.String, java.lang.String) metodo factory o per valore , usando il #setResourceBundle(java.util.ResourceBundle) setResourceBundle metodo . Questo bundle verrà usato per localizzare i messaggi di registrazione. Se un Logger non ha un nome proprio ResourceBundle o di bundle di risorse, erediterà il nome del ResourceBundle bundle di risorse o dal relativo elemento padre, in modo ricorsivo fino all'albero.

La maggior parte dei metodi di output del logger accetta un argomento "msg". Questo argomento msg può essere un valore non elaborato o una chiave di localizzazione. Durante la formattazione, se il logger ha (o eredita) una localizzazione ResourceBundle e se ResourceBundle ha un mapping per la stringa msg, la stringa msg viene sostituita dal valore localizzato. In caso contrario, viene usata la stringa msg originale. In genere, i formattatori usano la formattazione dello stile java.text.MessageFormat per formattare i parametri, quindi ad esempio una stringa di formato "{0}{1}" formatta due parametri come stringhe.

Un set di metodi accetta in alternativa un argomento "msgSupplier" anziché un argomento "msg". Questi metodi accettano una Supplier<String> funzione che viene richiamata per costruire il messaggio di log desiderato solo quando il messaggio deve essere effettivamente registrato in base al livello di log effettivo, eliminando così la costruzione di messaggi non necessari. Ad esempio, se lo sviluppatore vuole registrare lo stato di integrità del sistema per la diagnosi, con la versione di accettazione di stringhe, il codice sarà simile al seguente:

<code>

               class DiagnosisMessages {
                 static String systemHealthStatus() {
                   // collect system health information
                   ...
                 }
               }
               ...
               logger.log(Level.FINER, DiagnosisMessages.systemHealthStatus());
</code>

Con il codice precedente, lo stato di integrità viene raccolto inutilmente anche quando il livello di log FINER è disabilitato. Con la versione supplier-accetta come indicato di seguito, lo stato verrà raccolto solo quando il livello di log FINER è abilitato.

<code>

               logger.log(Level.FINER, DiagnosisMessages::systemHealthStatus);
</code>

Quando si cerca un ResourceBundle, il logger esaminerà innanzitutto se è stato specificato un bundle usando #setResourceBundle(java.util.ResourceBundle) setResourceBundlee quindi solo se è stato specificato un nome di bundle di risorse tramite il #getLogger(java.lang.String, java.lang.String) getLogger metodo factory. Se non viene trovato alcun ResourceBundle nome di bundle di risorse, verrà usato il nome del bundle di risorse più ResourceBundle vicino o ereditato dall'albero padre.<br> Quando un oggetto ResourceBundle è stato ereditato o specificato tramite il #setResourceBundle(java.util.ResourceBundle) setResourceBundle metodo , verrà ResourceBundle usato . In caso contrario, se il logger ha o ereditato solo un nome di bundle di risorse, il nome del bundle di risorse verrà mappato a un ResourceBundle oggetto, usando le impostazioni locali predefinite al momento della registrazione. <br id="ResourceBundleMapping">Quando si esegue il mapping dei nomi dei bundle di risorse agli ResourceBundle oggetti, il logger tenterà prima di tutto di usare il caricatore di classi di contesto java.lang.Thread#getContextClassLoader() del thread per eseguire il mapping del nome del bundle di risorse specificato a un ResourceBundleoggetto . Se il caricatore della classe di contesto del thread è null, proverà invece il caricatore della classe di sistema java.lang.ClassLoader#getSystemClassLoader(). Se l'oggetto ResourceBundle non viene ancora trovato, userà il caricatore di classe del primo chiamante del #getLogger(java.lang.String, java.lang.String) getLogger metodo factory.

La formattazione (inclusa la localizzazione) è responsabilità del gestore di output, che in genere chiamerà un formattatore.

Si noti che la formattazione non deve essere eseguita in modo sincrono. Può essere ritardato fino a quando un oggetto LogRecord non viene effettivamente scritto in un sink esterno.

I metodi di registrazione sono raggruppati in cinque categorie principali: <ul><li>

Sono disponibili un set di metodi "log" che accettano un livello di log, una stringa di messaggio e facoltativamente alcuni parametri per la stringa del messaggio. <li>

Esistono un set di metodi "logp" (per "log precise") che sono simili ai metodi "log", ma accettano anche un nome esplicito della classe di origine e un nome di metodo. <li>

Esiste un set di metodi "logrb" (per "log con bundle di risorse") simili al metodo "logp", ma accetta anche un oggetto bundle di risorse esplicito da usare per la localizzazione del messaggio di log. <li>

Esistono metodi pratici per le voci del metodo di traccia (i metodi di immissione), il metodo restituisce (i metodi di uscita) e genera eccezioni (i metodi "throwing"). <li>

Infine, sono disponibili un set di metodi pratici da usare nei casi più semplici, quando uno sviluppatore vuole semplicemente registrare una stringa semplice a un determinato livello di log. Questi metodi sono denominati in base ai nomi standard Level ("severe", "warning", "info" e così via) e accettano un singolo argomento, una stringa di messaggio. </ul>

Per i metodi che non accettano un nome di origine e un nome di metodo espliciti, il framework di registrazione eseguirà un "best effort" per determinare quale classe e metodo chiamato nel metodo di registrazione. Tuttavia, è importante rendersi conto che queste informazioni dedotte automaticamente possono essere approssimative (o potrebbero anche essere del tutto sbagliate!). Le macchine virtuali sono autorizzate a eseguire ottimizzazioni estese quando JITing e possono rimuovere completamente gli stack frame, rendendo impossibile individuare in modo affidabile la classe e il metodo chiamanti.

Tutti i metodi in Logger sono multithread-safe.

<b>Subclassing Information:</b> Si noti che una classe LogManager può fornire la propria implementazione di logger denominati per qualsiasi punto nello spazio dei nomi. Pertanto, tutte le sottoclassi di Logger (a meno che non vengano implementate insieme a una nuova classe LogManager) debbano occuparsi di ottenere un'istanza logger dalla classe LogManager e devono delegare operazioni come "isLoggable" e "log(LogRecord)" a tale istanza. Si noti che per intercettare tutti gli output di registrazione, le sottoclassi necessitano solo dell'override del metodo log(LogRecord). Tutti gli altri metodi di registrazione vengono implementati come chiamate a questo metodo log(LogRecord).

Aggiunta nella versione 1.4.

Documentazione java per java.util.logging.Logger.

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dal progetto Open Source Android e usato in base ai termini descritti nella licenza Creative Commons 2.5 Attribuzione.

Costruttori

Logger(IntPtr, JniHandleOwnership)	Costruttore usato durante la creazione di rappresentazioni gestite di oggetti JNI; chiamato dal runtime.
Logger(String, String)	Metodo protetto per costruire un logger per un sottosistema denominato.

Campi

GlobalLoggerName

GLOBAL_LOGGER_NAME è un nome per il logger globale.

Proprietà

AnonymousLogger	Creare un Logger anonimo.
Class	Restituisce la classe di runtime di questo Objectoggetto . (Ereditato da Object)
Filter	Ottenere il filtro corrente per questo Logger. -oppure- Impostare un filtro per controllare l'output in questo Logger.
Global	Restituisce l'oggetto logger globale con il nome Logger.
Handle	Handle per l'istanza di Android sottostante. (Ereditato da Object)
JniIdentityHashCode	Un oggetto Logger viene usato per registrare i messaggi per un sistema o un componente dell'applicazione specifico. (Ereditato da Object)
JniPeerMembers	Un oggetto Logger viene usato per registrare i messaggi per un sistema o un componente dell'applicazione specifico.
Level	Ottiene il livello di log specificato per questo Logger. -oppure- Impostare il livello di log che specifica i livelli di messaggio che verranno registrati da questo logger.
Name	Ottenere il nome per questo logger.
Parent	Restituisce l'elemento padre per questo Logger. -oppure- Impostare l'elemento padre per questo Logger.
PeerReference	Un oggetto Logger viene usato per registrare i messaggi per un sistema o un componente dell'applicazione specifico. (Ereditato da Object)
ResourceBundle	Recuperare il bundle di risorse di localizzazione per questo logger. -oppure- Imposta un bundle di risorse in questo logger.
ResourceBundleName	Recuperare il nome del bundle di risorse di localizzazione per questo logger.
ThresholdClass	Questa API supporta l'infrastruttura Mono per Android e non deve essere usata direttamente dal codice.
ThresholdType	Questa API supporta l'infrastruttura Mono per Android e non deve essere usata direttamente dal codice.
UseParentHandlers	Determinare se questo logger invia o meno l'output al logger padre. -oppure- Specificare se questo logger deve inviare o meno l'output al logger padre.

Metodi

AddHandler(Handler)	Aggiungere un gestore di log per ricevere i messaggi di registrazione.
Clone()	Crea e restituisce una copia di questo oggetto. (Ereditato da Object)
Config(ISupplier)	Registrare un messaggio CONFIG, che deve essere costruito solo se il livello di registrazione è tale che il messaggio verrà effettivamente registrato.
Config(String)	Registrare un messaggio CONFIG.
Dispose()	Un oggetto Logger viene usato per registrare i messaggi per un sistema o un componente dell'applicazione specifico. (Ereditato da Object)
Dispose(Boolean)	Un oggetto Logger viene usato per registrare i messaggi per un sistema o un componente dell'applicazione specifico. (Ereditato da Object)
Entering(String, String)	Registrare una voce di metodo.
Entering(String, String, Object)	Registrare una voce del metodo con un parametro.
Entering(String, String, Object[])	Registrare una voce del metodo con una matrice di parametri.
Equals(Object)	Indica se un altro oggetto è "uguale a" questo. (Ereditato da Object)
Exiting(String, String)	Registrare un metodo restituito.
Exiting(String, String, Object)	Registrare un metodo restituito con l'oggetto result.
Fine(ISupplier)	Registrare un messaggio FINE, che deve essere costruito solo se il livello di registrazione è tale che il messaggio verrà effettivamente registrato.
Fine(String)	Registrare un messaggio FINE.
Finer(ISupplier)	Registrare un messaggio FINER, che deve essere costruito solo se il livello di registrazione è tale che il messaggio verrà effettivamente registrato.
Finer(String)	Registrare un messaggio FINER.
Finest(ISupplier)	Registrare un messaggio FINEST, che deve essere costruito solo se il livello di registrazione è tale che il messaggio verrà effettivamente registrato.
Finest(String)	Registrare un messaggio FINEST.
GetAnonymousLogger(String)	Creare un Logger anonimo.
GetHandlers()	Ottenere i gestori associati a questo logger.
GetHashCode()	Restituisce un valore del codice hash per l'oggetto. (Ereditato da Object)
GetLogger(String)	Trovare o creare un logger per un sottosistema denominato.
GetLogger(String, String)	Trovare o creare un logger per un sottosistema denominato.
Info(ISupplier)	Registrare un messaggio INFO, che deve essere costruito solo se il livello di registrazione è tale che il messaggio verrà effettivamente registrato.
Info(String)	Registrare un messaggio INFO.
IsLoggable(Level)	Controllare se un messaggio del livello specificato verrebbe effettivamente registrato da questo logger.
JavaFinalize()	Chiamato dal Garbage Collector su un oggetto quando Garbage Collection determina che non sono presenti altri riferimenti all'oggetto . (Ereditato da Object)
Log(Level, ISupplier)	Registrare un messaggio, che deve essere costruito solo se il livello di registrazione è tale che il messaggio verrà effettivamente registrato.
Log(Level, String)	Registrare un messaggio senza argomenti.
Log(Level, String, Object)	Registrare un messaggio con un parametro dell'oggetto.
Log(Level, String, Object[])	Registrare un messaggio con una matrice di argomenti oggetto.
Log(Level, String, Throwable)	Registrare un messaggio, con le informazioni throwable associate.
Log(Level, Throwable, ISupplier)	Registrare un messaggio costruito in modo differitore, con le informazioni throwable associate.
Log(LogRecord)	Registrare un logRecord.
Logp(Level, String, String, ISupplier)	Registrare un messaggio costruito in modo differinte, specificando la classe di origine e il metodo, senza argomenti.
Logp(Level, String, String, String)	Registrare un messaggio, specificando la classe di origine e il metodo, senza argomenti.
Logp(Level, String, String, String, Object)	Registrare un messaggio, specificando la classe di origine e il metodo, con un singolo parametro oggetto per il messaggio di log.
Logp(Level, String, String, String, Object[])	Registrare un messaggio, specificando la classe e il metodo di origine, con una matrice di argomenti oggetto.
Logp(Level, String, String, String, Throwable)	Registrare un messaggio, specificando la classe di origine e il metodo, con le informazioni throwable associate.
Logp(Level, String, String, Throwable, ISupplier)	Registrare un messaggio costruito in modo differinte, specificando la classe di origine e il metodo, con le informazioni throwable associate.
Logrb(Level, String, String, ResourceBundle, String, Object[])	Registrare un messaggio, specificando la classe di origine, il metodo e il nome del bundle di risorse senza argomenti.
Logrb(Level, String, String, ResourceBundle, String, Throwable)	Registrare un messaggio, specificando classe di origine, metodo e bundle di risorse, con le informazioni throwable associate.
Logrb(Level, String, String, String, String)	Registrare un messaggio, specificando la classe di origine, il metodo e il nome del bundle di risorse senza argomenti.
Logrb(Level, String, String, String, String, Object)	Registrare un messaggio, specificando la classe di origine, il metodo e il nome del bundle di risorse, con un singolo parametro di oggetto per il messaggio di log.
Logrb(Level, String, String, String, String, Object[])	Registrare un messaggio, specificando la classe di origine, il metodo e il nome del bundle di risorse, con una matrice di argomenti oggetto.
Logrb(Level, String, String, String, String, Throwable)	Registrare un messaggio, specificando la classe di origine, il metodo e il nome del bundle di risorse, con le informazioni throwable associate.
Notify()	Riattiva un singolo thread in attesa del monitor dell'oggetto. (Ereditato da Object)
NotifyAll()	Riattiva tutti i thread in attesa del monitor dell'oggetto. (Ereditato da Object)
RemoveHandler(Handler)	Rimuovere un gestore di log.
SetHandle(IntPtr, JniHandleOwnership)	Imposta la proprietà Handle. (Ereditato da Object)
Severe(ISupplier)	Registrare un messaggio SEVERE, che deve essere costruito solo se il livello di registrazione è tale che il messaggio verrà effettivamente registrato.
Severe(String)	Registrare un messaggio GRAVE.
Throwing(String, String, Throwable)	Log che genera un'eccezione.
ToArray<T>()	Un oggetto Logger viene usato per registrare i messaggi per un sistema o un componente dell'applicazione specifico. (Ereditato da Object)
ToString()	Restituisce una rappresentazione di stringa dell'oggetto. (Ereditato da Object)
UnregisterFromRuntime()	Un oggetto Logger viene usato per registrare i messaggi per un sistema o un componente dell'applicazione specifico. (Ereditato da Object)
Wait()	Fa sì che il thread corrente attenda finché non viene risvegliato, in genere ricevendo <>una notifica</em> o <em>interrotto</em>. (Ereditato da Object)
Wait(Int64)	Fa sì che il thread corrente attenda finché non viene risvegliato, in genere ricevendo>< una notifica</em> o <em>interrotto</em> o fino a quando non è trascorsa una determinata quantità di tempo reale. (Ereditato da Object)
Wait(Int64, Int32)	Fa sì che il thread corrente attenda finché non viene risvegliato, in genere ricevendo>< una notifica</em> o <em>interrotto</em> o fino a quando non è trascorsa una determinata quantità di tempo reale. (Ereditato da Object)
Warning(ISupplier)	Registrare un messaggio WARNING, che deve essere costruito solo se il livello di registrazione è tale che il messaggio verrà effettivamente registrato.
Warning(String)	Registrare un messaggio DI AVVISO.

Implementazioni dell'interfaccia esplicita

IJavaPeerable.Disposed()	Un oggetto Logger viene usato per registrare i messaggi per un sistema o un componente dell'applicazione specifico. (Ereditato da Object)
IJavaPeerable.DisposeUnlessReferenced()	Un oggetto Logger viene usato per registrare i messaggi per un sistema o un componente dell'applicazione specifico. (Ereditato da Object)
IJavaPeerable.Finalized()	Un oggetto Logger viene usato per registrare i messaggi per un sistema o un componente dell'applicazione specifico. (Ereditato da Object)
IJavaPeerable.JniManagedPeerState	Un oggetto Logger viene usato per registrare i messaggi per un sistema o un componente dell'applicazione specifico. (Ereditato da Object)
IJavaPeerable.SetJniIdentityHashCode(Int32)	Un oggetto Logger viene usato per registrare i messaggi per un sistema o un componente dell'applicazione specifico. (Ereditato da Object)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	Un oggetto Logger viene usato per registrare i messaggi per un sistema o un componente dell'applicazione specifico. (Ereditato da Object)
IJavaPeerable.SetPeerReference(JniObjectReference)	Un oggetto Logger viene usato per registrare i messaggi per un sistema o un componente dell'applicazione specifico. (Ereditato da Object)

Metodi di estensione

JavaCast<TResult>(IJavaObject)	Esegue una conversione del tipo di tipo controllato dal runtime Android.
JavaCast<TResult>(IJavaObject)	Un oggetto Logger viene usato per registrare i messaggi per un sistema o un componente dell'applicazione specifico.
GetJniTypeName(IJavaPeerable)	Un oggetto Logger viene usato per registrare i messaggi per un sistema o un componente dell'applicazione specifico.