JMX 介绍

1. 什么是 JMX

         JMX （Java Management Extensions）是一个为应用程序，设备，系统等植入管理功能的框架。

        JMX 规范可以分为三层： 设备层， 代理层， 分布式服务层。 设备层规范定义了编写可由 JMX 管理的资源的标准，即如何写 MBean； 代理曾规范定义了创建代理的规范，封装了 MBean Server；分布式服务层主要定义了对代理层进行操作的管理接口和构件。

        如果一个 Java 对象可以由一个遵循 JMX 规范的管理器应用管理，那么这个Java 对象就可以称为一个可由 JMX 管理的资源。

        要使一个 Java 对象可管理，则必须创建相应的 MBean 对象，并通过这些 MBean 对象管理相应的 Java 对象。当拥有 MBean 类后，需要将其实例化并注册到 MBeanServer 上。

       一共有四种类型的 MBean ， 分别是标准类型 MBean， 动态类型 MBean， 开放类型 MBean 和模型类型 MBean。我们在下文将分别进行介绍。

2. JMX API 简单介绍

        本部分对 JMX 中常用的一些类进行简单的介绍。

2.1 MBeanServer

public ObjectInstance createMBean(String className, ObjectName name).

        创建 MBean，并将其注册到 MBeanServer.

public ObjectInstance registerMBean(Object object, ObjectName name).

        将Java对象注册到 MBeanServer。

public Set queryNames(ObjectName name, QueryExp query).

        根据对象名查找注册的 MBean， 返回的 Set 中包含的是查找到的 MBean  对应的 ObjectName。

public Set queryMBeans(ObjectName name, QueryExp query).

        返回的 Set 中包含的是 ObjectInstance 对象。

pubilc Attribute getAttribute(ObjectName name, String attributeName).

        返回指定 name 代表的 MBean 的名为 attributeName 的属性。

public void setAttribute(ObjectName name, Attribute attr).

        设置属性

public invoke(ObjectName name, String methodName, ..., ...).

       执行 指定 MBean 的指定方法。

2.2 MBeanServerFactory

public static MBeanServer createMBeanServer().

        创建 MBeanServer.

2.3 ObjectName

        ObjectName 由两部分组成： domain 和 键/值对。如下面是一个是一个有效的对象名称： 

        myDomain:type=Car,color=blue

public ObjectName(String name).

        根据 name 构造ObjectName  对象。

2.4 ObjectInstance

2.5 Attribute

3. 标准 MBean

        标准 MBean 是最简单的 MBean 类型。通过标准 MBean 来管理一个 Java 对象需要以下步骤：

        1. 创建一个接口， 命名规范为： Java 类名 + MBean 后缀。如 Java 类为 Car ，则需要创建 CarMBean 接口。

        2. 修改 Java 类，使它实现创建的接口。如上面提到的 CarMBean。

        3. 创建代理，该代理包含 MBeanServer 实例。

        4. 为 MBean 创建 ObjectName 实例。

        5. 实例化 MBeanServer。

        6. 将 MBean 注册到 MBeanServer。

        下面我们介绍一个标准 MBean 的例子。如我们有一个 Car 类：

[java]  view plain  copy

1. package test;  
2.   
3. public class Car{  
4.     private String color = "red";  
5.       
6.     public String getColor(){  
7.         return color;  
8.     }  
9.     public void setColor(String color){  
10.         this.color = color;  
11.     }  
12.     public void drive(){  
13.         System.out.println("Baby you can drive my car.");  
14.     }  
15. }  

        那么，第一步我们需要创建 名字为 CarMBean 的接口：

[java]  view plain  copy

1. package test;  
2.   
3. public interface CarMBean {  
4.     public String getColor();  
5.     public void setColor(String color);  
6.     public void drive();  
7. }  

        接下类使 Car 实现 CarMBean：

[java]  view plain  copy

1. package test;  
2.   
3. public class Car implements CarMBean{  
4.     private String color = "red";  
5.       
6.     public String getColor(){  
7.         return color;  
8.     }  
9.     public void setColor(String color){  
10.         this.color = color;  
11.     }  
12.     public void drive(){  
13.         System.out.println("Baby you can drive my car.");  
14.     }  
15. }  

        然后创建代理：

[java]  view plain  copy

