/**
* Returns the platform {@link javax.management.MBeanServer MBeanServer}. On the first call to
* this method, it first creates the platform <tt>MBeanServer</tt> by calling the {@link
* javax.management.MBeanServerFactory#createMBeanServer MBeanServerFactory.createMBeanServer}
* method and registers the platform MXBeans in this platform <tt>MBeanServer</tt> using the <a
* href="#MXBeanNames">MXBean names</a> defined in the class description. This method, in
* subsequent calls, will simply return the initially created platform <tt>MBeanServer</tt>.
*
* <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 <tt>MBeanServer</tt>.
*
* <p>If the system property <tt>javax.management.builder.initial</tt> is set, the platform
* <tt>MBeanServer</tt> 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 <tt>MBeanServer</tt> and hence allow for easier network publishing and discovery. Name
* conflicts with the platform MXBeans should be avoided.
*
* @return the platform <tt>MBeanServer</tt>; the platform MXBeans are registered into the
* platform <tt>MBeanServer</tt> 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);
}
}
}
}
return platformMBeanServer;
}
/**
* 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 TreeSet<>();
for (PlatformComponent component : PlatformComponent.values()) {
result.add(component.getMXBeanInterface());
}
return Collections.unmodifiableSet(result);
}
/**
* Returns a list of {@code Class} objects, subinterface of {@link PlatformManagedObject},
* representing all management interfaces for monitoring and managing the Java platform.
*
* @return a list of {@code Class} objects, subinterface of {@link PlatformManagedObject}
* representing the management interfaces for monitoring and managing the Java platform.
* @since 1.7
*/
public static List<Class<? extends PlatformManagedObject>> getAllPlatformMXBeanInterfaces() {
List<Class<? extends PlatformManagedObject>> result =
new ArrayList<Class<? extends PlatformManagedObject>>();
for (PlatformComponent component : PlatformComponent.values()) {
result.add(component.getMXBeanInterface());
}
return result;
}
/**
* 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
* @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 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
* @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 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.
* @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.
*
* @param connection the {@code MBeanServerConnection} to forward to.
* @param mxbeanInterface a management interface for a platform MXBean
* @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 management interface for
* the platform.
* @throws java.io.IOException if a communication problem occurred when accessing the {@code
* MBeanServerConnection}.
* @since 1.7
*/
public static <T extends PlatformManagedObject> List<T> getPlatformMXBeans(
MBeanServerConnection connection, Class<T> mxbeanInterface) throws java.io.IOException {
String className = mxbeanInterface.getName();
for (PlatformComponent component : PlatformComponent.values()) {
// comparing the class name first instead of the Class instance
// to avoid causing unnecessary class loading of
// the other MXBean interfaces
if (className.equals(component.getMXBeanInterfaceName())) {
if (component.getMXBeanInterface() == mxbeanInterface) {
return component.getMXBeans(connection, mxbeanInterface);
}
}
}
throw new IllegalArgumentException(
mxbeanInterface.getName() + " is not implemented by any of the platform MXBeans.");
}