浅谈JMX

JMX在Java编程语言中定义了应用程序以及网络管理和监控的体系结构、设计模式、应用程序接口以及服务。通常使用JMX来监控系统的运行状态或管理系统的某些方面，比如清空缓存、重新加载配置文件等

优点是可以非常容易的使应用程序被管理

伸缩性的架构使每个JMX Agent服务可以很容易的放入到Agent中，每个JMX的实现都提供几个核心的Agent服务，你也可以自己编写服务，服务可以很容易的部署，取消部署。

主要作用是提供接口，允许有不同的实现。

　　如果一个java对象可以由一个遵循JMX规范的管理器应用程序管理，那么这个java对象称为一个可由JMX管理的资源。实际上一个可由JMX管理的资源可以是一个应用程序、一种实现、一个服务、一个设备、一个用户等，一个可由JMX管理的资源也是由java编写。并提供了一个相应的java包装。

　　若要使一个java对象成为一个可由JMX管理的资源，则必须创建一个名为Managed Bean或者 MBean的对象，MBean会提供它所管理的一些java对象的属性和方法供管理应用程序使用，管理应用程序本身并不能直接访问托管的java对象，因此，需要选择托管的java对象的那些属性可以由管理应用程序使用。

　　当拥有了一个MBean类之后，需要将其实例化，并将其注册到另一个作为MBean服务器的java对象中，MBean服务器中保存了应用程序中注册的所有MBean，管理应用程序通过MBean服务器来访问MBean实例，可以将JMX与Servlet应用程序做一个类比，管理应用程序的作用类似于Web浏览器，MBean服务器的作用类似于Servlet容器，MBean服务器提供了使管理应用程序可以访问托管资源的方法。MBean实例就好比Servlet类或者Jsp页面，Web浏览器无法直接访问servlet实例或JSP页面，必须要通过Servlet容器才可以，管理应用程序也必须要通过MBean服务器来访问MBean实例。

　　共有四种类型的MBean，分别为标准类型、动态类型、开放类型、和模型类型，其中标准类型的MBean最容易编写，但是灵活性最低，其他三种类型的灵活性较好，其中我们对模型MBean感兴趣，因为Catalina中就使用了这种类型的MBean。

　　从结构上将，JMX规范分为三层：设备层、代理层和分布式服务层，MBean服务器位于代理层，MBean位于设备层，分布式服务层会在JMX规范将来的版本中涉及。

　　设备层规范定义了编写可由JMX管理的资源的标准，即如何编写MBean，代理层定义了创建代理的规范，代理封装了MBean服务器，提供了处理MBean的服务。代理和它所管理的MBean通常都位于同一个java虚拟机中，由于JMX规范附带了一个参考实现，因此并不需要自己编写MBean服务器。

　　MBeanServer类

　　MBean服务器是javax.management.MBeanServer接口的实例，要创建一个MBeanServer实例。只需要调用javax.management.MBeanServerFactory类的createMBean()方法即可。

　　要将一个MBean注册到MBean服务器中，可以调用MBeanServer实例的registerMBean（）方法，下面是registerMBean方法的签名；

ObjectInstance registerMBean(java.lang.Object object, ObjectName var2)
            throws InstanceAlreadyExistsException, MBeanRegistrationException, NotCompliantMBeanException;

要调用registerMBean方法，需要传入一个待注册的MBean实例（就是第一个参数）和一个ObjectName实例，ObjectName实例与HashMap中的键类似，它可以唯一地标识一个MBean实例。registerMBean方法会返回一个ObjectInstance实例。javax.management.ObjectInstance类封装了一个MBean实例的对象名称和它的类名。

　　要想获取MBean实例或匹配某个模式的一组MBean实例。可以使用MBeanServer接口提供的两个方法，分别是queryNames方法和 queryMBeans方法，queryNames方法返回一个java.util.Set实例，其中包含了匹配某个指定模式对象名称的一组MBean实例的对象名称，下面是queryNames方法的签名：

java.util.Set queryNames(ObjectName name, QueryExp query);

其中 query制定了过滤条件，若参数name为null 或者没有域，而且指定了key属性，name返回应注册的MBean实例的所有ObjectName实例，如果参数query为null，则不会对查找对象进行过滤。

　　queryMBeans方法与queryNames方法类似，它返回的也是一个java.util.Set实例，但是其中包含的是被选择的Mbean实例的ObjectInstance对象，queryMBean方法的签名如下：

java.util.Set queryMBeans(ObjectName name, QueryExp query);

　　一旦获得了所需要MBean实例对象名称，就可以操作托管资源在MBean实例中提供的属性或调用其方法，

　　可以通过调用MBeanServer接口的invoke方法调用已经注册的MBean实例的任何方法，MBeanServer接口的getAttribute方法和 setAttribut方法用于获取或设置已经注册的MBean实例的属性。

ObjectName类

　　MBean实例注册于MBean服务器中，MBean服务器中的每一个MBean实例都通过一个对象名称来唯一标识，就好像是HashMap中的每一个条目都通过一个键来唯一的标识一样。

　　对象名称是javax.managerment.ObjectName类的实例，对象名称由两部分组成，域和一个键/值对。域是一个字符串，也可以是空字符串，在对象名称中，域后接一个分号，然后是一个或者多个键/值对，在键/值对重，键(key)是一个非空字符串，并且不能包含下列字符：等号、逗号、分号、星号、和问号。在一个对象名称中，同一个键只能出现一次，

　　键与其值是由等号分隔的，键/值对之间用逗号号分隔。例如下面是一个有效的对象名称，其中包含两个键：

myDomain:type=Car,color=blue
域：key=value,key = value

ObjetName实例也表示在MBean服务器中搜索MBean实例的属性模式，ObjectName实例可以在域部分或者键值对部分使用通配符来表示模式，作为模式的ObjectName可以有 0 个或多个键。

标准MBean

　　标准MBean是最简单的MBean类型，要想通过标准MBean来管理一个java对象，需要执行以下步骤。

创建一个接口，该接口的命名规范为：java类名+MBean后缀。例如，如果想要管理的java类名为Car，则需要创建的接口命名为CarMBean；
修改java类，让其实现刚刚创建的CarMBean接口。
创建一个代理，该代理类必须包含一个MbeanServer实例。
为Mbean创建ObjectName实例；
实例化MBeanServer类，
将MBean注册到MBeanServer中；

　　标准MBean是最容易编写的MBean类型，但是用标准MBean就必须要修改原有的java类，在某些项目中，这不是问题，但是在其他一些项目（尤其是很多类的项目）中，这是不可以接受的，其他类型的MBean允许在不修改原有java类的基础上管理java对象，

下面是一个标准MBean的例子，其中假设你想要使其成为JMC可管理的类是Car，

第一步先创建一个符合命名规范的接口

 package myex20.pyrmont.Standardmbeantest;
 
 /**
  * <p>
  * <b>Title:CarMBean.java</b>
  * </p>
  * <p>
  * Copyright:ChenDong 2018
  * </p>
  * <p>
  * Company:仅学习时使用
  * </p>
  * <p>
  * 类功能描述:要管理Car类的标准MBean接口
  * 创建一个接口，该接口的命名规范为：java类名+MBean后缀。例如，如果想要管理的java类名为Car，则需要创建的接口命名为CarMBean；
  * </p>
  * <p>
  * 基本上来讲，要在接口中声明Car类中的所要提供的所有方法，在这个例子中，在CarMBean接口中生命了Car类的所有方法，如果不希望Car类的drive方法在管理应用程序中调用，
  * 只需要将drive方法的定义从CarMBean中移除即可。
  * </p>
  *
  * @author 陈东
  * @date 2018年12月4日 下午7:36:50
  * @version 1.0
  */
 public interface CarMBean {
     public String getColor();
 
     public void setColor(String color);
 
     public void drive();
 
 }

