| /* |
| * Copyright (c) 2003, 2013, 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 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; |
| |
| /** |
| * 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()); |
| } |
| } |
| 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) |
| 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) |
| 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) |
| 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) { |
| 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()); |
| } |
| } |
| } |