/*
 * Copyright (c) 2003, 2019, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

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.
 *
 * <h2><a id="MXBean">Platform MXBeans</a></h2>
 * <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:
 * <h3>1. Direct access to an MXBean interface</h3>
 * <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>
 * <h3>2. Indirect access to an MXBean interface via MBeanServer</h3>
 * <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()
    {
        // local variable required here; see JDK-8223553
        Stream<Class<? extends PlatformManagedObject>> pmos = platformComponents()
                .stream()
                .flatMap(pc -> pc.mbeanInterfaces().stream())
                .filter(clazz -> PlatformManagedObject.class.isAssignableFrom(clazz))
                .map(clazz -> clazz.asSubclass(PlatformManagedObject.class));
        return pmos.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;
        });
    }
}
