Tomcat7中的JMX使用（二）Dynamic MBean

 如上一篇文章所见Standard MBean在Tomcat的例子并不多，在jconsole中所看到的大量MBean（如Catalina下的Connector、Engine、Server、Service等），实际上是动态MBean（Dynamic MBean）。本文主要讲述Tomcat7中如何通过动态MBean的方式构造MBean的。

 

接触过动态MBean的朋友一定知道，它的实例肯定要实现一个接口，即javax.management.DynamicMBean。实现这个接口就意味着同时要实现它下面的6个方法：

Java代码  

1. public Object getAttribute(String attribute) throws AttributeNotFoundException,MBeanException, ReflectionException;   
2.   
3. public void setAttribute(Attribute attribute) throws AttributeNotFoundException,InvalidAttributeValueException, MBeanException, ReflectionException ;   
4.   
5. public AttributeList getAttributes(String[] attributes);  
6.   
7. public AttributeList setAttributes(AttributeList attributes);  
8.   
9. public Object invoke(String actionName, Object params[], String signature[]) throws MBeanException, ReflectionException ;      
10.   
11. public MBeanInfo getMBeanInfo();  

通过实现这个通用接口，jvm允许程序在运行时获取和设置MBean公开的属性和调用MBean上公开的方法。

 

上面简要介绍了动态MBean的实现方式，Tomcat中的实际情况比这个要复杂。因为要生成很多种MBean，如果每种类型都用代码写一个MBean就失去了动态MBean的威力，Tomcat7中实际是通过配置文件（即每个组件所在的包下面的mbeans-descriptors.xml）结合通用的动态MBean（org.apache.tomcat.util.modeler.BaseModelMBean）、描述MBean配置信息的org.apache.tomcat.util.modeler.ManagedBean来简化MBean的构造。（笔者注：实际就是用动态MBean实现了模型MBean的功能）

 

一般情况下动态MBean的产生分为两个阶段：一、加载org.apache.tomcat.util.modeler.ManagedBean对象，二、注册MBean实例。

 

1.加载org.apache.tomcat.util.modeler.ManagedBean对象

在Tomcat启动时加载的配置文件server.xml中有这么一行配置：

Xml代码  

1. <Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" />  

因此在Tomcat启动时将加载这个类，在这个类中有一个静态成员变量registry：

Java代码  

1. /** 
2.  * The configuration information registry for our managed beans. 
3.  */  
4. protected static Registry registry = MBeanUtils.createRegistry();  

也就是说类加载时registry就会获得Registry类的实例，这个Registry类很重要，在MBean的构造过程中将会多次涉及这个类里的方法。先看看MBeanUtils.createRegistry()方法：

Java代码  

1. /** 
2.  * Create and configure (if necessary) and return the registry of 
3.  * managed object descriptions. 
4.  */  
5. public static synchronized Registry createRegistry() {  
6.   
7.     if (registry == null) {  
8.         registry = Registry.getRegistry(null, null);  
9.         ClassLoader cl = MBeanUtils.class.getClassLoader();  
10.   
11.         registry.loadDescriptors("org.apache.catalina.mbeans",  cl);  
12.         registry.loadDescriptors("org.apache.catalina.authenticator", cl);  
13.         registry.loadDescriptors("org.apache.catalina.core", cl);  
14.         registry.loadDescriptors("org.apache.catalina", cl);  
15.         registry.loadDescriptors("org.apache.catalina.deploy", cl);  
16.         registry.loadDescriptors("org.apache.catalina.loader", cl);  
17.         registry.loadDescriptors("org.apache.catalina.realm", cl);  
18.         registry.loadDescriptors("org.apache.catalina.session", cl);  
19.         registry.loadDescriptors("org.apache.catalina.startup", cl);  
20.         registry.loadDescriptors("org.apache.catalina.users", cl);  
21.         registry.loadDescriptors("org.apache.catalina.ha", cl);  
22.         registry.loadDescriptors("org.apache.catalina.connector", cl);  
23.         registry.loadDescriptors("org.apache.catalina.valves",  cl);  
24.     }  
25.     return (registry);  
26.   
27. }  

