/* * Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation.  Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */  package java.util.logging; import java.util.*;import java.util.concurrent.CopyOnWriteArrayList;import java.security.*;import java.lang.ref.WeakReference; /** * A Logger object is used to log messages for a specific * system or application component.  Loggers are normally named, * using a hierarchical dot-separated namespace.  Logger names * can be arbitrary strings, but they should normally be based on * the package name or class name of the logged component, such * as java.net or javax.swing.  In addition it is possible to create * "anonymous" Loggers that are not stored in the Logger namespace. * <p> * Logger objects may be obtained by calls on one of the getLogger * factory methods.  These will either create a new Logger or * return a suitable existing Logger. It is important to note that * the Logger returned by one of the {@code getLogger} factory methods * may be garbage collected at any time if a strong reference to the * Logger is not kept. * <p> * Logging messages will be forwarded to registered Handler * objects, which can forward the messages to a variety of * destinations, including consoles, files, OS logs, etc. * <p> * Each Logger keeps track of a "parent" Logger, which is its * nearest existing ancestor in the Logger namespace. * <p> * Each Logger has a "Level" associated with it.  This reflects * a minimum Level that this logger cares about.  If a Logger's * level is set to <tt>null</tt>, then its effective level is inherited * from its parent, which may in turn obtain it recursively from its * parent, and so on up the tree. * <p> * The log level can be configured based on the properties from the * logging configuration file, as described in the description * of the LogManager class.  However it may also be dynamically changed * by calls on the Logger.setLevel method.  If a logger's level is * changed the change may also affect child loggers, since any child * logger that has <tt>null</tt> as its level will inherit its * effective level from its parent. * <p> * On each logging call the Logger initially performs a cheap * check of the request level (e.g., SEVERE or FINE) against the * effective log level of the logger.  If the request level is * lower than the log level, the logging call returns immediately. * <p> * After passing this initial (cheap) test, the Logger will allocate * a LogRecord to describe the logging message.  It will then call a * Filter (if present) to do a more detailed check on whether the * record should be published.  If that passes it will then publish * the LogRecord to its output Handlers.  By default, loggers also * publish to their parent's Handlers, recursively up the tree. * <p> * Each Logger may have a ResourceBundle name associated with it. * The named bundle will be used for localizing logging messages. * If a Logger does not have its own ResourceBundle name, then * it will inherit the ResourceBundle name from its parent, * recursively up the tree. * <p> * Most of the logger output methods take a "msg" argument.  This * msg argument may be either a raw value or a localization key. * During formatting, if the logger has (or inherits) a localization * ResourceBundle and if the ResourceBundle has a mapping for the msg * string, then the msg string is replaced by the localized value. * Otherwise the original msg string is used.  Typically, formatters use * java.text.MessageFormat style formatting to format parameters, so * for example a format string "{0} {1}" would format two parameters * as strings. * <p> * When mapping ResourceBundle names to ResourceBundles, the Logger * will first try to use the Thread's ContextClassLoader.  If that * is null it will try the SystemClassLoader instead.  As a temporary * transition feature in the initial implementation, if the Logger is * unable to locate a ResourceBundle from the ContextClassLoader or * SystemClassLoader the Logger will also search up the class stack * and use successive calling ClassLoaders to try to locate a ResourceBundle. * (This call stack search is to allow containers to transition to * using ContextClassLoaders and is likely to be removed in future * versions.) * <p> * Formatting (including localization) is the responsibility of * the output Handler, which will typically call a Formatter. * <p> * Note that formatting need not occur synchronously.  It may be delayed * until a LogRecord is actually written to an external sink. * <p> * The logging methods are grouped in five main categories: * <ul> * <li><p> *     There are a set of "log" methods that take a log level, a message *     string, and optionally some parameters to the message string. * <li><p> *     There are a set of "logp" methods (for "log precise") that are *     like the "log" methods, but also take an explicit source class name *     and method name. * <li><p> *     There are a set of "logrb" method (for "log with resource bundle") *     that are like the "logp" method, but also take an explicit resource *     bundle name for use in localizing the log message. * <li><p> *     There are convenience methods for tracing method entries (the *     "entering" methods), method returns (the "exiting" methods) and *     throwing exceptions (the "throwing" methods). * <li><p> *     Finally, there are a set of convenience methods for use in the *     very simplest cases, when a developer simply wants to log a *     simple string at a given log level.  These methods are named *     after the standard Level names ("severe", "warning", "info", etc.) *     and take a single argument, a message string. * </ul> * <p> * For the methods that do not take an explicit source name and * method name, the Logging framework will make a "best effort" * to determine which class and method called into the logging method. * However, it is important to realize that this automatically inferred * information may only be approximate (or may even be quite wrong!). * Virtual machines are allowed to do extensive optimizations when * JITing and may entirely remove stack frames, making it impossible * to reliably locate the calling class and method. * <P> * All methods on Logger are multi-thread safe. * <p> * <b>Subclassing Information:</b> Note that a LogManager class may * provide its own implementation of named Loggers for any point in * the namespace.  Therefore, any subclasses of Logger (unless they * are implemented in conjunction with a new LogManager class) should * take care to obtain a Logger instance from the LogManager class and * should delegate operations such as "isLoggable" and "log(LogRecord)" * to that instance.  Note that in order to intercept all logging * output, subclasses need only override the log(LogRecord) method. * All the other logging methods are implemented as calls on this * log(LogRecord) method. * * @since 1.4 */  public class Logger {    private static final Handler emptyHandlers[] = new Handler[0];    private static final int offValue = Level.OFF.intValue();    private LogManager manager;    private String name;    private final CopyOnWriteArrayList<Handler> handlers =        new CopyOnWriteArrayList<>();    private String resourceBundleName;    private volatile boolean useParentHandlers = true;    private volatile Filter filter;    private boolean anonymous;     private ResourceBundle catalog;     // Cached resource bundle    private String catalogName;         // name associated with catalog    private Locale catalogLocale;       // locale associated with catalog     // The fields relating to parent-child relationships and levels    // are managed under a separate lock, the treeLock.    private static Object treeLock = new Object();    // We keep weak references from parents to children, but strong    // references from children to parents.    private volatile Logger parent;    // our nearest parent.    private ArrayList<LogManager.LoggerWeakRef> kids;   // WeakReferences to loggers that have us as parent    private volatile Level levelObject;    private volatile int levelValue;  // current effective level value     /**     * GLOBAL_LOGGER_NAME is a name for the global logger.     *     * @since 1.6     */    public static final String GLOBAL_LOGGER_NAME = "global";     /**     * Return global logger object with the name Logger.GLOBAL_LOGGER_NAME.     *     * @return global logger object     * @since 1.7     */    public static final Logger getGlobal() {        return global;    }     /**     * The "global" Logger object is provided as a convenience to developers     * who are making casual use of the Logging package.  Developers     * who are making serious use of the logging package (for example     * 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     * <code>Logger.getGlobal()</code>.     * For compatibility with old JDK versions where the     * <code>Logger.getGlobal()</code> is not available use the call     * <code>Logger.getLogger(Logger.GLOBAL_LOGGER_NAME)</code>     * or <code>Logger.getLogger("global")</code>.     */    @Deprecated    public static final Logger global = new Logger(GLOBAL_LOGGER_NAME);     /**     * Protected method to construct a logger for a named subsystem.     * <p>     * The logger will be initially configured with a null Level     * and with useParentHandlers set to true.     *     * @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.  It may be null for anonymous Loggers.     * @param   resourceBundleName  name of ResourceBundle to be used for localizing     *                          messages for this logger.  May be null if none     *                          of the messages require localization.     * @throws MissingResourceException if the resourceBundleName is non-null and     *             no corresponding resource can be found.     */    protected Logger(String name, String resourceBundleName) {        this.manager = LogManager.getLogManager();        if (resourceBundleName != null) {            // Note: we may get a MissingResourceException here.            setupResourceInfo(resourceBundleName);        }        this.name = name;        levelValue = Level.INFO.intValue();    }     // This constructor is used only to create the global Logger.    // It is needed to break a cyclic dependence between the LogManager    // and Logger static initializers causing deadlocks.    private Logger(String name) {        // The manager field is not initialized here.        this.name = name;        levelValue = Level.INFO.intValue();    }     // It is called from the LogManager.<clinit> to complete    // initialization of the global Logger.    void setLogManager(LogManager manager) {        this.manager = manager;    }     private void checkAccess() throws SecurityException {        if (!anonymous) {            if (manager == null) {                // Complete initialization of the global Logger.                manager = LogManager.getLogManager();            }            manager.checkAccess();        }    }     /**     * Find or create a logger for a named subsystem.  If a logger has     * already been created with the given name it is returned.  Otherwise     * a new logger is created.     * <p>     * If a new logger is created its log level will be configured     * based on the LogManager configuration and it will configured     * to also send logging output to its parent's Handlers.  It will     * be registered in the LogManager global namespace.     * <p>     * Note: The LogManager may only retain a weak reference to the newly     * created Logger. It is important to understand that a previously     * created Logger with the given name may be garbage collected at any     * time if there is no strong reference to the Logger. In particular,     * this means that two back-to-back calls like     * {@code getLogger("MyLogger").log(...)} may use different Logger     * objects named "MyLogger" if there is no strong reference to the     * Logger named "MyLogger" elsewhere in the program.     *     * @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     * @return a suitable Logger     * @throws NullPointerException if the name is null.     */     // Synchronization is not required here. All synchronization for    // adding a new Logger object is handled by LogManager.addLogger().    public static Logger getLogger(String name) {        // This method is intentionally not a wrapper around a call        // to getLogger(name, resourceBundleName). If it were then        // this sequence:        //        //     getLogger("Foo", "resourceBundleForFoo");        //     getLogger("Foo");        //        // would throw an IllegalArgumentException in the second call        // because the wrapper would result in an attempt to replace        // the existing "resourceBundleForFoo" with null.        LogManager manager = LogManager.getLogManager();        return manager.demandLogger(name);    }     /**     * Find or create a logger for a named subsystem.  If a logger has     * already been created with the given name it is returned.  Otherwise     * a new logger is created.     * <p>     * If a new logger is created its log level will be configured     * based on the LogManager and it will configured to also send logging     * output to its parent's Handlers.  It will be registered in     * the LogManager global namespace.     * <p>     * Note: The LogManager may only retain a weak reference to the newly     * created Logger. It is important to understand that a previously     * created Logger with the given name may be garbage collected at any     * time if there is no strong reference to the Logger. In particular,     * this means that two back-to-back calls like     * {@code getLogger("MyLogger", ...).log(...)} may use different Logger     * objects named "MyLogger" if there is no strong reference to the     * Logger named "MyLogger" elsewhere in the program.     * <p>     * 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     * @param   resourceBundleName  name of ResourceBundle to be used for localizing     *                          messages for this logger. May be <CODE>null</CODE> if none of     *                          the messages require localization.     * @return a suitable Logger     * @throws MissingResourceException if the resourceBundleName is non-null and     *             no corresponding resource can be found.     * @throws IllegalArgumentException if the Logger already exists and uses     *             a different resource bundle name.     * @throws NullPointerException if the name is null.     */     // Synchronization is not required here. All synchronization for    // adding a new Logger object is handled by LogManager.addLogger().    public static Logger getLogger(String name, String resourceBundleName) {        LogManager manager = LogManager.getLogManager();        Logger result = manager.demandLogger(name);        if (result.resourceBundleName == null) {            // Note: we may get a MissingResourceException here.            result.setupResourceInfo(resourceBundleName);        } else if (!result.resourceBundleName.equals(resourceBundleName)) {            throw new IllegalArgumentException(result.resourceBundleName +                                " != " + resourceBundleName);        }        return result;    }      /**     * Create an anonymous Logger.  The newly created Logger is not     * registered in the LogManager namespace.  There will be no     * access checks on updates to the logger.     * <p>     * This factory method is primarily intended for use from applets.     * Because the resulting Logger is anonymous it can be kept private     * by the creating class.  This removes the need for normal security     * checks, which in turn allows untrusted applet code to update     * the control state of the Logger.  For example an applet can do     * a setLevel or an addHandler on an anonymous Logger.     * <p>     * Even although the new logger is anonymous, it is configured     * to have the root logger ("") as its parent.  This means that     * by default it inherits its effective level and handlers     * from the root logger.     * <p>     *     * @return a newly created private Logger     */    public static Logger getAnonymousLogger() {        return getAnonymousLogger(null);    }     /**     * Create an anonymous Logger.  The newly created Logger is not     * registered in the LogManager namespace.  There will be no     * access checks on updates to the logger.     * <p>     * This factory method is primarily intended for use from applets.     * Because the resulting Logger is anonymous it can be kept private     * by the creating class.  This removes the need for normal security     * checks, which in turn allows untrusted applet code to update     * the control state of the Logger.  For example an applet can do     * a setLevel or an addHandler on an anonymous Logger.     * <p>     * Even although the new logger is anonymous, it is configured     * to have the root logger ("") as its parent.  This means that     * by default it inherits its effective level and handlers     * from the root logger.     * <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     *             no corresponding resource can be found.     */     // Synchronization is not required here. All synchronization for    // adding a new anonymous Logger object is handled by doSetParent().    public static Logger getAnonymousLogger(String resourceBundleName) {        LogManager manager = LogManager.getLogManager();        // cleanup some Loggers that have been GC'ed        manager.drainLoggerRefQueueBounded();        Logger result = new Logger(null, resourceBundleName);        result.anonymous = true;        Logger root = manager.getLogger("");        result.doSetParent(root);        return result;    }     /**     * Retrieve the localization resource bundle for this     * logger for the current default locale.  Note that if     * the result is null, then the Logger will use a resource     * bundle inherited from its parent.     *     * @return localization bundle (may be null)     */    public ResourceBundle getResourceBundle() {        return findResourceBundle(getResourceBundleName());    }     /**     * Retrieve the localization resource bundle name for this     * logger.  Note that if the result is null, then the Logger     * will use a resource bundle name inherited from its parent.     *     * @return localization bundle name (may be null)     */    public String getResourceBundleName() {        return resourceBundleName;    }     /**     * Set a filter to control output on this Logger.     * <P>     * After passing the initial "level" check, the Logger will     * call this Filter to check if a log record should really     * be published.     *     * @param   newFilter  a filter object (may be null)     * @exception  SecurityException  if a security manager exists and if     *             the caller does not have LoggingPermission("control").     */    public void setFilter(Filter newFilter) throws SecurityException {        checkAccess();        filter = newFilter;    }     /**     * Get the current filter for this Logger.     *     * @return  a filter object (may be null)     */    public Filter getFilter() {        return filter;    }     /**     * Log a LogRecord.     * <p>

Lines 1–500 of 1530. Load more