public static ClassLoadingMXBean getClassLoadingMXBean() 
{
        return ManagementFactoryHelper.getClassLoadingMXBean();
}

Returns the managed bean for the class loading system of the Java virtual machine.

 public static CompilationMXBean getCompilationMXBean() 
{
        return ManagementFactoryHelper.getCompilationMXBean();
}

Returns the managed bean for the compilation system of the Java virtual machine. This method returns null if the Java virtual machine has no compilation system.

 public static List<GarbageCollectorMXBean> getGarbageCollectorMXBeans() 
{
        return ManagementFactoryHelper.getGarbageCollectorMXBeans();
}

Returns a list of GarbageCollectorMXBean objects in the Java virtual machine. The Java virtual machine may have one or more GarbageCollectorMXBean objects. It may add or remove GarbageCollectorMXBean during execution.

 public static MemoryMXBean getMemoryMXBean() 
{
        return ManagementFactoryHelper.getMemoryMXBean();
}

Returns the managed bean for the memory system of the Java virtual machine.

 public static List<MemoryManagerMXBean> getMemoryManagerMXBeans() 
{
        return ManagementFactoryHelper.getMemoryManagerMXBeans();
}

Returns a list of 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.

 public static List<MemoryPoolMXBean> getMemoryPoolMXBeans() 
{
        return ManagementFactoryHelper.getMemoryPoolMXBeans();
}

Returns a list of 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.

 public static OperatingSystemMXBean getOperatingSystemMXBean() 
{
        return ManagementFactoryHelper.getOperatingSystemMXBean();
}

Returns the managed bean for the operating system on which the Java virtual machine is running.

 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();
            for (PlatformComponent pc : PlatformComponent.values()) {
                List< ? extends PlatformManagedObject > list =
                    pc.getMXBeans(pc.getMXBeanInterface());
                for (PlatformManagedObject o : list) {
                    // Each PlatformComponent represents one management
                    // interface. Some MXBean may extend another one.
                    // The MXBean instances for one platform component
                    // (returned by pc.getMXBeans()) might be also
                    // the MXBean instances for another platform component.
                    // e.g. com.sun.management.GarbageCollectorMXBean
                    //
                    // So need to check if an MXBean instance is registered
                    // before registering into the platform MBeanServer
                    if (!platformMBeanServer.isRegistered(o.getObjectName())) {
                        addMXBean(platformMBeanServer, o);
                    }
                }
            }
        }
        return platformMBeanServer;
}

Returns the platform MBeanServer . On the first call to this method, it first creates the platform {@code MBeanServer} by calling the MBeanServerFactory.createMBeanServer method and registers each platform MXBean in this platform {@code MBeanServer} with its ObjectName . This method, in subsequent calls, will simply return the initially created platform {@code MBeanServer}.

MXBeans that get created and destroyed dynamically, for example, memory pools and managers , will automatically be registered and deregistered into the platform {@code MBeanServer}.