1. package test;  
2.   
3. import javax.management.Attribute;  
4. import javax.management.MBeanServer;  
5. import javax.management.MBeanServerFactory;  
6. import javax.management.ObjectName;  
7.   
8. public class StandardAgent {  
9.     private MBeanServer mBeanServer = null;  
10.     public StandardAgent(){  
11.         mBeanServer = MBeanServerFactory.newMBeanServer();  
12.     }  
13.       
14.     public MBeanServer getMBeanServer(){  
15.         return mBeanServer;  
16.     }  
17.       
18.     public ObjectName createObjectName(String name){  
19.         ObjectName objectName = null;  
20.         try{  
21.             objectName = new ObjectName(name);  
22.         }catch(Exception e){  
23.         }  
24.         return objectName;  
25.     }  
26.     private void createStandardBean(ObjectName objectName, String managedResourceClassName){  
27.         try{  
28.             mBeanServer.createMBean(managedResourceClassName, objectName);  
29.         }catch(Exception e){}  
30.     }  
31.       
32.     public static  void main(String[] args){  
33.         StandardAgent agent = new StandardAgent();  
34.         MBeanServer mBeanServer = agent.getMBeanServer();  
35.         String domain = mBeanServer.getDefaultDomain();  
36.         String managedResourceClassName = "test.Car";  
37.         ObjectName objectName = agent.createObjectName(domain + ":type=" + managedResourceClassName);  
38.         System.out.println("objectName: " + objectName);  
39.         agent.createStandardBean(objectName, managedResourceClassName);  
40.           
41.         try{  
42.             Attribute colorAttribute = new Attribute("Color", "blue");  
43.             mBeanServer.setAttribute(objectName, colorAttribute);  
44.             System.out.println(mBeanServer.getAttribute(objectName, "Color"));  
45.             mBeanServer.invoke(objectName, "drive", null, null);  
46.         }catch(Exception e){  
47.             e.printStackTrace();  
48.         }  
49.     }  
50. }  

         该类的 main() 方法首先创建 StandardAgent 的一个实例，并获取 MBeanServer。然后创建 ObjectName 实例，并使用 MBeanServer的默认域作为ObjectName 的域。然后通过 CarMBean 实例来管理 Car 对象。

4. 动态 MBean（略）

5. 开放 MBean （略）

6. 模型 MBean

        相对于标准 MBean，模型 MBean 更加灵活。如果我们不能修改已有的 Java 类，那么使用模型 MBean 是不错的选择。不过，模型 MBean 直接变成的难度更大一些。后面我们会介绍到使用 Apache 的 Common Modeler 来简化模型 MBean 过程。

6.1 模型 MBean 的相关类和接口

ModelMBean 接口

        使用模型 MBean，我们不需要像在标准 MBean 中那样定义接口。使用 ModelMBean 接口是不错的选择。

RequiredModelMBean 类

        JMX 的参考实现中的一个 ModelMBean 接口的默认实现类。

ModelMBeanInfo 接口

        编写模型 MBean 的最大挑战是告诉 ModelMBean 对象托管资源的哪些属性和方法可以暴露给代理。ModelMBeanInfo 对象描述了将会暴露给代理的构造函数、属性、操作甚至是监听器。

        创建了 ModelMBeanInfo 对象后，需要将其与 ModelMBean 对象关联。目前有两种方式可以做到这一点：

        1） 传入 ModelMBeanInfo 对象给 RequiredModelMBean 对象的构造函数。

        2） 调用 RequiredModelMBean 对象的 setModelMBeanInfo 方法。

        创建了 ModelMBean 对象后，需要调用 ModelMBean 接口的 setManagedResource() 方法将其与托管资源关联。该方法如下：

         public void setManagedResource(Object managedResource, String managedResourceType) ;

        managedResourceType 的值可以为 ObjectReference、Handle、IOR、EJBHandle 或 RMIReference，但当前只支持 ObjectReference。

ModelMBeanInfoSupport 类

        ModelMBeanInfo 接口的默认实现。该类的构造函数如下：

        public ModelMBeanInfoSupport(String className, String description, ModelMBeanAttributeInfo[] attributes, ModelMBeanConstructorInfo[] constructors, ModelMBeanOperationInfo[] operations, ModelMBeanNotificationInfo[] notifications);

        我们接下来介绍参数中出现的几个类。

ModelMBeanAttributeInfo 类

        模型 MBean 的属性信息。可以通过如下构造函数构造：

        public ModelMBeanAttributeInfo(String name, String type, String description, boolean isReadable, boolean isWritable, boolean isIs, Descriptor descriptor);

ModelMBeanConstructorInfo 类

ModelMBeanOperationInfo 类

        构造函数如下：

        public ModelMBeanOperationInfo(String name, String description, MBeanParameterInfo[] signature, String type, int impact, Descriptor descriptor);

ModelMBeanNotificationInfo 类

6.2 模型 MBean 示例

        我们需要使用模型 MBean 管理如下所示的 Car 对象：

[java]  view plain  copy

1. package test;  
2.   
3. public class Car implements CarMBean{  
4.     private String color = "red";  
5.       
6.     public String getColor(){  
7.         return color;  
8.     }  
9.     public void setColor(String color){  
10.         this.color = color;  
11.     }  
12.     public void drive(){  
13.         System.out.println("Baby you can drive my car.");  
14.     }  
15. }  

        对于模型 MBean，不需要像使用标准 MBean 那样自己编写接口并使 Car 继承该接口，而只需实例化 RequiredMBean 类即可。如下的 ModelAgent 类用来创建 ModelMbean 用于管理 Car 对象。