注意第8行Registry.getRegistry(null, null)方法的调用，看下它的实现就会发现返回的实际是Registry类的静态变量，这种调用后面会多次看到。接着还需要看一下MBeanUtils类的registry的定义：

Java代码  

1. /** 
2.  * The configuration information registry for our managed beans. 
3.  */  
4. private static Registry registry = createRegistry();  

因为此时MBeanUtils类还没在JVM里面加载过，它的成员变量registry为null，所以会调用Registry.getRegistry(null, null)方法构造对象，接下来会多次调用loadDescriptors方法，以下面这一句代码为例：

Java代码  

1. registry.loadDescriptors("org.apache.catalina.connector", cl);  

这里org.apache.catalina.connector实际上是一个package的路径全名，看下loadDescriptors方法：

Java代码  

1. /** Lookup the component descriptor in the package and 
2.  * in the parent packages. 
3.  * 
4.  * @param packageName 
5.  */  
6. public void loadDescriptors( String packageName, ClassLoader classLoader  ) {  
7.     String res=packageName.replace( '.', '/');  
8.   
9.     if( log.isTraceEnabled() ) {  
10.         log.trace("Finding descriptor " + res );  
11.     }  
12.   
13.     if( searchedPaths.get( packageName ) != null ) {  
14.         return;  
15.     }  
16.     String descriptors=res + "/mbeans-descriptors.ser";  
17.   
18.     URL dURL=classLoader.getResource( descriptors );  
19.   
20.     if( dURL == null ) {  
21.         descriptors=res + "/mbeans-descriptors.xml";  
22.         dURL=classLoader.getResource( descriptors );  
23.     }  
24.     if( dURL == null ) {  
25.         return;  
26.     }  
27.   
28.     log.debug( "Found " + dURL);  
29.     searchedPaths.put( packageName,  dURL );  
30.     try {  
31.         if( descriptors.endsWith(".xml" ))  
32.             loadDescriptors("MbeansDescriptorsDigesterSource", dURL, null);  
33.         else  
34.             loadDescriptors("MbeansDescriptorsSerSource", dURL, null);  
35.         return;  
36.     } catch(Exception ex ) {  
37.         log.error("Error loading " + dURL);  
38.     }  
39.   
40.     return;  
41. }  

第13到15行是先在Registry类的缓存searchedPaths中查找是否已经加载了该package所对应的配置文件，如果没有在第16到18行会在该包路径下面查找是否有mbeans-descriptors.ser文件，没有则在第20到23行查找同路径下的mbeans-descriptors.xml文件。找到之后在第29行放入缓存searchedPaths。我们既然以org.apache.catalina.connector为例，则找到的是该路径下的mbeans-descriptors.xml。所以会接着执行第32行loadDescriptors("MbeansDescriptorsDigesterSource", dURL, null)：

Java代码  

1. private void loadDescriptors(String sourceType, Object source,  
2.         String param) throws Exception {  
3.     load(sourceType, source, param);  
4. }  

这段代码会执行load方法：

Java代码  

