API java : LogManager

java.util.logging
Class LogManager

java.lang.Object
  java.util.logging.LogManager

public class LogManager
extends Object
extends Object

There is a single global LogManager object that is used to maintain a set of shared state about Loggers and log services.

This LogManager object:

Manages a hierarchical namespace of Logger objects. All named Loggers are stored in this namespace.
Manages a set of logging control properties. These are simple key-value pairs that can be used by Handlers and other logging objects to configure themselves.

The global LogManager object can be retrieved using LogManager.getLogManager(). The LogManager object is created during class initialization and cannot subsequently be changed.

At startup the LogManager class is located using the java.util.logging.manager system property.

By default, the LogManager reads its initial configuration from a properties file "lib/logging.properties" in the JRE directory. If you edit that property file you can change the default logging configuration for all uses of that JRE.

In addition, the LogManager uses two optional system properties that allow more control over reading the initial configuration:

"java.util.logging.config.class"
"java.util.logging.config.file"

These two properties may be set via the Preferences API, or as command line property definitions to the "java" command, or as system property definitions passed to JNI_CreateJavaVM.

If the "java.util.logging.config.class" property is set, then the property value is treated as a class name. The given class will be loaded, an object will be instantiated, and that object's constructor is responsible for reading in the initial configuration. (That object may use other system properties to control its configuration.) The alternate configuration class can use readConfiguration(InputStream) to define properties in the LogManager.

If "java.util.logging.config.class" property is not set, then the "java.util.logging.config.file" system property can be used to specify a properties file (in java.util.Properties format). The initial logging configuration will be read from this file.

If neither of these properties is defined then, as described above, the LogManager will read its initial configuration from a properties file "lib/logging.properties" in the JRE directory.

The properties for loggers and Handlers will have names starting with the dot-separated name for the handler or logger.

The global logging properties may include:

A property "handlers". This defines a whitespace separated list of class names for handler classes to load and register as handlers on the root Logger (the Logger named ""). Each class name must be for a Handler class which has a default constructor. Note that these Handlers may be created lazily, when they are first used.
A property "<logger>.handlers". This defines a whitespace or comma separated list of class names for handlers classes to load and register as handlers to the specified logger. Each class name must be for a Handler class which has a default constructor. Note that these Handlers may be created lazily, when they are first used.
A property "<logger>.useParentHandlers". This defines a boolean value. By default every logger calls its parent in addition to handling the logging message itself, this often result in messages being handled by the root logger as well. When setting this property to false a Handler needs to be configured for this logger otherwise no logging messages are delivered.
A property "config". This property is intended to allow arbitrary configuration code to be run. The property defines a whitespace separated list of class names. A new instance will be created for each named class. The default constructor of each class may execute arbitrary code to update the logging configuration, such as setting logger levels, adding handlers, adding filters, etc.

Note that all classes loaded during LogManager configuration are first searched on the system class path before any user class path. That includes the LogManager class, any config classes, and any handler classes.

Loggers are organized into a naming hierarchy based on their dot separated names. Thus "a.b.c" is a child of "a.b", but "a.b1" and a.b2" are peers.

All properties whose names end with ".level" are assumed to define log levels for Loggers. Thus "foo.level" defines a log level for the logger called "foo" and (recursively) for any of its children in the naming hierarchy. Log Levels are applied in the order they are defined in the properties file. Thus level settings for child nodes in the tree should come after settings for their parents. The property name ".level" can be used to set the level for the root of the tree.

All methods on the LogManager object are multi-thread safe.

Since:: 1.4

Field Summary

static String LOGGING_MXBEAN_NAME
          String representation of the ObjectName for LoggingMXBean.

Constructor Summary

protected LogManager()
          Protected constructor.

Method Summary

boolean addLogger(Logger logger)
          Add a named logger.

void addPropertyChangeListener(PropertyChangeListener l)
          Adds an event listener to be invoked when the logging properties are re-read.

void checkAccess()
          Check that the current context is trusted to modify the logging configuration.

Logger getLogger(String name)
          Method to find a named logger.

Enumeration<String> getLoggerNames()
          Get an enumeration of known logger names.

static LoggingMXBean getLoggingMXBean()
          Returns LoggingMXBean for managing loggers.

static LogManager getLogManager()
          Return the global LogManager object.

String getProperty(String name)
          Get the value of a logging property.

void readConfiguration()
          Reinitialize the logging properties and reread the logging configuration.

void readConfiguration(InputStream ins)
          Reinitialize the logging properties and reread the logging configuration from the given stream, which should be in java.util.Properties format.

void removePropertyChangeListener(PropertyChangeListener l)
          Removes an event listener for property change events.

void reset()
          Reset the logging configuration.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Summary
`static String`	`LOGGING_MXBEAN_NAME` String representation of the `ObjectName` for `LoggingMXBean`.

Constructor Summary
`protected`	`LogManager()` Protected constructor.

