--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/java.management/share/classes/java/lang/management/ManagementFactory.java Tue Sep 12 19:03:39 2017 +0200
@@ -0,0 +1,1023 @@
+/*
+ * Copyright (c) 2003, 2017, 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.lang.management;
+import java.io.FilePermission;
+import java.io.IOException;
+import javax.management.DynamicMBean;
+import javax.management.MBeanServer;
+import javax.management.MBeanServerConnection;
+import javax.management.MBeanServerFactory;
+import javax.management.MBeanServerPermission;
+import javax.management.NotificationEmitter;
+import javax.management.ObjectName;
+import javax.management.InstanceNotFoundException;
+import javax.management.MalformedObjectNameException;
+import javax.management.StandardEmitterMBean;
+import javax.management.StandardMBean;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+import java.util.Map;
+import java.security.AccessController;
+import java.security.Permission;
+import java.security.PrivilegedAction;
+import java.security.PrivilegedActionException;
+import java.security.PrivilegedExceptionAction;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Optional;
+import java.util.ServiceLoader;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import static java.util.stream.Collectors.toMap;
+import java.util.stream.Stream;
+import javax.management.JMX;
+import sun.management.Util;
+import sun.management.spi.PlatformMBeanProvider;
+import sun.management.spi.PlatformMBeanProvider.PlatformComponent;
+
+/**
+ * The {@code ManagementFactory} class is a factory class for getting
+ * managed beans for the Java platform.
+ * This class consists of static methods each of which returns
+ * one or more <i>platform MXBeans</i> representing
+ * the management interface of a component of the Java virtual
+ * machine.
+ *
+ * <h3><a id="MXBean">Platform MXBeans</a></h3>
+ * <p>
+ * A platform MXBean is a <i>managed bean</i> that
+ * conforms to the <a href="../../../javax/management/package-summary.html">JMX</a>
+ * Instrumentation Specification and only uses a set of basic data types.
+ * A JMX management application and the {@linkplain
+ * #getPlatformMBeanServer platform MBeanServer}
+ * can interoperate without requiring classes for MXBean specific
+ * data types.
+ * The data types being transmitted between the JMX connector
+ * server and the connector client are
+ * {@linkplain javax.management.openmbean.OpenType open types}
+ * and this allows interoperation across versions.
+ * See <a href="../../../javax/management/MXBean.html#MXBean-spec">
+ * the specification of MXBeans</a> for details.
+ *
+ * <a id="MXBeanNames"></a>
+ * <p>Each platform MXBean is a {@link PlatformManagedObject}
+ * and it has a unique
+ * {@link javax.management.ObjectName ObjectName} for
+ * registration in the platform {@code MBeanServer} as returned by
+ * by the {@link PlatformManagedObject#getObjectName getObjectName}
+ * method.
+ *
+ * <p>
+ * An application can access a platform MXBean in the following ways:
+ * <h4>1. Direct access to an MXBean interface</h4>
+ * <blockquote>
+ * <ul>
+ * <li>Get an MXBean instance by calling the
+ * {@link #getPlatformMXBean(Class) getPlatformMXBean} or
+ * {@link #getPlatformMXBeans(Class) getPlatformMXBeans} method
+ * and access the MXBean locally in the running
+ * virtual machine.
+ * </li>
+ * <li>Construct an MXBean proxy instance that forwards the
+ * method calls to a given {@link MBeanServer MBeanServer} by calling
+ * the {@link #getPlatformMXBean(MBeanServerConnection, Class)} or
+ * {@link #getPlatformMXBeans(MBeanServerConnection, Class)} method.
+ * The {@link #newPlatformMXBeanProxy newPlatformMXBeanProxy} method
+ * can also be used to construct an MXBean proxy instance of
+ * a given {@code ObjectName}.
+ * A proxy is typically constructed to remotely access
+ * an MXBean of another running virtual machine.
+ * </li>
+ * </ul>
+ * <h4>2. Indirect access to an MXBean interface via MBeanServer</h4>
+ * <ul>
+ * <li>Go through the platform {@code MBeanServer} to access MXBeans
+ * locally or a specific {@code MBeanServerConnection} to access
+ * MXBeans remotely.
+ * The attributes and operations of an MXBean use only
+ * <em>JMX open types</em> which include basic data types,
+ * {@link javax.management.openmbean.CompositeData CompositeData},
+ * and {@link javax.management.openmbean.TabularData TabularData}
+ * defined in
+ * {@link javax.management.openmbean.OpenType OpenType}.
+ * The mapping is specified in
+ * the {@linkplain javax.management.MXBean MXBean} specification
+ * for details.
+ * </li>
+ * </ul>
+ * </blockquote>
+ *
+ * <p>
+ * The {@link #getPlatformManagementInterfaces getPlatformManagementInterfaces}
+ * method returns all management interfaces supported in the Java virtual machine
+ * including the standard management interfaces listed in the tables
+ * below as well as the management interfaces extended by the JDK implementation.
+ * <p>
+ * A Java virtual machine has a single instance of the following management
+ * interfaces:
+ *
+ * <table class="striped" style="margin-left:2em">
+ * <caption style="display:none">The list of Management Interfaces and their single instances</caption>
+ * <thead>
+ * <tr>
+ * <th scope="col">Management Interface</th>
+ * <th scope="col">ObjectName</th>
+ * </tr>
+ * </thead>
+ * <tbody style="text-align:left;">
+ * <tr>
+ * <th scope="row"> {@link ClassLoadingMXBean} </th>
+ * <td> {@link #CLASS_LOADING_MXBEAN_NAME
+ * java.lang:type=ClassLoading}</td>
+ * </tr>
+ * <tr>
+ * <th scope="row"> {@link MemoryMXBean} </th>
+ * <td> {@link #MEMORY_MXBEAN_NAME
+ * java.lang:type=Memory}</td>
+ * </tr>
+ * <tr>
+ * <th scope="row"> {@link ThreadMXBean} </th>
+ * <td> {@link #THREAD_MXBEAN_NAME
+ * java.lang:type=Threading}</td>
+ * </tr>
+ * <tr>
+ * <th scope="row"> {@link RuntimeMXBean} </th>
+ * <td> {@link #RUNTIME_MXBEAN_NAME
+ * java.lang:type=Runtime}</td>
+ * </tr>
+ * <tr>
+ * <th scope="row"> {@link OperatingSystemMXBean} </th>
+ * <td> {@link #OPERATING_SYSTEM_MXBEAN_NAME
+ * java.lang:type=OperatingSystem}</td>
+ * </tr>
+ * <tr>
+ * <th scope="row"> {@link PlatformLoggingMXBean} </th>
+ * <td> {@link java.util.logging.LogManager#LOGGING_MXBEAN_NAME
+ * java.util.logging:type=Logging}</td>
+ * </tr>
+ * </tbody>
+ * </table>
+ *
+ * <p>
+ * A Java virtual machine has zero or a single instance of
+ * the following management interfaces.
+ *
+ * <table class="striped" style="margin-left:2em">
+ * <caption style="display:none">The list of Management Interfaces and their single instances</caption>
+ * <thead>
+ * <tr>
+ * <th scope="col">Management Interface</th>
+ * <th scope="col">ObjectName</th>
+ * </tr>
+ * </thead>
+ * <tbody style="text-align:left;">
+ * <tr>
+ * <th scope="row"> {@link CompilationMXBean} </th>
+ * <td> {@link #COMPILATION_MXBEAN_NAME
+ * java.lang:type=Compilation}</td>
+ * </tr>
+ * </tbody>
+ * </table>
+ *
+ * <p>
+ * A Java virtual machine may have one or more instances of the following
+ * management interfaces.
+ * <table class="striped" style="margin-left:2em">
+ * <caption style="display:none">The list of Management Interfaces and their single instances</caption>
+ * <thead>
+ * <tr>
+ * <th scope="col">Management Interface</th>
+ * <th scope="col">ObjectName</th>
+ * </tr>
+ * </thead>
+ * <tbody style="text-align:left;">
+ * <tr>
+ * <th scope="row"> {@link GarbageCollectorMXBean} </th>
+ * <td> {@link #GARBAGE_COLLECTOR_MXBEAN_DOMAIN_TYPE
+ * java.lang:type=GarbageCollector}{@code ,name=}<i>collector's name</i></td>
+ * </tr>
+ * <tr>
+ * <th scope="row"> {@link MemoryManagerMXBean} </th>
+ * <td> {@link #MEMORY_MANAGER_MXBEAN_DOMAIN_TYPE
+ * java.lang:type=MemoryManager}{@code ,name=}<i>manager's name</i></td>
+ * </tr>
+ * <tr>
+ * <th scope="row"> {@link MemoryPoolMXBean} </th>
+ * <td> {@link #MEMORY_POOL_MXBEAN_DOMAIN_TYPE
+ * java.lang:type=MemoryPool}{@code ,name=}<i>pool's name</i></td>
+ * </tr>
+ * <tr>
+ * <th scope="row"> {@link BufferPoolMXBean} </th>
+ * <td> {@code java.nio:type=BufferPool,name=}<i>pool name</i></td>
+ * </tr>
+ * </tbody>
+ * </table>
+ *
+ * @see <a href="../../../javax/management/package-summary.html">
+ * JMX Specification</a>
+ * @see <a href="package-summary.html#examples">
+ * Ways to Access Management Metrics</a>
+ * @see javax.management.MXBean
+ *
+ * @author Mandy Chung
+ * @since 1.5
+ */
+public class ManagementFactory {
+ // A class with only static fields and methods.
+ private ManagementFactory() {};
+
+ /**
+ * String representation of the
+ * {@code ObjectName} for the {@link ClassLoadingMXBean}.
+ */
+ public final static String CLASS_LOADING_MXBEAN_NAME =
+ "java.lang:type=ClassLoading";
+
+ /**
+ * String representation of the
+ * {@code ObjectName} for the {@link CompilationMXBean}.
+ */
+ public final static String COMPILATION_MXBEAN_NAME =
+ "java.lang:type=Compilation";
+
+ /**
+ * String representation of the
+ * {@code ObjectName} for the {@link MemoryMXBean}.
+ */
+ public final static String MEMORY_MXBEAN_NAME =
+ "java.lang:type=Memory";
+
+ /**
+ * String representation of the
+ * {@code ObjectName} for the {@link OperatingSystemMXBean}.
+ */
+ public final static String OPERATING_SYSTEM_MXBEAN_NAME =
+ "java.lang:type=OperatingSystem";
+
+ /**
+ * String representation of the
+ * {@code ObjectName} for the {@link RuntimeMXBean}.
+ */
+ public final static String RUNTIME_MXBEAN_NAME =
+ "java.lang:type=Runtime";
+
+ /**
+ * String representation of the
+ * {@code ObjectName} for the {@link ThreadMXBean}.
+ */
+ public final static String THREAD_MXBEAN_NAME =
+ "java.lang:type=Threading";
+
+ /**
+ * The domain name and the type key property in
+ * the {@code ObjectName} for a {@link GarbageCollectorMXBean}.
+ * The unique {@code ObjectName} for a {@code GarbageCollectorMXBean}
+ * can be formed by appending this string with
+ * "{@code ,name=}<i>collector's name</i>".
+ */
+ public final static String GARBAGE_COLLECTOR_MXBEAN_DOMAIN_TYPE =
+ "java.lang:type=GarbageCollector";
+
+ /**
+ * The domain name and the type key property in
+ * the {@code ObjectName} for a {@link MemoryManagerMXBean}.
+ * The unique {@code ObjectName} for a {@code MemoryManagerMXBean}
+ * can be formed by appending this string with
+ * "{@code ,name=}<i>manager's name</i>".
+ */
+ public final static String MEMORY_MANAGER_MXBEAN_DOMAIN_TYPE=
+ "java.lang:type=MemoryManager";
+
+ /**
+ * The domain name and the type key property in
+ * the {@code ObjectName} for a {@link MemoryPoolMXBean}.
+ * The unique {@code ObjectName} for a {@code MemoryPoolMXBean}
+ * can be formed by appending this string with
+ * {@code ,name=}<i>pool's name</i>.
+ */
+ public final static String MEMORY_POOL_MXBEAN_DOMAIN_TYPE=
+ "java.lang:type=MemoryPool";
+
+ /**
+ * Returns the managed bean for the class loading system of
+ * the Java virtual machine.
+ *
+ * @return a {@link ClassLoadingMXBean} object for
+ * the Java virtual machine.
+ */
+ public static ClassLoadingMXBean getClassLoadingMXBean() {
+ return getPlatformMXBean(ClassLoadingMXBean.class);
+ }
+
+ /**
+ * Returns the managed bean for the memory system of
+ * the Java virtual machine.
+ *
+ * @return a {@link MemoryMXBean} object for the Java virtual machine.
+ */
+ public static MemoryMXBean getMemoryMXBean() {
+ return getPlatformMXBean(MemoryMXBean.class);
+ }
+
+ /**
+ * Returns the managed bean for the thread system of
+ * the Java virtual machine.
+ *
+ * @return a {@link ThreadMXBean} object for the Java virtual machine.
+ */
+ public static ThreadMXBean getThreadMXBean() {
+ return getPlatformMXBean(ThreadMXBean.class);
+ }
+
+ /**
+ * Returns the managed bean for the runtime system of
+ * the Java virtual machine.
+ *
+ * @return a {@link RuntimeMXBean} object for the Java virtual machine.
+
+ */
+ public static RuntimeMXBean getRuntimeMXBean() {
+ return getPlatformMXBean(RuntimeMXBean.class);
+ }
+
+ /**
+ * Returns the managed bean for the compilation system of
+ * the Java virtual machine. This method returns {@code null}
+ * if the Java virtual machine has no compilation system.
+ *
+ * @return a {@link CompilationMXBean} object for the Java virtual
+ * machine or {@code null} if the Java virtual machine has
+ * no compilation system.
+ */
+ public static CompilationMXBean getCompilationMXBean() {
+ return getPlatformMXBean(CompilationMXBean.class);
+ }
+
+ /**
+ * Returns the managed bean for the operating system on which
+ * the Java virtual machine is running.
+ *
+ * @return an {@link OperatingSystemMXBean} object for
+ * the Java virtual machine.
+ */
+ public static OperatingSystemMXBean getOperatingSystemMXBean() {
+ return getPlatformMXBean(OperatingSystemMXBean.class);
+ }
+
+ /**
+ * Returns a list of {@link MemoryPoolMXBean} objects in the
+ * Java virtual machine.
+ * The Java virtual machine can have one or more memory pools.
+ * It may add or remove memory pools during execution.
+ *
+ * @return a list of {@code MemoryPoolMXBean} objects.
+ *
+ */
+ public static List<MemoryPoolMXBean> getMemoryPoolMXBeans() {
+ return getPlatformMXBeans(MemoryPoolMXBean.class);
+ }
+
+ /**
+ * Returns a list of {@link MemoryManagerMXBean} objects
+ * in the Java virtual machine.
+ * The Java virtual machine can have one or more memory managers.
+ * It may add or remove memory managers during execution.
+ *
+ * @return a list of {@code MemoryManagerMXBean} objects.
+ *
+ */
+ public static List<MemoryManagerMXBean> getMemoryManagerMXBeans() {
+ return getPlatformMXBeans(MemoryManagerMXBean.class);
+ }
+
+
+ /**
+ * Returns a list of {@link GarbageCollectorMXBean} objects
+ * in the Java virtual machine.
+ * The Java virtual machine may have one or more
+ * {@code GarbageCollectorMXBean} objects.
+ * It may add or remove {@code GarbageCollectorMXBean}
+ * during execution.
+ *
+ * @return a list of {@code GarbageCollectorMXBean} objects.
+ *
+ */
+ public static List<GarbageCollectorMXBean> getGarbageCollectorMXBeans() {
+ return getPlatformMXBeans(GarbageCollectorMXBean.class);
+ }
+
+ private static MBeanServer platformMBeanServer;
+ /**
+ * Returns the platform {@link javax.management.MBeanServer MBeanServer}.
+ * On the first call to this method, it first creates the platform
+ * {@code MBeanServer} by calling the
+ * {@link javax.management.MBeanServerFactory#createMBeanServer
+ * MBeanServerFactory.createMBeanServer}
+ * method and registers each platform MXBean in this platform
+ * {@code MBeanServer} with its
+ * {@link PlatformManagedObject#getObjectName ObjectName}.
+ * This method, in subsequent calls, will simply return the
+ * initially created platform {@code MBeanServer}.
+ * <p>
+ * MXBeans that get created and destroyed dynamically, for example,
+ * memory {@link MemoryPoolMXBean pools} and
+ * {@link MemoryManagerMXBean managers},
+ * will automatically be registered and deregistered into the platform
+ * {@code MBeanServer}.
+ * <p>
+ * If the system property {@code javax.management.builder.initial}
+ * is set, the platform {@code MBeanServer} creation will be done
+ * by the specified {@link javax.management.MBeanServerBuilder}.
+ * <p>
+ * It is recommended that this platform MBeanServer also be used
+ * to register other application managed beans
+ * besides the platform MXBeans.
+ * This will allow all MBeans to be published through the same
+ * {@code MBeanServer} and hence allow for easier network publishing
+ * and discovery.
+ * Name conflicts with the platform MXBeans should be avoided.
+ *
+ * @return the platform {@code MBeanServer}; the platform
+ * MXBeans are registered into the platform {@code MBeanServer}
+ * at the first time this method is called.
+ *
+ * @exception SecurityException if there is a security manager
+ * and the caller does not have the permission required by
+ * {@link javax.management.MBeanServerFactory#createMBeanServer}.
+ *
+ * @see javax.management.MBeanServerFactory
+ * @see javax.management.MBeanServerFactory#createMBeanServer
+ */
+ public static synchronized MBeanServer getPlatformMBeanServer() {
+ SecurityManager sm = System.getSecurityManager();
+ if (sm != null) {
+ Permission perm = new MBeanServerPermission("createMBeanServer");
+ sm.checkPermission(perm);
+ }
+
+ if (platformMBeanServer == null) {
+ platformMBeanServer = MBeanServerFactory.createMBeanServer();
+ platformComponents()
+ .stream()
+ .filter(PlatformComponent::shouldRegister)
+ .flatMap(pc -> pc.nameToMBeanMap().entrySet().stream())
+ .forEach(entry -> addMXBean(platformMBeanServer, entry.getKey(), entry.getValue()));
+ }
+ return platformMBeanServer;
+ }
+
+ /**
+ * Returns a proxy for a platform MXBean interface of a
+ * given <a href="#MXBeanNames">MXBean name</a>
+ * that forwards its method calls through the given
+ * {@code MBeanServerConnection}.
+ *
+ * <p>This method is equivalent to:
+ * <blockquote>
+ * {@link java.lang.reflect.Proxy#newProxyInstance
+ * Proxy.newProxyInstance}{@code (mxbeanInterface.getClassLoader(),
+ * new Class[] { mxbeanInterface }, handler)}
+ * </blockquote>
+ *
+ * where {@code handler} is an {@link java.lang.reflect.InvocationHandler
+ * InvocationHandler} to which method invocations to the MXBean interface
+ * are dispatched. This {@code handler} converts an input parameter
+ * from an MXBean data type to its mapped open type before forwarding
+ * to the {@code MBeanServer} and converts a return value from
+ * an MXBean method call through the {@code MBeanServer}
+ * from an open type to the corresponding return type declared in
+ * the MXBean interface.
+ *
+ * <p>
+ * If the MXBean is a notification emitter (i.e.,
+ * it implements
+ * {@link javax.management.NotificationEmitter NotificationEmitter}),
+ * both the {@code mxbeanInterface} and {@code NotificationEmitter}
+ * will be implemented by this proxy.
+ *
+ * <p>
+ * <b>Notes:</b>
+ * <ol>
+ * <li>Using an MXBean proxy is a convenience remote access to
+ * a platform MXBean of a running virtual machine. All method
+ * calls to the MXBean proxy are forwarded to an
+ * {@code MBeanServerConnection} where
+ * {@link java.io.IOException IOException} may be thrown
+ * when the communication problem occurs with the connector server.
+ * If thrown, {@link java.io.IOException IOException} will be wrappped in
+ * {@link java.lang.reflect.UndeclaredThrowableException UndeclaredThrowableException}.
+ * An application remotely accessing the platform MXBeans using
+ * proxy should prepare to catch {@code UndeclaredThrowableException} and
+ * handle its {@linkplain java.lang.reflect.UndeclaredThrowableException#getCause() cause}
+ * as if that cause had been thrown by the {@code MBeanServerConnection}
+ * interface.</li>
+ *
+ * <li>When a client application is designed to remotely access MXBeans
+ * for a running virtual machine whose version is different than
+ * the version on which the application is running,
+ * it should prepare to catch
+ * {@link java.io.InvalidObjectException InvalidObjectException}
+ * which is thrown when an MXBean proxy receives a name of an
+ * enum constant which is missing in the enum class loaded in
+ * the client application. If thrown,
+ * {@link java.io.InvalidObjectException InvalidObjectException} will be
+ * wrappped in
+ * {@link java.lang.reflect.UndeclaredThrowableException UndeclaredThrowableException}.
+ * </li>
+ *
+ * <li>{@link javax.management.MBeanServerInvocationHandler
+ * MBeanServerInvocationHandler} or its
+ * {@link javax.management.MBeanServerInvocationHandler#newProxyInstance
+ * newProxyInstance} method cannot be used to create
+ * a proxy for a platform MXBean. The proxy object created
+ * by {@code MBeanServerInvocationHandler} does not handle
+ * the properties of the platform MXBeans described in
+ * the <a href="#MXBean">class specification</a>.
+ *</li>
+ * </ol>
+ *
+ * @param connection the {@code MBeanServerConnection} to forward to.
+ * @param mxbeanName the name of a platform MXBean within
+ * {@code connection} to forward to. {@code mxbeanName} must be
+ * in the format of {@link ObjectName ObjectName}.
+ * @param mxbeanInterface the MXBean interface to be implemented
+ * by the proxy.
+ * @param <T> an {@code mxbeanInterface} type parameter
+ *
+ * @return a proxy for a platform MXBean interface of a
+ * given <a href="#MXBeanNames">MXBean name</a>
+ * that forwards its method calls through the given
+ * {@code MBeanServerConnection}, or {@code null} if not exist.
+ *
+ * @throws IllegalArgumentException if
+ * <ul>
+ * <li>{@code mxbeanName} is not with a valid
+ * {@link ObjectName ObjectName} format, or</li>
+ * <li>the named MXBean in the {@code connection} is
+ * not a MXBean provided by the platform, or</li>
+ * <li>the named MXBean is not registered in the
+ * {@code MBeanServerConnection}, or</li>
+ * <li>the named MXBean is not an instance of the given
+ * {@code mxbeanInterface}</li>
+ * </ul>
+ *
+ * @throws java.io.IOException if a communication problem
+ * occurred when accessing the {@code MBeanServerConnection}.
+ */
+ public static <T> T
+ newPlatformMXBeanProxy(MBeanServerConnection connection,
+ String mxbeanName,
+ Class<T> mxbeanInterface)
+ throws java.io.IOException {
+
+ // Only allow MXBean interfaces from the platform modules loaded by the
+ // bootstrap or platform class loader
+ final Class<?> cls = mxbeanInterface;
+ ClassLoader loader =
+ AccessController.doPrivileged(
+ (PrivilegedAction<ClassLoader>) () -> cls.getClassLoader());
+ if (!jdk.internal.misc.VM.isSystemDomainLoader(loader)) {
+ throw new IllegalArgumentException(mxbeanName +
+ " is not a platform MXBean");
+ }
+
+ try {
+ final ObjectName objName = new ObjectName(mxbeanName);
+ String intfName = mxbeanInterface.getName();
+ if (!isInstanceOf(connection, objName, intfName)) {
+ throw new IllegalArgumentException(mxbeanName +
+ " is not an instance of " + mxbeanInterface);
+ }
+
+ // check if the registered MBean is a notification emitter
+ boolean emitter = connection.isInstanceOf(objName, NOTIF_EMITTER);
+
+ // create an MXBean proxy
+ return JMX.newMXBeanProxy(connection, objName, mxbeanInterface,
+ emitter);
+ } catch (InstanceNotFoundException|MalformedObjectNameException e) {
+ throw new IllegalArgumentException(e);
+ }
+ }
+
+ // This makes it possible to obtain an instance of LoggingMXBean
+ // using newPlatformMXBeanProxy(mbs, on, LoggingMXBean.class)
+ // even though the underlying MXBean no longer implements
+ // java.util.logging.LoggingMXBean.
+ // Altough java.util.logging.LoggingMXBean is deprecated, an application
+ // that uses newPlatformMXBeanProxy(mbs, on, LoggingMXBean.class) will
+ // continue to work.
+ //
+ private static boolean isInstanceOf(MBeanServerConnection connection,
+ ObjectName objName, String intfName)
+ throws InstanceNotFoundException, IOException
+ {
+ // special case for java.util.logging.LoggingMXBean.
+ // java.util.logging.LoggingMXBean is deprecated and
+ // replaced with java.lang.management.PlatformLoggingMXBean,
+ // so we will consider that any MBean implementing
+ // java.lang.management.PlatformLoggingMXBean also implements
+ // java.util.logging.LoggingMXBean.
+ if ("java.util.logging.LoggingMXBean".equals(intfName)) {
+ if (connection.isInstanceOf(objName,
+ PlatformLoggingMXBean.class.getName())) {
+ return true;
+ }
+ }
+ return connection.isInstanceOf(objName, intfName);
+ }
+
+ /**
+ * Returns the platform MXBean implementing
+ * the given {@code mxbeanInterface} which is specified
+ * to have one single instance in the Java virtual machine.
+ * This method may return {@code null} if the management interface
+ * is not implemented in the Java virtual machine (for example,
+ * a Java virtual machine with no compilation system does not
+ * implement {@link CompilationMXBean});
+ * otherwise, this method is equivalent to calling:
+ * <pre>
+ * {@link #getPlatformMXBeans(Class)
+ * getPlatformMXBeans(mxbeanInterface)}.get(0);
+ * </pre>
+ *
+ * @param mxbeanInterface a management interface for a platform
+ * MXBean with one single instance in the Java virtual machine
+ * if implemented.
+ * @param <T> an {@code mxbeanInterface} type parameter
+ *
+ * @return the platform MXBean that implements
+ * {@code mxbeanInterface}, or {@code null} if not exist.
+ *
+ * @throws IllegalArgumentException if {@code mxbeanInterface}
+ * is not a platform management interface or
+ * not a singleton platform MXBean.
+ *
+ * @since 1.7
+ */
+ public static <T extends PlatformManagedObject>
+ T getPlatformMXBean(Class<T> mxbeanInterface) {
+ PlatformComponent<?> pc = PlatformMBeanFinder.findSingleton(mxbeanInterface);
+
+ List<? extends T> mbeans = pc.getMBeans(mxbeanInterface);
+ assert mbeans.isEmpty() || mbeans.size() == 1;
+ return mbeans.isEmpty() ? null : mbeans.get(0);
+ }
+
+ /**
+ * Returns the list of platform MXBeans implementing
+ * the given {@code mxbeanInterface} in the Java
+ * virtual machine.
+ * The returned list may contain zero, one, or more instances.
+ * The number of instances in the returned list is defined
+ * in the specification of the given management interface.
+ * The order is undefined and there is no guarantee that
+ * the list returned is in the same order as previous invocations.
+ *
+ * @param mxbeanInterface a management interface for a platform
+ * MXBean
+ * @param <T> an {@code mxbeanInterface} type parameter
+ *
+ * @return the list of platform MXBeans that implement
+ * {@code mxbeanInterface}.
+ *
+ * @throws IllegalArgumentException if {@code mxbeanInterface}
+ * is not a platform management interface.
+ *
+ * @since 1.7
+ */
+ public static <T extends PlatformManagedObject> List<T>
+ getPlatformMXBeans(Class<T> mxbeanInterface) {
+ // Validates at first the specified interface by finding at least one
+ // PlatformComponent whose MXBean implements this interface.
+ // An interface can be implemented by different MBeans, provided by
+ // different platform components.
+ PlatformComponent<?> pc = PlatformMBeanFinder.findFirst(mxbeanInterface);
+ if (pc == null) {
+ throw new IllegalArgumentException(mxbeanInterface.getName()
+ + " is not a platform management interface");
+ }
+
+ return platformComponents().stream()
+ .flatMap(p -> p.getMBeans(mxbeanInterface).stream())
+ .collect(Collectors.toList());
+ }
+
+ /**
+ * Returns the platform MXBean proxy for
+ * {@code mxbeanInterface} which is specified to have one single
+ * instance in a Java virtual machine and the proxy will
+ * forward the method calls through the given {@code MBeanServerConnection}.
+ * This method may return {@code null} if the management interface
+ * is not implemented in the Java virtual machine being monitored
+ * (for example, a Java virtual machine with no compilation system
+ * does not implement {@link CompilationMXBean});
+ * otherwise, this method is equivalent to calling:
+ * <pre>
+ * {@link #getPlatformMXBeans(MBeanServerConnection, Class)
+ * getPlatformMXBeans(connection, mxbeanInterface)}.get(0);
+ * </pre>
+ *
+ * @param connection the {@code MBeanServerConnection} to forward to.
+ * @param mxbeanInterface a management interface for a platform
+ * MXBean with one single instance in the Java virtual machine
+ * being monitored, if implemented.
+ * @param <T> an {@code mxbeanInterface} type parameter
+ *
+ * @return the platform MXBean proxy for
+ * forwarding the method calls of the {@code mxbeanInterface}
+ * through the given {@code MBeanServerConnection},
+ * or {@code null} if not exist.
+ *
+ * @throws IllegalArgumentException if {@code mxbeanInterface}
+ * is not a platform management interface or
+ * not a singleton platform MXBean.
+ * @throws java.io.IOException if a communication problem
+ * occurred when accessing the {@code MBeanServerConnection}.
+ *
+ * @see #newPlatformMXBeanProxy
+ * @since 1.7
+ */
+ public static <T extends PlatformManagedObject>
+ T getPlatformMXBean(MBeanServerConnection connection,
+ Class<T> mxbeanInterface)
+ throws java.io.IOException
+ {
+ PlatformComponent<?> pc = PlatformMBeanFinder.findSingleton(mxbeanInterface);
+ return newPlatformMXBeanProxy(connection, pc.getObjectNamePattern(), mxbeanInterface);
+ }
+
+ /**
+ * Returns the list of the platform MXBean proxies for
+ * forwarding the method calls of the {@code mxbeanInterface}
+ * through the given {@code MBeanServerConnection}.
+ * The returned list may contain zero, one, or more instances.
+ * The number of instances in the returned list is defined
+ * in the specification of the given management interface.
+ * The order is undefined and there is no guarantee that
+ * the list returned is in the same order as previous invocations.
+ *
+ * @param connection the {@code MBeanServerConnection} to forward to.
+ * @param mxbeanInterface a management interface for a platform
+ * MXBean
+ * @param <T> an {@code mxbeanInterface} type parameter
+ *
+ * @return the list of platform MXBean proxies for
+ * forwarding the method calls of the {@code mxbeanInterface}
+ * through the given {@code MBeanServerConnection}.
+ *
+ * @throws IllegalArgumentException if {@code mxbeanInterface}
+ * is not a platform management interface.
+ *
+ * @throws java.io.IOException if a communication problem
+ * occurred when accessing the {@code MBeanServerConnection}.
+ *
+ * @see #newPlatformMXBeanProxy
+ * @since 1.7
+ */
+ public static <T extends PlatformManagedObject>
+ List<T> getPlatformMXBeans(MBeanServerConnection connection,
+ Class<T> mxbeanInterface)
+ throws java.io.IOException
+ {
+ // Validates at first the specified interface by finding at least one
+ // PlatformComponent whose MXBean implements this interface.
+ // An interface can be implemented by different MBeans, provided by
+ // different platform components.
+ PlatformComponent<?> pc = PlatformMBeanFinder.findFirst(mxbeanInterface);
+ if (pc == null) {
+ throw new IllegalArgumentException(mxbeanInterface.getName()
+ + " is not a platform management interface");
+ }
+
+ // Collect all names, eliminate duplicates.
+ Stream<String> names = Stream.empty();
+ for (PlatformComponent<?> p : platformComponents()) {
+ names = Stream.concat(names, getProxyNames(p, connection, mxbeanInterface));
+ }
+ Set<String> objectNames = names.collect(Collectors.toSet());
+ if (objectNames.isEmpty()) return Collections.emptyList();
+
+ // Map names on proxies.
+ List<T> proxies = new ArrayList<>();
+ for (String name : objectNames) {
+ proxies.add(newPlatformMXBeanProxy(connection, name, mxbeanInterface));
+ }
+ return proxies;
+ }
+
+ // Returns a stream containing all ObjectNames of the MBeans represented by
+ // the specified PlatformComponent and implementing the specified interface.
+ // If the PlatformComponent is a singleton, the name returned by
+ // PlatformComponent.getObjectNamePattern() will be used, otherwise
+ // we will query the specified MBeanServerConnection (conn.queryNames)
+ // with the pattern returned by PlatformComponent.getObjectNamePattern()
+ // in order to find the names of matching MBeans.
+ // In case of singleton, we do not check whether the MBean is registered
+ // in the connection because the caller "getPlatformMXBeans" will do the check
+ // when creating a proxy.
+ private static Stream<String> getProxyNames(PlatformComponent<?> pc,
+ MBeanServerConnection conn,
+ Class<?> intf)
+ throws IOException
+ {
+ if (pc.mbeanInterfaceNames().contains(intf.getName())) {
+ if (pc.isSingleton()) {
+ return Stream.of(pc.getObjectNamePattern());
+ } else {
+ return conn.queryNames(Util.newObjectName(pc.getObjectNamePattern()), null)
+ .stream().map(ObjectName::getCanonicalName);
+ }
+ }
+ return Stream.empty();
+ }
+
+ /**
+ * Returns the set of {@code Class} objects, subinterface of
+ * {@link PlatformManagedObject}, representing
+ * all management interfaces for
+ * monitoring and managing the Java platform.
+ *
+ * @return the set of {@code Class} objects, subinterface of
+ * {@link PlatformManagedObject} representing
+ * the management interfaces for
+ * monitoring and managing the Java platform.
+ *
+ * @since 1.7
+ */
+ public static Set<Class<? extends PlatformManagedObject>>
+ getPlatformManagementInterfaces()
+ {
+ return platformComponents()
+ .stream()
+ .flatMap(pc -> pc.mbeanInterfaces().stream())
+ .filter(clazz -> PlatformManagedObject.class.isAssignableFrom(clazz))
+ .map(clazz -> clazz.asSubclass(PlatformManagedObject.class))
+ .collect(Collectors.toSet());
+ }
+
+ private static final String NOTIF_EMITTER =
+ "javax.management.NotificationEmitter";
+
+ private static void addMXBean(final MBeanServer mbs, String name, final Object pmo)
+ {
+ try {
+ ObjectName oname = ObjectName.getInstance(name);
+ // Make DynamicMBean out of MXBean by wrapping it with a StandardMBean
+ AccessController.doPrivileged((PrivilegedExceptionAction<Void>) () -> {
+ final DynamicMBean dmbean;
+ if (pmo instanceof DynamicMBean) {
+ dmbean = DynamicMBean.class.cast(pmo);
+ } else if (pmo instanceof NotificationEmitter) {
+ dmbean = new StandardEmitterMBean(pmo, null, true, (NotificationEmitter) pmo);
+ } else {
+ dmbean = new StandardMBean(pmo, null, true);
+ }
+
+ mbs.registerMBean(dmbean, oname);
+ return null;
+ });
+ } catch (MalformedObjectNameException mone) {
+ throw new IllegalArgumentException(mone);
+ } catch (PrivilegedActionException e) {
+ throw new RuntimeException(e.getException());
+ }
+ }
+
+ private static Collection<PlatformComponent<?>> platformComponents()
+ {
+ return PlatformMBeanFinder.getMap().values();
+ }
+
+ private static class PlatformMBeanFinder
+ {
+ private static final Map<String, PlatformComponent<?>> componentMap;
+ static {
+ // get all providers
+ List<PlatformMBeanProvider> providers = AccessController.doPrivileged(
+ (PrivilegedAction<List<PlatformMBeanProvider>>) () -> {
+ List<PlatformMBeanProvider> all = new ArrayList<>();
+ ServiceLoader.loadInstalled(PlatformMBeanProvider.class)
+ .forEach(all::add);
+ all.add(new DefaultPlatformMBeanProvider());
+ return all;
+ }, null, new FilePermission("<<ALL FILES>>", "read"),
+ new RuntimePermission("sun.management.spi.PlatformMBeanProvider.subclass"));
+
+ // load all platform components into a map
+ componentMap = providers.stream()
+ .flatMap(p -> toPlatformComponentStream(p))
+ // The first one wins if multiple PlatformComponents
+ // with same ObjectName pattern,
+ .collect(toMap(PlatformComponent::getObjectNamePattern,
+ Function.identity(),
+ (p1, p2) -> p1));
+ }
+
+ static Map<String, PlatformComponent<?>> getMap() {
+ return componentMap;
+ }
+
+ // Loads all platform components from a provider into a stream
+ // Ensures that two different components are not declared with the same
+ // object name pattern. Throws InternalError if the provider incorrectly
+ // declares two platform components with the same pattern.
+ private static Stream<PlatformComponent<?>>
+ toPlatformComponentStream(PlatformMBeanProvider provider)
+ {
+ return provider.getPlatformComponentList()
+ .stream()
+ .collect(toMap(PlatformComponent::getObjectNamePattern,
+ Function.identity(),
+ (p1, p2) -> {
+ throw new InternalError(
+ p1.getObjectNamePattern() +
+ " has been used as key for " + p1 +
+ ", it cannot be reused for " + p2);
+ }))
+ .values().stream();
+ }
+
+ // Finds the first PlatformComponent whose mbeanInterfaceNames() list
+ // contains the specified class name. An MBean interface can be implemented
+ // by different MBeans, provided by different platform components.
+ // For instance the MemoryManagerMXBean interface is implemented both by
+ // regular memory managers, and garbage collector MXBeans. This method is
+ // mainly used to verify that there is at least one PlatformComponent
+ // which provides an implementation of the desired interface.
+ static PlatformComponent<?> findFirst(Class<?> mbeanIntf)
+ {
+ String name = mbeanIntf.getName();
+ Optional<PlatformComponent<?>> op = getMap().values()
+ .stream()
+ .filter(pc -> pc.mbeanInterfaceNames().contains(name))
+ .findFirst();
+
+ if (op.isPresent()) {
+ return op.get();
+ } else {
+ return null;
+ }
+ }
+
+ // Finds a PlatformComponent whose mbeanInterface name list contains
+ // the specified class name, and make sure that one and only one exists.
+ static PlatformComponent<?> findSingleton(Class<?> mbeanIntf)
+ {
+ String name = mbeanIntf.getName();
+ Optional<PlatformComponent<?>> op = getMap().values()
+ .stream()
+ .filter(pc -> pc.mbeanInterfaceNames().contains(name))
+ .reduce((p1, p2) -> {
+ if (p2 != null) {
+ throw new IllegalArgumentException(mbeanIntf.getName() +
+ " can have more than one instance");
+ } else {
+ return p1;
+ }
+ });
+
+ PlatformComponent<?> singleton = op.isPresent() ? op.get() : null;
+ if (singleton == null) {
+ throw new IllegalArgumentException(mbeanIntf.getName() +
+ " is not a platform management interface");
+ }
+ if (!singleton.isSingleton()) {
+ throw new IllegalArgumentException(mbeanIntf.getName() +
+ " can have more than one instance");
+ }
+ return singleton;
+ }
+ }
+
+ static {
+ AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
+ System.loadLibrary("management");
+ return null;
+ });
+ }
+}