[java]  view plain  copy

1. package test;  
2.   
3. import javax.management.Attribute;  
4. import javax.management.Descriptor;  
5. import javax.management.MBeanOperationInfo;  
6. import javax.management.MBeanParameterInfo;  
7. import javax.management.MBeanServer;  
8. import javax.management.MBeanServerFactory;  
9. import javax.management.MalformedObjectNameException;  
10. import javax.management.ObjectName;  
11. import javax.management.modelmbean.DescriptorSupport;  
12. import javax.management.modelmbean.ModelMBean;  
13. import javax.management.modelmbean.ModelMBeanAttributeInfo;  
14. import javax.management.modelmbean.ModelMBeanInfo;  
15. import javax.management.modelmbean.ModelMBeanInfoSupport;  
16. import javax.management.modelmbean.ModelMBeanOperationInfo;  
17. import javax.management.modelmbean.RequiredModelMBean;  
18.   
19. public class ModelAgent {  
20.     private String MANAGED_CLASS_NAME = "test.Car";  
21.     private MBeanServer mBeanServer = null;  
22.       
23.     public ModelAgent(){  
24.         mBeanServer = MBeanServerFactory.createMBeanServer();  
25.     }  
26.       
27.     public MBeanServer getMBeanServer(){  
28.         return mBeanServer;  
29.     }  
30.       
31.     private ObjectName createObjectName(String name){  
32.         ObjectName objectName = null;  
33.         try{  
34.             objectName = new ObjectName(name);  
35.         }catch(MalformedObjectNameException e){  
36.             e.printStackTrace();  
37.         }  
38.         return objectName;  
39.     }  
40.       
41.     private ModelMBean createMBean(ObjectName objectName, String mbeanName){  
42.         ModelMBeanInfo mBeanInfo = createModelMBeanInfo(objectName, mbeanName);  
43.         RequiredModelMBean modelMBean = null;  
44.         try{  
45.             modelMBean = new RequiredModelMBean(mBeanInfo);  
46.         }catch(Exception e){  
47.             e.printStackTrace();  
48.         }  
49.         return modelMBean;  
50.     }  
51.       
52.     private ModelMBeanInfo createModelMBeanInfo(ObjectName inMbeanObjectName, String inMbeanName){  
53.         ModelMBeanInfo mBeanInfo = null;  
54.         ModelMBeanAttributeInfo[] attributes = new ModelMBeanAttributeInfo[1];  
55.         ModelMBeanOperationInfo[] operations = new ModelMBeanOperationInfo[3];  
56.         try{  
57.             attributes[0] = new ModelMBeanAttributeInfo("Color", "java.lang.String", "the color.", true, true, false, null);  
58.             operations[0] = new ModelMBeanOperationInfo("drive", "the drive method", null, "void", MBeanOperationInfo.ACTION, null);  
59.             operations[1] = new ModelMBeanOperationInfo("getColor", "get color attribute", null, "java.lang.String", MBeanOperationInfo.ACTION, null);  
60.             Descriptor setColorDesc = new DescriptorSupport(new String[]{  
61.                     "name=setColor", "descriptorType=operation", "class="+MANAGED_CLASS_NAME, "role=operation"  
62.             });  
63.             MBeanParameterInfo[] setColorParams = new MBeanParameterInfo[]{  
64.                 (new MBeanParameterInfo("new color", "java.lang.String", "new Color value"))      
65.             };  
66.             operations[2] = new ModelMBeanOperationInfo("setColor", "set Color attribute", setColorParams, "void", MBeanOperationInfo.ACTION, setColorDesc);  
67.             mBeanInfo = new ModelMBeanInfoSupport(MANAGED_CLASS_NAME, null, attributes, null, operations, null);  
68.         }catch(Exception e){  
69.             e.printStackTrace();  
70.         }  
71.         return mBeanInfo;  
72.     }  
73.       
74.     public static void main(String[] args){  
75.         ModelAgent agent = new ModelAgent();  
76.         MBeanServer mBeanServer = agent.getMBeanServer();  
77.         Car car = new Car();  
78.         String domain = mBeanServer.getDefaultDomain();  
79.         ObjectName objectName = agent.createObjectName(domain+":type=MyCar");  
80.         String mBeanName = "myBean";  
81.         ModelMBean modelMBean = agent.createMBean(objectName, mBeanName);  
82.         try{  
83.             //associate the Model MBean with our managed object  
84.             modelMBean.setManagedResource(car, "ObjectReference");  
85.             //register the model MBean to MBeanServer.  
86.             mBeanServer.registerMBean(modelMBean, objectName);  
87.         }catch(Exception e){}  
88.           
89.         try{  
90.             Attribute attribute = new Attribute("Color", "green");  
91.             mBeanServer.setAttribute(objectName, attribute);  
92.             String color = (String)mBeanServer.getAttribute(objectName, "Color");  
93.             System.out.println("Color:" + color);  
94.               
95.             attribute = new Attribute("Color", "blueeee");  
96.             mBeanServer.setAttribute(objectName, attribute);  
97.             color = (String)mBeanServer.getAttribute(objectName, "Color");  
98.             System.out.println("Color:" + color);  
99.               
100.             mBeanServer.invoke(objectName, "drive", null, null);  
101.         }catch(Exception e){  
102.             e.printStackTrace();  
103.         }  
104.     }  
105. }  