Method Summary
`boolean`	`addLogger(Logger logger)` Add a named logger.
`void`	`addPropertyChangeListener(PropertyChangeListener l)` Adds an event listener to be invoked when the logging properties are re-read.
`void`	`checkAccess()` Check that the current context is trusted to modify the logging configuration.
`Logger`	`getLogger(String name)` Method to find a named logger.
`Enumeration<String>`	`getLoggerNames()` Get an enumeration of known logger names.
`static LoggingMXBean`	`getLoggingMXBean()` Returns `LoggingMXBean` for managing loggers.
`static LogManager`	`getLogManager()` Return the global LogManager object.
`String`	`getProperty(String name)` Get the value of a logging property.
`void`	`readConfiguration()` Reinitialize the logging properties and reread the logging configuration.
`void`	`readConfiguration(InputStream ins)` Reinitialize the logging properties and reread the logging configuration from the given stream, which should be in java.util.Properties format.
`void`	`removePropertyChangeListener(PropertyChangeListener l)` Removes an event listener for property change events.
`void`	`reset()` Reset the logging configuration.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

LOGGING_MXBEAN_NAME

public static final String LOGGING_MXBEAN_NAME

String representation of the ObjectName for LoggingMXBean.

See Also:: Constant Field Values

Constructor Detail

LogManager

protected LogManager()

Protected constructor. This is protected so that container applications (such as J2EE containers) can subclass the object. It is non-public as it is intended that there only be one LogManager object, whose value is retrieved by calling Logmanager.getLogManager.

Method Detail

getLogManager

public static LogManager getLogManager()

Return the global LogManager object.

addPropertyChangeListener

public void addPropertyChangeListener(PropertyChangeListener l)
                               throws SecurityException

Adds an event listener to be invoked when the logging properties are re-read. Adding multiple instances of the same event Listener results in multiple entries in the property event listener table.

Parameters:: l - event listener
Throws:: SecurityException - if a security manager exists and if the caller does not have LoggingPermission("control").; NullPointerException - if the PropertyChangeListener is null.

removePropertyChangeListener

public void removePropertyChangeListener(PropertyChangeListener l)
                                  throws SecurityException

Removes an event listener for property change events. If the same listener instance has been added to the listener table through multiple invocations of addPropertyChangeListener, then an equivalent number of removePropertyChangeListener invocations are required to remove all instances of that listener from the listener table.

Returns silently if the given listener is not found.

Parameters:: l - event listener (can be null)
Throws:: SecurityException - if a security manager exists and if the caller does not have LoggingPermission("control").

addLogger

public boolean addLogger(Logger logger)

Add a named logger. This does nothing and returns false if a logger with the same name is already registered.

The Logger factory methods call this method to register each newly created Logger.

The application should retain its own reference to the Logger object to avoid it being garbage collected. The LogManager may only retain a weak reference.

Parameters:: logger - the new logger.
Returns:: true if the argument logger was registered successfully, false if a logger of that name already exists.
Throws:: NullPointerException - if the logger name is null.

getLogger

public Logger getLogger(String name)

Method to find a named logger.

Note that since untrusted code may create loggers with arbitrary names this method should not be relied on to find Loggers for security sensitive logging.

Parameters:: name - name of the logger
Returns:: matching logger or null if none is found

getLoggerNames

public Enumeration<String> getLoggerNames()

Get an enumeration of known logger names.

Note: Loggers may be added dynamically as new classes are loaded. This method only reports on the loggers that are currently registered.

Returns:: enumeration of logger name strings

readConfiguration

public void readConfiguration()
                       throws IOException,
                              SecurityException

Reinitialize the logging properties and reread the logging configuration.

The same rules are used for locating the configuration properties as are used at startup. So normally the logging properties will be re-read from the same file that was used at startup.

Any log level definitions in the new configuration file will be applied using Logger.setLevel(), if the target Logger exists.

A PropertyChangeEvent will be fired after the properties are read.

Throws:: SecurityException - if a security manager exists and if the caller does not have LoggingPermission("control").; IOException - if there are IO problems reading the configuration.

reset

public void reset()
           throws SecurityException

Reset the logging configuration.

For all named loggers, the reset operation removes and closes all Handlers and (except for the root logger) sets the level to null. The root logger's level is set to Level.INFO.

Throws:: SecurityException - if a security manager exists and if the caller does not have LoggingPermission("control").

readConfiguration

public void readConfiguration(InputStream ins)
                       throws IOException,
                              SecurityException

Reinitialize the logging properties and reread the logging configuration from the given stream, which should be in java.util.Properties format. A PropertyChangeEvent will be fired after the properties are read.

Any log level definitions in the new configuration file will be applied using Logger.setLevel(), if the target Logger exists.

Parameters:: ins - stream to read properties from
Throws:: SecurityException - if a security manager exists and if the caller does not have LoggingPermission("control").; IOException - if there are problems reading from the stream.

