You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
898 lines
35 KiB
898 lines
35 KiB
/*
|
|
* Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
|
|
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
|
|
package java.lang.management;
|
|
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.ObjectInstance;
|
|
import javax.management.ObjectName;
|
|
import javax.management.InstanceAlreadyExistsException;
|
|
import javax.management.InstanceNotFoundException;
|
|
import javax.management.MalformedObjectNameException;
|
|
import javax.management.MBeanRegistrationException;
|
|
import javax.management.NotCompliantMBeanException;
|
|
import javax.management.StandardEmitterMBean;
|
|
import javax.management.StandardMBean;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
import java.util.Set;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
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 javax.management.JMX;
|
|
import sun.management.ManagementFactoryHelper;
|
|
import sun.management.ExtendedPlatformComponent;
|
|
|
|
/**
|
|
* 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 name="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 name="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 <tt>MBeanServerConnection</tt> 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:
|
|
*
|
|
* <blockquote>
|
|
* <table border summary="The list of Management Interfaces and their single instances">
|
|
* <tr>
|
|
* <th>Management Interface</th>
|
|
* <th>ObjectName</th>
|
|
* </tr>
|
|
* <tr>
|
|
* <td> {@link ClassLoadingMXBean} </td>
|
|
* <td> {@link #CLASS_LOADING_MXBEAN_NAME
|
|
* java.lang:type=ClassLoading}</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td> {@link MemoryMXBean} </td>
|
|
* <td> {@link #MEMORY_MXBEAN_NAME
|
|
* java.lang:type=Memory}</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td> {@link ThreadMXBean} </td>
|
|
* <td> {@link #THREAD_MXBEAN_NAME
|
|
* java.lang:type=Threading}</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td> {@link RuntimeMXBean} </td>
|
|
* <td> {@link #RUNTIME_MXBEAN_NAME
|
|
* java.lang:type=Runtime}</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td> {@link OperatingSystemMXBean} </td>
|
|
* <td> {@link #OPERATING_SYSTEM_MXBEAN_NAME
|
|
* java.lang:type=OperatingSystem}</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td> {@link PlatformLoggingMXBean} </td>
|
|
* <td> {@link java.util.logging.LogManager#LOGGING_MXBEAN_NAME
|
|
* java.util.logging:type=Logging}</td>
|
|
* </tr>
|
|
* </table>
|
|
* </blockquote>
|
|
*
|
|
* <p>
|
|
* A Java virtual machine has zero or a single instance of
|
|
* the following management interfaces.
|
|
*
|
|
* <blockquote>
|
|
* <table border summary="The list of Management Interfaces and their single instances">
|
|
* <tr>
|
|
* <th>Management Interface</th>
|
|
* <th>ObjectName</th>
|
|
* </tr>
|
|
* <tr>
|
|
* <td> {@link CompilationMXBean} </td>
|
|
* <td> {@link #COMPILATION_MXBEAN_NAME
|
|
* java.lang:type=Compilation}</td>
|
|
* </tr>
|
|
* </table>
|
|
* </blockquote>
|
|
*
|
|
* <p>
|
|
* A Java virtual machine may have one or more instances of the following
|
|
* management interfaces.
|
|
* <blockquote>
|
|
* <table border summary="The list of Management Interfaces and their single instances">
|
|
* <tr>
|
|
* <th>Management Interface</th>
|
|
* <th>ObjectName</th>
|
|
* </tr>
|
|
* <tr>
|
|
* <td> {@link GarbageCollectorMXBean} </td>
|
|
* <td> {@link #GARBAGE_COLLECTOR_MXBEAN_DOMAIN_TYPE
|
|
* java.lang:type=GarbageCollector}<tt>,name=</tt><i>collector's name</i></td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td> {@link MemoryManagerMXBean} </td>
|
|
* <td> {@link #MEMORY_MANAGER_MXBEAN_DOMAIN_TYPE
|
|
* java.lang:type=MemoryManager}<tt>,name=</tt><i>manager's name</i></td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td> {@link MemoryPoolMXBean} </td>
|
|
* <td> {@link #MEMORY_POOL_MXBEAN_DOMAIN_TYPE
|
|
* java.lang:type=MemoryPool}<tt>,name=</tt><i>pool's name</i></td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td> {@link BufferPoolMXBean} </td>
|
|
* <td> {@code java.nio:type=BufferPool,name=}<i>pool name</i></td>
|
|
* </tr>
|
|
* </table>
|
|
* </blockquote>
|
|
*
|
|
* @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
|
|
* <tt>ObjectName</tt> for the {@link ClassLoadingMXBean}.
|
|
*/
|
|
public final static String CLASS_LOADING_MXBEAN_NAME =
|
|
"java.lang:type=ClassLoading";
|
|
|
|
/**
|
|
* String representation of the
|
|
* <tt>ObjectName</tt> for the {@link CompilationMXBean}.
|
|
*/
|
|
public final static String COMPILATION_MXBEAN_NAME =
|
|
"java.lang:type=Compilation";
|
|
|
|
/**
|
|
* String representation of the
|
|
* <tt>ObjectName</tt> for the {@link MemoryMXBean}.
|
|
*/
|
|
public final static String MEMORY_MXBEAN_NAME =
|
|
"java.lang:type=Memory";
|
|
|
|
/**
|
|
* String representation of the
|
|
* <tt>ObjectName</tt> for the {@link OperatingSystemMXBean}.
|
|
*/
|
|
public final static String OPERATING_SYSTEM_MXBEAN_NAME =
|
|
"java.lang:type=OperatingSystem";
|
|
|
|
/**
|
|
* String representation of the
|
|
* <tt>ObjectName</tt> for the {@link RuntimeMXBean}.
|
|
*/
|
|
public final static String RUNTIME_MXBEAN_NAME =
|
|
"java.lang:type=Runtime";
|
|
|
|
/**
|
|
* String representation of the
|
|
* <tt>ObjectName</tt> 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 <tt>ObjectName</tt> for a {@link GarbageCollectorMXBean}.
|
|
* The unique <tt>ObjectName</tt> for a <tt>GarbageCollectorMXBean</tt>
|
|
* can be formed by appending this string with
|
|
* "<tt>,name=</tt><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 <tt>ObjectName</tt> for a {@link MemoryManagerMXBean}.
|
|
* The unique <tt>ObjectName</tt> for a <tt>MemoryManagerMXBean</tt>
|
|
* can be formed by appending this string with
|
|
* "<tt>,name=</tt><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 <tt>ObjectName</tt> for a {@link MemoryPoolMXBean}.
|
|
* The unique <tt>ObjectName</tt> for a <tt>MemoryPoolMXBean</tt>
|
|
* can be formed by appending this string with
|
|
* <tt>,name=</tt><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 ManagementFactoryHelper.getClassLoadingMXBean();
|
|
}
|
|
|
|
/**
|
|
* 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 ManagementFactoryHelper.getMemoryMXBean();
|
|
}
|
|
|
|
/**
|
|
* 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 ManagementFactoryHelper.getThreadMXBean();
|
|
}
|
|
|
|
/**
|
|
* 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 ManagementFactoryHelper.getRuntimeMXBean();
|
|
}
|
|
|
|
/**
|
|
* Returns the managed bean for the compilation system of
|
|
* the Java virtual machine. This method returns <tt>null</tt>
|
|
* if the Java virtual machine has no compilation system.
|
|
*
|
|
* @return a {@link CompilationMXBean} object for the Java virtual
|
|
* machine or <tt>null</tt> if the Java virtual machine has
|
|
* no compilation system.
|
|
*/
|
|
public static CompilationMXBean getCompilationMXBean() {
|
|
return ManagementFactoryHelper.getCompilationMXBean();
|
|
}
|
|
|
|
/**
|
|
* 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 ManagementFactoryHelper.getOperatingSystemMXBean();
|
|
}
|
|
|
|
/**
|
|
* 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 <tt>MemoryPoolMXBean</tt> objects.
|
|
*
|
|
*/
|
|
public static List<MemoryPoolMXBean> getMemoryPoolMXBeans() {
|
|
return ManagementFactoryHelper.getMemoryPoolMXBeans();
|
|
}
|
|
|
|
/**
|
|
* 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 <tt>MemoryManagerMXBean</tt> objects.
|
|
*
|
|
*/
|
|
public static List<MemoryManagerMXBean> getMemoryManagerMXBeans() {
|
|
return ManagementFactoryHelper.getMemoryManagerMXBeans();
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns a list of {@link GarbageCollectorMXBean} objects
|
|
* in the Java virtual machine.
|
|
* The Java virtual machine may have one or more
|
|
* <tt>GarbageCollectorMXBean</tt> objects.
|
|
* It may add or remove <tt>GarbageCollectorMXBean</tt>
|
|
* during execution.
|
|
*
|
|
* @return a list of <tt>GarbageCollectorMXBean</tt> objects.
|
|
*
|
|
*/
|
|
public static List<GarbageCollectorMXBean> getGarbageCollectorMXBeans() {
|
|
return ManagementFactoryHelper.getGarbageCollectorMXBeans();
|
|
}
|
|
|
|
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();
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
HashMap<ObjectName, DynamicMBean> dynmbeans =
|
|
ManagementFactoryHelper.getPlatformDynamicMBeans();
|
|
for (Map.Entry<ObjectName, DynamicMBean> e : dynmbeans.entrySet()) {
|
|
addDynamicMBean(platformMBeanServer, e.getValue(), e.getKey());
|
|
}
|
|
for (final PlatformManagedObject o :
|
|
ExtendedPlatformComponent.getMXBeans()) {
|
|
if (!platformMBeanServer.isRegistered(o.getObjectName())) {
|
|
addMXBean(platformMBeanServer, o);
|
|
}
|
|
}
|
|
}
|
|
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
|
|
* <tt>MBeanServerConnection</tt>.
|
|
*
|
|
* <p>This method is equivalent to:
|
|
* <blockquote>
|
|
* {@link java.lang.reflect.Proxy#newProxyInstance
|
|
* Proxy.newProxyInstance}<tt>(mxbeanInterface.getClassLoader(),
|
|
* new Class[] { mxbeanInterface }, handler)</tt>
|
|
* </blockquote>
|
|
*
|
|
* where <tt>handler</tt> is an {@link java.lang.reflect.InvocationHandler
|
|
* InvocationHandler} to which method invocations to the MXBean interface
|
|
* are dispatched. This <tt>handler</tt> converts an input parameter
|
|
* from an MXBean data type to its mapped open type before forwarding
|
|
* to the <tt>MBeanServer</tt> and converts a return value from
|
|
* an MXBean method call through the <tt>MBeanServer</tt>
|
|
* 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 <tt>mxbeanInterface</tt> and <tt>NotificationEmitter</tt>
|
|
* 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
|
|
* <tt>MBeanServerConnection</tt> where
|
|
* {@link java.io.IOException 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 <tt>IOException</tt> as if
|
|
* accessing with the <tt>MBeanServerConnector</tt> 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. </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 <tt>MBeanServerInvocationHandler</tt> does not handle
|
|
* the properties of the platform MXBeans described in
|
|
* the <a href="#MXBean">class specification</a>.
|
|
*</li>
|
|
* </ol>
|
|
*
|
|
* @param connection the <tt>MBeanServerConnection</tt> to forward to.
|
|
* @param mxbeanName the name of a platform MXBean within
|
|
* <tt>connection</tt> to forward to. <tt>mxbeanName</tt> 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
|
|
* <tt>MBeanServerConnection</tt>, or {@code null} if not exist.
|
|
*
|
|
* @throws IllegalArgumentException if
|
|
* <ul>
|
|
* <li><tt>mxbeanName</tt> is not with a valid
|
|
* {@link ObjectName ObjectName} format, or</li>
|
|
* <li>the named MXBean in the <tt>connection</tt> is
|
|
* not a MXBean provided by the platform, or</li>
|
|
* <li>the named MXBean is not registered in the
|
|
* <tt>MBeanServerConnection</tt>, or</li>
|
|
* <li>the named MXBean is not an instance of the given
|
|
* <tt>mxbeanInterface</tt></li>
|
|
* </ul>
|
|
*
|
|
* @throws java.io.IOException if a communication problem
|
|
* occurred when accessing the <tt>MBeanServerConnection</tt>.
|
|
*/
|
|
public static <T> T
|
|
newPlatformMXBeanProxy(MBeanServerConnection connection,
|
|
String mxbeanName,
|
|
Class<T> mxbeanInterface)
|
|
throws java.io.IOException {
|
|
|
|
// Only allow MXBean interfaces from rt.jar loaded by the
|
|
// bootstrap class loader
|
|
final Class<?> cls = mxbeanInterface;
|
|
ClassLoader loader =
|
|
AccessController.doPrivileged(new PrivilegedAction<ClassLoader>() {
|
|
public ClassLoader run() {
|
|
return cls.getClassLoader();
|
|
}
|
|
});
|
|
if (!sun.misc.VM.isSystemDomainLoader(loader)) {
|
|
throw new IllegalArgumentException(mxbeanName +
|
|
" is not a platform MXBean");
|
|
}
|
|
|
|
try {
|
|
final ObjectName objName = new ObjectName(mxbeanName);
|
|
// skip the isInstanceOf check for LoggingMXBean
|
|
String intfName = mxbeanInterface.getName();
|
|
if (!connection.isInstanceOf(objName, intfName)) {
|
|
throw new IllegalArgumentException(mxbeanName +
|
|
" is not an instance of " + mxbeanInterface);
|
|
}
|
|
|
|
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 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 = PlatformComponent.getPlatformComponent(mxbeanInterface);
|
|
if (pc == null) {
|
|
T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
|
|
if (mbean != null) {
|
|
return mbean;
|
|
}
|
|
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 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) {
|
|
PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
|
|
if (pc == null) {
|
|
T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
|
|
if (mbean != null) {
|
|
return Collections.singletonList(mbean);
|
|
}
|
|
throw new IllegalArgumentException(mxbeanInterface.getName() +
|
|
" is not a platform management interface");
|
|
}
|
|
return Collections.unmodifiableList(pc.getMXBeans(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 {@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 = PlatformComponent.getPlatformComponent(mxbeanInterface);
|
|
if (pc == null) {
|
|
T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
|
|
if (mbean != null) {
|
|
ObjectName on = mbean.getObjectName();
|
|
return ManagementFactory.newPlatformMXBeanProxy(connection,
|
|
on.getCanonicalName(),
|
|
mxbeanInterface);
|
|
}
|
|
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 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
|
|
{
|
|
PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
|
|
if (pc == null) {
|
|
T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
|
|
if (mbean != null) {
|
|
ObjectName on = mbean.getObjectName();
|
|
T proxy = ManagementFactory.newPlatformMXBeanProxy(connection,
|
|
on.getCanonicalName(), mxbeanInterface);
|
|
return Collections.singletonList(proxy);
|
|
}
|
|
throw new IllegalArgumentException(mxbeanInterface.getName() +
|
|
" is not a platform management interface");
|
|
}
|
|
return Collections.unmodifiableList(pc.getMXBeans(connection, mxbeanInterface));
|
|
}
|
|
|
|
/**
|
|
* 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()
|
|
{
|
|
Set<Class<? extends PlatformManagedObject>> result =
|
|
new HashSet<>();
|
|
for (PlatformComponent component: PlatformComponent.values()) {
|
|
result.add(component.getMXBeanInterface());
|
|
}
|
|
return Collections.unmodifiableSet(result);
|
|
}
|
|
|
|
private static final String NOTIF_EMITTER =
|
|
"javax.management.NotificationEmitter";
|
|
|
|
/**
|
|
* Registers an MXBean.
|
|
*/
|
|
private static void addMXBean(final MBeanServer mbs, final PlatformManagedObject pmo) {
|
|
// Make DynamicMBean out of MXBean by wrapping it with a StandardMBean
|
|
try {
|
|
AccessController.doPrivileged(new PrivilegedExceptionAction<Void>() {
|
|
public Void run() throws InstanceAlreadyExistsException,
|
|
MBeanRegistrationException,
|
|
NotCompliantMBeanException {
|
|
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, pmo.getObjectName());
|
|
return null;
|
|
}
|
|
});
|
|
} catch (PrivilegedActionException e) {
|
|
throw new RuntimeException(e.getException());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Registers a DynamicMBean.
|
|
*/
|
|
private static void addDynamicMBean(final MBeanServer mbs,
|
|
final DynamicMBean dmbean,
|
|
final ObjectName on) {
|
|
try {
|
|
AccessController.doPrivileged(new PrivilegedExceptionAction<Void>() {
|
|
@Override
|
|
public Void run() throws InstanceAlreadyExistsException,
|
|
MBeanRegistrationException,
|
|
NotCompliantMBeanException {
|
|
mbs.registerMBean(dmbean, on);
|
|
return null;
|
|
}
|
|
});
|
|
} catch (PrivilegedActionException e) {
|
|
throw new RuntimeException(e.getException());
|
|
}
|
|
}
|
|
}
|