Starting with J2SE 5.0, the Java platform includes significant monitoring and management features:
The Java virtual machine (JVM) is instrumented for monitoring and management, providing built-in ("out-of-the-box") management capabilities for for both remote and local access. For more information, see JMX Monitoring and Management and SNMP Monitoring and Management.
The JVM include a platform MBean server (management agent) and platform MBeans that JMX management applications can use. These are implementations of the monitoring and management API described below.
Example code is provided in the
The java.lang.management package provides the interface for monitoring and managing the JVM.
The API provides access to information such as:
The API includes logging monitoring and management capabilities. The java.util.logging.LoggingMXBean interface provides for management of the logging facility.
The com.sun.management package contains Sun Microsystems' platform extension to the management API.
A graphical JMX monitoring tool,
you to monitor the performance of a JVM and instrumented applications, providing information to help
you optimize performance. For
more information, see Using
jconsole. Other command-line tools are also available: see J2SE Monitoring and
Management Tools for more information.
Java Management Extensions (JMX) API version 1.2. The JMX API allows you to instrument applications for monitoring and management. The RMI connector allows this instrumentation to be remotely accessible. This API, formerly an optional extension, is now included in J2SE.
MBeans are managed beans, Java objects that represent resources to be managed. An MBean has a management interface consisting of:
For example, an MBean representing an application's
configuration could have attributes representing the different
configuration parameters, such as a cache size. Reading the
CacheSize attribute would return the current size of
the cache. Writing
CacheSize would update the size of
the cache, potentially changing the behavior of the running
application. An operation such as
save could store the
current configuration persistently. The MBean could send a
notification such as
when the configuration changes.
MBeans can be standard or dynamic. Standard MBeans are Java objects that conform to design patterns derived from the JavaBeans component model. Dynamic MBeans define their management interface at runtime.
A standard MBean exposes the resource to be managed directly through its attributes and operations. Attributes are exposed through "getter" and "setter" methods. Operations are the other methods of the class that are available to managers. All these methods are defined statically in the MBean interface and are visible to a JMX agent through introspection. This is the most straightforward way of making a new resource manageable.
A dynamic MBean is an MBean that defines its management interface at runtime. For example, a configuration MBean could determine the names and types of the attributes it exposes by parsing an XML file.
To be useful, an MBean must be registered in an MBean Server, also called an MBean agent. An MBean Server is a repository of MBeans. Each MBean is registered with a unique name within the MBean Server. Usually the only access to the MBeans is through the MBean Server. In other words, code does not access an MBean directly, but rather accesses the MBean by name through the MBean Server.
Starting with release 5.0, J2SE includes a built-in platform MBean server. For more information, see Using the Platform MBean Server.
There are two ways to create an MBean. One is to construct a
Java object that will be the MBean, then use the
registerMBean method to register
it in the MBean Server. The other is to create and register the
MBean in a single operation using one of the
registerMBean method is simpler for local use,
but cannot be used remotely. The
can be used remotely, but sometimes requires attention to class
loading issues. An MBean can perform actions when it is registered
in or unregistered from an MBean Server if it implements the
General instruction on instrumenting your applications for JMX management is beyond the scope of this document. J2SE includes extensive JMX documentation, including:
A platform MBean (also called an MXBean) is an MBean for
monitoring and managing the Java Virtual Machine (JVM). Each
MXBean encapsulates a part of JVM functionality such as the JVM's
class loading system, JIT compilation system, garbage collector, and so on. The
package defines the platform MXBeans.
Table 1 lists all the platform MBeans and the aspect of the VM
that they manage. Each platform MXBean has a unique
registration in the platform MBeanServer. A JVM may have
zero, one, or more than one instance of each MXBean, depending on
its function, as shown in the table.
|Interface||Manages||Object Name||Instances Per VM|
||Class loading system||
||Zero or one|
||One or more|
(sub-interface of GarbageCollectorMXBean)
||One or more|
||One or more|
||Underlying operating system||
The Platform MBean Server can be shared by different
managed components running within the same Java Virtual Machine.
You can access the Platform MBean Server with the method
The first call to this method, creates the platform
MBeanServer and registers the platform MXBeans using their
unique ObjectNames. Subsequently, it returns the initially created
MXBeans that get created and destroyed dynamically, for example,
memory pools and managers, will automatically be registered and
deregistered into the platform MBeanServer. If the
system property javax.management.builder.initial is set,
the platform MBeanServer creation will be done by the
Use the platform MBeanServer to register other MBeans besides the platform MXBeans. This enables all MBeans to be published through the same MBeanServer and makes network publishing and discovery easier.
The LoggingMXBean enables you to:
The unique ObjectName of the LoggingMXBean is:
java.util.logging:type=Logging, kept in
There is a single global instance of the LoggingMXBean,
which you can get by calling