Spring与JMX集成

Spring与JMX集成，实现方式灵活而且简单，主要体现在：

1、可以自动探测实现MBean接口的MBean对象，而且可以将一个普通的Spring Bean注册为MBean；

2、定制管理MBean的接口，根据需要暴露特定管理MBean的操作；

3、使用注解定义MBean管理接口；

4、可以实现对本地和远程MBean的代理。

标准MBean管理

对于实现标准MBean接口MBean资源，在Spring中可以设置不同的探测模式，主要是通过MBeanExporter来实现。例如，定义MBean管理接口：

 packageorg.shirdrn.spring.jmx.autodetect;

 publicinterfaceMyObjectMBean{
 publiclonggetId();
 publicvoidsetId(longid);
 publicStringgetName();
 publicvoidsetName(Stringname);
 publicStringshow();
 }

对应的MBean实现，如下所示：

 packageorg.shirdrn.spring.jmx.autodetect;

 importorg.apache.log4j.Logger;

 publicclassMyObjectimplementsMyObjectMBean{

 privatestaticfinalLoggerLOG=Logger.getLogger(MyObject.class);
 privatelongid;
 privateStringname;

 publicMyObject(){
 super();
 }

 publicMyObject(longid,Stringname){
 super();
 this.id=id;
 this.name=name;
 }

 publiclonggetId(){
 returnid;
 }

 publicvoidsetId(longid){
 this.id=id;
 }

 publicStringgetName(){
 returnname;
 }

 publicvoidsetName(Stringname){
 this.name=name;
 }

 publicStringshow(){
 StringBuffersb=newStringBuffer().append("id=").append(id).append(
 ",name=").append(name);
 LOG.info("show()="+sb.toString());
 returnsb.toString();
 }
 }

上面是一个标准MBean的实现，可以使用JavaSE 6平台的JMX服务来管理，但是在Spring集成的环境下，也可以重用这些MBean实现，例如下面是一个典型的配置：

 <?xmlversion="1.0"encoding="UTF-8"?>
 <beans
 xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
 <beanid="mbServer"class="org.springframework.jmx.export.MBeanExporter">
 <propertyname="autodetectModeName">
 <value>AUTODETECT_ALL</value>
 </property>
 </bean>
 <beanname="mydomain:myobj=MyObjectMBean"class="org.shirdrn.spring.jmx.autodetect.MyObject">
 <propertyname="id">
 <value>90000000001</value>
 </property>
 <propertyname="name">
 <value>shirdrn</value>
 </property>
 </bean>
 </beans>

上面配置中，MBeanExporter会查找本地MBean Server，指定的探测模式autodetectModeName为AUTODETECT_ALL，这也是MBeanExporter的默认值（这个属性完全可以省略，不用配置），无需手动向MBean Server进行注册，便能管理配置的MBean对象“mydomain:myobj=MyObjectMBean”。

对于探测模式autodetectModeName属性，Spring提供了4个取值：

AUTODETECT_NONE 不启用自动探测，需要手动向MBean Server进行注册，即通过MBeanExporter的beans属性进入注册；

AUTODETECT_MBEAN 在当前IOC容器中进行查找MBean组件；

AUTODETECT_ASSEMBLER 设置根据MBeanInfoAssembler的策略进行探测；

AUTODETECT_ALL 自动探测，是AUTODETECT_MBEAN和AUTODETECT_ASSEMBLER的并集。

另外，Spring的MBeanExporter也提供了autodetect属性，取值为true和false，指定对MBean组件的探测行为。

普通Spring Bean管理

对于一个普通的Spring Bean，也可以作为MBean来进行管理，Spring可以很好地支持。如下面一个普通的Java类：

 packageorg.shirdrn.spring.jmx;

 importorg.apache.log4j.Logger;

 publicclassMyJavaObject{

 privatestaticfinalLoggerLOG=Logger.getLogger(MyJavaObject.class);
 privatelongid;
 privateStringname;

 publicMyJavaObject(){
 super();
 }

 publicMyJavaObject(longid,Stringname){
 super();
 this.id=id;
 this.name=name;
 }

 publiclonggetId(){
 returnid;
 }

 publicvoidsetId(longid){
 this.id=id;
 }

 publicStringgetName(){
 returnname;
 }

 publicvoidsetName(Stringname){
 this.name=name;
 }

 publicStringshow(){
 StringBuffersb=newStringBuffer().append("id=").append(id).append(
 ",name=").append(name);
 LOG.info("show()="+sb.toString());
 returnsb.toString();
 }
 }

