Java Management Extensions (JMX)
is a framework that provides a standard way of exposing Java resources, for example, application servers,
to a system management infrastructure. Using the JMX framework, a
provider can implement functions, such as listing the configuration
settings, and editing the settings. This framework also includes a
notification layer that management applications can use to monitor
events such as the startup of an application server.
JMX key features
The key features of the
WebSphere® Application Server Version 6 implementation
of JMX include:
- All processes that run the JMX agent.
- All run-time administration that is performed through JMX operations.
- Connectors that are used to connect a JMX agent to a remote JMX-enabled
management application. The following connectors are supported:
- SOAP JMX Connector
- JMX Remote application programming interface (JSR 160) Remote
Method Invocation over the Internet Inter-ORB Protocol (RMI-IIOP)
JMX Connector, (the JSR160RMI connector)
- Remote Method Invocation over the Internet Inter-ORB Protocol
(RMI-IIOP) JMX Connector
- Inter-Process Communications (IPC)
- Protocol adapters that provide a management view of the JMX agent
through a given protocol. Management applications that connect to
a protocol adapter are usually specific to a given protocol.
- The ability to query and update the configuration settings of
a run-time object.
- The ability to load, initialize, change, and monitor application
components and resources during run-time.
JMX architecture
The JMX architecture is structured into three layers:
- Instrumentation layer - Dictates how resources can be wrapped
within special Java beans, called managed beans
(MBeans).
- Agent layer - Consists of the MBean server and agents, which provide
a management infrastructure. The services that are implemented include:
- Monitoring
- Event notification
- Timers
- Management layer - Defines how external management applications
can interact with the underlying layers in terms of protocols, APIs,
and so on. This layer uses an implementation of the distributed services
specification (JSR-077), which is not yet part of the Java 2 platform, Enterprise Edition (J2EE) specification.
The layered architecture of JMX is summarized in the following
figure:

Figure 1: JMX architecture
JMX distributed administration
The following figure shows how the JMX architecture fits into the
overall distributed administration topology of a WebSphere Application Server, Network Deployment environment:

Figure 2: WebSphere Application Server distributed
administration of JMX
The key points of this distributed administration architecture
include:
- Internal MBeans that are local to the Java virtual
machine (JVM) register with the local MBean server.
- External MBeans have a local proxy to their MBean server. The
proxy registers with the local MBean server.
Using the MBean proxy
the local MBean server can pass the message to an external MBean server
that is located on:
- A node agent that has an MBean proxy for all the servers within
its node. The MBean proxies for other nodes are not used.
- The deployment manager has MBean proxies for all the node agents
in the cell.
JMX Mbeans
WebSphere Application Server provides
a number of MBeans, each of which has different functions and operations
available. For example, an application server MBean can expose operations
such as start and stop. An application MBean can expose operations
such as install and uninstall. Some JMX usage scenarios that you can
encounter include:
- External programs that are written to control the WebSphere Application Server, Network Deployment run time and
its WebSphere resources by programmatically
accessing the JMX API.
- Third-party applications that include custom JMX MBeans as part
of the deployed code, supporting the JMX API management of application
components and resources.
The following example illustrates how to obtain the name of a
particular MBean:
Using Jacl:
set am [$AdminControl queryNames type=ApplicationManager,process=server1,*]
Using Jython:
am = AdminControl.queryNames('type=ApplicationManager,process=server1,*')
Each WebSphere Application Server runtime
MBean can have attributes, operations, and notifications. The complete
documentation for each MBean that is supplied with the product is
available in this information center at .
JMX benefits
The use of JMX for management functions in
WebSphere Application Server provides the following
benefits:
- Enables the management of Java applications
without significant investment.
- Relies on a core-managed object server that acts as a management
agent.
- Java applications can embed a managed object
server and make some of its functionality available as one or several
MBeans that are registered with the object server.
- Provides a scalable management architecture.
- Every JMX agent service is an independent module that can be plugged
into the management agent.
- The API is extensible, allowing new WebSphere Application Server and custom application
features to be easily added and exposed through this management interface.
- Integrates existing management solutions.
- Each process is self-sufficient when it comes to the management
of its resources. No central point of control exists. In principle,
a JMX-enabled management client can be connected to any managed process
and interact with the MBeans that are hosted by that process.
- JMX provides a single, flat, domain-wide approach to system management.
Separate processes interact through MBean proxies that support a single
management client to seamlessly navigate through a network of managed
processes.
- Defines the interfaces that are necessary for management only.
- Provides a standard API for exposing application and administrative
resources to management tools.