Design questions on using JMX

Question

I have been reading about JMX and trying to understand it
I have some specific design realted questions and wanted some opinions to validate my understanding
Assume a simple j2ee application that exposes 2 webservices .
I would like to find out how many times each service is called and the total number of success/faults/errors
encountered for each service along with params like starttime etc
From what I have understood , I will have to first create a Bean , say "StatsCollector"
and then creae a StatsCollectorMBean interface.
The StatsCollector will provide the methods to set/update the above values and those will also be exposed by the StatsCollectorMBean interface
1) I have trouble understanding how to create and maintain the MBean Resource...
Shouldnt there be always 1 instance of this resource ? ie shouldnt there be only one StatsCollector ?
Most of the examples create a simple class "Hello implements HelloMBean" and that makes it a MBean
but they create Hello hello = new Hello() and then register it with the MBean server
What if we create multiple objects of Hello? Wouldnt that defeat the porpose of the MBean ?
I think that we need to make sure that this resource is always created once only.
Is that correct ?
2) Is it the right practice to separate your MBean and your "managed" resource ?
ie in the above case , should there be a Singleton StatsCollector POJO that stores the Appliction
statistics and another StatsMBean that will be the MBean that will access the POJO ? This makes sure that your Resource does not have
dependency management classes.
3) How does the application update the values in the MBean ?
In the above example , how do you update the success and failure counts in the MBean from the application ?
Can I update the singleton StatsCollector directly or do I have to go through the MBean Server to update
any value in the MBean ?
If I update them directly , will they be "visible" thru the MBean server ?
4) Assuming that the above app gets deployed in a appserver like WebSphere and in a Clustered environment ,
how to ensure that statisitcs are collected for all the services on all servers cummulativly ?
Is this something that the appserver should provide ? Do we register the MBean with the Appserver
MBean server ?
Any ideas/suggestions will be helpful !
thanks
Pat

Answer 1

Hello pat,
very interesting questions. You are covering the main JMX design questions there.
You should have a look (if you not already did) to the JMX best practices : http://java.sun.com/javase/technologies/core/mntr-mgmt/javamanagement/best-practices.jsp
This document summarize common JMX design patterns.
Answers to your questions:
1) The resources you want to manage/monitor are Web Services. The life cycle of these services is handled by the J2EE container itself. As you say, the tricky part is to link the WebService resource life cycle to the MBean resource
The MBean leaves inside its own container, the MBeanServer.
You should identify an initialization phase in which you create your MBeans and register them inside the MBeanServer once.
In your case, you can go for a single collector that monitors the 2 Web Services or a collector per Web Service. It seems that you want to track each service independently. Having 2 MBeans should offer a more flexible solution.
If you go for 1 MBean, you should name it "<your management domain>:type=StatsCollector". This name identify an MBean for which you have a single instance. Once the collector registered with this name, the MBeanServer will guarantee that no MBean with the same name can be registered.
If you go for 2 MBeans, you should add the Web Service name to each MBean ObjectName. For example:
MBean 1 : "<your management domain>:type=StatsCollector,name=MyWebService1"
MBean 2 : "<your management domain>:type=StatsCollector,name=MyWebService2"
Example of MBean creation and registration code :
StatsCollector collector1 = new StatsCollector();
ManagementFactory.getPlatformMBeanServer().registerMBean(collector1,
new ObjectName("com.foo.bar:type=StatsCollector,name=WebService1");
At this point you have an MBean registered inside the platform MBeanServer.
2) A Standard MBean is formed of a java interface and a class. Generally the interface and the class are not separated. They could be but I don't see a strong reason in your case to have the POJO and interface not being the same object.
3) You shouldn't expose the methods to set the values in your MBean interface. Only getters should be visible. It means that you will have to keep a direct reference to the collectors to update the statistics. During your initialization phase, you could use JNDI to register the collector instances. The WebServices will then use JNDI to retrieve the collectors.
An example of a simplified StatsCollector class and StatsCollectorMBean interface
public interface StatsCollectorMBean {
public int getNumRequests();
public class StatsCollector implements StatsCollectorMBean {
private int numRequests.
public int getNumRequests() {
return average;
public serviceCalled() {
numRequests++;
In the above example, serviceCalled is not part of the management interface and is called by the Web Service.
4) Difficult question for which I can't provide you with a reply. JMX doesn't offer such cumulative service in a standard way. In some appserver (glassfish for instance), MBeans are cascaded inside the domain server. There is no cumulative representation offered, but you could implement your own by defining new MBeans linked to the StatsCollector ones.
To conclude, Appservers are offering some "out of the box" management and monitoring features . For example glassfish relies on the AMX framework (that is JMX based) . AMX (https://glassfish.dev.java.net/javaee5/amx/) allows you to monitor and manage your services. A possible solution would be to rely on this infrastructure to build your own management and monitoring.
Hope this help.
Regards.
Jean-Francois Denise