public void testDefaultLoggerProperties() throws Exception { // mock LogManager has no default logger assertNull(mockManager.getLogger("")); assertNull(mockManager.getLogger("global")); // non-mock LogManager has two default logger Logger global = manager.getLogger("global"); Logger root = manager.getLogger(""); assertSame(global, Logger.global); assertSame(root, global.getParent()); // root properties manager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props)); assertNull(root.getFilter()); assertEquals(2, root.getHandlers().length); assertEquals(Level.FINE, root.getLevel()); assertEquals("", root.getName()); assertSame(root.getParent(), null); assertNull(root.getResourceBundle()); assertNull(root.getResourceBundleName()); assertTrue(root.getUseParentHandlers()); }
/** * Finds a registered logger for a subsystem, or creates one in case no logger has been registered * yet. * * <p>If a logger with the specified name has already been registered, the behavior depends on the * resource bundle that is currently associated with the existing logger. * * <ul> * <li>If the existing logger uses the same resource bundle as specified by <code> * resourceBundleName</code>, the existing logger is returned. * <li>If the existing logger currently does not localize messages, the existing logger is * modified to use the bundle specified by <code>resourceBundleName</code>. The existing * logger is then returned. Therefore, all subsystems currently using this logger will * produce localized messages from now on. * <li>If the existing logger already has an associated resource bundle, but a different one * than specified by <code>resourceBundleName</code>, an <code>IllegalArgumentException * </code> is thrown. * </ul> * * @param name the name for the logger, for example "java.awt" or "org.gnu.foo". The name should * be based on the name of the package issuing log records and consist of dot-separated Java * identifiers. * @param resourceBundleName the name of a resource bundle for localizing messages, or <code>null * </code> to indicate that messages do not need to be localized. * @return a logger for the subsystem specified by <code>name</code>. * @throws java.util.MissingResourceException if <code>resourceBundleName</code> is not <code>null * </code> and no such bundle could be located. * @throws IllegalArgumentException if a logger for the subsystem identified by <code>name</code> * has already been created, but uses a different resource bundle for localizing messages. * @throws NullPointerException if <code>name</code> is <code>null</code>. */ public static Logger getLogger(String name, String resourceBundleName) { LogManager lm = LogManager.getLogManager(); Logger result; if (name == null) throw new NullPointerException(); /* * Without synchronized(lm), it could happen that another thread would * create a logger between our calls to getLogger and addLogger. While * addLogger would indicate this by returning false, we could not be sure * that this other logger was still existing when we called getLogger a * second time in order to retrieve it -- note that LogManager is only * allowed to keep weak references to registered loggers, so Loggers can be * garbage collected at any time in general, and between our call to * addLogger and our second call go getLogger in particular. Of course, we * assume here that LogManager.addLogger etc. are synchronizing on the * global LogManager object. There is a comment in the implementation of * LogManager.addLogger referring to this comment here, so that any change * in the synchronization of LogManager will be reflected here. */ synchronized (lock) { synchronized (lm) { result = lm.getLogger(name); if (result == null) { boolean couldBeAdded; result = new Logger(name, resourceBundleName); couldBeAdded = lm.addLogger(result); if (!couldBeAdded) throw new IllegalStateException("cannot register new logger"); } else { /* * The logger already exists. Make sure it uses the same * resource bundle for localizing messages. */ String existingBundleName = result.getResourceBundleName(); /* * The Sun J2SE 1.4 reference implementation will return the * registered logger object, even if it does not have a resource * bundle associated with it. However, it seems to change the * resourceBundle of the registered logger to the bundle whose * name was passed to getLogger. */ if ((existingBundleName == null) && (resourceBundleName != null)) { /* * If ResourceBundle.getBundle throws an exception, the * existing logger will be unchanged. This would be * different if the assignment to resourceBundleName came * first. */ result.resourceBundle = ResourceBundle.getBundle(resourceBundleName); result.resourceBundleName = resourceBundleName; return result; } if ((existingBundleName != resourceBundleName) && ((existingBundleName == null) || !existingBundleName.equals(resourceBundleName))) { throw new IllegalArgumentException(); } } } } return result; }
/** @see java.util.logging.Logger#getResourceBundleName() */ @Override public String getResourceBundleName() { return delegate.getResourceBundleName(); }