Tomcat源码阅读之JMX部分的设计与实现

在继续分析Tomcat的源码之前，先来分析一下Tomcat对JMX的支持，以及在Tomcat中的一些代码实现细节。。。

这里来看看Tomcat都通过JMX托管了那些对象吧：

嗯，从图上就可以看出，托管的东西还挺多的。。。其实感觉通过JMX这种方式还挺高端的，起码可以实现远程对Tomcat服务器的管理和配置。。。还挺方便的。。。

好啦，接下来就来看看Tomcat中是如何通过JMX来托管自己的对象的吧。。。

先来看一张比较重要的图：

这里是Tomcat中JMX部分比较重要的几个基本类型吧，首先是BaseModelMBean类型：

首先它实现了DynamicMBean接口，嗯，这个接口是啥呢？如果对JMX有稍微多一些了解的话，就会知道了，实现了这个接口，代表这个类型的对象可以被注册到MBServer上面去，这与前面的自己的一一篇文章里面介绍的注册到MBServer上面的对象少有不懂，Dynamic意味着这个对象是动态的，JMX通过调用一些方法可以动态的来获取这个对象的信息，它的属性，它暴露的方法什么的，以及进行动态的调用。。。这里具体的内容就不详细说了，去稍微了解一下JMX的部分就很容易明白了。。

另外它还是先了ModelMBeanNotificationBroadcaster，代表当前对象可以作为NotificationListener的容器，可以在这个对象里面添加listener，当当前托管的对象的属性发生改变了之后会通知这些注册的listener进行一些处理，例如写log啥的。。。

好啦，介绍完了BaseModelMBean类型，接下来来看看ManagedBean类型吧，它是干嘛的呢，刚开始这名字把我给糊弄了。。。。在介绍它之前先来看一段XML配置文件：

<mbeans-descriptors><mbean name="StandardServer" description="Standard Server Component" domain="Catalina" group="Server" type="org.apache.catalina.core.StandardServer"><attribute name="address" description="The address on which we wait for shutdown commands." type="java.lang.String"/><attribute name="managedResource" description="The managed resource this MBean is associated with" type="java.lang.Object"/><attribute name="port" description="TCP port for shutdown messages" type="int"/><attribute name="serverInfo" description="Tomcat server release identifier" type="java.lang.String" writeable="false"/><attribute name="serviceNames" description="Object names of all services we know about" type="[Ljavax.management.ObjectName;" writeable="false"/><attribute name="shutdown" description="Shutdown password" type="java.lang.String"/><attribute name="stateName" description="The name of the LifecycleState that this component is currently in" type="java.lang.String" writeable="false"/><operation name="await" description="Wait for the shutdown message" impact="ACTION" returnType="void"/><operation name="storeConfig" description="Save current state to server.xml file" impact="ACTION" returnType="void"></operation></mbean></mbeans-descriptors>

这个是在Tomcat代码中，core包里面的mbeans-descriptors.xml里面的内容，看内容就知道这个是对StanderServer对象的描述，例如属性，方法啥的。。。

那么这里就可以开始说ManagedBean是干啥的了，这里，一个<mbean></mbean>元素就会对应生成一个ManagedBean对象，用于保存和记录XML关于对象的描述。。。

好啦，到这里如果有一定基础的话就已经知道ManagedBean与BaseModelMBean之间的关系了，以及是如何运行的了。。

上图中还有一个MBean对象。。。那么它是干啥的呢。。？就拿StanderServer来举例子吧，

（1）首先Tomcat会通过读取刚刚说的xml文件，这些文件分散在Tomcat的许多源码包中

（2）通过里面元素的声明，创建相应的ManagedBean对象，用于维护这些信息。。

（3）当创建了一个StanderServer对象之后，会先找到它对应的ManagedBean对象，然后用这两个对象来生成相应的BaseModelMBean对象，然后将这个对象注册到MBServer上面去。。。

这样也就动态的将StanderServer通过XML文件的描述注册到了JMX上去，生成的BaseModelMBean对象通过调用StanderServer的ManagedBean对象，将需要的数据暴露给JMX就可以了。。。。

如下图：

