Logger Classe

Definizione

Spazio dei nomi:

Java.Util.Logging

Assembly:

Mono.Android.dll

Un oggetto Logger viene usato per registrare i messaggi per un componente di sistema o 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 separato 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. Verranno creati un nuovo logger o restituito 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.

La registrazione dei messaggi verrà inoltrata 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 nell'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 al metodo Logger.setLevel. Se il livello di un logger viene modificato, la modifica può influire anche sui logger figlio, poiché qualsiasi logger figlio con null come livello erediterà il livello effettivo dal relativo padre.

In ogni chiamata di registrazione il Logger esegue inizialmente un controllo economico del livello di richiesta (ad esempio, GRAVE 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 LogRecord per descrivere il messaggio di registrazione. Verrà quindi chiamato un filtro (se presente) per eseguire un controllo più dettagliato sul fatto che il record debba essere pubblicato. Se viene superato, verrà pubblicato logRecord nei gestori di output. Per impostazione predefinita, i loggger pubblicano anche i gestori padre, in modo ricorsivo verso l'alto dell'albero.

Ogni Logger può avere un ResourceBundle oggetto associato a esso. L'oggetto ResourceBundle può essere specificato in base al nome, usando 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 la localizzazione dei messaggi di registrazione. Se un logger non ha il ResourceBundle proprio nome o il proprio bundle di risorse, erediterà il ResourceBundle nome o il nome del bundle di risorse dal relativo 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 una stringa di formato "{0}{1}" formatterebbe 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 richiamata per costruire il messaggio di log desiderato solo quando il messaggio deve essere registrato in base al livello di log effettivo, eliminando così la costruzione di messaggi non necessaria. Ad esempio, se lo sviluppatore vuole registrare lo stato di integrità del sistema per la diagnosi, con la versione di accettazione stringa, 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 fineR a livello di log è disabilitato. Con la versione di accettazione del fornitore 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 oggetto , il logger esaminerà prima se è stato specificato un ResourceBundlebundle 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 ResourceBundle viene trovato alcun nome del bundle di risorse, userà il nome del ResourceBundle bundle di risorse più 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 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 del bundle di risorse agli ResourceBundle oggetti, il logger tenterà prima di tutto di usare il caricatore della classe di contesto java.lang.Thread#getContextClassLoader() per eseguire il mapping del nome del bundle di risorse specificato a un ResourceBundleoggetto . Se il caricatore della classe di contesto del thread è null, tenterà 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) è la responsabilità del gestore di output, che in genere chiamerà un formattatore.

Si noti che la formattazione non deve verificarsi in modo sincrono. Potrebbe essere ritardato fino a quando un LogRecord non viene effettivamente scritto in un sink esterno.

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

Esistono un set di metodi "log" che accettano un livello di log, una stringa di messaggi e facoltativamente alcuni parametri nella stringa del messaggio. <li>

Esistono un set di metodi "logp" (per "log preciso") che sono come i metodi "log", ma accettano anche un nome esplicito della classe di origine e il nome del metodo. <li>

Esistono un set di metodi "logrb" (per "log con bundle di risorse") come il metodo "logp", ma anche un oggetto bundle di risorse esplicito da usare per localizzare il 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 di generazione). <li>

Infine, esistono 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 come nomi di livello standard ("grave", "avviso", "info", ecc.) 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à una "migliore operazione" per determinare quale classe e metodo chiamato nel metodo di registrazione. Tuttavia, è importante capire che queste informazioni dedotte automaticamente possono essere approssimative (o anche abbastanza sbagliate!). Le macchine virtuali possono eseguire ottimizzazioni estese quando JITing e possono rimuovere completamente i frame dello stack, rendendo impossibile individuare in modo affidabile la classe e il metodo chiamante.

Tutti i metodi in Logger sono multi-thread safe.

<b Subclassing Information:</b>> Si noti che una classe LogManager può fornire la propria implementazione di Loggers denominata per qualsiasi punto nello spazio dei nomi. Pertanto, tutte le sottoclassi di Logger (a meno che non siano implementate insieme a una nuova classe LogManager) devono prestare attenzione a ottenere un'istanza di 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 richiedono solo l'override del metodo log(LogRecord). Tutti gli altri metodi di registrazione vengono implementati come chiamate al metodo log(LogRecord).

