Logger Classe

Définition

Espace de noms:

Java.Util.Logging

Assembly:

Mono.Android.dll

Un objet Logger est utilisé pour journaliser les messages d’un composant système ou d’application spécifique.

[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

Héritage

Object

Object

Logger

Attributs

RegisterAttribute

Remarques

Un objet Logger est utilisé pour journaliser les messages d’un composant système ou d’application spécifique. Les enregistreurs d’événements sont normalement nommés à l’aide d’un espace de noms hiérarchique séparé par des points. Les noms d’enregistreurs d’événements peuvent être des chaînes arbitraires, mais ils doivent normalement être basés sur le nom du package ou le nom de classe du composant journalisé, tel que java.net ou javax.swing. En outre, il est possible de créer des enregistreurs d’événements « anonymes » qui ne sont pas stockés dans l’espace de noms Logger.

Les objets enregistreur d’événements peuvent être obtenus par des appels sur l’une des méthodes de fabrique getLogger. Celles-ci créent un enregistreur d’événements ou retournent un enregistreur d’événements existant approprié. Il est important de noter que l’enregistreur d’événements retourné par l’une des méthodes de getLogger fabrique peut être récupéré à tout moment si une référence forte à l’enregistreur d’événements n’est pas conservée.

Les messages de journalisation sont transférés vers des objets gestionnaires inscrits, qui peuvent transférer les messages vers diverses destinations, notamment les consoles, les fichiers, les journaux du système d’exploitation, etc.

Chaque enregistreur d’événements effectue le suivi d’un enregistreur d’événements « parent », qui est son ancêtre existant le plus proche dans l’espace de noms Logger.

Chaque enregistreur d’événements a un « niveau » associé à celui-ci. Cela reflète un niveau minimal que cet enregistreur d’événements s’intéresse. Si le niveau d’un enregistreur d’événements est défini nullsur , son niveau effectif est hérité de son parent, qui peut à son tour l’obtenir de manière récursive de son parent, et ainsi de suite sur l’arborescence.

Le niveau de journal peut être configuré en fonction des propriétés du fichier de configuration de journalisation, comme décrit dans la description de la classe LogManager. Toutefois, il peut également être modifié dynamiquement par des appels sur la méthode Logger.setLevel. Si le niveau d’un enregistreur d’événements est modifié, la modification peut également affecter les enregistreurs d’événements enfants, car tout enregistreur d’événements enfant dont le niveau héritera null de son niveau effectif de son parent.

Sur chaque appel de journalisation, l’enregistreur d’événements effectue initialement un contrôle bon marché du niveau de requête (par exemple, SEVERE ou FINE) par rapport au niveau de journal effectif de l’enregistreur d’événements. Si le niveau de requête est inférieur au niveau du journal, l’appel de journalisation retourne immédiatement.

Après avoir passé ce test initial (bon marché), l’enregistreur d’événements alloue un LogRecord pour décrire le message de journalisation. Il appelle ensuite un filtre (le cas échéant) pour effectuer une vérification plus détaillée sur la publication de l’enregistrement. Si cela le transmet, publie le LogRecord dans ses gestionnaires de sortie. Par défaut, les enregistreurs d’événements publient également dans les gestionnaires de leur parent, récursivement dans l’arborescence.

Chaque enregistreur d’événements peut avoir un ResourceBundle associé à celui-ci. Il ResourceBundle peut être spécifié par nom, à l’aide de la #getLogger(java.lang.String, java.lang.String) méthode de fabrique ou par valeur , à l’aide de la #setResourceBundle(java.util.ResourceBundle) setResourceBundle méthode. Ce bundle sera utilisé pour localiser les messages de journalisation. Si un enregistreur d’événements n’a pas son propre ResourceBundle nom ou son nom d’offre groupée de ressources, il hérite du ResourceBundle nom du groupe de ressources de son parent, de manière récursive dans l’arborescence.

La plupart des méthodes de sortie de l’enregistreur d’événements prennent un argument « msg ». Cet argument msg peut être une valeur brute ou une clé de localisation. Pendant la mise en forme, si l’enregistreur d’événements a (ou hérite) d’une localisation ResourceBundle et si celui-ci ResourceBundle a un mappage pour la chaîne msg, la chaîne msg est remplacée par la valeur localisée. Sinon, la chaîne de msg d’origine est utilisée. En règle générale, les formateurs utilisent la mise en forme de style java.text.MessageFormat pour mettre en forme des paramètres. Par exemple, une chaîne de format «{0}{1} » met en forme deux paramètres sous forme de chaînes.

Un ensemble de méthodes prend également un « msgSupplier » au lieu d’un argument « msg ». Ces méthodes prennent une Supplier<String> fonction qui est appelée pour construire le message de journal souhaité uniquement lorsque le message doit réellement être journalisé en fonction du niveau de journal effectif, éliminant ainsi la construction inutile des messages. Par exemple, si le développeur souhaite enregistrer l’état d’intégrité du système pour le diagnostic, avec la version acceptant la chaîne, le code ressemble à ceci :

<code>

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

Avec le code ci-dessus, l’état d’intégrité est collecté inutilement même lorsque le niveau de journal FINER est désactivé. Avec la version d’acceptation du fournisseur comme ci-dessous, l’état est collecté uniquement lorsque la finER au niveau du journal est activée.

<code>

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

Lorsque vous recherchez un ResourceBundle, l’enregistreur d’événements examine d’abord si un bundle a été spécifié à l’aide #setResourceBundle(java.util.ResourceBundle) setResourceBundle, puis uniquement si un nom d’ensemble de ressources a été spécifié par le biais de la #getLogger(java.lang.String, java.lang.String) getLogger méthode de fabrique. Si aucun nom de groupe de ressources n’est ResourceBundle trouvé, il utilise le nom de groupe de ressources le plus proche ou le plus ResourceBundle proche hérité de son arborescence parente.<br> Lorsqu’un ResourceBundle a été hérité ou spécifié par le biais de la #setResourceBundle(java.util.ResourceBundle) setResourceBundle méthode, celui-ci ResourceBundle sera utilisé. Dans le cas contraire, si l’enregistreur d’événements n’a ou hérité qu’un nom d’offre groupée de ressources, ce nom sera mappé à un ResourceBundle objet à l’aide des paramètres régionaux par défaut au moment de la journalisation. <br id="ResourceBundleMapping">Lors du mappage des noms de groupes de ressources aux ResourceBundle objets, l’enregistreur d’événements essaie d’abord d’utiliser le chargeur de classe de contexte java.lang.Thread#getContextClassLoader() pour mapper le nom de groupe de ressources donné à un ResourceBundle. Si le chargeur de classe de contexte de thread est null, il essaie le chargeur de classe système java.lang.ClassLoader#getSystemClassLoader() à la place. Si la ResourceBundle valeur est toujours introuvable, elle utilise le chargeur de classe du premier appelant de la #getLogger(java.lang.String, java.lang.String) getLogger méthode de fabrique.

La mise en forme (y compris la localisation) est la responsabilité du gestionnaire de sortie, qui appelle généralement un formateur.

Notez que la mise en forme n’a pas besoin de se produire de manière synchrone. Il peut être retardé jusqu’à ce qu’un LogRecord soit réellement écrit dans un récepteur externe.

Les méthodes de journalisation sont regroupées dans cinq catégories principales : <ul><li>

Il existe un ensemble de méthodes « log » qui prennent un niveau de journal, une chaîne de message et éventuellement certains paramètres de la chaîne de message. <Li>

Il existe un ensemble de méthodes « logp » (pour « log precise ») qui sont similaires aux méthodes « log », mais prennent également un nom de classe source explicite et un nom de méthode. <Li>

Il existe un ensemble de méthodes « logrb » (pour « log with resource bundle ») qui sont similaires à la méthode « logp », mais prennent également un objet de bundle de ressources explicite pour une utilisation dans la localisation du message de journal. <Li>

Il existe des méthodes pratiques pour le suivi des entrées de méthode (les méthodes « entrée »), les méthodes renvoie (les méthodes « sortie ») et lèvent des exceptions (les méthodes « throwing »). <Li>

Enfin, il existe un ensemble de méthodes pratiques à utiliser dans les cas les plus simples, lorsqu’un développeur souhaite simplement enregistrer une chaîne simple au niveau du journal donné. Ces méthodes sont nommées après les noms de niveau standard (« sévère », « avertissement », « info », etc.) et prennent un seul argument, une chaîne de message. </ul>

Pour les méthodes qui ne prennent pas de nom de source et de nom de méthode explicites, l’infrastructure de journalisation effectue un « meilleur effort » pour déterminer la classe et la méthode appelées dans la méthode de journalisation. Toutefois, il est important de se rendre compte que ces informations déduites automatiquement peuvent uniquement être approximatives (ou peut même être assez incorrectes !). Les machines virtuelles sont autorisées à effectuer des optimisations étendues lorsque JITing et peuvent entièrement supprimer des trames de pile, ce qui rend impossible de localiser de manière fiable la classe et la méthode appelantes.

Toutes les méthodes sur Logger sont sécurisées à plusieurs threads.

<b>Sous-classe Information :</b> Notez qu’une classe LogManager peut fournir sa propre implémentation des enregistreurs nommés pour n’importe quel point de l’espace de noms. Par conséquent, les sous-classes de Logger (à moins qu’elles ne soient implémentées conjointement avec une nouvelle classe LogManager) doivent prendre soin d’obtenir une instance Logger à partir de la classe LogManager et doivent déléguer des opérations telles que « isLoggable » et « log(LogRecord) » à cette instance. Notez que pour intercepter toutes les sorties de journalisation, les sous-classes n’ont besoin que de remplacer la méthode log(LogRecord). Toutes les autres méthodes de journalisation sont implémentées en tant qu’appels sur cette méthode log(LogRecord).

Ajouté dans la version 1.4.

Documentation Java pour java.util.logging.Logger.

Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.

Constructeurs

Logger(IntPtr, JniHandleOwnership)	Constructeur utilisé lors de la création de représentations managées d’objets JNI ; appelée par le runtime.
Logger(String, String)	Méthode protégée pour construire un enregistreur d’événements pour un sous-système nommé.

Champs

GlobalLoggerName

GLOBAL_LOGGER_NAME est un nom pour l’enregistreur d’événements global.

Propriétés

AnonymousLogger	Créez un enregistreur d’événements anonyme.
Class	Retourne la classe runtime de ce Object. (Hérité de Object)
Filter	Obtenez le filtre actuel pour cet enregistreur d’événements. -ou- Définissez un filtre pour contrôler la sortie sur cet enregistreur d’événements.
Global	Retourne l’objet enregistreur d’événements global avec le nom Logger.
Handle	Handle de l’instance Android sous-jacente. (Hérité de Object)
JniIdentityHashCode	Un objet Logger est utilisé pour journaliser les messages d’un composant système ou d’application spécifique. (Hérité de Object)
JniPeerMembers	Un objet Logger est utilisé pour journaliser les messages d’un composant système ou d’application spécifique.
Level	Obtenez le niveau de journal spécifié pour cet enregistreur d’événements. -ou- Définissez le niveau de journal spécifiant les niveaux de message qui seront enregistrés par cet enregistreur d’événements.
Name	Obtenez le nom de cet enregistreur d’événements.
Parent	Retourne le parent de cet enregistreur d’événements. -ou- Définissez le parent de cet enregistreur d’événements.
PeerReference	Un objet Logger est utilisé pour journaliser les messages d’un composant système ou d’application spécifique. (Hérité de Object)
ResourceBundle	Récupérez le bundle de ressources de localisation pour cet enregistreur d’événements. -ou- Définit un ensemble de ressources sur cet enregistreur d’événements.
ResourceBundleName	Récupérez le nom du groupe de ressources de localisation pour cet enregistreur d’événements.
ThresholdClass	Cette API prend en charge l’infrastructure Mono pour Android et n’est pas destinée à être utilisée directement à partir de votre code.
ThresholdType	Cette API prend en charge l’infrastructure Mono pour Android et n’est pas destinée à être utilisée directement à partir de votre code.
UseParentHandlers	Découvrez si cet enregistreur d’événements envoie ou non sa sortie à son enregistreur d’événements parent. -ou- Spécifiez si cet enregistreur d’événements doit envoyer sa sortie à son enregistreur d’événements parent.

Méthodes

AddHandler(Handler)	Ajoutez un gestionnaire de journaux pour recevoir des messages de journalisation.
Clone()	Crée et retourne une copie de cet objet. (Hérité de Object)
Config(ISupplier)	Journalisez un message CONFIG, qui est à construire uniquement si le niveau de journalisation est tel que le message sera réellement journalisé.
Config(String)	Journaliser un message CONFIG.
Dispose()	Un objet Logger est utilisé pour journaliser les messages d’un composant système ou d’application spécifique. (Hérité de Object)
Dispose(Boolean)	Un objet Logger est utilisé pour journaliser les messages d’un composant système ou d’application spécifique. (Hérité de Object)
Entering(String, String)	Journaliser une entrée de méthode.
Entering(String, String, Object)	Journaliser une entrée de méthode, avec un paramètre.
Entering(String, String, Object[])	Journaliser une entrée de méthode, avec un tableau de paramètres.
Equals(Object)	Indique si un autre objet est « égal à » celui-ci. (Hérité de Object)
Exiting(String, String)	Journaliser un retour de méthode.
Exiting(String, String, Object)	Journalisez un retour de méthode, avec un objet de résultat.
Fine(ISupplier)	Journalisez un message FINE, qui est à construire uniquement si le niveau de journalisation est tel que le message sera réellement journalisé.
Fine(String)	Journaliser un message FINE.
Finer(ISupplier)	Journalisez un message FINER, qui est à construire uniquement si le niveau de journalisation est tel que le message sera réellement journalisé.
Finer(String)	Journaliser un message FINER.
Finest(ISupplier)	Journalisez un message FINEST, qui est à construire uniquement si le niveau de journalisation est tel que le message sera réellement journalisé.
Finest(String)	Journaliser un message FINEST.
GetAnonymousLogger(String)	Créez un enregistreur d’événements anonyme.
GetHandlers()	Obtenez les gestionnaires associés à cet enregistreur d’événements.
GetHashCode()	Retourne une valeur de code de hachage pour l'objet. (Hérité de Object)
GetLogger(String)	Recherchez ou créez un enregistreur d’événements pour un sous-système nommé.
GetLogger(String, String)	Recherchez ou créez un enregistreur d’événements pour un sous-système nommé.
Info(ISupplier)	Journalisez un message INFO, qui est à construire uniquement si le niveau de journalisation est tel que le message sera réellement journalisé.
Info(String)	Journaliser un message INFO.
IsLoggable(Level)	Vérifiez si un message du niveau donné est enregistré par cet enregistreur d’événements.
JavaFinalize()	Appelé par le garbage collector sur un objet lorsque le garbage collection détermine qu’il n’y a plus de références à l’objet. (Hérité de Object)
Log(Level, ISupplier)	Journalisez un message, qui est à construire uniquement si le niveau de journalisation est tel que le message sera réellement journalisé.
Log(Level, String)	Journaliser un message, sans arguments.
Log(Level, String, Object)	Journalisez un message, avec un paramètre d’objet.
Log(Level, String, Object[])	Consignez un message, avec un tableau d’arguments d’objet.
Log(Level, String, Throwable)	Journalisez un message, avec les informations levées associées.
Log(Level, Throwable, ISupplier)	Journalisez un message construit de manière différée, avec les informations levées associées.
Log(LogRecord)	Journaliser un LogRecord.
Logp(Level, String, String, ISupplier)	Consignez un message construit de manière différée, spécifiant la classe source et la méthode, sans arguments.
Logp(Level, String, String, String)	Journaliser un message, en spécifiant la classe source et la méthode, sans arguments.
Logp(Level, String, String, String, Object)	Consignez un message, en spécifiant la classe source et la méthode, avec un seul paramètre d’objet dans le message de journal.
Logp(Level, String, String, String, Object[])	Consignez un message, spécifiant la classe source et la méthode, avec un tableau d’arguments d’objet.
Logp(Level, String, String, String, Throwable)	Consignez un message, en spécifiant la classe source et la méthode, avec les informations levées associées.
Logp(Level, String, String, Throwable, ISupplier)	Journalisez un message construit de manière différée, en spécifiant la classe source et la méthode, avec les informations throwables associées.
Logrb(Level, String, String, ResourceBundle, String, Object[])	Journaliser un message, en spécifiant la classe source, la méthode et le nom du groupe de ressources sans arguments.
Logrb(Level, String, String, ResourceBundle, String, Throwable)	Journalisez un message, en spécifiant la classe source, la méthode et le bundle de ressources, avec les informations levées associées.
Logrb(Level, String, String, String, String)	Journaliser un message, en spécifiant la classe source, la méthode et le nom du groupe de ressources sans arguments.
Logrb(Level, String, String, String, String, Object)	Journalisez un message, en spécifiant la classe source, la méthode et le nom du groupe de ressources, avec un seul paramètre d’objet dans le message de journal.
Logrb(Level, String, String, String, String, Object[])	Consignez un message, en spécifiant la classe source, la méthode et le nom du groupe de ressources, avec un tableau d’arguments d’objet.
Logrb(Level, String, String, String, String, Throwable)	Journalisez un message, en spécifiant la classe source, la méthode et le nom du groupe de ressources, avec les informations levées associées.
Notify()	Réveille un thread unique qui attend le moniteur de cet objet. (Hérité de Object)
NotifyAll()	Réveille tous les threads qui attendent le moniteur de cet objet. (Hérité de Object)
RemoveHandler(Handler)	Supprimez un gestionnaire de journaux.
SetHandle(IntPtr, JniHandleOwnership)	Définit la propriété Handle. (Hérité de Object)
Severe(ISupplier)	Journalisez un message SEVERE, qui est à construire uniquement si le niveau de journalisation est tel que le message sera réellement journalisé.
Severe(String)	Journaliser un message SEVERE.
Throwing(String, String, Throwable)	Journal qui lève une exception.
ToArray<T>()	Un objet Logger est utilisé pour journaliser les messages d’un composant système ou d’application spécifique. (Hérité de Object)
ToString()	Retourne une représentation de chaîne de l'objet. (Hérité de Object)
UnregisterFromRuntime()	Un objet Logger est utilisé pour journaliser les messages d’un composant système ou d’application spécifique. (Hérité de Object)
Wait()	Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti par em ou><em>interrompu</em>.<> (Hérité de Object)
Wait(Int64)	Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti< par> em>ou <em>interrompu/em>,< ou jusqu’à ce qu’une certaine quantité de temps réel s’est écoulée. (Hérité de Object)
Wait(Int64, Int32)	Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti< par> em>ou <em>interrompu/em>,< ou jusqu’à ce qu’une certaine quantité de temps réel s’est écoulée. (Hérité de Object)
Warning(ISupplier)	Journalisez un message WARNING, qui est à construire uniquement si le niveau de journalisation est tel que le message sera réellement journalisé.
Warning(String)	Journaliser un message WARNING.

Implémentations d’interfaces explicites

IJavaPeerable.Disposed()	Un objet Logger est utilisé pour journaliser les messages d’un composant système ou d’application spécifique. (Hérité de Object)
IJavaPeerable.DisposeUnlessReferenced()	Un objet Logger est utilisé pour journaliser les messages d’un composant système ou d’application spécifique. (Hérité de Object)
IJavaPeerable.Finalized()	Un objet Logger est utilisé pour journaliser les messages d’un composant système ou d’application spécifique. (Hérité de Object)
IJavaPeerable.JniManagedPeerState	Un objet Logger est utilisé pour journaliser les messages d’un composant système ou d’application spécifique. (Hérité de Object)
IJavaPeerable.SetJniIdentityHashCode(Int32)	Un objet Logger est utilisé pour journaliser les messages d’un composant système ou d’application spécifique. (Hérité de Object)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	Un objet Logger est utilisé pour journaliser les messages d’un composant système ou d’application spécifique. (Hérité de Object)
IJavaPeerable.SetPeerReference(JniObjectReference)	Un objet Logger est utilisé pour journaliser les messages d’un composant système ou d’application spécifique. (Hérité de Object)

Méthodes d’extension

JavaCast<TResult>(IJavaObject)	Effectue une conversion de type vérifiée par le runtime Android.
JavaCast<TResult>(IJavaObject)	Un objet Logger est utilisé pour journaliser les messages d’un composant système ou d’application spécifique.
GetJniTypeName(IJavaPeerable)	Un objet Logger est utilisé pour journaliser les messages d’un composant système ou d’application spécifique.