A standard MBean is defined by writing a Java interface called SomethingMBean and a Java class called Something that implements that interface. Every method in the interface defines either an attribute or an operation in the MBean. By default, every method defines an operation. Attributes and operations are methods that follow certain design patterns. A standard MBean is composed of an MBean interface and a class. The MBean interface lists the methods for all exposed attributes and operations. The class implements this interface and provides the functionality of the instrumented resource.
The following sections examine an example of a standard MBean and a simple JMX technology-enabled agent (JMX agent) that manages the MBean.
MBean Interface
An example of a basic MBean interface,
HelloMBean , follows:
package com.example;
public interface HelloMBean {
public void sayHello();
public int add(int x, int y);
public String getName();
public int getCacheSize();
public void setCacheSize(int size);
}
By convention, an MBean interface takes the name of the Java class that implements it, with the suffix
MBean added. In this case, the interface is called
HelloMBean. The
Hello class that implements this interface is described in the next section.
According to the JMX specification, an MBean interface consists of named and typed attributes that are readable and possibly writable, in addition to the named and typed operations that can be invoked by the applications that are managed by the MBean. The
HelloMBean interface declares two operations: the Java methods
add() and
sayHello().
HelloMBean declares two attributes:
Name is a read-only string, and
CacheSize is an integer that can be both read and written. Getter and setter methods are declared to allow the managed application to access and possibly change the attribute values. As defined by the JMX specification, a
getter is any public method that does not return void and whose name begins with
get. A getter enables a manager to read the value of the attribute, whose type is that of the returned object. A
setter is any public method that takes a single parameter and whose name begins with
set. A setter enables a manager to write a new value in the attribute, whose type is the same as that of the parameter.
MBean Implementation
The
Hello Java class that follows implements the
HelloMBean MBean interface:
package com.example;
public class Hello ...
implements HelloMBean {
public void sayHello() {
System.out.println("hello, world");
}
public int add(int x, int y) {
return x + y;
}
public String getName() {
return this.name;
}
public int getCacheSize() {
return this.cacheSize;
}
public synchronized void setCacheSize(int size) {
...
this.cacheSize = size;
System.out.println("Cache size now " + this.cacheSize);
}
...
private final String name = "Reginald";
private int cacheSize = DEFAULT_CACHE_SIZE;
private static final int
DEFAULT_CACHE_SIZE = 200;
}
The straightforward Hello class provides the definitions of the operations and attributes that are declared by HelloMBean. The sayHello() and add() operations are extremely simple, but real-life operations can be as simple or as sophisticated as needed.
The methods to get the Name attribute and to get and set the CacheSize attribute are also defined. In this example, the Name attribute value never changes. However, in a real scenario this attribute might change as the managed resource runs. For example, the attribute might represent statistics such as uptime or memory usage. Here, the attribute is merely the name Reginald.
Calling the setCacheSize method enables you to alter the CacheSize attribute from its declared default value of 200. In a real scenario, changing the CacheSizeattribute could require other operations to be performed, such as discarding entries or allocating new entries. This example merely prints a message to confirm that the cache size has changed. However, more sophisticated operations could be defined instead of the simple call to println().
With the Hello MBean and its interface thus defined, they can now be used to manage the resource they represent, as shown in the following section.
Creating a JMX Agent to Manage a Resource
Once a resource has been instrumented by MBeans, the management of that resource is performed by a JMX agent.
The core component of a JMX agent is the MBean server. An MBean server is a managed object server in which MBeans are registered. A JMX agent also includes a set of services to manage MBeans. See the API documentation for the
MBeanServer interface for details of the MBean server implementation.
The
Main class that follows represents a basic JMX agent:
package com.example;
import java.lang.management.*;
import javax.management.*;
public class Main {
public static void main(String[] args)
throws Exception {
MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
ObjectName name = new ObjectName("com.example:type=Hello");
Hello mbean = new Hello();
mbs.registerMBean(mbean, name);
...
System.out.println("Waiting forever...");
Thread.sleep(Long.MAX_VALUE);
}
}
The JMX agent
Main begins by obtaining an MBean server that has been created and initialized by the platform, by calling the
getPlatformMBeanServer() method of the
java.lang.management.ManagementFactory class. If no MBean server has been created by the platform already, then
getPlatformMBeanServer() creates an MBean server automatically by calling the JMX method
MBeanServerFactory.createMBeanServer(). The
MBeanServer instance obtained by
Main is named
mbs.
Next,
Main defines an object name for the MBean instance that it will create. Every JMX MBean must have an object name. The object name is an instance of the JMX class
ObjectName and must conform to the syntax defined by the JMX specification. Namely, the object name must contain a domain and a list of key-properties. In the object name defined by
Main, the domain is
com.example (the package in which the example MBean is contained). In addition, the key-property declares that this object is of the type
Hello.
An instance of a
Hello object, named
mbean, is created. The
Hello object named
mbean is then registered as an MBean in the MBean server
mbs with the object name
name, by passing the object and the object name into a call to the JMX method
MBeanServer.registerMBean().
With the Hello MBean registered in the MBean server, Main simply waits for management operations to be performed on Hello. In this example, these management operations are invoking sayHello() and add(), and getting and setting the attribute values.