1. public List<ObjectName> load( String sourceType, Object source,  
2.         String param) throws Exception {  
3.     if( log.isTraceEnabled()) {  
4.         log.trace("load " + source );  
5.     }  
6.     String location=null;  
7.     String type=null;  
8.     Object inputsource=null;  
9.   
10.     if( source instanceof URL ) {  
11.         URL url=(URL)source;  
12.         location=url.toString();  
13.         type=param;  
14.         inputsource=url.openStream();  
15.         if( sourceType == null ) {  
16.             sourceType = sourceTypeFromExt(location);  
17.         }  
18.     } else if( source instanceof File ) {  
19.         location=((File)source).getAbsolutePath();  
20.         inputsource=new FileInputStream((File)source);              
21.         type=param;  
22.         if( sourceType == null ) {  
23.             sourceType = sourceTypeFromExt(location);  
24.         }  
25.     } else if( source instanceof InputStream ) {  
26.         type=param;  
27.         inputsource=source;  
28.     } else if( source instanceof Class<?> ) {  
29.         location=((Class<?>)source).getName();  
30.         type=param;  
31.         inputsource=source;  
32.         if( sourceType== null ) {  
33.             sourceType="MbeansDescriptorsIntrospectionSource";  
34.         }  
35.     }  
36.       
37.     if( sourceType==null ) {  
38.         sourceType="MbeansDescriptorsDigesterSource";  
39.     }  
40.     ModelerSource ds=getModelerSource(sourceType);  
41.     List<ObjectName> mbeans =  
42.         ds.loadDescriptors(this, type, inputsource);  
43.   
44.     return mbeans;  
45. }  

第10到35行说穿是是为该方法适配多种数据源类型给inputsource变量赋上一个输入流。第40行会根据sourceType构造一个ModelerSource对象：

Java代码  

1. private ModelerSource getModelerSource( String type )  
2.         throws Exception  
3. {  
4.     if( type==null ) type="MbeansDescriptorsDigesterSource";  
5.     if( type.indexOf( ".") < 0 ) {  
6.         type="org.apache.tomcat.util.modeler.modules." + type;  
7.     }  
8.   
9.     Class<?> c = Class.forName(type);  
10.     ModelerSource ds=(ModelerSource)c.newInstance();  
11.     return ds;  
12. }  

上面看到sourceType传入的值是"MbeansDescriptorsDigesterSource"。所以getModelerSource方法最后返回的是org.apache.tomcat.util.modeler.modules.MbeansDescriptorsDigesterSource类的一个实例。

最后执行该ModelerSource对象的loadDescriptors(this, type, inputsource) 方法，因为该方法是一个抽象方法，所以这里实际执行的org.apache.tomcat.util.modeler.modules.MbeansDescriptorsDigesterSource类的loadDescriptors方法：

Java代码  

1. @Override  
2. public List<ObjectName> loadDescriptors( Registry registry, String type,  
3.         Object source) throws Exception {  
4.     setRegistry(registry);  
5.     setType(type);  
6.     setSource(source);  
7.     execute();  
8.     return mbeans;  
9. }  

前三个set方法毋庸多言，关键是最后的execute方法：

Java代码  

1. public void execute() throws Exception {  
2.     if (registry == null) {  
3.         registry = Registry.getRegistry(null, null);  
4.     }  
5.   
6.     InputStream stream = (InputStream) source;  
7.   
8.     if (digester == null) {  
9.         digester = createDigester();  
10.     }  
11.     ArrayList<ManagedBean> loadedMbeans = new ArrayList<ManagedBean>();  
12.       
13.     synchronized (digester) {  
14.           
15.         // Process the input file to configure our registry  
16.         try {  
17.             // Push our registry object onto the stack  
18.             digester.push(loadedMbeans);  
19.             digester.parse(stream);  
20.         } catch (Exception e) {  
21.             log.error("Error digesting Registry data", e);  
22.             throw e;  
23.         } finally {  
24.             digester.reset();  
25.         }  
26.       
27.     }  
28.     Iterator<ManagedBean> iter = loadedMbeans.iterator();  
29.     while (iter.hasNext()) {  
30.         registry.addManagedBean(iter.next());  
31.     }  
32. }  

在第3行又看到了前面提到的Registry.getRegistry(null, null)方法，这里就是获取Registry的静态成员的引用。这段方法作用就是对source进行一次Digester解析，如果还不了解Digester解析，可以看看之前Tomcat源码分析的一篇文章： Tomcat7启动分析（三）Digester的使用。注意第18行digester的顶层对象是loadedMbeans，重点看下第9行createDigester()方法的调用：

Java代码  