可以看到这里暴露出来的属性以及方法与XML文件里面描述的是相同的。。。

这样一来，就算是基本上搞清楚了Tomcat如何通过xml文件来动态的生成对一些对象在JMX的动态注册。。

好了，有了上面的内容，接下来再来看看Tomcat中如何具体使用这些类型，这里就有两个重要的类型要介绍了：

首先是MBeanUtils类型，它是一个工具类，主要是进行一些初始化。。。。

我们来看他的两个重要的类属性：

    /**     * The configuration information registry for our managed beans.     */    private static Registry registry = createRegistry();  //创建registry对象    /**     * The <code>MBeanServer</code> for this application.     */    private static MBeanServer mserver = createServer();  //创建mbeanserver

这里首先创建了Registry对象，接着创建了MBeanServer对象，先来看看createRegistry方法吧：

    public static synchronized Registry createRegistry() {        if (registry == null) {            registry = Registry.getRegistry(null, null);   //这里会创建Registry对象            ClassLoader cl = MBeanUtils.class.getClassLoader();            //用当前的应用程序classLoader来家在这些包里面的mbeans xml，并且用Registry对象来加载这些文件里面定义的mbean，生成ManagedBean            //这里managedbean的作用是保存管理那些mbean的描述信息，待会用这些信息来构造属于这个mbean的DynamicMBean，然后保存在rregistry对象里面            registry.loadDescriptors("org.apache.catalina.mbeans",  cl);            registry.loadDescriptors("org.apache.catalina.authenticator", cl);            registry.loadDescriptors("org.apache.catalina.core", cl);            registry.loadDescriptors("org.apache.catalina", cl);            registry.loadDescriptors("org.apache.catalina.deploy", cl);            registry.loadDescriptors("org.apache.catalina.loader", cl);            registry.loadDescriptors("org.apache.catalina.realm", cl);            registry.loadDescriptors("org.apache.catalina.session", cl);            registry.loadDescriptors("org.apache.catalina.startup", cl);            registry.loadDescriptors("org.apache.catalina.users", cl);            registry.loadDescriptors("org.apache.catalina.ha", cl);            registry.loadDescriptors("org.apache.catalina.connector", cl);            registry.loadDescriptors("org.apache.catalina.valves",  cl);            registry.loadDescriptors("org.apache.catalina.storeconfig",  cl);            registry.loadDescriptors("org.apache.tomcat.util.descriptor.web",  cl);        }        return (registry);    }

这里其实做的事情首先由创建Registry对象，通过Registry类型的静态方法来创建的。。。接着做的事情其实分别加载下面的包里面的mbeans-descriptors.xml文件，然后创建相应的ManagedBean对象。。。。

    public static synchronized MBeanServer createServer() {        if (mserver == null) {            mserver = Registry.getRegistry(null, null).getMBeanServer();  //从registry对象中获取mbserver对象        }        return (mserver);    }

这里创建mbserver其实也是调用的Registry的静态方法来做的。。。

好了。。对于MBeanUtils类型，就先介绍到这里吧。。。

接下来来看看Registry的定义：

    private MBeanServer server = null;  //用于注册的mbserver    /**     * The set of ManagedBean instances for the beans this registry     * knows about, keyed by name.     */    private HashMap<String,ManagedBean> descriptors = new HashMap<>();  //key是定义的mbean的名字，value是生成的ManagedBean对象，他保存的有mbean的具体信息    /** List of managed beans, keyed by class name     */    private HashMap<String,ManagedBean> descriptorsByClass = new HashMap<>();  //其实key是className，value是为其生成的ManagedBean(mbean里面定义的type)    // map to avoid duplicated searching or loading descriptors    private HashMap<String,URL> searchedPaths = new HashMap<>();   //用于索引包里面的mbean xml ，key是包的名字

首先是比较重要的属性的定义，这里具体他们是干嘛用的后面的注释应该说的还蛮清楚的。。。

     //用于返回用到的Registry对象    public static synchronized Registry getRegistry(Object key, Object guard) {        Registry localRegistry;        if( perLoaderRegistries!=null ) {            if( key==null )                key=Thread.currentThread().getContextClassLoader();            if( key != null ) {                localRegistry = perLoaderRegistries.get(key);                if( localRegistry == null ) {                    localRegistry=new Registry();//                    localRegistry.key=key;                    localRegistry.guard=guard;                    perLoaderRegistries.put( key, localRegistry );                    return localRegistry;                }                if( localRegistry.guard != null &&                        localRegistry.guard != guard ) {                    return null; // XXX Should I throw a permission ex ?                }                return localRegistry;            }        }        // static        if (registry == null) {            registry = new Registry();        }        if( registry.guard != null &&                registry.guard != guard ) {            return null;        }        return (registry);    }

getRegistry方法，可以看到这里其实用了一个单例的Registry对象，

接下来我们来看一下最重要的Registry的registerComponent方法吧，它用于在mbserver上面注册对象：

    //注册一个组件    public void registerComponent(Object bean, ObjectName oname, String type)           throws Exception    {        if( log.isDebugEnabled() ) {            log.debug( "Managed= "+ oname);        }        if( bean ==null ) {            log.error("Null component " + oname );            return;        }        try {            if( type==null ) {  //如果没有名字，那么获取类型的名字                type=bean.getClass().getName();            }            ManagedBean managed = findManagedBean(null, bean.getClass(), type);  //获取这个对象所用的ManagedBean            // The real mbean is created and registered            DynamicMBean mbean = managed.createMBean(bean);  //通过ManagedBean创建一个DynamicMBean            if(  getMBeanServer().isRegistered( oname )) {                if( log.isDebugEnabled()) {                    log.debug("Unregistering existing component " + oname );                }                getMBeanServer().unregisterMBean( oname );  //如果这个已经注册了，那么取消这个名字的注册            }            getMBeanServer().registerMBean( mbean, oname);  //将刚刚创建的ManagedBean注册起来        } catch( Exception ex) {            log.error("Error registering " + oname, ex );            throw ex;        }    }

其实这里跟上面分析的内容是一直的，首先获取要注册对象的ManagedBean对象，然后通过它来创建一个DynamicMBean对象，这里一般都是BaseModelMBean类型的对象（有的时候可以通过在xml文件中指定，为对象创建其他的类型），然后在将刚刚创建的DynamicMBean对象注册到mbserver上面去。。。。

好啦，总的来说Tomcat这部分做的还挺好的，通过XML文件描述来动态的在mbserver上面注册对象。。。

而且可以很方便的使用。。如下代码，利用tomcat的代码来动态的注册自己定义的对象：

package registTest;import javax.management.Notification;import javax.management.NotificationListener;import javax.management.ObjectName;import org.apache.tomcat.util.modeler.BaseModelMBean;import org.apache.tomcat.util.modeler.ManagedBean;import org.apache.tomcat.util.modeler.Registry;public class Fjs {private String name;public String getName() {return name;}public void setName(String name) {this.name = name;}public void hello() {System.out.println("hello  : " + name);}public static void main(String args[]) throws Exception {Registry registry = new Registry();registry.loadDescriptors("registTest",  Fjs.class.getClassLoader());ObjectName name = new ObjectName("fjs:type=hello");Fjs fjs = new Fjs();ManagedBean manager = registry.findManagedBean(Fjs.class.getName());BaseModelMBean dmb = (BaseModelMBean)manager.createMBean(fjs);dmb.addAttributeChangeNotificationListener(new NotificationListener(){@Overridepublic void handleNotification(Notification notification,Object handback) {// TODO Auto-generated method stubSystem.out.println(notification);}}, null, null);registry.getMBeanServer().registerMBean(dmb, name);Thread.currentThread().sleep(Long.MAX_VALUE);}}

嗯，Fjs类型的描述文件如下：

<mbeans-descriptors><mbean name="Fjs" description="Standard Server Component" domain="Catalina" group="Server" type="registTest.Fjs"><attribute name="name" description="名字" type="java.lang.String"/><operation name="hello" description="Wait for the shutdown message" impact="ACTION" returnType="void"/></mbean></mbeans-descriptors>

简单吧。。没做多少工作就实现了通过xml文件描述动态的注册对象到mbserver上面去。。。。