7. Apache 的 Commons Modeler 模型 MBean 库

        使用 Apache 的 Modeler 库创建 Model MBean 的最大帮助是，我们不需要再写复杂的代码来创建 ModelMBeanInfo 对象了。只需要一个 MBean 描述符来对模型 MBean 进行描述，就可以轻松的创建 Model MBean。

1. mbean descriptor (MBean 描述符）

        我们先看一个 MBean 描述符的例子：

[html]  view plain  copy

1. <mbean name="StandardServer"   
2.   className="org.apache.catalina.mbeans.StandardServerMBean"   
3.   description="Standard Server Component"  
4.   domain="Catalina"   
5.   group="Server"   
6.   type="org.apache.catalina.core.StandardServer">  
7.   
8.   <attribute name="debug"  
9.     description="The debugging detail level for this component"  
10.     type="int"/>  
11.   <attribute name="managedResource"  
12.     description="The managed resource this MBean is associated with"  
13.     type="java.lang.Object"/>  
14.   <attribute name="port"  
15.     description="TCP port for shutdown message"  
16.     type="int"/>  
17.   <attribute name="shutdown"  
18.     description="Shutdown password"  
19.     type="java.lang.String"/>  
20.   <operation name="store"  
21.     description="Save current state to server.xml"  
22.     impact="ACTION"  
23.     returnType="void">  
24.   </operation>  
25. </mbean>  

        上面所示代码生命了一个模型 MBean。这个 MBean 有以下特点：

        1） 它的唯一标识是 StandardServer。

        2） 该 MBean 是 StandardServerMBean 的一个对象。

        3） 它负责管理的对象是 org.apache.catalina.core.StandardServer 类的实例。

        4） domain 属性是 Catalina； group 属性石 Server

        5） 这个 MBean 有四个暴露属性： debug、managedResource、port、shutdown，另外还有一个暴露方法 store().

2. Tomcat Modeler 常用类介绍

Registry 类

ManagedBean 类

        对 Model MBean 的描述。

BaseModelMBean 类

        实现了 ModelMBean 接口。使用这个类就不需要 RequiredModelMBean 类了。另外，该类有一个比较有用的字段 resource。resource 字段标识该模型 MBean 管理的资源。如果在 MBean 描述符的声明中没有指定 className，则默认使用 BaseModelMBean。

3. 使用 Tomcat Model 实现模型 MBean

        我们仍然使用对 Car 类进行管理的例子。

[java]  view plain  copy

1. package test;  
2.   
3. public class Car{  
4.     private String color = "red";  
5.       
6.     public Car(){  
7.         System.out.println("Car constructor");  
8.     }  
9.   
10.     public String getColor(){  
11.         return color;  
12.     }  
13.     public void setColor(String color){  
14.         this.color = color;  
15.     }  
16.     public void drive(){  
17.         System.out.println("Baby you can drive my car.");  
18.     }  
19. }  

我们的 MBean 描述符文件 mbeans-descriptors.xml 文件如下：

[html]  view plain  copy

1. <?xml version="1.0"?>  
2. <!DOCTYPE mbeans-descriptors PUBLIC  
3.   "-//Apache Software Foundation//DTD Model MBeans Configuration File"   
4.   "http://jakarta.apache.org/commons/dtds/mbeans-descriptors.dtd">  
5.   
6. <mbeans-descriptors>  
7.   <mbean name="myBean"  
8.     className="javax.management.modelmbean.RequiredModelMBean"  
9.     description="The ModelMBean that manages our Car object"  
10.     type="test.Car">  
11.     
12.     <attribute name="Color"  
13.       description="The car color"  
14.       type="java.lang.String"/>  
15.     <operation name="drive"  
16.       description="drive method"  
17.       impact="ACTION"  
18.       returnType="void">  
19.       <parameter name="driver" description="the driver parameter" type="java.lang.String"/>  
20.     </operation>  
21.   </mbean>  
22. </mbeans-descriptors>  

        代理类 ModelAgent.java 如下所示：