jmx+spring学习

转自:http://blog.csdn.net/shirdrn/article/details/6358688

 

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

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

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

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

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

 

标准MBean管理

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

 

  1. package org.shirdrn.spring.jmx.autodetect;  
  2.   
  3. public interface MyObjectMBean {  
  4.     public long getId();  
  5.     public void setId(long id);  
  6.     public String getName();  
  7.     public void setName(String name);  
  8.     public String show();  
  9. }  

 

对应的MBean实现,如下所示:

 

  1. package org.shirdrn.spring.jmx.autodetect;  
  2.   
  3. import org.apache.log4j.Logger;  
  4.   
  5. public class MyObject implements MyObjectMBean {  
  6.       
  7.     private static final Logger LOG = Logger.getLogger(MyObject.class);  
  8.     private long id;  
  9.     private String name;  
  10.       
  11.     public MyObject() {  
  12.         super();  
  13.     }  
  14.       
  15.     public MyObject(long id, String name) {  
  16.         super();  
  17.         this.id = id;  
  18.         this.name = name;  
  19.     }  
  20.   
  21.     public long getId() {  
  22.         return id;  
  23.     }  
  24.   
  25.     public void setId(long id) {  
  26.         this.id = id;  
  27.     }  
  28.   
  29.     public String getName() {  
  30.         return name;  
  31.     }  
  32.   
  33.     public void setName(String name) {  
  34.         this.name = name;  
  35.     }  
  36.   
  37.     public String show() {  
  38.         StringBuffer sb = new StringBuffer().append("id=").append(id).append(  
  39.                 ", name=").append(name);  
  40.         LOG.info("show()=" + sb.toString());  
  41.         return sb.toString();  
  42.     }  
  43. }  

 

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

 

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans  
  3.     xmlns="http://www.springframework.org/schema/beans"  
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">  
  6.     <bean id="mbServer" class="org.springframework.jmx.export.MBeanExporter">  
  7.         <property name="autodetectModeName">  
  8.             <value>AUTODETECT_ALL</value>  
  9.         </property>  
  10.     </bean>  
  11.     <bean name="mydomain:myobj=MyObjectMBean" class="org.shirdrn.spring.jmx.autodetect.MyObject">  
  12.         <property name="id">  
  13.             <value>90000000001</value>  
  14.         </property>  
  15.         <property name="name">  
  16.             <value>shirdrn</value>  
  17.         </property>  
  18.     </bean>  
  19. </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类:

 

  1. package org.shirdrn.spring.jmx;  
  2.   
  3. import org.apache.log4j.Logger;  
  4.   
  5. public class MyJavaObject {  
  6.   
  7.     private static final Logger LOG = Logger.getLogger(MyJavaObject.class);  
  8.     private long id;  
  9.     private String name;  
  10.   
  11.     public MyJavaObject() {  
  12.         super();  
  13.     }  
  14.   
  15.     public MyJavaObject(long id, String name) {  
  16.         super();  
  17.         this.id = id;  
  18.         this.name = name;  
  19.     }  
  20.   
  21.     public long getId() {  
  22.         return id;  
  23.     }  
  24.   
  25.     public void setId(long id) {  
  26.         this.id = id;  
  27.     }  
  28.   
  29.     public String getName() {  
  30.         return name;  
  31.     }  
  32.   
  33.     public void setName(String name) {  
  34.         this.name = name;  
  35.     }  
  36.   
  37.     public String show() {  
  38.         StringBuffer sb = new StringBuffer().append("id=").append(id).append(  
  39.                 ", name=").append(name);  
  40.         LOG.info("show()=" + sb.toString());  
  41.         return sb.toString();  
  42.     }  
  43. }  

 

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

 

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans  
  3.     xmlns="http://www.springframework.org/schema/beans"  
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">  
  6.     <bean id="mbServer" class="org.springframework.jmx.export.MBeanExporter">  
  7.         <property name="beans">  
  8.             <map>  
  9.                 <entry key="mydomain:myjavaobj=MyJavaObject" value-ref="myobj"/>  
  10.             </map>  
  11.         </property>  
  12.     </bean>  
  13.     <bean name="myobj" class="org.shirdrn.spring.jmx.MyJavaObject">  
  14.         <property name="id">  
  15.             <value>90000000001</value>  
  16.         </property>  
  17.         <property name="name">  
  18.             <value>shirdrn</value>  
  19.         </property>  
  20.     </bean>  
  21. </beans>  

 

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

 

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

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

 

  1. <bean id="assembler" class="org.springframework.jmx.export.assembler.MethodNameBasedMBeanInfoAssembler">  
  2.     <property name="managedMethods"  value="setId,setName,show" />  
  3. </bean>  

 

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

 

  1. package org.shirdrn.spring.jmx.selected.interfaces;  
  2.   
  3. public interface SelectedMethodsInterface {  
  4.     public long setId(long id);  
  5.     public void setName(String name);  
  6.     public void show();  
  7. }  

 

