Package Summary Overview Summary

### class:JMX [NONE]
public class JMX extends Object Static methods from the JMX API. There are no instances of this class. Since: 1.6

### field:DEFAULT_VALUE_FIELD [NONE]
### DEFAULT_VALUE_FIELD public static final String DEFAULT_VALUE_FIELD The name of the `defaultValue` field. See Also: Constant Field Values

### field:IMMUTABLE_INFO_FIELD [NONE]
### IMMUTABLE_INFO_FIELD public static final String IMMUTABLE_INFO_FIELD The name of the `immutableInfo` field. See Also: Constant Field Values

### field:INTERFACE_CLASS_NAME_FIELD [NONE]
### INTERFACE_CLASS_NAME_FIELD public static final String INTERFACE_CLASS_NAME_FIELD The name of the `interfaceClassName` field. See Also: Constant Field Values

### field:LEGAL_VALUES_FIELD [NONE]
### LEGAL_VALUES_FIELD public static final String LEGAL_VALUES_FIELD The name of the `legalValues` field. See Also: Constant Field Values

### field:MAX_VALUE_FIELD [NONE]
### MAX_VALUE_FIELD public static final String MAX_VALUE_FIELD The name of the `maxValue` field. See Also: Constant Field Values

### field:MIN_VALUE_FIELD [NONE]
### MIN_VALUE_FIELD public static final String MIN_VALUE_FIELD The name of the `minValue` field. See Also: Constant Field Values

### field:MXBEAN_FIELD [NONE]
### MXBEAN_FIELD public static final String MXBEAN_FIELD The name of the `mxbean` field. See Also: Constant Field Values

### field:OPEN_TYPE_FIELD [NONE]
### OPEN_TYPE_FIELD public static final String OPEN_TYPE_FIELD The name of the `openType` field. See Also: Constant Field Values

### field:ORIGINAL_TYPE_FIELD [NONE]
### ORIGINAL_TYPE_FIELD public static final String ORIGINAL_TYPE_FIELD The name of the `originalType` field. See Also: Constant Field Values

### method:newMBeanProxy(javax.management.MBeanServerConnection,javax.management.ObjectName,java.lang.Class) [NONE]
- ### newMBeanProxy public static <T> T newMBeanProxy (MBeanServerConnection connection, ObjectName objectName, Class<T> interfaceClass) Make a proxy for a Standard MBean in a local or remote MBean Server. If you have an MBean Server `mbs` containing an MBean with `ObjectName` `name`, and if the MBean's management interface is described by the Java interface `MyMBean`, you can construct a proxy for the MBean like this:
      MyMBean proxy = JMX.newMBeanProxy(mbs, name, MyMBean.class);
  Suppose, for example, `MyMBean` looks like this:
      public interface MyMBean {
          public String getSomeAttribute();
          public void setSomeAttribute(String value);
          public void someOperation(String param1, int param2);
      }
Then you can execute: `proxy.getSomeAttribute()` which will result in a call to `mbs.``getAttribute``(name, "SomeAttribute")` . `proxy.setSomeAttribute("whatever")` which will result in a call to `mbs.``setAttribute``(name, new Attribute("SomeAttribute", "whatever"))` . `proxy.someOperation("param1", 2)` which will be translated into a call to `mbs.``invoke``(name, "someOperation", <etc>)` . The object returned by this method is a `Proxy` whose `InvocationHandler` is an `MBeanServerInvocationHandler`. This method is equivalent to `newMBeanProxy(connection, objectName, interfaceClass, false)` . Type Parameters: `T` - allows the compiler to know that if the `interfaceClass` parameter is `MyMBean.class`, for example, then the return type is `MyMBean`. Parameters: `connection` - the MBean server to forward to. `objectName` - the name of the MBean within `connection` to forward to. `interfaceClass` - the management interface that the MBean exports, which will also be implemented by the returned proxy. Returns: the new proxy instance. Throws: `IllegalArgumentException` - if `interfaceClass` is not a compliant MBean interface

### method:newMBeanProxy(javax.management.MBeanServerConnection,javax.management.ObjectName,java.lang.Class,boolean) [NONE]
### newMBeanProxy public static <T> T newMBeanProxy (MBeanServerConnection connection, ObjectName objectName, Class<T> interfaceClass, boolean notificationEmitter) Make a proxy for a Standard MBean in a local or remote MBean Server that may also support the methods of `NotificationEmitter`. This method behaves the same as `newMBeanProxy(MBeanServerConnection, ObjectName, Class)` , but additionally, if `notificationEmitter` is `true` , then the MBean is assumed to be a `NotificationBroadcaster` or `NotificationEmitter` and the returned proxy will implement `NotificationEmitter` as well as `interfaceClass`. A call to `NotificationBroadcaster.addNotificationListener(NotificationListener, NotificationFilter, Object)` on the proxy will result in a call to `MBeanServerConnection.addNotificationListener(ObjectName, NotificationListener, NotificationFilter, Object)` , and likewise for the other methods of `NotificationBroadcaster` and `NotificationEmitter`. Type Parameters: `T` - allows the compiler to know that if the `interfaceClass` parameter is `MyMBean.class`, for example, then the return type is `MyMBean`. Parameters: `connection` - the MBean server to forward to. `objectName` - the name of the MBean within `connection` to forward to. `interfaceClass` - the management interface that the MBean exports, which will also be implemented by the returned proxy. `notificationEmitter` - make the returned proxy implement `NotificationEmitter` by forwarding its methods via `connection`. Returns: the new proxy instance. Throws: `IllegalArgumentException` - if `interfaceClass` is not a compliant MBean interface