它并没有实现MBean管理接口，可以通过MBeanExporter的beans属性进行注册，配置如下所示：

 <?xmlversion="1.0"encoding="UTF-8"?>
 <beans
 xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
 <beanid="mbServer"class="org.springframework.jmx.export.MBeanExporter">
 <propertyname="beans">
 <map>
 <entrykey="mydomain:myjavaobj=MyJavaObject"value-ref="myobj"/>
 </map>
 </property>
 </bean>
 <beanname="myobj"class="org.shirdrn.spring.jmx.MyJavaObject">
 <propertyname="id">
 <value>90000000001</value>
 </property>
 <propertyname="name">
 <value>shirdrn</value>
 </property>
 </bean>
 </beans>

因为org.shirdrn.spring.jmx.MyJavaObject没有对应的MBean接口，所以默认情况下，该类中public的成员都会暴露出来，通过MBeanServer可以管理。实际上，系统中MBean的某些属性或方法可能不需要暴露给外部进行管理，为了克服这种缺点，Spring提供了基于方法列表和接口定制的功能，可以将你所感兴趣的属性或方法暴露给外部管理。

基于方法列表和接口定制的MBean管理

对于上述普通的Java类MyJavaObject，可以通过定制接口和方法列表，来暴露MBean属性或方法。例如，一个方法列表，可以在进行配置的时候指定，如下所示：

 <beanid="assembler"class="org.springframework.jmx.export.assembler.MethodNameBasedMBeanInfoAssembler">
 <propertyname="managedMethods"value="setId,setName,show"/>
 </bean>

上面通过org.springframework.jmx.export.assembler.MethodNameBasedMBeanInfoAssembler来进行方法列表的设置。而对于接口，可以定义一个接口，如下所示：

 packageorg.shirdrn.spring.jmx.selected.interfaces;

 publicinterfaceSelectedMethodsInterface{
 publiclongsetId(longid);
 publicvoidsetName(Stringname);
 publicvoidshow();
 }

Spring配置，如下所示：

 <beanid="assembler"class="org.springframework.jmx.export.assembler.InterfaceBasedMBeanInfoAssembler">
 <propertyname="managedInterfaces">
 <list>
 <value>org.shirdrn.spring.jmx.selected.interfaces.SelectedMethodsInterface</value>
 </list>
 </property>
 </bean>

上面通过org.springframework.jmx.export.assembler.InterfaceBasedMBeanInfoAssembler，可以设置一个接口列表，来管理MBean暴露的接口。

对于上面两种方式，都得到一个assembler实例，需要将其注入到org.springframework.jmx.export.MBeanExporter中，如下所示：

 <beanid="exporter"class="org.springframework.jmx.export.MBeanExporter">
 <propertyname="beans">
 <map>
 <entrykey="mydomain:javaObj=MyJavaObject"value-ref="javaObject"/>
 </map>
 </property>
 <propertyname="assembler"ref="assembler"/>
 </bean>

基于注解的MBean管理

对于一个普通的Java类，作为MBean需要被管理，可以通过注解指定要暴露的属性和方法，示例如下：

 packageorg.shirdrn.spring.jmx.annotation;

 importorg.apache.log4j.Logger;
 importorg.springframework.jmx.export.annotation.ManagedAttribute;
 importorg.springframework.jmx.export.annotation.ManagedOperation;
 importorg.springframework.jmx.export.annotation.ManagedResource;

 @ManagedResource(objectName="annojmx:myjao=AnnotationObject",description="MyJavaAnnotationObject")
 publicclassMyJavaAnnotationObject{

 privatestaticfinalLoggerLOG=Logger.getLogger(MyJavaAnnotationObject.class);
 privatelongid;
 privateStringname;

 publicMyJavaAnnotationObject(){
 super();
 }

 publicMyJavaAnnotationObject(longid,Stringname){
 super();
 this.id=id;
 this.name=name;
 }

 @ManagedAttribute
 publiclonggetId(){
 returnid;
 }

 publicvoidsetId(longid){
 this.id=id;
 }

 publicStringgetName(){
 returnname;
 }

 @ManagedAttribute
 publicvoidsetName(Stringname){
 this.name=name;
 }

 @ManagedOperation
 publicStringshow(){
 StringBuffersb=newStringBuffer().append("id=").append(id).append(
 ",name=").append(name);
 LOG.info("show()="+sb.toString());
 returnsb.toString();
 }
 }

