< prev index next >
jdk/src/java.logging/share/classes/java/util/logging/LogManager.java
Print this page
@@ -41,10 +41,11 @@
import java.util.stream.Collectors;
import java.util.stream.Stream;
import jdk.internal.misc.JavaAWTAccess;
import jdk.internal.misc.SharedSecrets;
import sun.misc.ManagedLocalsThread;
+import sun.util.logging.internal.LoggingProviderImpl;
/**
* There is a single global LogManager object that is used to
* maintain a set of shared state about Loggers and log services.
* <p>
@@ -434,11 +435,12 @@
readPrimordialConfiguration = true;
try {
readConfiguration();
// Platform loggers begin to delegate to java.util.logging.Logger
- sun.util.logging.PlatformLogger.redirectPlatformLoggers();
+ jdk.internal.logger.BootstrapLogger.redirectTemporaryLoggers();
+
} catch (Exception ex) {
assert false : "Exception raised while reading logging configuration: " + ex;
}
}
}
@@ -1479,11 +1481,11 @@
* Reads and initializes the logging configuration from the given input stream.
*
* <p>
* Any {@linkplain #addConfigurationListener registered configuration
* listener} will be invoked after the properties are read.
- * <p>
+ *
* @apiNote This {@code readConfiguration} method should only be used for
* initializing the configuration during LogManager initialization or
* used with the "java.util.logging.config.class" property.
* When this method is called after loggers have been created, all
* existing loggers will be {@linkplain #reset() reset}. Then any
@@ -2361,11 +2363,12 @@
} finally {
configurationLock.unlock();
}
}
- static final Permission controlPermission = new LoggingPermission("control", null);
+ static final Permission controlPermission =
+ new LoggingPermission("control", null);
void checkPermission() {
SecurityManager sm = System.getSecurityManager();
if (sm != null)
sm.checkPermission(controlPermission);
@@ -2605,6 +2608,71 @@
// after all listeners have been invoked.
if (t instanceof Error) throw (Error)t;
if (t instanceof RuntimeException) throw (RuntimeException)t;
}
+ /**
+ * This class allows the {@link LoggingProviderImpl} to demand loggers on
+ * behalf of system and application classes.
+ */
+ private static final class LoggingProviderAccess
+ implements LoggingProviderImpl.LogManagerAccess,
+ PrivilegedAction<Void> {
+
+ private LoggingProviderAccess() {
+ }
+
+ /**
+ * Demands a logger on behalf of the given {@code caller}.
+ * <p>
+ * If a named logger suitable for the given caller is found
+ * returns it.
+ * Otherwise, creates a new logger suitable for the given caller.
+ *
+ * @param name The logger name.
+ * @param caller The caller on which behalf the logger is created/retrieved.
+ * @return A logger for the given {@code caller}.
+ *
+ * @throws NullPointerException if {@code name} is {@code null}
+ * or {@code caller} is {@code null}.
+ * @throws IllegalArgumentException if {@code manager} is not the default
+ * LogManager.
+ * @throws SecurityException if a security manager is present and the
+ * calling code doesn't have the
+ * {@link LoggingPermission LoggingPermission("demandLogger", null)}.
+ */
+ @Override
+ public Logger demandLoggerFor(LogManager manager, String name, /* Module */ Class<?> caller) {
+ if (manager != getLogManager()) {
+ // having LogManager as parameter just ensures that the
+ // caller will have initialized the LogManager before reaching
+ // here.
+ throw new IllegalArgumentException("manager");
+ }
+ Objects.requireNonNull(name);
+ SecurityManager sm = System.getSecurityManager();
+ if (sm != null) {
+ sm.checkPermission(controlPermission);
+ }
+ if (caller.getClassLoader() == null) {
+ return manager.demandSystemLogger(name,
+ Logger.SYSTEM_LOGGER_RB_NAME, caller);
+ } else {
+ return manager.demandLogger(name, null, caller);
+ }
+ }
+
+ @Override
+ public Void run() {
+ LoggingProviderImpl.setLogManagerAccess(INSTANCE);
+ return null;
+ }
+
+ static final LoggingProviderAccess INSTANCE = new LoggingProviderAccess();
+ }
+
+ static {
+ AccessController.doPrivileged(LoggingProviderAccess.INSTANCE, null,
+ controlPermission);
+ }
+
}
< prev index next >