If the system property {@code javax.management.builder.initial} is set, the platform {@code MBeanServer} creation will be done by the specified javax.management.MBeanServerBuilder .

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.

 public static T getPlatformMXBean(Class<T> mxbeanInterface) 
{
        PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
        if (pc == null)
            throw new IllegalArgumentException(mxbeanInterface.getName() +
                " is not a platform management interface");
        if (!pc.isSingleton())
            throw new IllegalArgumentException(mxbeanInterface.getName() +
                " can have zero or more than one instances");
        return pc.getSingletonMXBean(mxbeanInterface);
}

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 CompilationMXBean ); otherwise, this method is equivalent to calling:

   getPlatformMXBeans(mxbeanInterface) .get(0);

 public static T getPlatformMXBean(MBeanServerConnection connection,
    Class<T> mxbeanInterface) throws IOException 
{
        PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
        if (pc == null)
            throw new IllegalArgumentException(mxbeanInterface.getName() +
                " is not a platform management interface");
        if (!pc.isSingleton())
            throw new IllegalArgumentException(mxbeanInterface.getName() +
                " can have zero or more than one instances");
        return pc.getSingletonMXBean(connection, mxbeanInterface);
}

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 CompilationMXBean ); otherwise, this method is equivalent to calling:

    Class)
       mxbeanInterface) .get(0);

 public static List<T> getPlatformMXBeans(Class<T> mxbeanInterface) 
{
        PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
        if (pc == null)
            throw new IllegalArgumentException(mxbeanInterface.getName() +
                " is not a platform management interface");
        return Collections.unmodifiableList(pc.getMXBeans(mxbeanInterface));
}

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.

 public static List<T> getPlatformMXBeans(MBeanServerConnection connection,
    Class<T> mxbeanInterface) throws IOException 
{
        PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
        if (pc == null) {
            throw new IllegalArgumentException(mxbeanInterface.getName() +
                " is not a platform management interface");
        }
        return Collections.unmodifiableList(pc.getMXBeans(connection, 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.

 public static Set<PlatformManagedObject> getPlatformManagementInterfaces() 
{
        Set< Class< ? extends PlatformManagedObject > > result =
            new TreeSet<  >();
        for (PlatformComponent component: PlatformComponent.values()) {
            result.add(component.getMXBeanInterface());
        }
        return Collections.unmodifiableSet(result);
}

Returns the set of {@code Class} objects, subinterface of PlatformManagedObject , representing all management interfaces for monitoring and managing the Java platform.

 public static RuntimeMXBean getRuntimeMXBean() 
{
        return ManagementFactoryHelper.getRuntimeMXBean();
}

Returns the managed bean for the runtime system of the Java virtual machine.

 public static ThreadMXBean getThreadMXBean() 
{
        return ManagementFactoryHelper.getThreadMXBean();
}

Returns the managed bean for the thread system of the Java virtual machine.

 public static T newPlatformMXBeanProxy(MBeanServerConnection connection,
    String mxbeanName,
    Class<T> mxbeanInterface) throws IOException 
{
        final Class interfaceClass = mxbeanInterface;
        // Only allow MXBean interfaces from rt.jar loaded by the
        // bootstrap class loader
        final ClassLoader loader =
            AccessController.doPrivileged(new PrivilegedAction< ClassLoader >() {
                public ClassLoader run() {
                    return interfaceClass.getClassLoader();
                }
            });
        if (loader != null) {
            throw new IllegalArgumentException(mxbeanName +
                " is not a platform MXBean");
        }
        try {
            final ObjectName objName = new ObjectName(mxbeanName);
            // skip the isInstanceOf check for LoggingMXBean
            String intfName = interfaceClass.getName();
            if (!connection.isInstanceOf(objName, intfName)) {
                throw new IllegalArgumentException(mxbeanName +
                    " is not an instance of " + interfaceClass);
            }
            final Class[] interfaces;
            // 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);
        }
}

Returns a proxy for a platform MXBean interface of a given MXBean name that forwards its method calls through the given MBeanServerConnection.

This method is equivalent to:

Proxy.newProxyInstance (mxbeanInterface.getClassLoader(), new Class[] { mxbeanInterface }, handler)

where handler is an InvocationHandler to which method invocations to the MXBean interface are dispatched. This handler converts an input parameter from an MXBean data type to its mapped open type before forwarding to the MBeanServer and converts a return value from an MXBean method call through the MBeanServer from an open type to the corresponding return type declared in the MXBean interface.

If the MXBean is a notification emitter (i.e., it implements NotificationEmitter ), both the mxbeanInterface and NotificationEmitter will be implemented by this proxy.

Notes:

1. 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 MBeanServerConnection where IOException may be thrown when the communication problem occurs with the connector server. An application remotely accesses the platform MXBeans using proxy should prepare to catch IOException as if accessing with the MBeanServerConnector interface.
2. 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 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.
3. MBeanServerInvocationHandler or its newProxyInstance method cannot be used to create a proxy for a platform MXBean. The proxy object created by MBeanServerInvocationHandler does not handle the properties of the platform MXBeans described in the class specification.