Spring配置,如下所示:

 

  1. <bean id="assembler" class="org.springframework.jmx.export.assembler.InterfaceBasedMBeanInfoAssembler">  
  2.     <property name="managedInterfaces">  
  3.         <list>  
  4.             <value>org.shirdrn.spring.jmx.selected.interfaces.SelectedMethodsInterface</value>  
  5.         </list>  
  6.     </property>  
  7. </bean>  

 

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

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

 

  1. <bean id="exporter" class="org.springframework.jmx.export.MBeanExporter">  
  2.     <property name="beans">  
  3.         <map>  
  4.             <entry key="mydomain:javaObj=MyJavaObject" value-ref="javaObject" />  
  5.         </map>  
  6.     </property>  
  7.     <property name="assembler" ref="assembler" />  
  8. </bean>  

 

 

基于注解的MBean管理

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

 

  1. package org.shirdrn.spring.jmx.annotation;  
  2.   
  3. import org.apache.log4j.Logger;  
  4. import org.springframework.jmx.export.annotation.ManagedAttribute;  
  5. import org.springframework.jmx.export.annotation.ManagedOperation;  
  6. import org.springframework.jmx.export.annotation.ManagedResource;  
  7.   
  8. @ManagedResource(objectName = "annojmx:myjao=AnnotationObject", description = "MyJavaAnnotationObject")  
  9. public class MyJavaAnnotationObject {  
  10.       
  11.     private static final Logger LOG = Logger.getLogger(MyJavaAnnotationObject.class);  
  12.     private long id;  
  13.     private String name;  
  14.   
  15.     public MyJavaAnnotationObject() {  
  16.         super();  
  17.     }  
  18.   
  19.     public MyJavaAnnotationObject(long id, String name) {  
  20.         super();  
  21.         this.id = id;  
  22.         this.name = name;  
  23.     }  
  24.   
  25.     @ManagedAttribute  
  26.     public long getId() {  
  27.         return id;  
  28.     }  
  29.   
  30.     public void setId(long id) {  
  31.         this.id = id;  
  32.     }  
  33.   
  34.     public String getName() {  
  35.         return name;  
  36.     }  
  37.   
  38.     @ManagedAttribute  
  39.     public void setName(String name) {  
  40.         this.name = name;  
  41.     }  
  42.   
  43.     @ManagedOperation  
  44.     public String show() {  
  45.         StringBuffer sb = new StringBuffer().append("id=").append(id).append(  
  46.                 ", name=").append(name);  
  47.         LOG.info("show()=" + sb.toString());  
  48.         return sb.toString();  
  49.     }  
  50. }  

 

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

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

 

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"  
  4.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">  
  5.     <bean id="exporter" class="org.springframework.jmx.export.MBeanExporter">  
  6.         <property name="assembler" ref="assembler" />  
  7.         <property name="namingStrategy" ref="namingStrategy" />  
  8.     </bean>  
  9.     <bean id="assembler"  
  10.         class="org.springframework.jmx.export.assembler.MetadataMBeanInfoAssembler">  
  11.         <property name="attributeSource" ref="jmxas" />  
  12.     </bean>  
  13.     <bean id="namingStrategy"  
  14.         class="org.springframework.jmx.export.naming.MetadataNamingStrategy">  
  15.         <property name="attributeSource" ref="jmxas" />  
  16.     </bean>  
  17.     <bean id="jmxas" class="org.springframework.jmx.export.annotation.AnnotationJmxAttributeSource" />  
  18.     <bean id="javaObj"  
  19.         class="org.shirdrn.spring.jmx.annotation.MyJavaAnnotationObject">  
  20.         <property name="id" value="201122121200" />  
  21.         <property name="name" value="shirdrn" />  
  22.     </bean>  
  23. </beans>  

 

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

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

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

 

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"  
  4.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">  
  5.     <bean class="org.springframework.jmx.export.annotation.AnnotationMBeanExporter"/>  
  6.     <bean name="myAnnoObject"  
  7.         class="org.shirdrn.spring.jmx.annotation.MyJavaAnnotationObject">  
  8.         <property name="id" value="201122121200" />  
  9.         <property name="name" value="shirdrn" />  
  10.     </bean>  
  11. </beans>  

 

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

 

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"  
  4.     xsi:schemaLocation="http://www.springframework.org/schema/beans   
  5.         http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
  6.         http://www.springframework.org/schema/context   
  7.         http://www.springframework.org/schema/context/spring-context-2.5.xsd">  
  8.     <context:mbean-export registration="failOnExisting" />  
  9.     <bean name="myAnnoObject"  
  10.         class="org.shirdrn.spring.jmx.annotation.MyJavaAnnotationObject">  
  11.         <property name="id" value="201122121200" />  
  12.         <property name="name" value="shirdrn" />  
  13.     </bean>  
  14. </beans>  

 

 