上面@ManagedResource表示指定该类的实例作为MBean注册到MBean Server中，然后可以通过对属性和方法分别使用@ManagedAttribute和@ManagedOperation来指定暴露的属性和方法。有关这些注解的详细内容，可以查阅相关文档。

下面是一个基本的配置内容：

 <?xmlversion="1.0"encoding="UTF-8"?>
 <beansxmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:p="http://www.springframework.org/schema/p"
 xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
 <beanid="exporter"class="org.springframework.jmx.export.MBeanExporter">
 <propertyname="assembler"ref="assembler"/>
 <propertyname="namingStrategy"ref="namingStrategy"/>
 </bean>
 <beanid="assembler"
 class="org.springframework.jmx.export.assembler.MetadataMBeanInfoAssembler">
 <propertyname="attributeSource"ref="jmxas"/>
 </bean>
 <beanid="namingStrategy"
 class="org.springframework.jmx.export.naming.MetadataNamingStrategy">
 <propertyname="attributeSource"ref="jmxas"/>
 </bean>
 <beanid="jmxas"class="org.springframework.jmx.export.annotation.AnnotationJmxAttributeSource"/>
 <beanid="javaObj"
 class="org.shirdrn.spring.jmx.annotation.MyJavaAnnotationObject">
 <propertyname="id"value="201122121200"/>
 <propertyname="name"value="shirdrn"/>
 </bean>
 </beans>

上面使用了Spring的MBeanExporter，可以看到，Spring配置内容相对较多。

Spring还提供两种简化配置的方式，

一种是，提供了org.springframework.jmx.export.annotation.AnnotationMBeanExporter，可以将上述配置大大简化，等价的配置如下所示：

 <?xmlversion="1.0"encoding="UTF-8"?>
 <beansxmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:p="http://www.springframework.org/schema/p"
 xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
 <beanclass="org.springframework.jmx.export.annotation.AnnotationMBeanExporter"/>
 <beanname="myAnnoObject"
 class="org.shirdrn.spring.jmx.annotation.MyJavaAnnotationObject">
 <propertyname="id"value="201122121200"/>
 <propertyname="name"value="shirdrn"/>
 </bean>
 </beans>

另一种是，提供了<context:mbean-export />标签，更加简洁，等价的配置如下所示：

 <?xmlversion="1.0"encoding="UTF-8"?>
 <beansxmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context-2.5.xsd">
 <context:mbean-exportregistration="failOnExisting"/>
 <beanname="myAnnoObject"
 class="org.shirdrn.spring.jmx.annotation.MyJavaAnnotationObject">
 <propertyname="id"value="201122121200"/>
 <propertyname="name"value="shirdrn"/>
 </bean>
 </beans>

通过远程代理访问MBean

根据JavaSE 6平台的JMX技术架构定义，分为设备层、代理层、远程管理层这三层，我们通过可以使用Spring提供的org.springframework.jmx.access.MBeanProxyFactoryBean实现，定义代理，来访问MBean Server管理MBean资源。实际上，Spring提供的这个代理功能位于JMX架构的远程管理层，那么在代理层和远程管理层之间，要定义连接器，才能通过远程管理层访问到代理层的MBean Server组件。下面通过实例来实现：

首先，定义个普通的Java类，作为待管理的MBean，如下所示：

 packageorg.shirdrn.spring.jmx.rmi;

 importorg.apache.log4j.Logger;

 publicclassMyJavaObject{

 privatestaticfinalLoggerLOG=Logger.getLogger(MyJavaObject.class);
 privatelongid;
 privateStringname;

 publicMyJavaObject(){
 super();
 }

 publicMyJavaObject(longid,Stringname){
 super();
 this.id=id;
 this.name=name;
 }

 publiclonggetId(){
 returnid;
 }

 publicvoidsetId(longid){
 this.id=id;
 }

 publicStringgetName(){
 returnname;
 }

 publicvoidsetName(Stringname){
 this.name=name;
 }

 publicStringshow(){
 StringBuffersb=newStringBuffer().append("id=").append(id).append(
 ",name=").append(name);
 LOG.info("show()="+sb.toString());
 returnsb.toString();
 }
 }

其次，定义了一个Java接口，来按需暴露操作MBean资源的方法：

 packageorg.shirdrn.spring.jmx.rmi;

 publicinterfaceMyManagedInterfaces{
 publiclongsetId(longid);
 publicStringgetName();
 publicStringshow();
 }

