|
FlexDoc/Javadoc 2.0 Demo Java Doc |
An application can replace the logging backend even when the java.logging module is present, by simply providing and declaring an implementation of the System.LoggerFinder service.
Default Implementation
The system default LoggerFinder implementation uses java.util.logging as the backend framework when the java.logging module is present. It returns a logger instance that will route log messages to a java.util.logging.Logger. Otherwise, if java.logging is not present, the default implementation will return a simple logger instance that will route log messages of INFO level and above to the console (System.err).
Logging Configuration
Logger instances obtained from the LoggerFinder factory methods are not directly configurable by the application. Configuration is the responsibility of the underlying logging backend, and usually requires using APIs specific to that backend.
For the default LoggerFinder implementation using java.util.logging as its backend, refer to java.util.logging for logging configuration. For the default LoggerFinder implementation returning simple loggers when the java.logging module is absent, the configuration is implementation dependent.
Usually an application that uses a logging framework will log messages through a logger facade defined (or supported) by that framework. Applications that wish to use an external framework should log through the facade associated with that framework.
A system class that needs to log messages will typically obtain a System.Logger instance to route messages to the logging framework selected by the application.
Libraries and classes that only need loggers to produce log messages should not attempt to configure loggers by themselves, as that would make them dependent from a specific implementation of the LoggerFinder service.
In addition, when a security manager is present, loggers provided to
system classes should not be directly configurable through the logging
backend without requiring permissions.
It is the responsibility of the provider of
the concrete LoggerFinder implementation to ensure that
these loggers are not configured by untrusted code without proper
permission checks, as configuration performed on such loggers usually
affects all applications in the same Java Runtime.
Message Levels and Mapping to backend levels
A logger finder is responsible for mapping from a
System.Logger.Level to a level supported by the logging backend it uses.
The default LoggerFinder using java.util.logging as the backend
maps System.Logger levels to
java.util.logging levels
of corresponding severity - as described in Logger.Level.
Constructor Summary |
||
protected |
Creates a new instance of LoggerFinder.
|
Method Summary |
||
Returns a localizable instance of Logger
for the given module.
|
||
abstract System.Logger |
Returns an instance of Logger
for the given module.
|
|
static System.LoggerFinder |
Returns the LoggerFinder instance.
|
Methods inherited from class java.lang.Object |
protected LoggerFinder |
() |
public abstract System.Logger getLogger |
public System.Logger getLocalizedLogger |
An implementation of LoggerFinder may override this method, for example, when the underlying logging backend provides its own mechanism for localizing log messages, then such a LoggerFinder would be free to return a logger that makes direct use of the mechanism provided by the backend.
public static System.LoggerFinder getLoggerFinder |
() |
|
FlexDoc/Javadoc 2.0 Demo Java Doc |