1.    protected static Digester createDigester() {  
2.   
3.        Digester digester = new Digester();  
4.        digester.setNamespaceAware(false);  
5.        digester.setValidating(false);  
6.        URL url = Registry.getRegistry(null, null).getClass().getResource  
7.            ("/org/apache/tomcat/util/modeler/mbeans-descriptors.dtd");  
8.        digester.register  
9.            ("-//Apache Software Foundation//DTD Model MBeans Configuration File",  
10.                url.toString());  
11.          
12.        // Configure the parsing rules  
13.        digester.addObjectCreate  
14.            ("mbeans-descriptors/mbean",  
15.            "org.apache.tomcat.util.modeler.ManagedBean");  
16.        digester.addSetProperties  
17.            ("mbeans-descriptors/mbean");  
18.        digester.addSetNext  
19.            ("mbeans-descriptors/mbean",  
20.                "add",  
21.            "java.lang.Object");  
22.          
23.        digester.addObjectCreate  
24.            ("mbeans-descriptors/mbean/attribute",  
25.            "org.apache.tomcat.util.modeler.AttributeInfo");  
26.        digester.addSetProperties  
27.            ("mbeans-descriptors/mbean/attribute");  
28.        digester.addSetNext  
29.            ("mbeans-descriptors/mbean/attribute",  
30.                "addAttribute",  
31.            "org.apache.tomcat.util.modeler.AttributeInfo");  
32.               
33. ......  
34.          
35.        return digester;  
36.    }  

上面这段代码其实很长，但绝大部分都是模板代码，理解几句的含义后面代码都很相似。这就是一个xml文件的解析，第13到15行是值在碰到xml文件的mbeans-descriptors节点的子节点mbean时构造一个org.apache.tomcat.util.modeler.ManagedBean对象，第16到17行是读取该节点属性值填充到ManagedBean对象的pojo属性中，第18到21行以ManagedBean对象为入参调用上一段代码分析提到的loadedMbeans对象的add方法。类似的，第23到31行是指在碰到mbeans-descriptors/mbean/attribute节点时构造org.apache.tomcat.util.modeler.AttributeInfo对象，填充pojo属性，并调用父节点构造的对象（即ManagedBean对象）的addAttribute方法。其它代码类似，不再赘述。

 

接回到上面MbeansDescriptorsDigesterSource类的execute方法第28到31行，在Digester解析完成之后迭代loadedMbeans对象，并调用registry.addManagedBean方法将这些ManagedBean添加到registry中。这样，一次registry.loadDescriptors("org.apache.catalina.connector", cl)调用就会加载该包路径下相对应的ManagedBean对象到Registry类的成员变量中。

 

下面的时序图列出从GlobalResourcesLifecycleListener类加载其静态成员变量registry到Registry类加载完相应包所对应的ManagedBean的关键方法调用过程：

2.注册MBean实例

2.1.查找ManagedBean

上面说的是一个ManagedBean的加载过程，但它不是一个MBean，可以把它看作一个描述MBean的配置信息的对象，以前面提到的org.apache.catalina.connector为例，在Tomcat7的默认配置启动后实际上有两个Connector实例，因为在server.xml中配置了两条connector节点：

Xml代码  

1. <Connector port="8080" protocol="HTTP/1.1"  
2.            connectionTimeout="20000"  
3.            redirectPort="8443" />  
4.   
5.   
6. <Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />  

所对应jconsole中会看到两个相应的MBean对象：

但ManageBean实际只是加载了一次。了解了ManagedBean与MBean的对应关系，接下来看看一个MBean是怎么注册到JVM中的。

 

看过前面Tomcat启动分析的朋友知道容器各组件在启动过程中会相继调用它们的initInternal()、startInternal()两个方法，还是以上面提到的Connector组件为例，Tomcat启动时解析server.xml文件过程中碰到Connector节点配置会构造org.apache.catalina.connector.Connector对象并调用它的initInternal方法：

Java代码  