通过远程代理访问MBean

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

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

 

  1. package org.shirdrn.spring.jmx.rmi;  
  2.   
  3. import org.apache.log4j.Logger;  
  4.   
  5. public class MyJavaObject {  
  6.       
  7.     private static final Logger LOG = Logger.getLogger(MyJavaObject.class);  
  8.     private long id;  
  9.     private String name;  
  10.   
  11.     public MyJavaObject() {  
  12.         super();  
  13.     }  
  14.   
  15.     public MyJavaObject(long id, String name) {  
  16.         super();  
  17.         this.id = id;  
  18.         this.name = name;  
  19.     }  
  20.   
  21.     public long getId() {  
  22.         return id;  
  23.     }  
  24.   
  25.     public void setId(long id) {  
  26.         this.id = id;  
  27.     }  
  28.   
  29.     public String getName() {  
  30.         return name;  
  31.     }  
  32.   
  33.     public void setName(String name) {  
  34.         this.name = name;  
  35.     }  
  36.   
  37.     public String show() {  
  38.         StringBuffer sb = new StringBuffer().append("id=").append(id).append(  
  39.                 ", name=").append(name);  
  40.         LOG.info("show()=" + sb.toString());  
  41.         return sb.toString();  
  42.     }  
  43. }  

 

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

 

  1. package org.shirdrn.spring.jmx.rmi;  
  2.   
  3. public interface MyManagedInterfaces {  
  4.     public long setId(long id);  
  5.     public String getName();  
  6.     public String show();  
  7. }  

 

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

 

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">  
  5.     <bean id="exporter" class="org.springframework.jmx.export.MBeanExporter">  
  6.         <property name="beans">  
  7.             <map>  
  8.                 <entry key="mydomain:myjavaobj=MyJavaObject" value-ref="myJavaObj" />  
  9.             </map>  
  10.         </property>  
  11.         <property name="assembler" ref="assembler" />  
  12.     </bean>  
  13.     <bean id="assembler"  
  14.         class="org.springframework.jmx.export.assembler.InterfaceBasedMBeanInfoAssembler">  
  15.         <property name="managedInterfaces">  
  16.             <list>  
  17.                 <value>org.shirdrn.spring.jmx.rmi.MyManagedInterfaces</value>  
  18.             </list>  
  19.         </property>  
  20.     </bean>     
  21.     <bean name="myJavaObj" class="org.shirdrn.spring.jmx.rmi.MyJavaObject">  
  22.         <property name="id" value="88000000001" />  
  23.         <property name="name" value="shirdrn" />  
  24.     </bean>  
  25.     <bean id="server" class="org.springframework.jmx.support.ConnectorServerFactoryBean" depends-on="registry">  
  26.         <property name="objectName">  
  27.             <value>connector:name=rmi</value>  
  28.         </property>  
  29.         <property name="serviceUrl">  
  30.             <value>service:jmx:rmi://localhost/jndi/rmi://localhost:1099/jmxrmi</value>  
  31.         </property>  
  32.     </bean>  
  33.     <bean id="registry" class="org.springframework.remoting.rmi.RmiRegistryFactoryBean">  
  34.         <property name="port">  
  35.             <value>1099</value>  
  36.         </property>  
  37.     </bean>  
  38. </beans>  

 

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

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

