jdk-sandbox: comparison jdk/src/share/classes/java/util/logging/Logger.java

equal deleted inserted replaced

-:705325a63a58
+:61c9885d76e2
 * in products) should create and use their own Logger objects,
 * with appropriate names, so that logging can be controlled on a
 * suitable per-Logger granularity. Developers also need to keep a
 * strong reference to their Logger objects to prevent them from
 * being garbage collected.
-* <p>
+*
 * @deprecated Initialization of this field is prone to deadlocks.
 * The field must be initialized by the Logger class initialization
 * which may cause deadlocks with the LogManager class initialization.
 * In such cases two class initialization wait for each other to complete.
 * The preferred way to get the global logger object is via the call
 * If the named Logger already exists and does not yet have a
 * localization resource bundle then the given resource bundle
 * name is used.  If the named Logger already exists and has
 * a different resource bundle name then an IllegalArgumentException
 * is thrown.
-* <p>
+*
 * @param   name    A name for the logger.  This should
 *                          be a dot-separated name and should normally
 *                          be based on the package name or class name
 *                          of the subsystem, such as java.net
 *                          or javax.swing
 * to have the root logger ("") as its parent.  This means that
 * by default it inherits its effective level and handlers
 * from the root logger. Changing its parent via the
 * {@link #setParent(java.util.logging.Logger) setParent} method
 * will still require the security permission specified by that method.
-* <p>
 *
 * @return a newly created private Logger
 */
 public static Logger getAnonymousLogger() {
 return getAnonymousLogger(null);
 * to have the root logger ("") as its parent.  This means that
 * by default it inherits its effective level and handlers
 * from the root logger.  Changing its parent via the
 * {@link #setParent(java.util.logging.Logger) setParent} method
 * will still require the security permission specified by that method.
-* <p>
+*
 * @param   resourceBundleName  name of ResourceBundle to be used for localizing
 *                          messages for this logger.
 *          May be null if none of the messages require localization.
 * @return a newly created private Logger
 * @throws MissingResourceException if the resourceBundleName is non-null and
 * Log a message, with no arguments.
 * <p>
 * If the logger is currently enabled for the given message
 * level then the given message is forwarded to all the
 * registered output Handler objects.
-* <p>
+*
 * @param   level   One of the message level identifiers, e.g., SEVERE
 * @param   msg     The string message (or a key in the message catalog)
 */
 public void log(Level level, String msg) {
 if (!isLoggable(level)) {
 * <p>
 * If the logger is currently enabled for the given message
 * level then the message is constructed by invoking the provided
 * supplier function and forwarded to all the registered output
 * Handler objects.
-* <p>
+*
 * @param   level   One of the message level identifiers, e.g., SEVERE
 * @param   msgSupplier   A function, which when called, produces the
 *                        desired log message
 */
 public void log(Level level, Supplier<String> msgSupplier) {
 * Log a message, with one object parameter.
 * <p>
 * If the logger is currently enabled for the given message
 * level then a corresponding LogRecord is created and forwarded
 * to all the registered output Handler objects.
-* <p>
+*
 * @param   level   One of the message level identifiers, e.g., SEVERE
 * @param   msg     The string message (or a key in the message catalog)
 * @param   param1  parameter to the message
 */
 public void log(Level level, String msg, Object param1) {
 * Log a message, with an array of object arguments.
 * <p>
 * If the logger is currently enabled for the given message
 * level then a corresponding LogRecord is created and forwarded
 * to all the registered output Handler objects.
-* <p>
+*
 * @param   level   One of the message level identifiers, e.g., SEVERE
 * @param   msg     The string message (or a key in the message catalog)
 * @param   params  array of parameters to the message
 */
 public void log(Level level, String msg, Object params[]) {
 * <p>
 * Note that the thrown argument is stored in the LogRecord thrown
 * property, rather than the LogRecord parameters property.  Thus it is
 * processed specially by output Formatters and is not treated
 * as a formatting parameter to the LogRecord message property.
-* <p>
+*
 * @param   level   One of the message level identifiers, e.g., SEVERE
 * @param   msg     The string message (or a key in the message catalog)
 * @param   thrown  Throwable associated with log message.
 */
 public void log(Level level, String msg, Throwable thrown) {
 * <p>
 * Note that the thrown argument is stored in the LogRecord thrown
 * property, rather than the LogRecord parameters property.  Thus it is
 * processed specially by output Formatters and is not treated
 * as a formatting parameter to the LogRecord message property.
-* <p>
+*
 * @param   level   One of the message level identifiers, e.g., SEVERE
 * @param   thrown  Throwable associated with log message.
 * @param   msgSupplier   A function, which when called, produces the
 *                        desired log message
 * @since   1.8
 * with no arguments.
 * <p>
 * If the logger is currently enabled for the given message
 * level then the given message is forwarded to all the
 * registered output Handler objects.
-* <p>
+*
 * @param   level   One of the message level identifiers, e.g., SEVERE
 * @param   sourceClass    name of class that issued the logging request
 * @param   sourceMethod   name of method that issued the logging request
 * @param   msg     The string message (or a key in the message catalog)
 */
 * <p>
 * If the logger is currently enabled for the given message
 * level then the message is constructed by invoking the provided
 * supplier function and forwarded to all the registered output
 * Handler objects.
-* <p>
+*
 * @param   level   One of the message level identifiers, e.g., SEVERE
 * @param   sourceClass    name of class that issued the logging request
 * @param   sourceMethod   name of method that issued the logging request
 * @param   msgSupplier   A function, which when called, produces the
 *                        desired log message
 * with a single object parameter to the log message.
 * <p>
 * If the logger is currently enabled for the given message
 * level then a corresponding LogRecord is created and forwarded
 * to all the registered output Handler objects.
-* <p>
+*
 * @param   level   One of the message level identifiers, e.g., SEVERE
 * @param   sourceClass    name of class that issued the logging request
 * @param   sourceMethod   name of method that issued the logging request
 * @param   msg      The string message (or a key in the message catalog)
 * @param   param1    Parameter to the log message.
 * with an array of object arguments.
 * <p>
 * If the logger is currently enabled for the given message
 * level then a corresponding LogRecord is created and forwarded
 * to all the registered output Handler objects.
-* <p>
+*
 * @param   level   One of the message level identifiers, e.g., SEVERE
 * @param   sourceClass    name of class that issued the logging request
 * @param   sourceMethod   name of method that issued the logging request
 * @param   msg     The string message (or a key in the message catalog)
 * @param   params  Array of parameters to the message
 * <p>
 * Note that the thrown argument is stored in the LogRecord thrown
 * property, rather than the LogRecord parameters property.  Thus it is
 * processed specially by output Formatters and is not treated
 * as a formatting parameter to the LogRecord message property.
-* <p>
+*
 * @param   level   One of the message level identifiers, e.g., SEVERE
 * @param   sourceClass    name of class that issued the logging request
 * @param   sourceMethod   name of method that issued the logging request
 * @param   msg     The string message (or a key in the message catalog)
 * @param   thrown  Throwable associated with log message.
 * <p>
 * Note that the thrown argument is stored in the LogRecord thrown
 * property, rather than the LogRecord parameters property.  Thus it is
 * processed specially by output Formatters and is not treated
 * as a formatting parameter to the LogRecord message property.
-* <p>
+*
 * @param   level   One of the message level identifiers, e.g., SEVERE
 * @param   sourceClass    name of class that issued the logging request
 * @param   sourceMethod   name of method that issued the logging request
 * @param   thrown  Throwable associated with log message.
 * @param   msgSupplier   A function, which when called, produces the
 * registered output Handler objects.
 * <p>
 * The msg string is localized using the named resource bundle.  If the
 * resource bundle name is null, or an empty String or invalid
 * then the msg string is not localized.
-* <p>
+*
 * @param   level   One of the message level identifiers, e.g., SEVERE
 * @param   sourceClass    name of class that issued the logging request
 * @param   sourceMethod   name of method that issued the logging request
 * @param   bundleName     name of resource bundle to localize msg,
 *                         can be null
 * to all the registered output Handler objects.
 * <p>
 * The msg string is localized using the named resource bundle.  If the
 * resource bundle name is null, or an empty String or invalid
 * then the msg string is not localized.
-* <p>
+*
 * @param   level   One of the message level identifiers, e.g., SEVERE
 * @param   sourceClass    name of class that issued the logging request
 * @param   sourceMethod   name of method that issued the logging request
 * @param   bundleName     name of resource bundle to localize msg,
 *                         can be null
 * to all the registered output Handler objects.
 * <p>
 * The msg string is localized using the named resource bundle.  If the
 * resource bundle name is null, or an empty String or invalid
 * then the msg string is not localized.
-* <p>
+*
 * @param   level   One of the message level identifiers, e.g., SEVERE
 * @param   sourceClass    name of class that issued the logging request
 * @param   sourceMethod   name of method that issued the logging request
 * @param   bundleName     name of resource bundle to localize msg,
 *                         can be null.
 * to all the registered output Handler objects.
 * <p>
 * The {@code msg} string is localized using the given resource bundle.
 * If the resource bundle is {@code null}, then the {@code msg} string is not
 * localized.
-* <p>
+*
 * @param   level   One of the message level identifiers, e.g., SEVERE
 * @param   sourceClass    Name of the class that issued the logging request
 * @param   sourceMethod   Name of the method that issued the logging request
 * @param   bundle         Resource bundle to localize {@code msg},
 *                         can be {@code null}.
 * <p>
 * Note that the thrown argument is stored in the LogRecord thrown
 * property, rather than the LogRecord parameters property.  Thus it is
 * processed specially by output Formatters and is not treated
 * as a formatting parameter to the LogRecord message property.
-* <p>
+*
 * @param   level   One of the message level identifiers, e.g., SEVERE
 * @param   sourceClass    name of class that issued the logging request
 * @param   sourceMethod   name of method that issued the logging request
 * @param   bundleName     name of resource bundle to localize msg,
 *                         can be null
 * <p>
 * Note that the thrown argument is stored in the LogRecord thrown
 * property, rather than the LogRecord parameters property.  Thus it is
 * processed specially by output Formatters and is not treated
 * as a formatting parameter to the LogRecord message property.
-* <p>
+*
 * @param   level   One of the message level identifiers, e.g., SEVERE
 * @param   sourceClass    Name of the class that issued the logging request
 * @param   sourceMethod   Name of the method that issued the logging request
 * @param   bundle         Resource bundle to localize {@code msg},
 *                         can be {@code null}
 * Log a method entry.
 * <p>
 * This is a convenience method that can be used to log entry
 * to a method.  A LogRecord with message "ENTRY", log level
 * FINER, and the given sourceMethod and sourceClass is logged.
-* <p>
+*
 * @param   sourceClass    name of class that issued the logging request
 * @param   sourceMethod   name of method that is being entered
 */
 public void entering(String sourceClass, String sourceMethod) {
 logp(Level.FINER, sourceClass, sourceMethod, "ENTRY");
 * <p>
 * This is a convenience method that can be used to log entry
 * to a method.  A LogRecord with message "ENTRY {0}", log level
 * FINER, and the given sourceMethod, sourceClass, and parameter
 * is logged.
-* <p>
+*
 * @param   sourceClass    name of class that issued the logging request
 * @param   sourceMethod   name of method that is being entered
 * @param   param1         parameter to the method being entered
 */
 public void entering(String sourceClass, String sourceMethod, Object param1) {
 * This is a convenience method that can be used to log entry
 * to a method.  A LogRecord with message "ENTRY" (followed by a
 * format {N} indicator for each entry in the parameter array),
 * log level FINER, and the given sourceMethod, sourceClass, and
 * parameters is logged.
-* <p>
+*
 * @param   sourceClass    name of class that issued the logging request
 * @param   sourceMethod   name of method that is being entered
 * @param   params         array of parameters to the method being entered
 */
 public void entering(String sourceClass, String sourceMethod, Object params[]) {
 * Log a method return.
 * <p>
 * This is a convenience method that can be used to log returning
 * from a method.  A LogRecord with message "RETURN", log level
 * FINER, and the given sourceMethod and sourceClass is logged.
-* <p>
+*
 * @param   sourceClass    name of class that issued the logging request
 * @param   sourceMethod   name of the method
 */
 public void exiting(String sourceClass, String sourceMethod) {
 logp(Level.FINER, sourceClass, sourceMethod, "RETURN");
 * <p>
 * This is a convenience method that can be used to log returning
 * from a method.  A LogRecord with message "RETURN {0}", log level
 * FINER, and the gives sourceMethod, sourceClass, and result
 * object is logged.
-* <p>
+*
 * @param   sourceClass    name of class that issued the logging request
 * @param   sourceMethod   name of the method
 * @param   result  Object that is being returned
 */
 public void exiting(String sourceClass, String sourceMethod, Object result) {
 * <p>
 * Note that the thrown argument is stored in the LogRecord thrown
 * property, rather than the LogRecord parameters property.  Thus it is
 * processed specially by output Formatters and is not treated
 * as a formatting parameter to the LogRecord message property.
-* <p>
+*
 * @param   sourceClass    name of class that issued the logging request
 * @param   sourceMethod  name of the method.
 * @param   thrown  The Throwable that is being thrown.
 */
 public void throwing(String sourceClass, String sourceMethod, Throwable thrown) {
 * Log a SEVERE message.
 * <p>
 * If the logger is currently enabled for the SEVERE message
 * level then the given message is forwarded to all the
 * registered output Handler objects.
-* <p>
+*
 * @param   msg     The string message (or a key in the message catalog)
 */
 public void severe(String msg) {
 log(Level.SEVERE, msg);
 }
 * Log a WARNING message.
 * <p>
 * If the logger is currently enabled for the WARNING message
 * level then the given message is forwarded to all the
 * registered output Handler objects.
-* <p>
+*
 * @param   msg     The string message (or a key in the message catalog)
 */
 public void warning(String msg) {
 log(Level.WARNING, msg);
 }
 * Log an INFO message.
 * <p>
 * If the logger is currently enabled for the INFO message
 * level then the given message is forwarded to all the
 * registered output Handler objects.
-* <p>
+*
 * @param   msg     The string message (or a key in the message catalog)
 */
 public void info(String msg) {
 log(Level.INFO, msg);
 }
 * Log a CONFIG message.
 * <p>
 * If the logger is currently enabled for the CONFIG message
 * level then the given message is forwarded to all the
 * registered output Handler objects.
-* <p>
+*
 * @param   msg     The string message (or a key in the message catalog)
 */
 public void config(String msg) {
 log(Level.CONFIG, msg);
 }
 * Log a FINE message.
 * <p>
 * If the logger is currently enabled for the FINE message
 * level then the given message is forwarded to all the
 * registered output Handler objects.
-* <p>
+*
 * @param   msg     The string message (or a key in the message catalog)
 */
 public void fine(String msg) {
 log(Level.FINE, msg);
 }
 * Log a FINER message.
 * <p>
 * If the logger is currently enabled for the FINER message
 * level then the given message is forwarded to all the
 * registered output Handler objects.
-* <p>
+*
 * @param   msg     The string message (or a key in the message catalog)
 */
 public void finer(String msg) {
 log(Level.FINER, msg);
 }
 * Log a FINEST message.
 * <p>
 * If the logger is currently enabled for the FINEST message
 * level then the given message is forwarded to all the
 * registered output Handler objects.
-* <p>
+*
 * @param   msg     The string message (or a key in the message catalog)
 */
 public void finest(String msg) {
 log(Level.FINEST, msg);
 }
 * <p>
 * If the logger is currently enabled for the SEVERE message
 * level then the message is constructed by invoking the provided
 * supplier function and forwarded to all the registered output
 * Handler objects.
-* <p>
+*
 * @param   msgSupplier   A function, which when called, produces the
 *                        desired log message
 * @since   1.8
 */
 public void severe(Supplier<String> msgSupplier) {
 * <p>
 * If the logger is currently enabled for the WARNING message
 * level then the message is constructed by invoking the provided
 * supplier function and forwarded to all the registered output
 * Handler objects.
-* <p>
+*
 * @param   msgSupplier   A function, which when called, produces the
 *                        desired log message
 * @since   1.8
 */
 public void warning(Supplier<String> msgSupplier) {
 * <p>
 * If the logger is currently enabled for the INFO message
 * level then the message is constructed by invoking the provided
 * supplier function and forwarded to all the registered output
 * Handler objects.
-* <p>
+*
 * @param   msgSupplier   A function, which when called, produces the
 *                        desired log message
 * @since   1.8
 */
 public void info(Supplier<String> msgSupplier) {
 * <p>
 * If the logger is currently enabled for the CONFIG message
 * level then the message is constructed by invoking the provided
 * supplier function and forwarded to all the registered output
 * Handler objects.
-* <p>
+*
 * @param   msgSupplier   A function, which when called, produces the
 *                        desired log message
 * @since   1.8
 */
 public void config(Supplier<String> msgSupplier) {
 * <p>
 * If the logger is currently enabled for the FINE message
 * level then the message is constructed by invoking the provided
 * supplier function and forwarded to all the registered output
 * Handler objects.
-* <p>
+*
 * @param   msgSupplier   A function, which when called, produces the
 *                        desired log message
 * @since   1.8
 */
 public void fine(Supplier<String> msgSupplier) {
 * <p>
 * If the logger is currently enabled for the FINER message
 * level then the message is constructed by invoking the provided
 * supplier function and forwarded to all the registered output
 * Handler objects.
-* <p>
+*
 * @param   msgSupplier   A function, which when called, produces the
 *                        desired log message
 * @since   1.8
 */
 public void finer(Supplier<String> msgSupplier) {
 * <p>
 * If the logger is currently enabled for the FINEST message
 * level then the message is constructed by invoking the provided
 * supplier function and forwarded to all the registered output
 * Handler objects.
-* <p>
+*
 * @param   msgSupplier   A function, which when called, produces the
 *                        desired log message
 * @since   1.8
 */
 public void finest(Supplier<String> msgSupplier) {
 handlers.remove(handler);
 }
 /**
 * Get the Handlers associated with this logger.
-* <p>
+*
 * @return  an array of all registered Handlers
 */
 public Handler[] getHandlers() {
 return accessCheckedHandlers();
 }
 /**
 * Set the parent for this Logger.  This method is used by
 * the LogManager to update a Logger when the namespace changes.
 * <p>
 * It should not be called from application code.
-* <p>
+*
 * @param  parent   the new parent logger
 * @throws  SecurityException  if a security manager exists and if
 *          the caller does not have LoggingPermission("control").
 */
 public void setParent(Logger parent) {

changeset 24196	61c9885d76e2
parent 23899	a926ecef7eb3