再次，看一下我们模拟代理层Spring配置server.xml内容：

 <?xmlversion="1.0"encoding="UTF-8"?>
 <beansxmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
 <beanid="exporter"class="org.springframework.jmx.export.MBeanExporter">
 <propertyname="beans">
 <map>
 <entrykey="mydomain:myjavaobj=MyJavaObject"value-ref="myJavaObj"/>
 </map>
 </property>
 <propertyname="assembler"ref="assembler"/>
 </bean>
 <beanid="assembler"
 class="org.springframework.jmx.export.assembler.InterfaceBasedMBeanInfoAssembler">
 <propertyname="managedInterfaces">
 <list>
 <value>org.shirdrn.spring.jmx.rmi.MyManagedInterfaces</value>
 </list>
 </property>
 </bean>
 <beanname="myJavaObj"class="org.shirdrn.spring.jmx.rmi.MyJavaObject">
 <propertyname="id"value="88000000001"/>
 <propertyname="name"value="shirdrn"/>
 </bean>
 <beanid="server"class="org.springframework.jmx.support.ConnectorServerFactoryBean"depends-on="registry">
 <propertyname="objectName">
 <value>connector:name=rmi</value>
 </property>
 <propertyname="serviceUrl">
 <value>service:jmx:rmi://localhost/jndi/rmi://localhost:1099/jmxrmi</value>
 </property>
 </bean>
 <beanid="registry"class="org.springframework.remoting.rmi.RmiRegistryFactoryBean">
 <propertyname="port">
 <value>1099</value>
 </property>
 </bean>
 </beans>

上半部分配置已经非常熟悉，就是将MBean注册到MBean Server中。下半部分是有关连接器的配置，它是基于RMI协议来进行适配，通过Spring提供的org.springframework.jmx.support.ConnectorServerFactoryBean来实现器，这样，远程管理层可以连接到启动的连接服务器，来访问MBean资源。

然后，我们启动MBean Server及其连接服务器，代码如下所示：

 packageorg.shirdrn.spring.jmx.rmi;

 importorg.apache.log4j.Logger;
 importorg.springframework.context.support.ClassPathXmlApplicationContext;

 publicclassServer{

 privatestaticfinalLoggerLOG=Logger.getLogger(Server.class);

 publicstaticvoidmain(String[]args)throwsException{
 newClassPathXmlApplicationContext("org/shirdrn/spring/jmx/rmi/server.xml");
 LOG.info("Serverstarted.");

 Objectlock=newObject();
 synchronized(lock){
 lock.wait();
 }
 }
 }

启动后，我们定义的MBean已经注册到本地MBean Server中，同时启动了连接器，监听1099端口。

接着，我们定义远程访问层的Spring配置proxy.xml内容，如下所示：

 <?xmlversion="1.0"encoding="UTF-8"?>
 <beansxmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
 <beanid="proxy"class="org.springframework.jmx.access.MBeanProxyFactoryBean">
 <propertyname="connectOnStartup"value="true"/>
 <propertyname="objectName"value="mydomain:myjavaobj=MyJavaObject"/>
 <propertyname="proxyInterface">
 <value>org.shirdrn.spring.jmx.rmi.MyManagedInterfaces</value>
 </property>
 <propertyname="serviceUrl">
 <value>service:jmx:rmi://localhost/jndi/rmi://localhost:1099/jmxrmi</value>
 </property>
 </bean>
 </beans>

最后，启动代理，访问MBean资源，代码如下所示：

 packageorg.shirdrn.spring.jmx.rmi;

 importorg.apache.log4j.Logger;
 importorg.springframework.context.ApplicationContext;
 importorg.springframework.context.support.ClassPathXmlApplicationContext;

 publicclassProxy{

 privatestaticfinalLoggerLOG=Logger.getLogger(Proxy.class);

 publicstaticvoidmain(String[]args)throwsException{
 ApplicationContextctx=newClassPathXmlApplicationContext(
 "org/shirdrn/spring/jmx/rmi/proxy.xml");
 LOG.info("Proxyserverstarted.");
 MyManagedInterfacesproxy=(MyManagedInterfaces)ctx.getBean("proxy");
 Stringmessage=proxy.show();
 LOG.info("proxy.show()="+message);

 Objectlock=newObject();
 synchronized(lock){
 lock.wait();
 }
 }
 }

这里，只能访问通过org.shirdrn.spring.jmx.rmi.MyManagedInterfaces接口定义的方法来操作注册到MBean Server中的MBean资源。