### method:newMXBeanProxy(javax.management.MBeanServerConnection,javax.management.ObjectName,java.lang.Class) [NONE]
### newMXBeanProxy public static <T> T newMXBeanProxy (MBeanServerConnection connection, ObjectName objectName, Class<T> interfaceClass) Make a proxy for an MXBean in a local or remote MBean Server. If you have an MBean Server `mbs` containing an MXBean with `ObjectName` `name`, and if the MXBean's management interface is described by the Java interface `MyMXBean`, you can construct a proxy for the MXBean like this:
    MyMXBean proxy = JMX.newMXBeanProxy(mbs, name, MyMXBean.class);
Suppose, for example, `MyMXBean` looks like this:
                                                                                                            public interface MyMXBean {
        public String getSimpleAttribute();
        public void setSimpleAttribute(String value);
        public MemoryUsage getMappedAttribute();
        public void setMappedAttribute(MemoryUsage memoryUsage);
        public MemoryUsage someOperation(String param1, MemoryUsage param2);
    }
Then: `proxy.getSimpleAttribute()` will result in a call to `mbs.``getAttribute``(name, "SimpleAttribute")` . `proxy.setSimpleAttribute("whatever")` will result in a call to `mbs.``setAttribute``(name, new Attribute("SimpleAttribute", "whatever"))` . Because `String` is a simple type , in the sense of `SimpleType`, it is not changed in the context of an MXBean. The MXBean proxy behaves the same as a Standard MBean proxy (see `newMBeanProxy`) for the attribute `SimpleAttribute` . `proxy.getMappedAttribute()` will result in a call to `mbs.getAttribute("MappedAttribute")`. The MXBean mapping rules mean that the actual type of the attribute `MappedAttribute` will be `CompositeData` and that is what the `mbs.getAttribute` call will return. The proxy will then convert the `CompositeData` back into the expected type `MemoryUsage` using the MXBean mapping rules. Similarly, `proxy.setMappedAttribute(memoryUsage)` will convert the `MemoryUsage` argument into a `CompositeData` before calling `mbs.setAttribute`. `proxy.someOperation("whatever", memoryUsage)` will convert the `MemoryUsage` argument into a `CompositeData` and call `mbs.invoke`. The value returned by `mbs.invoke` will be also be a `CompositeData`, and the proxy will convert this into the expected type `MemoryUsage` using the MXBean mapping rules. The object returned by this method is a `Proxy` whose `InvocationHandler` is an `MBeanServerInvocationHandler`. This method is equivalent to `newMXBeanProxy(connection, objectName, interfaceClass, false)` . Type Parameters: `T` - allows the compiler to know that if the `interfaceClass` parameter is `MyMXBean.class`, for example, then the return type is `MyMXBean`. Parameters: `connection` - the MBean server to forward to. `objectName` - the name of the MBean within `connection` to forward to. `interfaceClass` - the MXBean interface, which will also be implemented by the returned proxy. Returns: the new proxy instance. Throws: `IllegalArgumentException` - if `interfaceClass` is not a `compliant MXBean interface`

### method:newMXBeanProxy(javax.management.MBeanServerConnection,javax.management.ObjectName,java.lang.Class,boolean) [NONE]
### newMXBeanProxy public static <T> T newMXBeanProxy (MBeanServerConnection connection, ObjectName objectName, Class<T> interfaceClass, boolean notificationEmitter) Make a proxy for an MXBean in a local or remote MBean Server that may also support the methods of `NotificationEmitter`. This method behaves the same as `newMXBeanProxy(MBeanServerConnection, ObjectName, Class)` , but additionally, if `notificationEmitter` is `true` , then the MXBean is assumed to be a `NotificationBroadcaster` or `NotificationEmitter` and the returned proxy will implement `NotificationEmitter` as well as `interfaceClass`. A call to `NotificationBroadcaster.addNotificationListener(NotificationListener, NotificationFilter, Object)` on the proxy will result in a call to `MBeanServerConnection.addNotificationListener(ObjectName, NotificationListener, NotificationFilter, Object)` , and likewise for the other methods of `NotificationBroadcaster` and `NotificationEmitter`. Type Parameters: `T` - allows the compiler to know that if the `interfaceClass` parameter is `MyMXBean.class`, for example, then the return type is `MyMXBean`. Parameters: `connection` - the MBean server to forward to. `objectName` - the name of the MBean within `connection` to forward to. `interfaceClass` - the MXBean interface, which will also be implemented by the returned proxy. `notificationEmitter` - make the returned proxy implement `NotificationEmitter` by forwarding its methods via `connection`. Returns: the new proxy instance. Throws: `IllegalArgumentException` - if `interfaceClass` is not a `compliant MXBean interface`

### method:isMXBeanInterface(java.lang.Class) [NONE]
### isMXBeanInterface public static boolean isMXBeanInterface (Class<?> interfaceClass) Test whether an interface is an MXBean interface. An interface is an MXBean interface if it is public, annotated `@MXBean` or `@MXBean(true)` or if it does not have an `@MXBean` annotation and its name ends with "`MXBean`". Parameters: `interfaceClass` - The candidate interface. Returns: true if `interfaceClass` is a `compliant MXBean interface` Throws: `NullPointerException` - if `interfaceClass` is null.