Aggiunta nella versione 1.4.

Documentazione Java per java.util.logging.Logger.

Le parti di questa pagina sono modifiche in base al lavoro creato e condiviso dal Android Open Source e usato in base ai termini descritti nella .

Costruttori

Logger(IntPtr, JniHandleOwnership)	Costruttore utilizzato 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 componente di sistema o applicazione specifico. (Ereditato da Object)
JniPeerMembers	Un oggetto Logger viene usato per registrare i messaggi per un componente di sistema o 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 componente di sistema o applicazione specifico. (Ereditato da Object)
ResourceBundle	Recuperare il bundle di risorse di localizzazione per questo logger. -oppure- Imposta un bundle di risorse su 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	Scoprire se questo logger invia o meno l'output al logger padre. -oppure- Specificare se questo logger deve inviare 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 componente di sistema o applicazione specifico. (Ereditato da Object)
Dispose(Boolean)	Un oggetto Logger viene usato per registrare i messaggi per un componente di sistema o applicazione specifico. (Ereditato da Object)
Entering(String, String)	Registrare una voce di metodo.
Entering(String, String, Object)	Registrare una voce di metodo con un parametro.
Entering(String, String, Object[])	Registrare una voce di 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()	Ottiene 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 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 informazioni throwable associate.
Log(LogRecord)	Registrare un logRecord.
Logp(Level, String, String, ISupplier)	Registrare un messaggio costruito in modo differimento, specificando la classe di origine e il metodo, senza argomenti.
Logp(Level, String, String, String)	Registrare un messaggio, specificando la classe e il metodo di origine, senza argomenti.
Logp(Level, String, String, String, Object)	Registrare un messaggio, specificando la classe e il metodo di origine, con un singolo parametro oggetto per il messaggio di log.
Logp(Level, String, String, String, Object[])	Registrare un messaggio, specificando la classe di origine e il metodo, con una matrice di argomenti oggetto.
Logp(Level, String, String, String, Throwable)	Registrare un messaggio, specificando la classe e il metodo di origine, con le informazioni Throwable associate.
Logp(Level, String, String, Throwable, ISupplier)	Registrare un messaggio costruito in modo differimento, 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 la classe di origine, il metodo e il 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 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 monitoraggio di questo 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 GRAVE, 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 componente di sistema o applicazione specifico. (Ereditato da Object)
ToString()	Restituisce una rappresentazione in formato stringa dell'oggetto. (Ereditato da Object)
UnregisterFromRuntime()	Un oggetto Logger viene usato per registrare i messaggi per un componente di sistema o applicazione specifico. (Ereditato da Object)
Wait()	Fa sì che il thread corrente attenda finché non viene risvegliato, in genere eseguendo <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 eseguendo <una notifica</>em> o <em>interrotto</em> o fino a quando non è trascorsa una certa quantità di tempo reale. (Ereditato da Object)
Wait(Int64, Int32)	Fa sì che il thread corrente attenda finché non viene risvegliato, in genere eseguendo <una notifica</>em> o <em>interrotto</em> o fino a quando non è trascorsa una certa 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 componente di sistema o applicazione specifico. (Ereditato da Object)
IJavaPeerable.DisposeUnlessReferenced()	Un oggetto Logger viene usato per registrare i messaggi per un componente di sistema o applicazione specifico. (Ereditato da Object)
IJavaPeerable.Finalized()	Un oggetto Logger viene usato per registrare i messaggi per un componente di sistema o applicazione specifico. (Ereditato da Object)
IJavaPeerable.JniManagedPeerState	Un oggetto Logger viene usato per registrare i messaggi per un componente di sistema o applicazione specifico. (Ereditato da Object)
IJavaPeerable.SetJniIdentityHashCode(Int32)	Un oggetto Logger viene usato per registrare i messaggi per un componente di sistema o applicazione specifico. (Ereditato da Object)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	Un oggetto Logger viene usato per registrare i messaggi per un componente di sistema o applicazione specifico. (Ereditato da Object)
IJavaPeerable.SetPeerReference(JniObjectReference)	Un oggetto Logger viene usato per registrare i messaggi per un componente di sistema o applicazione specifico. (Ereditato da Object)

Metodi di estensione

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