1. @Override  
2. protected void initInternal() throws LifecycleException {  
3.   
4.     super.initInternal();  

在这个方法的开始会调用它的父类org.apache.catalina.util.LifecycleMBeanBase的initInternal方法：

Java代码  

1. private ObjectName oname = null;  
2. protected MBeanServer mserver = null;  
3.   
4. /** 
5.  * Sub-classes wishing to perform additional initialization should override 
6.  * this method, ensuring that super.initInternal() is the first call in the 
7.  * overriding method. 
8.  */  
9. @Override  
10. protected void initInternal() throws LifecycleException {  
11.       
12.     // If oname is not null then registration has already happened via  
13.     // preRegister().  
14.     if (oname == null) {  
15.         mserver = Registry.getRegistry(null, null).getMBeanServer();  
16.           
17.         oname = register(this, getObjectNameKeyProperties());  
18.     }  
19. }  

先获取MBeanServer的实例，接着调用内部的register方法，将当前对象注册到MBeanServer中，看下register方法：

Java代码  

1. protected final ObjectName register(Object obj,  
2.         String objectNameKeyProperties) {  
3.       
4.     // Construct an object name with the right domain  
5.     StringBuilder name = new StringBuilder(getDomain());  
6.     name.append(':');  
7.     name.append(objectNameKeyProperties);  
8.   
9.     ObjectName on = null;  
10.   
11.     try {  
12.         on = new ObjectName(name.toString());  
13.           
14.         Registry.getRegistry(null, null).registerComponent(obj, on, null);  
15.     } catch (MalformedObjectNameException e) {  
16.         log.warn(sm.getString("lifecycleMBeanBase.registerFail", obj, name),  
17.                 e);  
18.     } catch (Exception e) {  
19.         log.warn(sm.getString("lifecycleMBeanBase.registerFail", obj, name),  
20.                 e);  
21.     }  
22.   
23.     return on;  
24. }  

重点是第14行调用Registry类的registerComponent方法来注册：

Java代码  

1. public void registerComponent(Object bean, ObjectName oname, String type)  
2.        throws Exception  
3. {  
4.     if( log.isDebugEnabled() ) {  
5.         log.debug( "Managed= "+ oname);  
6.     }  
7.   
8.     if( bean ==null ) {  
9.         log.error("Null component " + oname );  
10.         return;  
11.     }  
12.   
13.     try {  
14.         if( type==null ) {  
15.             type=bean.getClass().getName();  
16.         }  
17.   
18.         ManagedBean managed = findManagedBean(bean.getClass(), type);  
19.   
20.         // The real mbean is created and registered  
21.         DynamicMBean mbean = managed.createMBean(bean);  
22.   
23.         if(  getMBeanServer().isRegistered( oname )) {  
24.             if( log.isDebugEnabled()) {  
25.                 log.debug("Unregistering existing component " + oname );  
26.             }  
27.             getMBeanServer().unregisterMBean( oname );  
28.         }  
29.   
30.         getMBeanServer().registerMBean( mbean, oname);  
31.     } catch( Exception ex) {  
32.         log.error("Error registering " + oname, ex );  
33.         throw ex;  
34.     }  
35. }  

在第18行根据当前要注册的对象（即Connector对象）的类型查找ManagedBean，沿着这个方法追会发现依次调用了一堆同名的findManagedBean方法，一直到findManagedBean(String name)：

Java代码  

1. public ManagedBean findManagedBean(String name) {  
2.     // XXX Group ?? Use Group + Type  
3.     ManagedBean mb = descriptors.get(name);  
4.     if( mb==null )  
5.         mb = descriptorsByClass.get(name);  
6.     return mb;  
7. }  

这段代码意思是依次从Registry类的静态成员变量descriptors、descriptorsByClass中查找相应ManagedBean。那这两个HashMap是什么时候put值进去的呢？答案就在上一部分分析的最后加载ManagedBean时最终调用Registry类的addManagedBean方法：

Java代码  

1. public void addManagedBean(ManagedBean bean) {  
2.     // XXX Use group + name  
3.     descriptors.put(bean.getName(), bean);  
4.     if( bean.getType() != null ) {  
5.         descriptorsByClass.put( bean.getType(), bean );  
6.     }  
7. }  

2.2.创建DynamicMBean

在上面的registerComponent方法的第21行调用查找到的ManagedBean对象的createMBean方法来获取实际的DynamicMBean对象：

Java代码  

1. public DynamicMBean createMBean(Object instance)  
2.     throws InstanceNotFoundException,  
3.     MBeanException, RuntimeOperationsException {  
4.   
5.     BaseModelMBean mbean = null;  
6.   
7.     // Load the ModelMBean implementation class  
8.     if(getClassName().equals(BASE_MBEAN)) {  
9.         // Skip introspection  
10.         mbean = new BaseModelMBean();  
11.     } else {  
12.         Class<?> clazz = null;  
13.         Exception ex = null;  
14.         try {  
15.             clazz = Class.forName(getClassName());  
16.         } catch (Exception e) {  
17.         }  
18.         
19.         if( clazz==null ) {    
20.             try {  
21.                 ClassLoader cl= Thread.currentThread().getContextClassLoader();  
22.                 if ( cl != null)  
23.                     clazz= cl.loadClass(getClassName());  
24.             } catch (Exception e) {  
25.                 ex=e;  
26.             }  
27.         }  
28.   
29.         if( clazz==null) {   
30.             throw new MBeanException  
31.                 (ex, "Cannot load ModelMBean class " + getClassName());  
32.         }  
33.         try {  
34.             // Stupid - this will set the default minfo first....  
35.             mbean = (BaseModelMBean) clazz.newInstance();  
36.         } catch (RuntimeOperationsException e) {  
37.             throw e;  
38.         } catch (Exception e) {  
39.             throw new MBeanException  
40.                 (e, "Cannot instantiate ModelMBean of class " +  
41.                  getClassName());  
42.         }  
43.     }  
44.       
45.     mbean.setManagedBean(this);  
46.       
47.     // Set the managed resource (if any)  
48.     try {  
49.         if (instance != null)  
50.             mbean.setManagedResource(instance, "ObjectReference");  
51.     } catch (InstanceNotFoundException e) {  
52.         throw e;  
53.     }  
54.     return (mbean);  
55.   
56. }  

这段代码看起来长，仔细分析实际就是根据ManagedBean对象的getClassName方法返回的值通过反射等方式来构造一个对象返回。而getClassName方法调用的实际就是第1部分提到的Digester解析时构造ManagedBean对象时自动从xml文件中读取并填充的pojo属性className，以现在所说的Connector为例，在mbeans-descriptors.xml中的配置：

Xml代码  

1. <mbean         name="CoyoteConnector"  
2.           className="org.apache.catalina.mbeans.ConnectorMBean"  
3.         description="Implementation of a Coyote connector"  
4.              domain="Catalina"  
5.               group="Connector"  
6.                type="org.apache.catalina.connector.Connector">  

所以此时构造返回的是一个org.apache.catalina.mbeans.ConnectorMBean对象。可以看到这个类的继承关系，它的父类是org.apache.catalina.mbeans.ClassNameMBean，它父类的父类就是org.apache.tomcat.util.modeler.BaseModelMBean，从这三种类中可以分别看到通常的动态MBean要实现的6个方法的定义，有兴趣的可以继续研究这些方法的实现，实际上它们都用到了什么所说的ManagedBean对象的相关方法，因为与该MBean要暴露的方法、操作的描述信息都是在加载相应的ManagedBean对象时读取的，所以动态MBean的实现必然也是需要调用它们的。

 

2.3.注册DynamicMBean

在上面的registerComponent方法的第30行getMBeanServer().registerMBean( mbean, oname)，这就是将该DynamicMBean对象注册到MBeanServer中。

 

下面的时序图列出从Connector的initInternal方法到注册MBean的关键方法调用过程：