getProperty

public String getProperty(String name)

Get the value of a logging property. The method returns null if the property is not found.

Parameters:: name - property name
Returns:: property value

checkAccess

public void checkAccess()
                 throws SecurityException

Check that the current context is trusted to modify the logging configuration. This requires LoggingPermission("control").

If the check fails we throw a SecurityException, otherwise we return normally.

Throws:: SecurityException - if a security manager exists and if the caller does not have LoggingPermission("control").

getLoggingMXBean

public static LoggingMXBean getLoggingMXBean()

Returns LoggingMXBean for managing loggers. The LoggingMXBean can also obtained from the platform MBeanServer method.

Returns:: a LoggingMXBean object.
See Also:: ManagementFactory

Package :

Ces informations proviennent du site de http://java.sun.com

Remarques

Contenu

Le contenu de cette page provient du site de Sun, et est généré depuis un cache sur l'infobrol après certains traitements automatisés. La présentation peut donc différer du document original, mais le contenu aussi. Vous pouvez utiliser ce bouton pour afficher la page originale du site de Sun :

Quels sont les motivations de cette démarche?

Maintenir les pages en cache sur différents sites peut offrir plus de disponibilité.

Chaque page est indexée dans la base de donnée, ce qui permet de retrouver facilement les informations, au moyen des sommaires, du moteur de recherche interne, etc.

Des facilités sont mises en place pour que les membres de l'infobrol puissent effectuer des traductions en français des différents documents. Ceci devrait permettre aux débutants en programmation Java de consulter les API en français s'ils maîtrisent moins bien la langue de Shakespeare. Dans le cas où une traduction a été soumise, elle est disponible au moyen d'un lien en bas de page. Si la traduction a été validée, la page s'affiche par défaut en français, et un lien en bas de page permet d'atteindre la version en anglais.

Le code sur l'infobrol est automatiquement coloré selon la syntaxe, et les différents mots clés sont transformés en liens pour accéder rapidement aux informations.

Vous avez la possibilité de partager vos expériences en proposant vos propres extraits de code en utilisant le bouton "ajouter un commentaire" en bas de page. Si vous visitez simplement l'infobrol, vous avez déjà accès à cette fonction, mais si vous étes membre du brol, vous pouvez en plus utiliser des boutons supplémentaires de mise en forme, dont la coloration automatique de vos extraits de codes.

<- LoginModule LogRecord ->

Réseaux sociaux

|Plus d'options...

Vous pouvez modifier vos préférences dans votre profil pour ne plus afficher les interactions avec les réseaux sociaux sur ces pages.

Nuage de mots clés

7 mots clés dont 0 définis manuellement (plus d'information...).

Avertissement

Cette page ne possède pas encore de mots clés manuels, ceci est donc un exemple automatique (les niveaux de pertinence sont fictifs, mais les liens sont valables). Pour tester le nuage avec une page qui contient des mots définis manuellement, vous pouvez cliquer ici.

Vous pouvez modifier vos préférences dans votre profil pour ne plus afficher le nuage de mots clés.

Structure du document

Réseaux sociaux
Nuage de mots clés
- Avertissement :

Astuce pour imprimer les couleurs des cellules de tableaux : http://www.gaudry.be/ast-rf-450.html

Aucun commentaire pour cette page

tection. Enregistrement IDDN n° 5329-1885
Document créé le 30/08/06 23:59, dernière modification le Vendredi 17 Juin 2011, 12:12
Source du document imprimé : http://www.gaudry.be/java-api-rf-java/util/logging/LogManager.html Document affiché 1 fois ce mois de Juin.
St.Gaudry©07.01.02

Outils (masquer)

Recherche (afficher)

Utilisateur (masquer)

Nouveaux :
S'enregistrer

Liste des Membres

Qui est en ligne?
FAQ du forum

FAQ

Apparence (afficher)

Stats (afficher)

15832 documents
452 astuces.
549 niouzes.
3099 definitions.
447 membres.
8115 messages.

Document genere en :
0,59 seconde

Mises à jour :

Citation (masquer)

Dans votre ascension professionnelle, soyez toujours très gentil pour ceux que vous dépassez en montant. Vous les retrouverez au même endroit en redescendant.

Woody Allen

Nous sommes le Samedi 02 Juin 2012, 00:04, toutes les heures sont au format GMT+1.00 Heure, heure d'été (+1)

API java : LogManager

java.util.logging Class LogManager

LOGGING_MXBEAN_NAME

LogManager

getLogManager

addPropertyChangeListener

removePropertyChangeListener

addLogger

getLogger

getLoggerNames

readConfiguration

reset

readConfiguration

getProperty

checkAccess

getLoggingMXBean

Remarques

Contenu

Quels sont les motivations de cette démarche?

Réseaux sociaux

Nuage de mots clés

Structure du document

java.util.logging
Class LogManager