然后让我们想要被管理的原java类也就是 Car类实现该接口

 package myex20.pyrmont.Standardmbeantest;
 
 /**
  * <p>
  * <b>Title:Car.java</b>
  * </p>
  * <p>
  * Copyright:ChenDong 2018
  * </p>
  * <p>
  * Company:仅学习时使用
  * </p>
  * <p>
  * 类功能描述:
  * </p>
  *
  * @author 陈东
  * @date 2018年12月4日 下午7:34:25
  * @version 1.0
  */
 public class Car implements CarMBean {
     private String color = "red";
 
     public String getColor() {
         return color;
     }
 
     public void setColor(String color) {
         this.color = color;
     }
 
     public void drive() {
         System.out.println("Baby you can drive my*" + color + "*car.");
     }
 }

然后创建一个代理类包含一个 MBeanServer类的实例来管理 Mbean

 package myex20.pyrmont.Standardmbeantest;
 
 import javax.management.Attribute;
 import javax.management.AttributeNotFoundException;
 import javax.management.InstanceAlreadyExistsException;
 import javax.management.InstanceNotFoundException;
 import javax.management.InvalidAttributeValueException;
 import javax.management.MBeanException;
 import javax.management.MBeanRegistrationException;
 import javax.management.MBeanServer;
 import javax.management.MBeanServerFactory;
 import javax.management.NotCompliantMBeanException;
 import javax.management.ObjectName;
 import javax.management.ReflectionException;
 
 /**
  * <p>
  * <b>Title:StandardAgent.java</b>
  * </p>
  * <p>
  * Copyright:ChenDong 2018
  * </p>
  * <p>
  * Company:仅学习时使用
  * </p>
  * <p>
  * 类功能描述: 代理类用来实例化MBean服务器，并使用MBean服务器注册CarBean实例。首先要注意的是变量
  * MBeanServer，StandardAgent类的构造函数会将一个MBeanServer实例赋值给变量MBeanServer。
  * 构造函数会调用MBeanServerFactory类的createMBeanServer方法 创建一个MBeanServer实例，
  * createMBeanServer方法
  * 会返回JMX参考实现的一个默认的MBeanServer对象。资深JMX程序员可能会实现自己的MBeanServer，
  * </p>
  * * @author 陈东
  *
  * @date 2018年12月4日 下午7:44:13
  * @version 1.0
  */
 public class StandardAgent {
     /**
      * 管理MBean的服务器实例
      */
     private MBeanServer mBeanServer = null;
 
     /**
      *
      *
      * <p>
      * Title:无参数构造器
      * </p>
      *
      * <p>
      * Description: 使用默认构造创建一个新的{@code StandardAgent }实例
      * </p>
      */
     public StandardAgent() {
         // 使用MBeanServerFactory工程类 创建MBeanServer实例
         mBeanServer = MBeanServerFactory.createMBeanServer();
     }
 
     /**
      *
      *
      * <p>
      * Title: getMBeanServer
      * </p>
      *
      * @date 2018年12月4日 下午7:51:31
      *
      *       <p>
      *       功能描述: 获取代理类中的MBeanServer实例
      *       </p>
      *
      * @return
      */
     public MBeanServer getMBeanServer() {
         return mBeanServer;
     }
 
     /**
      *
      *
      * <p>
      * Title: createObjectName
      * </p>
      *
      * @date 2018年12月4日 下午7:55:07
      *
      *       <p>
      *       功能描述: 根据指定的name属性来创建 {@code ObjectName} 实例
      *       </p>
      *
      * @param name
      * @return
      */
     public ObjectName createObjectName(String name) {
         ObjectName objectName = null;
         try {
             objectName = new ObjectName(name);
         } catch (Exception e) {
             e.printStackTrace();
         }
         return objectName;
 
     }
 
     /**
      *
      *
      * <p>
      * Title: createStandardBean
      * </p>
      *
      * @date 2018年12月4日 下午8:09:01
      *       <p>
      *       功能描述: 方法中会调用MBeanServer实例的createMBean方法，createMBean方法接收托管资源的类名，
      *       和一个ObjectName实例，该ObjectName实例
      *       唯一的表示了为托管资源创建的MBean实例，creatMBean方法也会将创建的MBean实例注册到MBean
      *       服务器中。由于标准MBean实例遵循了特定的命名规则，因此不需要
      *       为createMbean方法提供MBean的类名，如果托管资源的类名是Car，则创建的MBean的类名为CarMBean。
      *       </p>
      *
      *
      * @param objectName
      * @param managedResourceClassName
      */
     @SuppressWarnings("unused")
     private void createStandardBean(ObjectName objectName, String managedResourceClassName) {
         try {
             mBeanServer.createMBean(managedResourceClassName, objectName);
         } catch (InstanceAlreadyExistsException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         } catch (NotCompliantMBeanException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         } catch (MBeanRegistrationException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         } catch (MBeanException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         } catch (ReflectionException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
 
     }
 
     public static void main(String[] args) {
         // 创建一个代理类的实例
         StandardAgent agent = new StandardAgent();
         // 获取一个MBeanServer 的引用
         MBeanServer mBeanServer = agent.getMBeanServer();
 
         /**
          * 为我们要管理的CarBean实例
          * 创建一个ObjectName对象，MBeanServer实例的默认域会作为ObjectName实例的域使用。
          * 一个名为type的键会被添加到域的后面，键type的值是托管资源的完全限定名；
          */
         // 获取 MBeanServer实例的默认域
         String domain = mBeanServer.getDefaultDomain();
         // 被托管资源java类的完全限定名 不是对应的MBean包装类
         String managedResourceClassName = "myex20.pyrmont.Standardmbeantest.Car";
         // 然后创建ObjectName对象
         ObjectName oname = agent.createObjectName(domain + ":type=" + managedResourceClassName);
         // 调用 agent的 createStandardMBean方法，并传入创建好的 对象名称对象 和 托管资源java类的 类限定名
         // 接着 就会调用MBeanServer的 creatMBean来创建并管理
         // CarMBean，也就是通过CarMBean实例来管理Car对象。
         agent.createStandardBean(oname, managedResourceClassName);
         // 创建一个名为 colorattribute的Attribute类型的对象，用来表示Car类的color属性，并设置其值 为blue，
         Attribute colorattribute = new Attribute("Color", "blue");
         // 然后 用MBean 服务器对象的setAttribute方法，传入代表 CarMBean 的ObjectName 对象 与 为
         // CarBean管理的Car设置的Attitude对象
         try {
             mBeanServer.setAttribute(oname, colorattribute);
             System.out.println(mBeanServer.getAttribute(oname, "Color"));
             mBeanServer.invoke(oname, "drive", null, null);
         } catch (InstanceNotFoundException | InvalidAttributeValueException | AttributeNotFoundException
                 | ReflectionException | MBeanException e) {
 
             e.printStackTrace();
         }
 
     }
 
 }

剩余步骤大家看上面代码吧，不想再写啦哈。

从上面的例子我们可以看到，我们已经可以通过StandardAgent类来直接访问Car对象了，但是这里的关键问题是可以选择那些功能要暴露出来，那些方法需要对外隐藏。

模型MBean

　　相对于标准MBean，模型MBean更具有灵活性，在编程上，模型MBean难度更大一些，但是也不需要为可管理的对象修改原java类了，如果不能修改已有的java类，那么使用模型MBean是一个不错的选择。

　　使用模型MBean与使用标准MBean有一些区别，在使用标准MBean来管理资源时，需要定义一个接口，然后让托管资源实现该接口，而使用模型MBean时，不需要定义接口，相反是可以使用javax.management.modelmbean.ModelMBean接口来表示模型MBean

，只需要实现该接口，在JMX的参考实现中，有一个javax.management.modelmbean.RequiredModelMBean类，是ModelMBean接口的默认实现，可以实例化RequiredModelMBean类或者其子类，也可以使用ModelMBean接口的其他实现类。

　编写一个模型MBean的最大挑战是告诉ModelMBean对象托管资源的那些属性和方法可以暴露给代理，可以通过创建 javax.management,modelmbean.ModelMBeanInfo对象来完成这个任务，ModelMBeanInfo对象描述了将会暴露给代理的构造函数、属性、操作、甚至是监听器。创建ModelMBeanInfo对象是一件特别枯燥的事情，但当创建了该实例后，只需要将其与ModelMBean对象相关联即可。

　使用RequiredModelMBean类作为ModelMBean的实现，有两种方式可以将ModelMBeanInfo对象相关联；

传入一个ModelMBeanInfo对象到 RequiredModelMBean对象的构造函数中
调用RequiredModelMBean类的setModelMBeanInfo方法，并传入一个ModelMBean对象

　　在创建了ModelMBean对象之后，需要调用ModelMbean接口的setManagedResource方法将 ModelMBean与其托管的资源相互关联，该方法的签名如下

public void setManagedResource(java.lang.Object managedResource, java.lang.String managedResourceType) throws MBeanException, RuntimeOperationsException, InstanceNotFoundException, InvalidTargetObjectTypeException ;

字符串参数 managedResourceType的值只可以是下面之一：ObjectReference、Handle、IOR、EJBHandle或者RMIReference。当前只支持ObjectReference。

　　还需要创建一个ObjectName实例，并将MBean实例注册到MBean服务器中，下面先介绍一下ModelMBeanInfo接口，该接口的实例会将托管资源的属性和方法提供给代理层。

MBeanInfo 接口与 ModelMBeanInfo接口

　　javax.management,mbean.ModelMBeanInfo接口描述了要通过ModelMBean暴露给代理层的构造函数、属性、方法、和监听器，其中构造函数是 javax.management.modelmbean.ModelMBeanConstructorInfo类的实例，属性是javax.management.modelmbean.ModelMBeanAttributeInfo类的实例，方法是javax.management.modelmbean.ModelMBeanOperationInfo类的实例，监听器是 javax.management.modelmbean.ModelMBeanNotificationInfo类的实例，

　　JMX提供了ModelMBeanInfo接口的默认实现，即javax.management.modelmbean.ModelMBeanInfoSupport类。下面展示一下我们后面要使用的ModelMBeanInfoSupport类的构造函数：

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

可以通过调用ModelMBeanAttributeInfo类的构造函数来创建ModelMBeanAttributeInfo对象：

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

下面是参数列表：

name：属性的名称
type，属性的类型名
description:对属性的描述
isReadable:,true表示针对该属性有一个getter方法，false表示没有
isWriteable：true 表示针对该属性有一个 setter方法，false表示没有
isIs，true 表示针对该属性有一个getter方法，false表示没有
descriptor:Descriptor类的实例，包含Attribute的适当元数据，如果它为null，会创建默认的Descriptor实例。

可以使用下面的构造函数创建一个 ModelMBeanOperationInfo对象

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

下面是参数列表；

name：方法名
description :方法描述
signature：MBeanParameterInfo对象的数组，描述了方法的参数
type：方法的返回值类型
impact：方法的影响是一个整型变量，为了方便大家的使用使用了javax.management.MBeanOperationInfo类中的几种常量来表示

    /**
     * 方法返回信息但不改变任何状态
     */
    public static final int INFO = 0;

 /**
     *    指示该操作是写式的：它具有效果，但不从MBean返回任何信息
     */
    public static final int ACTION = 1;

 /**
     *指示该操作既读又写：它具有效果，并且还返回来自MBean的信息
     */
    public static final int ACTION_INFO = 2;

 /**
     * 指示操作的影响是未知的，或者无法使用其他值之一来表示。
     */
    public static final int UNKNOWN = 3;

只可以选择上面的四种

descriptor：Descriptor实例，包含MBeanOperationInfo实例的适当元数据

我们还是使用原来的Car类作为MBean的管理对象代码如下

package myex20.pyrmont.Standardmbeantest;
 
/**
 * <p>
 * <b>Title:Car.java</b>
 * </p>
 * <p>
 * Copyright:ChenDong 2018
 * </p>
 * <p>
 * Company:仅学习时使用
 * </p>
 * <p>
 * 类功能描述:
 * </p>
 *
 * @author 陈东
 * @date 2018年12月4日 下午7:34:25
 * @version 1.0
 */
public class Car {
    private String color = "red";
 
    public String getColor() {
        return color;
    }
 
    public void setColor(String color) {
        this.color = color;
    }
 
    public void drive() {
        System.out.println("Baby you can drive my*" + color + "*car.");
    }
}

对于模型MBean，不需要像使用标准MBean那样，编写一个接口，只需要实例化RequiredMBean类，下面展示一个ModelAgent类的定义，该类用来创建模型MBean实例，并管理Car对象。

 package myex20.pyrmont.modelmbeantest1;
 
 import javax.management.Attribute;
 import javax.management.AttributeNotFoundException;
 import javax.management.Descriptor;
 import javax.management.InstanceNotFoundException;
 import javax.management.InvalidAttributeValueException;
 import javax.management.MBeanException;
 import javax.management.MBeanInfo;
 import javax.management.MBeanOperationInfo;
 import javax.management.MBeanParameterInfo;
 import javax.management.MBeanServer;
 import javax.management.MBeanServerFactory;
 import javax.management.MalformedObjectNameException;
 import javax.management.ObjectName;
 import javax.management.ReflectionException;
 import javax.management.RuntimeOperationsException;
 import javax.management.modelmbean.DescriptorSupport;
 import javax.management.modelmbean.InvalidTargetObjectTypeException;
 import javax.management.modelmbean.ModelMBean;
 import javax.management.modelmbean.ModelMBeanAttributeInfo;
 import javax.management.modelmbean.ModelMBeanInfo;
 import javax.management.modelmbean.ModelMBeanInfoSupport;
 import javax.management.modelmbean.ModelMBeanOperationInfo;
 import javax.management.modelmbean.RequiredModelMBean;
 
 /**
  * <p>
  * <b>Title:ModelAgent.java</b>
  * </p>
  * <p>
  * Copyright:ChenDong 2018
  * </p>
  * <p>
  * Company:仅学习时使用
  * </p>
  * <p>
  * 类功能描述:用于创建模型MBean的实例，在该类中用其JMX参考中的默认实现RequiredModelMBean，并管理Car
  * 并包含一个MBeanServer实例
  *
  * </p>
  * <p>
  * 请访问下面网址 进行 参考学习 {@see https://www.cnblogs.com/ChenD/p/10061598.html}
  * </p>
  *
  * @author 陈东
  * @date 2018年12月5日 下午9:24:36
  * @version 1.0
  */
 public class ModelAgent {
     /**
      * 管理的Car类的完全限定名
      */
     private String MANAGED_CLASS_NAME = "myex20.pyrmont.modelmbeantest1.Car";
 
     /**
      * 用于管理MBean的MBeanServer实例
      */
     private MBeanServer mBServer = null;
 
     public ModelAgent() {
         mBServer = MBeanServerFactory.createMBeanServer();
     }
 
     public MBeanServer getMBeanServer() {
         return mBServer;
     }
 
     /**
      *
      *
      * <p>
      * Title: createObjectName
      * </p>
      *
      * @date 2018年12月5日 下午9:39:47
      *
      *       <p>
      *       功能描述:用指定的name创建ObjectName对象
      *       </p>
      *
      * @param name
      * @return
      */
     private ObjectName createObjectName(String name) {
         ObjectName obj = null;
 
         try {
             obj = new ObjectName(name);
         } catch (MalformedObjectNameException e) {
 
             e.printStackTrace();
         }
         return obj;
 
     }
 
     /**
      *
      *
      * <p>
      * Title: createMBean
      * </p>
      *
      * @date 2018年12月6日 下午9:39:09
      *
      *       <p>
      *       功能描述:创建 ModelMBean
      *       </p>
      *
      * @param objectName
      * @param mbeanName
      * @return
      */
     private ModelMBean createMBean(ObjectName objectName, String mbeanName) {
         // ModelMBeanInfo接口描述了要通过ModelMBean暴露给代理层的构造函数、属性、方法、和监听器
         // 先创建一个描述 要创建的ModelMBean类 要暴露给代理层的 各种 信息
         ModelMBeanInfo mBeanInfo = createModelMBeanInfo(objectName, mbeanName);
         RequiredModelMBean modelMBean = null;
         try {
             modelMBean = new RequiredModelMBean(mBeanInfo);
         } catch (Exception e) {
             e.printStackTrace();
         }
         return modelMBean;
     }
 
     /**
      *
      *
      * <p>
      * Title: createModelMBeanInfo
      * </p>
      *
      * @date 2018年12月5日 下午10:03:03
      *
      *       <p>
      *       功能描述:为ModelMBean 类创建类信息 ModelMBeanInfo
      *
      *       </p>
      *       <p>
      *       对象 ModelMBeanInfo对象的几个子接口 构造函数是
      *       javax.management.modelmbean.ModelMBeanConstructorInfo类的实例，
      *       属性是javax.
      *       management.modelmbean.ModelMBeanAttributeInfo类的实例，方法是javax.
      *       management.modelmbean.ModelMBeanOperationInfo类的实例，监听器是
      *       javax.management.modelmbean.ModelMBeanNotificationInfo类的实例，
      *       </p>
      *
      * @param inMBeanObjectName
      * @param inMBeanName
      * @return
      */
     private ModelMBeanInfo createModelMBeanInfo(ObjectName inMBeanObjectName, String inMBeanName) {
 
         // ModelMBean类的 类信息接口
         ModelMBeanInfo mBeaninfo = null;
         // ModelMBean类的 属性 对象集合
         ModelMBeanAttributeInfo[] attributes = new ModelMBeanAttributeInfo[1];
         // ModelMBean类的 方法 对象集合
         ModelMBeanOperationInfo[] operations = new ModelMBeanOperationInfo[3];
         try {
 
             // 属性名：Color，类型：java.lang.String 描述信息：the Color。 isReadable：true
             // 有getter方法，isWriteable：true 有setter方法
             // isIS ：false 无getter方法，descriptor ：无
             attributes[0] = new ModelMBeanAttributeInfo("Color", "java.lang.String", "the Color.", true, true, false,
                     null);
             /**
              * 第三个参数为 该方法的参数数组 null代表无参数，
              */
             operations[0] = new ModelMBeanOperationInfo("drive", "the drive method", null, "void",
                     MBeanOperationInfo.ACTION, null);
             /**
              * Car的getColor方法
              *
              */
             operations[1] = new ModelMBeanOperationInfo("getColor", "get color attribute", null, "java.lang.String",
                     MBeanOperationInfo.ACTION, null);
 
             // setColor方法
             String fileds[] = new String[] { "name=setColor", "descriptorType=operation", "class=" + MANAGED_CLASS_NAME,
                     "role=operation" };
             Descriptor setColorDesc = new DescriptorSupport(fileds);
             /**
              * MBeanOperationInfo 描述方法的参数对象
              */
             MBeanParameterInfo[] setColorParams = new MBeanParameterInfo[] {
                     new MBeanParameterInfo("new color", "java.lang.String", "new Color value") };
             /**
              * name：方法名 description :方法描述
              * signature：MBeanParameterInfo对象的数组，描述了方法的参数 type：方法的返回值类型
              * impact：方法的影响 是一个整型变量 ，为了方便大家的使用
              * 使用了javax.management.MBeanOperationInfo类中的几种常量来表示
              * ACTION:指示该操作是写式的：它具有效果，但不从MBean返回任何信息
              */
 
             operations[2] = new ModelMBeanOperationInfo("setColor", "set color attribute", setColorParams, "void",
                     MBeanOperationInfo.ACTION, setColorDesc);
 
             mBeaninfo = new ModelMBeanInfoSupport(MANAGED_CLASS_NAME, null, attributes, null, operations, null);
 
         } catch (Exception e) {
             e.printStackTrace();
         }
         return mBeaninfo;
 
     }
 
     public static void main(String[] args) {
 
         ModelAgent agent = new ModelAgent();
         MBeanServer server = agent.getMBeanServer();
         Car car = new Car();
         // 获取 MBeanServer实例的默认域
         String domain = server.getDefaultDomain();
         ObjectName objectName = agent.createObjectName((domain + ":type=MyCar"));
         String mbeanName = "myMBean";
         ModelMBean bean = agent.createMBean(objectName, mbeanName);
         // 在创建了ModelMBean对象之后，需要调用ModelMbean接口的setManagedResource方法将
         // ModelMBean与其托管的资源相互关联，
         // public void setManagedResource(java.lang.Object managedResource,
         // java.lang.String managedResourceType) throws MBeanException,
         // RuntimeOperationsException, InstanceNotFoundException,
         // InvalidTargetObjectTypeException ;
         // managedResourceType 目前只支持 ObjectReference
         try {
             bean.setManagedResource(car, "ObjectReference");
             // 将与托管资源关联好的ModelMBean 注册到 MBean服务器中
             server.registerMBean(bean, objectName);
 
         } catch (Exception e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
         // 管理代理类
 
         try {
             Attribute attribute = new Attribute("Color", "green");
             server.setAttribute(objectName, attribute);
             String color = (String) server.getAttribute(objectName, "Color");
             System.out.println("Color:" + color);
 
             attribute = new Attribute("Color", "blue");
             server.setAttribute(objectName, attribute);
             color = (String) server.getAttribute(objectName, "Color");
             System.out.println("Color:" + color);
 
                     server.invoke(objectName, "drive", null, null);
             server.invoke(objectName, "setColor", new String[]{"blue"},new String[]{"java.lang.String"});
             server.invoke(objectName, "drive", null, null);
 
         } catch (Exception e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
 
     }
 
 }

在执行main之后的运行结果

Color:green
Color:blue
Baby you can drive my*red*car.
Baby you can drive my*blue*car.

因为在使用MBeanServer类的invoke时看下方法签名吧我一次传带参数的值就传错了记录下

public Object invoke(ObjectName name, String operationName,
                         Object params[], String signature[])
            throws InstanceNotFoundException, MBeanException,
                   ReflectionException;

name：注册时用的ObjectName对象
operationName：要调用的方法名
params：代表参数数组定义成Object 是为了可以满足任何类型的参数，按照参数顺序依次定义数组内容
signature：也是一个数组代表参数元素的类型例如参数是String 那么它的类型就是 java.lang.String

从上面的例子我们已经看出来了最麻烦的就是创建ModelMBeanInfo信息了，如果这个步骤不可以简化那么这个ModelMBean将不具备可用性，

那么为了简化创建ModelMBeanInfo信息引入了一个Commons Modeler 库

Commons Modeler

　　Commons Modeler 库是Apache软件基金会的Jakarta项目的一部分，目的就是使编写模型MBean更加方便，事实上最大的帮助是不需要向上面一样写创建ModelMBeanInfo对象的代码了。

回忆下之前的例子，在创建RequiredModelMBean实例时，需要创建一个ModelMBeanInfo对象，并将其传给RequiredModelMBean类的构造函数：

ModelMBeanInfo mBeanInfo = createModelMBeanInfo(objectName, mbeanName);
        RequiredModelMBean modelMBean = null;
        try {
            modelMBean = new RequiredModelMBean(mBeanInfo);
        } catch (Exception e) {
            e.printStackTrace();
        }

ModelMbeanInfo对象描述了将要由MBean实例暴露出来的属性和方法，实现createModelMBeanInfo方法是特别枯燥的而且麻烦死了，因为必须列出所有要暴露出来的属性和方法并将它们传给ModelMBeanInfo对象。

　　而使用Commons Modeler库，就不在需要创建ModelMBeanInfo对象了，相反对模型MBean的描述被封装在一个 org.apache.catalina.modeler.ManagedBean对象中。不需要编写代码在MBean中暴露出属性和方法。只需要编写一个mbean描述文件（一个XML文档），列出想要创建的MBean，对于每个MBean，需要写出MBean类和托管资源类的完全限定名，此外还有由MBean暴露出来的属性和方法，然后使用org.apache.commons.modeler.Registry实例来读取这个XML文档，并创建一个MBeanServer实例，在按照mbean描述文件中的XML元素创建所有的ManagedBean实例。

　　然后调用ManagedBean实例的createMBean方法创建模型MBean，这之后就是普通的流程了，需要创建ObjectName对象的实例，并将其与MBean实例一起注册到MBean服务器中，下面会先介绍一下mbean描述文件的格式，然后讨论Modeler库中的三个重要的类，分别是Registry类，ManagedBean类、和BaseModelMBean类。

注意：为了更好的理解Modeler库，org.apache.catalina.mbeans包中与MBean相关类的工作原理。我们仍然使用老版本,

MBean描述符

　　MBean描述符是一个XML 文档，该文档描述了将会由Mbean服务器管理的 ModelMBean的实例，MBean描述符以下面的头信息开始：

<?xml version="1.0"?>
<!DOCTYPE mbeans-descriptors PUBLIC
"-//Apache Software Foundation//DTD Model MBeans Configuration File"
"http://jakarta.apache.org/commons/dtds/mbeans-descriptors.dtd">

　　接下来是mbeans-descriptors的根元素

<mbeans-descriptors>
...
</mbeans-descriptors>

　　在开始和末尾的mbeans-descriptors标签内部是mbean元素，每一个mbean元素标签表示一个模型MBean，mbean元素包含了分别用来表示属性、方法、构造函数、和通知的元素。

mbean元素

　　mbean元素描述了一个模型MBean，包含创建对应ModelMBeanInfo对象的信息。mbean元素的定义如下所示：

<!ELEMENT mbean(descriptor?,attribute*,constructor*,notification*,operation*)>

　　mbean元素定义了具体的规范，mbean元素可以有一个可选的descriptor元素，0个或者多个attribute元素。0个或者多个constructor元素，0个或者多个notification元素。0个或者多个operation元素。

　　mbean元素可以有如下的属性：

className ：实现ModelMBean接口的java类的完全限定名，若该属性未赋值，则默认使用org.apache.commons.modeler.BaseModelMBean类；
description：该ModelMBean类的简单描述
domain：在创建ModelMBean的ObjectName对象时，托管的bean 的 ModelMBean实例被注册到MBeanServer的域名。
group：组分类的可选名，可以用来选择具有相似MBean实例类的组；
name：唯一标识模型MBean的名称，一般情况下，会使用相关服务器组件的基类名。
type：托管资源实现类的完全限定java类名。

attribute 元素

　　使用attribute元素描述MBean的javaBean属性。attribute元素有一个可选的descripotr元素，attribute元素可以由如下的属性：

description：该属性的简单描述
displayName：该属性的显示名称；
getMethod：返回 attribute元素的getter方法；
is：一个布尔值，指明该属性是否是一个布尔值，是否有getter方法，默认情况下，该属性值为false；
name：该javaBean属性的名称：
readable：一个布尔值，指明该属性对管理应用程序来说是否可读，该属性默认值为 true；
setMethod，设置 attribute属性的setter方法；
type：该属性的完全限定java类名；
writeable：一个布尔值。指明该属性对管理应用程序来说是否可写，该属性的默认值为true；

operation 元素

　　operation元素描述了模型MBean 中要暴露给管理应用程序的公共方法，它可以有.个或者多个parameter子元素和如下的属性：

description：方法的简单描述
impact：指明方法的影响，可选值，ACTION、ACTION-INFO、INFO或UNKNOWN；值的意思参考 ModelMBeanOperationInfo对象的讲述；
name：公共方法的名称；
returnType：方法返回值的完全限定的java类名。

parameter 元素

　　parameter元素描述了将要传递给构造函数或者方法的参数，它可以有如下的属性：

description：该参数的简单描述
name：参数名
type：该参数完全限定的java类名

mbean元素的示例

　　在Catalin的 mbean-descriptors.xml文件中声明了一系列模型MBean，该文件位于org.apache.catalina.mbean 包下，下面给出了 mbean-descriptors.xml文件中对于StandardServer MBean的声明

<mbean name="StandardServer" className="org.apache.catalina.mbeans.StandardServerMBean"
description="Standard Server Component"
domain="Catalina"
group="Server"
type="org.apache.catalina.core.StandardServer">
 
<attribute name="debug"
description="The debugging detail level fot this component"
type="int"/>
 
<attribute name="managedResource"
description="The managed resource this MBean is asscoiated with"
type="java.lang.Object"/>
 
<attribute name="port"
description="TCP port for shutdown messages"
type="int"/>
 
<attribute name="shutdown"
description="Shutdown password"
type="java.lang.String"/>
 
<operation name="store"
description="Save current state to server.xml file"
impact="ACTION"
returnType="void">
</operation>
</mbean>

上述代码中的mbean元素声明了一个模型MBean，其唯一标识是StandardServer，该MBean是org.apache.catalina.mbeans.StandardServerMBean类的一个对象，负责管理org.apache.catalina.core.StandardServer类的对象。

domain属性的值是 Catalina，group的属性是Server。

　　模型MBean暴露出的属性有四个，分别是debug、managedResource、port和shutdown。正如mbean元素中嵌套的四个attribute元素所描述的一样，此外，Mbean还暴露出了一个方法，即 store方法，由 operation元素描述。

自己编写一个模型MBean类

使用Commons Modeler库，需要在mbean元素的className属性中指明自定义的模型MBean的类型，默认情况下，Commons Modeler库使用 org.apache.commons.modeler.BaseModelMBean类。

有以下两种情况。其中可能需要对BaseModelMBean类进行扩展：

需要覆盖托管资源的属性或方法
需要添加在托管资源中没有定义的属性或方法

在org.apahce.catalina.mbeans包下，Catalina 提供了BaseModelMBean类的很多子类，可以用来实现上面的需求。

Registry类.

org.apahce.commons.modeler.Registry类定义了很多方法，下面是可以使用该类做的事情。

获取 javax.managedment.MBeanServer类的一个实例，所以不需要在调用javax.managedment.MbeanServerFactory类的createMBeanServer方法了
使用 loadRegistry方法获取MBean的描述文件
创建一个ManagedBean对象，用于创建模型MBean的实例。

ManagedMBean

　　ManagedMBean对象描述了一个模型MBean，该类用于取代javax.managedment.MBeanInfo对象。

BaseModelMBean

　　org.apache.commons.modeler.BaseModelMbean类实现了 javax.managedment.modelmbean.ModelMBean接口，使用这个类，就不需要使用javax.managedment.modelmbean.RequiredMoldeMBean这个类了，

　　该类用一个比较有用的字段是resource字段。resource字段表示该模型MBean管理的资源。resource字段的定义如下；

protected  java.lang.Object resource = null;

使用Modeler库 API

下面代码给出了想要管理器对象Car类的定义

 package myex20.pyrmont.modelmbeantest2;
 
 /**
  * <p>
  * <b>Title:Car.java</b>
  * </p>
  * <p>
  * Copyright:ChenDong 2018
  * </p>
  * <p>
  * Company:仅学习时使用
  * </p>
  * <p>
  * 类功能描述:modelmbeantest2 中 要被管理的对象
  * </p>
  *
  * @author 陈东
  * @date 2018年12月10日 下午10:20:53
  * @version 1.0
  */
 public class Car {
     public Car() {
         System.out.println("Car constructor");
     }
 
     private String color = "red";
 
     public String getColor() {
 
         return this.color;
     }
 
     public void setColor(String color) {
         this.color = color;
     }
 
     public void drive() {
         System.out.println("Baby  you can drive my " + color + " Car");
     }
 
 }

　　使用Commons Modeler 库，不需要使用硬编码的方式，将托管对象的所有属性和方法都写在代码中，相反，可以将他们写在一个xml文件中，作为MBean的描述符文件，在这个例子当中，这样的文档是car-mbean-descriptor.xml文件，如下面所所示

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mbeans-descriptors PUBLIC
 "-//Apache Software Foundation//DTD Model MBeans Configuration File"
 "http://jakarta.apache.org/commons/dtds/mbeans-descriptors.dtd">
 
<mbeans-descriptors>
 
  <mbean name="myMBean"
    className="javax.management.modelmbean.RequiredModelMBean"
    description="The ModelMBean that manages our Car object"
    type="ex20.pyrmont.modelmbeantest.Car">
 
    <attribute name="Color"
      description="The car color"
      type="java.lang.String"/>
 
    <operation name="drive"
      description="drive method"
      impact="ACTION"
      returnType="void">
      <parameter name="driver" description="the driver parameter"
        type="java.lang.String"/>
    </operation>
 
  </mbean>
 
</mbeans-descriptors>

那么我们写完这个描述文件之后，就需要一个在写一个代理类ModelAgent.java，具体看下面哈

package myex20.pyrmont.modelmbeantest2;
 
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
 
import javax.management.Attribute;
import javax.management.MBeanServer;
import javax.management.MalformedObjectNameException;
import javax.management.ObjectName;
import javax.management.modelmbean.ModelMBean;
 
import org.apache.commons.modeler.ManagedBean;
import org.apache.commons.modeler.Registry;
 
/**
 * <p>
 * <b>Title:ModelAgent.java</b>
 * </p>
 * <p>
 * Copyright:ChenDong 2018
 * </p>
 * <p>
 * Company:仅学习时使用
 * </p>
 * <p>
 * 类功能描述: modelmbeantest2包下的代理类
 * </p>
 *
 * @author 陈东
 * @date 2018年12月11日 下午7:43:28
 * @version 1.0
 */
public class ModelAgent {
    /**
     * <p>
     * 作用1：获取 {@link javax.management.MBeanServer }
     * </p>
     *
     * <p>
     * 作用2：使用loadRegistry方法来读取mbean描述文件；
     * </p>
     *
     * <p>
     * 作用3：创建一个@
     * {@link org.apache.commons.modeler.ManagedBean}用于创建一个{@code ModelMBean}
     * </p>
     */
    private Registry registry;
 
    private MBeanServer mbeanServer;
 
    public ModelAgent() {
        registry = createRegistry();
        mbeanServer = Registry.getServer();
    }
 
    public MBeanServer getMBeanServer() {
        return mbeanServer;
    }
 
    /**
     *
     *
     * <p>
     * Title: createRegistrt
     * </p>
     *
     * @date 2018年12月11日 下午8:28:44
     *
     *       <p>
     *       功能描述:创建Registry，
     *       </p>
     *
     * @return
     */
    private Registry createRegistry() {
 
        Registry registry = null;
 
        try {
            URL url = ModelAgent.class.getResource("/myex20/pyrmont/modelmbeantest2/car-mbean-descriptor.xml");
            InputStream io = url.openStream();
            Registry.loadRegistry(io);
            registry = Registry.getRegistry();
        } catch (Exception e) {
 
            e.printStackTrace();
        }
        return registry;
    }
 
    /**
     *
     *
     * <p>
     * Title: createModleMBean
     * </p>
     * <p>
     * 功能描述:用于创建指定名字的 ModelMBean 这里的名字必须是 mbean描述文件中的 mbean 元素的name属性所指定的才可以
     * 否则返回null
     * </p>
     *
     * @date 2018年12月11日 下午8:46:54
     *
     *
     *
     * @param mbeanName
     * @return
     * @throws Exception
     */
    private ModelMBean createModleMBean(String mbeanName) throws Exception {
        // 根据指定的名字去找mbean描述文件中对应的配置所代表的 ManagedBean对象
        ManagedBean managed = registry.findManagedBean(mbeanName);
        if (managed == null) {
            System.out.println("ManagedBean is null");
            return null;
        }
        // 创建ModelMBean
        ModelMBean mbean = managed.createMBean();
 
        return mbean;
    }
 
    /**
     *
     *
     * <p>
     * Title: createObjectName
     * </p>
     *
     * @date 2018年12月11日 下午8:45:25
     *
     *       <p>
     *       功能描述:创建用于向mbean服务器注册时为MBean做唯一标识 的ObjectName
     *       </p>
     *
     * @return
     */
    private ObjectName createObjectName() {
        ObjectName objectname = null;
        String domain = mbeanServer.getDefaultDomain();
        try {
            objectname = new ObjectName(domain + ":type=MyCar");
        } catch (MalformedObjectNameException e) {
 
            e.printStackTrace();
        }
 
        return objectname;
    }
 
    public static void main(String[] args) {
        // 实例化代理类
        ModelAgent agent = new ModelAgent();
        // 使用代理类 获取MBeanServer
        MBeanServer server = agent.getMBeanServer();
        // 要被托管的资源
        Car car = new Car();
        // 创建ObjectName
        ObjectName objectName = agent.createObjectName();
 
        try {
            // 创建ModelMBean对象 名字必须在mbean 描述文件中有对应mbean元素
            ModelMBean modelMBean = agent.createModleMBean("myMBean");
            // 将托管资源 与 modelMBean对象关联起来
            /**
             * 在创建了ModelMBean对象之后，需要调用ModelMbean接口的setManagedResource方法将
             * ModelMBean与其托管的资源相互关联， public void
             * setManagedResource(java.lang.Object managedResource,
             * java.lang.String managedResourceType) throws MBeanException,
             * RuntimeOperationsException, InstanceNotFoundException,
             * InvalidTargetObjectTypeException ; managedResourceType 目前只支持
             * ObjectReference
             */
            modelMBean.setManagedResource(car, "ObjectReference");
            // 将modelMBean 注册到 mbeanServer
            server.registerMBean(modelMBean, objectName);
 
        } catch (Exception e) {
 
            e.printStackTrace();
        }
 
        // 管理这个托管资源
        try {
 
            Attribute attribute = new Attribute("Color", "green");
            server.setAttribute(objectName, attribute);
            String color = (String) server.getAttribute(objectName, "Color");
            System.out.println("mbeanserver getAttribute  Color:" + color);
            System.out.println("Car's Color:" + car.getColor());
 
            attribute = new Attribute("Color", "blue");
            server.setAttribute(objectName, attribute);
            color = (String) server.getAttribute(objectName, "Color");
            System.out.println("mbeanserver getAttribute  Color:" + color);
            System.out.println("Car's Color:" + car.getColor());
 
            server.invoke(objectName, "drive", null, null);
        } catch (Exception e) {
            e.printStackTrace();
        }
 
    }
 
}

运行main方法后的结果

十二月 11, 2018 9:41:28 下午 org.apache.commons.modeler.Registry loadRegistry
信息: Loading registry information
十二月 11, 2018 9:41:28 下午 org.apache.commons.modeler.Registry getRegistry
信息: Creating new Registry instance
十二月 11, 2018 9:41:28 下午 org.apache.commons.modeler.Registry getServer
信息: Creating MBeanServer
十二月 11, 2018 9:41:28 下午 org.apache.commons.modeler.Registry loadRegistry
信息: Loading registry information
Car constructor
mbeanserver getAttribute  Color:green
Car's Color:green
mbeanserver getAttribute  Color:blue
Car's Color:blue
Baby  you can drive my blue Car

看下我们在使用了Commons Modeler库之后减少了好多代码吧

Catalina中的MBean

　　Catalina 在 org.apache.catalina.mbeans包中提供了一系列的MBean类，这些MBean类都直接或者间接的继承自 org.apahce.commons.modeler.BaseModelMBean类，下面会为大家展示一下 Tomcat 4 中三个最重要的MBean类，分别是ClassNameMBean类，

StandardServerMBean类、和MBeanFactory类，还有一个重要的工具类 MBeanUtil类。

BaseModelMBean类

　　因为下面要讲解的类直接或者间接都会继承该类，所以有必要讲解下该类的一些重要的属性以及方法

首先有一个 java.lang.Object 类型名为 resource的变量表示托管资源的实例对象

protected Object resource = null;

还有一个重要的方法也就将托管资源和该ModelMBean相关联的方法 setManagedResource(Object resource,String type),看下面的展示

    /**
     *
     *
     * <p>
     * Title: setManagedResource
     * </p>
     *
     * @date 2018年12月11日 下午10:13:06
     *
     *       <p>
     *       功能描述: 将 指定的 托管资源 resource ，绑定到当前的ModelMBean中
     *       </p>
     *
     * @param resource 指定的托管资源
     * @param type 指定type 目前只支持 {@code objectreference}
     * @throws InstanceNotFoundException
     * @throws InvalidTargetObjectTypeException 若 type 不为 {@code objectreference} 抛出错误
     * @throws MBeanException
     * @throws RuntimeOperationsException 若 指定的托管资源resource是null 则抛出错误
     */
    public void setManagedResource(Object resource, String type) throws InstanceNotFoundException,
            InvalidTargetObjectTypeException, MBeanException, RuntimeOperationsException {
        if (resource == null) {
            throw new RuntimeOperationsException(new IllegalArgumentException("Managed resource is null"),
                    "Managed resource is null");
        } else if (!"objectreference".equalsIgnoreCase(type)) {
            throw new InvalidTargetObjectTypeException(type);
        } else {
            this.resource = resource;
        }
    }

ClassNameMBean

　　org.apahce.catalina.mbeans.ClassNameMBean类继承自 org.apache.commons.modeler.BaseModelMBean类，它提供了一个属性className，用于表示托管资源的类名，详细的内容看下面

 package org.apache.catalina.mbeans;
 
 import javax.management.MBeanException;
 import javax.management.RuntimeOperationsException;
 import org.apache.commons.modeler.BaseModelMBean;
 
 /**
  *
  * <p>
  * <b>Title:ClassNameMBean.java</b>
  * </p>
  * <p>
  * Copyright:ChenDong 2018
  * </p>
  * <p>
  * Company:仅学习时使用
  * </p>
  * <p>
  * 类功能描述:这个类创建一个名为className属性，该属性将托管对象的完全限定类名报告为其值。
  * </p>
  *
  * @author 陈东
  * @date 2018年12月11日 下午10:18:52
  * @version 1.0
  */
 public class ClassNameMBean extends BaseModelMBean {
 
     // ---------------------------------------------------------- Constructors
 
     /**
      *
      * 用默认的<code>ModelMBeanInfo</code>信息构造ModelMBean。
      *
      * @exception MBeanException
      *                如果对象的初始化引发异常
      * @exception RuntimeOperationsException
      *                如果发生错误
      */
     public ClassNameMBean() throws MBeanException, RuntimeOperationsException {
 
         super();
 
     }
 
     // ------------------------------------------------------------ Properties
 
     /**
      * 返回其托管资源类的完全限定名
      */
     public String getClassName() {
 
         return (this.resource.getClass().getName());
 
     }
 
 }

　　ClassNameMBean类时BaseModelMBean类的子类，其属性className在托管资源中是不可见的，mbeans-descriptors.xml文件中的很多mbean元素使用该类作为其ModelMBean的类型。

StandardServerMBean类

　　StandardServerMBean类继承自 org.apache.commons.modeler.BaseModelMBean类，用于管理 org.apache.catalina.core.StandardServer类的实例，StandardServerMBean类是ModelMBean类的一个示例，它重写了托管资源的store方法，当管理应用程序调用store方法的时候，实际上会执行StandardServerMBean实例的store方法，而不是托管资源StandardServer对象的store方法，

 package org.apache.catalina.mbeans;
 
 import javax.management.InstanceNotFoundException;
 import javax.management.MBeanException;
 import javax.management.MBeanServer;
 import javax.management.RuntimeOperationsException;
 import org.apache.catalina.Server;
 import org.apache.catalina.ServerFactory;
 import org.apache.catalina.core.StandardServer;
 import org.apache.commons.modeler.BaseModelMBean;
 
 /**
  *
  * <p>
  * <b>Title:StandardServerMBean.java</b>
  * </p>
  * <p>
  * Copyright:ChenDong 2018
  * </p>
  * <p>
  * Company:仅学习时使用
  * </p>
  * <p>
  * 类功能描述: {@code org.apache.catalina.core.StandardServer} 组件的ModelMBean实现。
  * </p>
  *
  * @author 陈东
  * @date 2018年12月13日 下午7:36:09
  * @version 1.0
  */
 
 public class StandardServerMBean extends BaseModelMBean {
 
     // ------------------------------------------------------- Static Variables
 
     /**
      * 应用程序的<code>MBeanServer</code> 组件
      */
     private static MBeanServer mserver = MBeanUtils.createServer();
 
     // ----------------------------------------------------------- Constructors
 
     /**
      *
      * 使用默认的<code>ModelMBeanInfo</code> 实现一个<code>ModelMBean</code>
      *
      * @exception MBeanException
      *                如果对象的初始化器引发异常
      * @exception RuntimeOperationsException
      *
      */
     public StandardServerMBean() throws MBeanException, RuntimeOperationsException {
 
         super();
 
     }
 
     // ------------------------------------------------------------- Attributes
 
     // ------------------------------------------------------------- Operations
 
     /**
      *
      * 将整个<code>Server</code>的配置信息写入{@code server.xml}配置文件。
      *
      * @exception InstanceNotFoundException
      *                如果找不到托管资源对象
      * @exception MBeanException
      *                如果对象的初始化器抛出异常，或者不支持持久性
      * @exception RuntimeOperationsException
      *                如果持久性机制报告了异常
      */
     public synchronized void store() throws InstanceNotFoundException,
         MBeanException, RuntimeOperationsException {
 
         Server server = ServerFactory.getServer();
         if (server instanceof StandardServer) {
             try {
                 ((StandardServer) server).store();
             } catch (Exception e) {
                 throw new MBeanException(e, "Error updating conf/server.xml");
             }
         }
 
     }
 
 }

StandardServerMBean 是一种模型MBean，继承自BaseModelMBean，并重写了托管资源（org.apache.catalina.core.StandardServer）的一个方法

浅谈JMX的更多相关文章

浅谈springboot自动配置原理
前言 springboot自动配置关键在于@SpringBootApplication注解,启动类之所以作为项目启动的入口,也是因为该注解,下面浅谈下这个注解的作用和实现原理 @SpringBootA ...
浅谈 Fragment 生命周期
版权声明:本文为博主原创文章,未经博主允许不得转载. 微博:厉圣杰源码:AndroidDemo/Fragment 文中如有纰漏,欢迎大家留言指出. Fragment 是在 Android 3.0 中 ...
浅谈 LayoutInflater
浅谈 LayoutInflater 版权声明:本文为博主原创文章,未经博主允许不得转载. 微博:厉圣杰源码:AndroidDemo/View 文中如有纰漏,欢迎大家留言指出. 在 Android 的 ...
浅谈Java的throw与throws
转载:http://blog.csdn.net/luoweifu/article/details/10721543 我进行了一些加工,不是本人原创但比原博主要更完善~ 浅谈Java异常以前虽然知道一 ...
浅谈SQL注入风险 - 一个Login拿下Server
前两天,带着学生们学习了简单的ASP.NET MVC,通过ADO.NET方式连接数据库,实现增删改查. 可能有一部分学生提前预习过,在我写登录SQL的时候,他们鄙视我说:“老师你这SQL有注入,随便都 ...
浅谈WebService的版本兼容性设计
在现在大型的项目或者软件开发中,一般都会有很多种终端, PC端比如Winform.WebForm,移动端,比如各种Native客户端(iOS, Android, WP),Html5等,我们要满足以上所 ...
浅谈angular2+ionic2
浅谈angular2+ionic2 前言: 不要用angular的语法去写angular2,有人说二者就像Java和JavaScript的区别. 1. 项目所用:angular2+ionic2 ...
iOS开发之浅谈MVVM的架构设计与团队协作
今天写这篇博客是想达到抛砖引玉的作用,想与大家交流一下思想,相互学习,博文中有不足之处还望大家批评指正.本篇博客的内容沿袭以往博客的风格,也是以干货为主,偶尔扯扯咸蛋(哈哈~不好好工作又开始发表博客啦 ...
Linux特殊符号浅谈
Linux特殊字符浅谈我们经常跟键盘上面那些特殊符号比如(?.!.~...)打交道,其实在Linux有其独特的含义,大致可以分为三类:Linux特殊符号.通配符.正则表达式. Linux特殊符号又可 ...

随机推荐

MySQL优化相关参数--先做个记录，以后可能用得到
innodb_io_capacity:可设置的磁盘IO性能参数,越高代表当前mysql的IO性能更好,可用做决策刷脏页速度的参数: innodb_flush_neighbors:刷脏页是否开启连坐机制 ...
springboot项目的maven的pom.xml文件第一行报错 Unknown Error
springboot项目的maven的pom.xml文件第一行报错 Unknown Error https://blog.csdn.net/mini_jike/article/details/9239 ...
查看MySQL 连接信息--连接空闲时间及正在执行的SQL
MySQL 客户端与MySQL server建立连接后,就可以执行SQL语句了. 如何查看一个连接上是否正在执行SQL语句,或者连接是否处于空闲呢? 下面我们做下测试. 1.查看连接的空闲时间首先看 ...
LC 265. Paint House II
There are a row of n houses, each house can be painted with one of the k colors. The cost of paintin ...
Swagger介绍及使用
相信无论是前端还是后端开发,都或多或少地被接口文档折磨过.前端经常抱怨后端给的接口文档与实际情况不一致.后端又觉得编写及维护接口文档会耗费不少精力,经常来不及更新.其实无论是前端调用后端,还是后端调用 ...
vue-cli2.x版本安装vue-cli建项目
全局安装vue-cli 命令行输入: vue-cli版本在3以下 npm install --global vue-cli 安装vue-cli后,可以查看一下是否安装成功vue --version, ...
Spring-Kafka —— KafkaListener定时启动和停止
一.定时启动的应用场景比如现在单机环境下,我们需要利用Kafka做数据持久化的功能,由于用户活跃的时间为早上10点至晚上12点,那在这个时间段做一个大数据量的持久化可能会影响数据库性能导致用户体验降 ...
Golang的goroutine协程和channel通道
一:简介因为并发程序要考虑很多的细节,以保证对共享变量的正确访问,使得并发编程在很多情况下变得很复杂.但是Go语言在开发并发时,是比较简洁的.它通过channel来传递数据.数据竞争这个问题在gol ...
python字典操作+文件操作+函数
师从百测besttest今天老牛教了些函数调用的知识,布置了个作业如下: # 1.写一个商品管理的小程序# 2.商品存在文件里面# 1.添加商品# 输入产品名称.颜色.价格# 要校验商品是否存在,价格 ...
keepalived脑裂问题
一.对脑裂的理解在高可用(HA)系统中,当联系2个节点的“心跳线”断开时,本来为一整体.动作协调的HA系统,就分裂成为2个独立的个体.由于相互失去了联系,都以为是对方出了故障.两个节点上的HA软件像 ...

浅谈JMX

MBeanServer类

ObjectName类

标准MBean

模型MBean

MBeanInfo 接口 与 ModelMBeanInfo接口

Commons Modeler

MBean描述符

mbean元素

attribute 元素

operation 元素

parameter 元素

mbean元素的示例

自己编写一个模型MBean类

Registry类.

ManagedMBean

BaseModelMBean

使用Modeler库 API

Catalina中的MBean

BaseModelMBean类

ClassNameMBean

StandardServerMBean类

浅谈JMX的更多相关文章

随机推荐

热门专题

　　MBeanServer类

MBeanInfo 接口与 ModelMBeanInfo接口