(ClassPathXmlApplicationContext contextnew ClassPathXmlApplicationContext("com/jmx/spring/server.xml");  该句启动容器服务,此时在window任务管理器中将产生一个javaw.exe进程,通过context.clost()可以关闭javaw.exe进程)

  1. package org.shirdrn.spring.jmx.rmi;  
  2.   
  3. import org.apache.log4j.Logger;  
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  5.   
  6. public class Server {  
  7.       
  8.     private static final Logger LOG = Logger.getLogger(Server.class);  
  9.       
  10.     public static void main(String[] args) throws Exception {  
  11.         new ClassPathXmlApplicationContext("org/shirdrn/spring/jmx/rmi/server.xml");  
  12.         LOG.info("Server started.");  
  13.           
  14.         Object lock = new Object();  
  15.         synchronized (lock) {  
  16.             lock.wait();  
  17.         }  
  18.     }  
  19. }  

 

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

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

 

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">  
  5.     <bean id="proxy" class="org.springframework.jmx.access.MBeanProxyFactoryBean">  
  6.         <property name="connectOnStartup" value="true" />  
  7.         <property name="objectName" value="mydomain:myjavaobj=MyJavaObject" />  
  8.         <property name="proxyInterface">  
  9.             <value>org.shirdrn.spring.jmx.rmi.MyManagedInterfaces</value>  
  10.         </property>  
  11.         <property name="serviceUrl">  
  12.             <value>service:jmx:rmi://localhost/jndi/rmi://localhost:1099/jmxrmi</value>  
  13.         </property>  
  14.     </bean>  
  15. </beans>  

 

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

 

  1. package org.shirdrn.spring.jmx.rmi;  
  2.   
  3. import org.apache.log4j.Logger;  
  4. import org.springframework.context.ApplicationContext;  
  5. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  6.   
  7. public class Proxy {  
  8.       
  9.     private static final Logger LOG = Logger.getLogger(Proxy.class);  
  10.       
  11.     public static void main(String[] args) throws Exception {  
  12.         ApplicationContext ctx = new ClassPathXmlApplicationContext(  
  13.                 "org/shirdrn/spring/jmx/rmi/proxy.xml");  
  14.         LOG.info("Proxy server started.");  
  15.         MyManagedInterfaces proxy = (MyManagedInterfaces) ctx.getBean("proxy");  
  16.         String message = proxy.show();  
  17.         LOG.info("proxy.show() = " + message);  
  18.           
  19.         Object lock = new Object();  
  20.         synchronized (lock) {  
  21.             lock.wait();  
  22.         }  
  23.     }  
  24. }  

 

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

 

附:

spring中关于jmx包括几个概念: 
MBeanExporter: 从字面上很容易理解, 用来将一些spring的bean作为MBean暴露给MBEanServer. 
MBeanServerFactoryBean: 也可以在spring中作为一个spring bean注入, 它用来将外部或者当前机器上的MBeanServer包装成一个bean 
MBeanInfoAssembler : 用来控制作为MBean的spring bean的哪些属性或方法将暴露出去,  以及决定何种形式的bean会被暴露成MBean. 不同的实现有不同的暴露方式. 
ObjectNamingStrategy : 用来控制作为MBean暴露出去的spring bean在MBeanServer中将如何命名(ObjectName), 描述, 指定初始值等, ObjectName通常采用"域:键=值,键=值,...". 
ConnectorServerFactoryBean : 用来给外界访问当前spring中的MBeanServer bean提供一个连接器, 也就是给MBeanServer开一个外加访问的口子, 比如"service:jmx:jmxmp://localhost:9875" 让外界通过jmxmp协议, 通过9875端口来访问MBeanServer, 外界要访问MBeanServer, 必须提供一个connector. 默认连接器是jmxmp协议service:jmx:jmxmp://localhost:9875 , 也可以通过其他协议的连接器, 比如协议RMI,IIOP, Burlap,Hessian,SOAP 
MBeanServerConnectionFactoryBean: 用来创建一个访问MBeanServer的客户端连接器, 比如MBeanServer bean暴露了一个服务器端连接器, 那么客户端就可以通过这个连接器来访问MBeanServer中的MBean. 可以理解为ConnectorServerFactoryBean的对应物, server与client之间就是这两种连接器建立通讯连接 
MBeanProxyFactoryBean: 用来创建客户端访问远程MBeanServer中的MBean的代理, 客户端要访问服务器端的bean, 除了客户端连接器之外, 还需要一个代理, 相当于一个服务器端的stub. 

 

你可能感兴趣的:(spring)