BlogJava-hengheng123456789-文章分类-JMX

利用JBossMX开发标准MBean（经典！转）

哼哼 — Thu, 21 Dec 2006 03:05:00 GMT

利用 JBossMX 开发标准 MBean

原文（http://www.ebook520.com/showbooktext.asp?id=2090&backcolor=E7F4FE&backsize=15）

JBoss 服务器是建立在 JBoss 的 JMX 实现工具（ JBossMX ）基础上的，访问 JBoss 网站（ http://www.jboss.org ）可以下载到独立的 JBoss JMX 实现工具软件包。将下载到的 jbossmx-1.1.2.zip 压缩包解压之后，把下列 jar 文件添加到 CLASSPATH 中：

jbossmx-1.1.2/jbossmx-1.1.2/lib/jboss-jmx.jar

jbossmx-1.1.2/jbossmx-1.1.2/lib/jboss-jmx-core.jar

JBOSS_HOME/client/gnu-regexp.jar

JBOSS_HOME/client/jbossall-client.jar

标准

MBean 在 JBoss 中使用范围最广， JBoss 中的许多组件都是利用标准 MBean 开发的。

1 ．计数器 MBean

下面是一个计数器 MBean 的开发示例。

（ 1 ）确定 MBean 的接口。

分析计数器的功能，确定了两个方法，即 add() 和 get() ， add() 负责加数， get() 负责加数并取回总数：

package com.liuyang.jmx.mbeans.counter;

public interface CounterMBean {

public void add(int num);

public int get(int num);

}

从代码中可以看到，开发标准 MBean 的 MBean 接口和开发普通接口除了需要在 MBean 类名称后面加上“ MBean ”之外，没有其他区别。

（ 2 ）实现 MBean 接口。

CounterMBean 是一个标准 MBean ，所以 MBean 实现类的名称必须和 MBean 接口之间遵守标准 MBean 的命名规范，所以 CounterMBean 的实现类 Counter 比 CounterMBean 少了尾部的 MBean 部分，下面是 Counter 的实现代码：

package com.liuyang.jmx.mbeans.counter;

public class Counter implements CounterMBean {

int sum = 0;

public void add(int num) {

sum+=num;

}

public int get(int num) {

sum+=num;

return sum;

}

从代码中也可以看到，标准 MBean 实现类与普通的 Java 程序也没什么区别。

（ 3 ）利用 JMX API 编写调用 CounterMBean 的程序。

JMX API 是 Sun 公司为 JMX 技术所设计的一套用来开发 JMX 应用的编程接口，通过 JMX API 可以管理和控制前面开发的 CounterMBean 资源。下面是利用 JMX API 编写调用 CounterMBean 的程序代码：

package com.liuyang.jmx.mbeans.counter;

import javax.management.MBeanServer;

import javax.management.MBeanServerFactory;

import javax.management.ObjectName;

public class CounterServer {

public static void main(String[] args) throws Exception {

MBeanServer server = MBeanServerFactory.createMBeanServer();

ObjectName name = new ObjectName("book.liuyang:service=Counter");

server.registerMBean(new Counter(), name);

String[] sig1 = {"int"};

Object[] opArgs1 = {new Integer(3)};

Object result1 = server.invoke(name, "add", opArgs1, sig1);

System.out.println(result1);

String[] sig2 = {"int"};

Object[] opArgs2 = {new Integer(0)};

Object result2 = server.invoke(name, "get", opArgs2, sig2);

System.out.println(result2);

}

2 ． ObjectName

ObjectName 代表一个 MBean 对象的名，创建一个 ObjectName 需要符合 MBean 的命名规范，例如：

ObjectName name = new ObjectName("book.liuyang:service=Counter");

3 ． MBeanServer

在 CounterServer 程序中，首先创建的 MBeanServer 这个对象代表前文中介绍的 MBean 服务器，它负责管理 MBean 资源，每个 MBean 资源可以被注册到 MBeanServer 之中：

server.registerMBean(new Counter(), name);

通过 MBeanServer 的 invoke 方法还可以调用一个 MBean ，在调用时需要传递一些与调用有关的参数：

Object result1 = server.invoke(name, "add", opArgs1, sig1);

其中：

name 是被调用对象的对象名。

"add" 要求调用被调对象的方法名称。

opArgs1 是一个数组，包含着的每个数据将被作为参数传递到被调方法。

sig1 是一个数组，包含着将被作为参数传递的每个数据的数据类型。

调用之后返回的对象包含着执行的结果。

4 ． MBeanServerFactory

MBeanServerFactory 是产生 MBeanServer 的工厂类，使用的 JMX 实现工具不同，通过 MBeanServerFactory 创建的 MBeanServer 实现对象也不同。如果 MBeanServer 已经被创建了，那么可以通过下面的方法获取：

MBeanServer server = MBeanServerFactory.newMBeanServer();

通过这个实例，可以了解到使用 MBeanServer 来控制 MBean 的基本方法，下面的用户查询 MBean 将进一步介绍通过 MBeanServer 对 MBean 的属性进行查询的方法。

5 ．用户查询 MBean

首先，确定 MBean 的接口。

用户查询 MBean 中的用户是这个 MBean 所代表的对象，这个设计的用户包括名称和角色，在这个例子中将对这两个属性进行监控，这是 JMX 为开发者提供的一种机制，所有被管理的 MBean 都在 MBeanServer 的控制之中，这个控制不仅包括上个计数器实例中所演示的方法调用功能，也包含对这些 MBean 的相关信息进行考察的功能。

package com.liuyang.jmx.mbeans.user;

public interface UserMBean {

public String getName();

    publicvoid setName(String name);

    public String getRole();

    public void setRole(String string);

}

UserMBean 中被设定了两个属性： name 和 role ，并遵照 Java Bean 的规则为它们提供了 get() 和 set() 方法。通过这两个方法可以设定 UserMBean 的两个属性。

package com.liuyang.jmx.mbeans.user;

public class User implements UserMBean {

private String name = "";

private String password = "";

private String role = "";

public String getName() {

return name;

}

publicvoid setName(String name) {

this.name = name;

}

public String getRole() {

return role;

}

public void setRole(String string) {

role = string;

}

User 这个类只是以最简单的方式实现了 UserMBean 接口。

下面的 UserQueries 演示了通过 MBeanServer 对 MBean 的属性进行查询的方法，代码如下：

package com.liuyang.jmx.mbeans.user;

import java.util.Iterator;

import java.util.Set;

import javax.management.Attribute;

import javax.management.MBeanServer;

import javax.management.MBeanServerFactory;

import javax.management.ObjectName;

import javax.management.Query;

import javax.management.QueryExp;

public class UserQueries {

publicstaticvoid main(String[] args) throws Exception {

MBeanServer server = MBeanServerFactory.createMBeanServer();

ObjectName user1 = new ObjectName("book.liuyang:Name=user1");

ObjectName user2 = new ObjectName("book.liuyang:Name=user2");

server.createMBean("com.liuyang.jmx.mbeans.user.User", user1);

    server.createMBean("com.liuyang.jmx.mbeans.user.User", user2);

    server.setAttribute(user1, new Attribute("Name", "user1"));

    server.setAttribute(user2, new Attribute("Name", "user2"));

server.setAttribute(user1, new Attribute("Role", "code"));

server.setAttribute(user2, new Attribute("Role", "test"));

QueryExp exp = Query.match(Query.attr("Name"),Query.value("user1"));

ObjectName scope = new ObjectName("book.liuyang:*");

Set set = server.queryNames(scope, exp);

Iterator it = set.iterator();

System.out.println(" 下列 MBean 的名字是： user1");

while (it.hasNext()) {

System.out.println(it.next());

}

scope = new ObjectName("book.liuyang:*");

exp = Query.initialSubString(Query.attr("Role"),Query.value("t"));

set = server.queryNames(scope, exp);

it = set.iterator();

System.out.println(" 下列 MBean 的角色是： test");

while (it.hasNext()) {

System.out.println(it.next());

}

在 UserQueries 中创建了两个 MBean 对象：

server.createMBean("com.liuyang.jmx.mbeans.user.User", user1);

这是 MBeanServer 通过 MBean 类的名称创建 MBean 实例的方法。

然后分别设置它们的属性：

server.setAttribute(user1, new Attribute("Name", "user1"));

一个 Attribute 对象代表一个属性。

JMX API 为查询服务建立标准的接口方法，第一步是建立查询表达式：

QueryExp exp = Query.match(Query.attr("Name"),Query.value("user1"));

这个查询表达式是以全匹配的方式进行的， JMX 还支持部分模糊查询的功能：

exp = Query.initialSubString(Query.attr("Role"),Query.value("t"));

initialSubString 建立的查询方法只会匹配名称的开始部分，在这里只要以“ t ”开头的值都会被匹配。

然后，通过一个 MBean 名称对象来代表查询范围：

ObjectName scope = new ObjectName("book.liuyang:*");

最后，通过 MBeanServer 执行查询表达式的操作，得到结果：

Set set = server.queryNames(scope, exp);

运行 UserQueries 可以得到查询结果。

哼哼 2006-12-21 11:05 发表评论

开发Jboss Mbean服务

哼哼 — Thu, 14 Dec 2006 10:03:00 GMT

众所周知Jboss依赖于JMX来装载MBean服务，而这些MBean服务组成了具体服务器实例的差异性。标准JBoss发布版本提供的所有功能都是基于MBean的。所以，如果要为JBoss服务器添加新的服务，最好的方法是开发自己的JMX MBean服务。
MBean服务的生命周期是由如下三个JBoss MBean负责的：SARDeployer、ServiceConfigurator、ServiceController。

如自定义MBean服务依赖于其他MBean服务，可以通过如下方法实现：
1、在自定义MBean接口中添加Service中任何方法。
这种方式避免了对JBoss具体接口的依赖。
2、为自定义MBean接口扩展org.jboss.system.Service接口。

3、为自定义MBean接口扩展org.jboss.system.ServiceMBean接口。
最简单的办法是将自定义MBean接口继承于ServiceMBean接口，将MBean实现类继承ServiceMBeanSupport类。ServiceMBeanSupport已经实现了ServiceMBean接口，ServiceMBeanSupport还集成了日志、JBoss服务状态管理跟踪功能，这些方法需要我们具体实现createService、startService、stopService和destroyService中的部分方法。

下面介绍基于ServiceMBean接口和ServiceMBeanSupport类的JNDIMapMBean接口及其JNDIMap实现类。

package org.joss.chap2.ex2;

import javax.naming.NamingException;

import org.jboss.system.ServiceMBean;

public interface JNDIMapMBean extends ServiceMBean
{
public String getJndiName();
public void setJndiName(String jndiName) throws NamingException;
}

package org.joss.chap2.ex2;

import java.util.HashMap;

import javax.management.MBeanServer;
import javax.management.ObjectName;
import javax.naming.InitialContext;
import javax.naming.Name;
import javax.naming.NamingException;

import org.jboss.naming.NonSerializableFactory;
import org.jboss.system.ServiceMBeanSupport;

public class JNDIMap extends ServiceMBeanSupport implements JNDIMapMBean
{
private String jndiName;
private HashMap contextMap = new HashMap();

public JNDIMap()
{
super();
// TODO Auto-generated constructor stub
}

public String getJndiName()
{

return jndiName;
}

public void setJndiName(String jndiName) throws NamingException
{
  String oldName = this.jndiName;
  this.jndiName = jndiName;
  if(super.getState()==STARTED)
  {
   unbind(oldName);
   try
   {
    rebind();
   }
   catch(Exception e)
   {
    NamingException ne = new NamingException("Failed to update jndiName");
    ne.setRootCause(e);
    throw ne;
   }
  }

}

public void startService()throws Exception
{
  rebind();
}

public void stopService()
{
  unbind(jndiName);
}

private void rebind() throws NamingException
{
  InitialContext rootCtx = new InitialContext();
  Name fullName = rootCtx.getNameParser("").parse(jndiName);
  NonSerializableFactory.rebind(fullName,contextMap,true);
}

private void unbind(String jndiName)
{
  try
  {
   InitialContext rootCtx = new InitialContext();
   rootCtx.unbind(jndiName);
   NonSerializableFactory.unbind(jndiName);
  }
  catch(NamingException e)
  {
   System.out.println(e);
  }
}

public String getName()
{
// TODO Auto-generated method stub
return null;
}

public int getState()
{
// TODO Auto-generated method stub
return 0;
}

public String getStateString()
{
// TODO Auto-generated method stub
return null;
}

public void jbossInternalLifecycle(String arg0) throws Exception
{
// TODO Auto-generated method stub

}

public void create() throws Exception
{
// TODO Auto-generated method stub

}

public void start() throws Exception
{
// TODO Auto-generated method stub

}

public void stop()
{
// TODO Auto-generated method stub

}

public void destroy()
{
// TODO Auto-generated method stub

}

public ObjectName preRegister(MBeanServer arg0, ObjectName arg1)
   throws Exception
{
  // TODO Auto-generated method stub
  return null;
}

public void postRegister(Boolean arg0)
{
// TODO Auto-generated method stub

}

public void preDeregister() throws Exception
{
// TODO Auto-generated method stub

}

public void postDeregister()
{
// TODO Auto-generated method stub

}

name="chap2.ex2:service=JNDIMap">

inmemory/map/MapTest
jboss:service=Naming

哼哼 2006-12-14 18:03 发表评论

基于JBoss来写MBean （转）

哼哼 — Tue, 12 Dec 2006 08:40:00 GMT

来源：http://www.blogjava.net/chengang/archive/2006/03/07/34091.html

一、 HelloWorld实例

1、准备工作

　　JBOSS实现了JMX规范，这个实例是基于JBOSS来实现的。请先去下载一个JBOSS，我是jboss-3.2.6，下载地址：http://www.jboss.com/downloads/index#as。这个实例需要JBOSS的两个JAR包的支持：jboss-system-3.2.6.jar、jboss-jmx-3.2.6.jar，如果你和我一样用Eclipse来开发（推荐），那么把这个两个包加入到项目的库引用中（加入到库引用的方法参考前面两章）。

2、程序代码

　　假设我们有一个叫message的属性要需要经常进行改动配置的，那么我们就把它写成一个MBean。

1、HelloWorldServiceMBean接口

　　在写MBean之前，我们先需要写一个MBean接口，接口里的方法都是属性的set/get方法。这个接口必须继承接口ServiceMBean。

import org.jboss.system.ServiceMBean;
public interface HelloWorldServiceMBean extends ServiceMBean {
String getMessage();
void setMessage(String message);
}

2、HelloWorldService实现类

　　然后写出HelloWorldServiceMBean接口的实现类HelloWorldService，这个实现类还必须继承ServiceMBeanSupport类。这种类再简单不过了，就是属性和相应的set/get方法，EJB中叫实体类、Hibernate中叫POJO。

import org.jboss.system.ServiceMBeanSupport;
public class HelloWorldService extends ServiceMBeanSupport implements HelloWorldServiceMBean {
    private String message;
    public String getMessage() {
        System.out.println("getMessage()=" + message);
        return message;
    }

    public void setMessage(String message) {
        System.out.println("setMessage(" + message + ")");
        this.message = message;
    }
}

3、配置文件jboss-service.xml

        Hello World

说明：

l code项指向MBean的实现类HelloWorldService
l name项是一个名称，格式一般是：[说明性文字]:service=[类名]
l attribute是为属性设置初始值，这样当JBOSS一加载HelloWorldService类时，message属性就有了一个初始值Hello World。注意Message的第一个字母必须是大写。

二、将实例部署到JBOSS

　　在jboss-3.2.6\server\default\deploy目录下创建一个hello.sar目录，然后创建如下目录文件结构：

其他说明：

l 也可以将hello.sar目录用zip格式压缩成一个同名的hello.sar文件，放到jboss-3.2.6\server\default\deploy目录下。
l JBOSS支持热部署，也就是说你在布置这个目录时并不需要重启JBOSS。

三、MBean的效果

打开网址：http://127.0.0.1:8080/jmx-console/　，出现下图

然后单击“service=HelloWorld”项打开详细页面如下：

将“HelloWorld”改成“Hello World，ChenGang”，再单击“Apply Changes”应用修改，得到如下效果：

四、其他类如何使用Messag属性

　　现在我们可以通过一个自动提供的WEB页面来设置Message属性了，接下来的问题是：“在其他类中应该如何得到Message的属性值”。MBean在JBoss是只保留一个MBean的实例（单例模式？），也就是说问题转成我们如何去取得这个唯一实例。例程如下：

1、创建一个使用到Message属性的类

import org.jboss.mx.util.MBeanProxyExt;
import org.jboss.mx.util.ObjectNameFactory;
public class Client {
    public void go() {
        HelloWorldServiceMBean mbean = (HelloWorldServiceMBean) MBeanProxyExt.create(HelloWorldServiceMBean.class, ObjectNameFactory.create(www.chengang.com.cn:service=HelloWorld));
        String msg = mbean.getMessage();
        System.out.println("Client.go()=" + msg);
    }
}

注意：go方法里是三句。第一句比较长，它是根据jboss-service.xml文件中设置的MBean名称，来取得此MBean在JBOSS中的实例。

2、在Mbean中加一个相应的调用Client.go的方法

　在HelloWorldServiceMBean接口中加入一句：

void callGo();

在HelloWorldService类中加入现实方法：

    public void callGo() {
        new Client().go();
    }

3、更新布署

将三个类的class文件：Clien.class、HelloWorldServiceMBean.class、HelloWorldService.class，更新到JBOSS的hello.sar\example\mbean目录下。然后重启JBOSS。

4、查看效果

打开JBOSS提供的MBean设置页面，如下，发现多了一个callGo。

单击callGo项后的invoke按钮，得到如下的DOS输出：

五、其他说明

l 本实例仅演示了一个Message属性，你当然可以在HelloWorldService中加入更多属性，别忘了在HelloWorldServiceMBean接口也加入相应的set/get方法。
l 本实例的message属性是String类型的，但JMX也支持其他的类型，甚至是XML信息。对于jboss-service.xml中的XML信息，这时属性类型要求是org.w3c.dom.Element，JMX将它封装成了一个XML的DOM对象。
l 回顾一下，JMX也是将配置信息写在了一个文件（jboss-service.xml文件）里嘛，相对于将配置文件写到*.properties文件的方式，它似乎也没什么新鲜的地方。但通过本章实例我们可以看到JMX的一些好处：我们不用写代码去读配置文件的信息，而且JMX支持的属性类型是多种多样的（如上面说的org.w3c.dom.Element）。更重要的是JMX还提供了一整套的属性之前互相访问、互相调用的功能，这个HelloWorld实例所反映的只是冰山一角而已。

六、参考资料：http://www.huihoo.com/java/jmx/jmx_base.html　

哼哼 2006-12-12 16:40 发表评论

7、用JDK5.0的JConsole来连接MBean

哼哼 — Thu, 31 Aug 2006 04:55:00 GMT

前面所有看效果都是通过Html网页来看的。JDK5.0自带了一个jmx客户端，叫jconsole，位于c:\jdk\bin\jconsole.exe。我们来用用这个客户端来连接Mbean Server。
　
一、vm参数方式
　
1、还是用第一篇的那个HelloAgent，修改HelloAgent，将第一句：
MBeanServer server = MBeanServerFactory.createMBeanServer();
改为：MBeanServer server = ManagementFactory.getPlatformMBeanServer();
注：ManagementFactory的全路径为：java.lang.management.ManagementFactory
　
2、修改Eclipse的run选项，把“-Dcom.sun.management.jmxremote=HelloAgent”这一句加入到run选项中
　
3、运行HelloAgent，然后在Dos窗口输入“jconsole”来启到JConsole
4、单击“连接”
　
二、RMI方式
　
　　还是用jconsole，但方式变了。这里不需要象上面那样修改Eclipse run的vm选项。
　
1、还是用第一篇的HelloAgent，加上一段代码，启动一个JMXConnectorServer服务

import javax.management.MBeanServer;
import javax.management.MBeanServerFactory;
import javax.management.ObjectName;
import javax.management.remote.JMXConnectorServer;
import javax.management.remote.JMXConnectorServerFactory;
import javax.management.remote.JMXServiceURL;

import com.sun.jdmk.comm.HtmlAdaptorServer;

public class HelloAgent {
    public static void main(String args[]) throws Exception {
        MBeanServer server = MBeanServerFactory.createMBeanServer();
        ObjectName helloName = new ObjectName("chengang:name=HelloWorld");
        Hello hello = new Hello();
        server.registerMBean(hello, helloName);
        ObjectName adapterName = new ObjectName("HelloAgent:name=htmladapter,port=8082");
        HtmlAdaptorServer adapter = new HtmlAdaptorServer();
        server.registerMBean(adapter, adapterName);
        adapter.start();
        System.out.println("start.....");

        // Create an RMI connector and start it
        JMXServiceURL url = new JMXServiceURL("service:jmx:rmi:///jndi/rmi://localhost:9999/server");
        JMXConnectorServer cs = JMXConnectorServerFactory.newJMXConnectorServer(url, null, server);
        cs.start();
        System.out.println("rmi　start.....");
    }
}

　
2、在Dos运行一个命令：rmiregistry 9999

3、运行HelloAgent，然后再在dos下运行命令jconsole
输入service:jmx:rmi:///jndi/rmi://localhost:9999/server
　
三、总结
　　连接MBeanServer的方式除了Html、JConsole，还有一些第三方的客户端，比较有名的是MC4j，通过这些客户端我们可以很容易去访问MBean。这也就是我们为什么要用JMX的其中一个原因：试想如果我自己搞一套标准，势必要自己开发一个客户端，那会是一个不小的工作量。

哼哼 2006-08-31 12:55 发表评论

6、模型Bean：Model Bean

哼哼 — Wed, 30 Aug 2006 02:04:00 GMT

在上一节是用apache的commons-modeler来开发的一个model，只不过commons-modeler帮助我们实现了很多的代码，而我们只需要写描述XML文件就行了。这一节，来一个实打实的Model Bean，不借助任何第三方工具包。例子还是沿用Hello这个类，以便于和以前的实现相比较。
　
一、Model MBean实例
1、Hello.java还是和以前的一样。这里它没有再加上一个MBean接口了，只是一个很普通的类。

public class Hello{
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void printHello() {
        System.out.println("Hello World, " + name);
    }
    public void printHello(String whoName) {
        System.out.println("Hello , " + whoName);
    }
}

　
2、接下来是HelloAgent的写法，和以前就差一句：把“new Hello()”这一句删除了，加上了ModelMbeanUtils.createModlerMbean();

import javax.management.MBeanServer;
import javax.management.MBeanServerFactory;
import javax.management.ObjectName;
import javax.management.modelmbean.RequiredModelMBean;

import com.sun.jdmk.comm.HtmlAdaptorServer;

public class HelloAgent {
    public static void main(String[] args) throws Exception {
        MBeanServer server = MBeanServerFactory.createMBeanServer();
        ObjectName helloName = new ObjectName("chengang:name=HelloWorld");
        //Hello hello = new Hello();
        RequiredModelMBean hello = ModelMBeanUtils.createModlerMBean();
        server.registerMBean(hello, helloName);
        ObjectName adapterName = new ObjectName("HelloAgent:name=htmladapter,port=8082");
        HtmlAdaptorServer adapter = new HtmlAdaptorServer();
        server.registerMBean(adapter, adapterName);
        adapter.start();
        System.out.println("start.....");
    }
}

3、ModelMbeanUtils这个类是要我们自己来实现的，也是写model Bean最麻烦的地方，它主要是返回一个RequiredModelMBean类，此类主要包括了一个ModelMBeanInfo类的信息。在 ModelMBeanInfo中定义了所有对需要管理的属性和方法的描述。具体代码如下：

import javax.management.Descriptor;
import javax.management.MBeanOperationInfo;
import javax.management.MBeanParameterInfo;
import javax.management.modelmbean.DescriptorSupport;
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;
public class ModelMBeanUtils {
    private static final boolean READABLE = true;
    private static final boolean WRITABLE = true;
    private static final boolean BOOLEAN = true;
    private static final String STRING_CLASS = "java.lang.String";
    public static RequiredModelMBean createModlerMBean() {
        RequiredModelMBean model = null;
        try {
            model = new RequiredModelMBean();
            model.setManagedResource(new Hello(), "ObjectReference");
            ModelMBeanInfo info = createModelMBeanInfo();
            model.setModelMBeanInfo(info);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return model;
    }
    private static ModelMBeanInfo createModelMBeanInfo() {
        //////////////////////////////////////////////////////////////////
        //                        属性                                        //
        //////////////////////////////////////////////////////////////////
        // 构造name属性信息
        Descriptor portAttrDesc = new DescriptorSupport();
        portAttrDesc.setField("name", "Name");
        portAttrDesc.setField("descriptorType", "attribute");
        portAttrDesc.setField("displayName", "Name");
        portAttrDesc.setField("getMethod", "getName");
        portAttrDesc.setField("setMethod", "setName");
        ModelMBeanAttributeInfo nameAttrInfo = new ModelMBeanAttributeInfo(//
                "Name", // 属性名
                STRING_CLASS, //属性类型
                "people name", // 描述文字
                READABLE, WRITABLE, !BOOLEAN, // 读写
                portAttrDesc // 属性描述子
        );
        //////////////////////////////////////////////////////////////////
        //                        方法                                        //
        //////////////////////////////////////////////////////////////////
        // 构造 getName操作描述符信息
        Descriptor getStateDesc = new DescriptorSupport(new String[] {
          "name=getName", "descriptorType=operation", "class=Hello",
          "role=operation" });

        ModelMBeanOperationInfo getName = new ModelMBeanOperationInfo(//
          "getName", //
          "get name attribute", //
          null, //
          "java.lang.String", //
          MBeanOperationInfo.ACTION, //
          getStateDesc //
        );

        // 构造 setName操作描述符信息
        Descriptor setStateDesc = new DescriptorSupport(new String[] {
          "name=setName", "descriptorType=operation", "class=Hello",
          "role=operation" });

MBeanParameterInfo[] setStateParms = new MBeanParameterInfo[] { (new MBeanParameterInfo(
"name", "java.lang.String", "new name value")) };

        ModelMBeanOperationInfo setName = new ModelMBeanOperationInfo(//
          "setName", //
          "set name attribute", //
          setStateParms, //
          "void", //
          MBeanOperationInfo.ACTION, //
          setStateDesc //
        );

        //构造 printHello()操作的信息
        ModelMBeanOperationInfo print1Info = new ModelMBeanOperationInfo(//
                "printHello", //
                null, //
                null, //
                "void", //
                MBeanOperationInfo.INFO, //
                null //
        );
        // 构造printHello(String whoName)操作信息
        ModelMBeanOperationInfo print2Info;
        MBeanParameterInfo[] param2 = new MBeanParameterInfo[1];
        param2[0] = new MBeanParameterInfo("whoName", STRING_CLASS, "say hello to who");
        print2Info = new ModelMBeanOperationInfo(//
                "printHello", //
                null,//
                param2,//
                "void", //
                MBeanOperationInfo.INFO, //
                null//
        );
        //////////////////////////////////////////////////////////////////
        //                        最后总合                                    //
        //////////////////////////////////////////////////////////////////
        // create ModelMBeanInfo
        ModelMBeanInfo mbeanInfo = new ModelMBeanInfoSupport(//
                RequiredModelMBean.class.getName(), // MBean类
                null, // 描述文字
                new ModelMBeanAttributeInfo[] { // 所有的属性信息（数组）
                nameAttrInfo },//只有一个属性
                null, // 所有的构造函数信息
                new ModelMBeanOperationInfo[] { // 所有的操作信息（数组）
                        getName,
                        setName,
                        print1Info,
                        print2Info },//
                null, // 所有的通知信息(本例无)
                null//MBean描述子
        );
        return mbeanInfo;
    }
}

4、看效果的方法和以前一样，运行HelloAgent，用浏览器打开：http://localhost:8082 。效果图和standard mbean一样，就不再帖出来了，去第一篇去看吧http://blog.sohu.com/members/somebody076/545896.html

二、总结
　
   我们发现模型Mbean(Model MBean)要比标准MBean(standard mbean)复杂多了，那有什么理由让我们选择使用模型MBean吗？我认为，最大的理由就是模型MBean可以动态配置。试想一下这个应用场景：由于安全或其他原因，系统要把某个MBean公开的可管理方法隐藏起来。这时，如果你是用标准MBean，这需要修改接口类，然后重新编译发布；如果用 Apache commons-modeler来写的模型MBean，则只需要修改XML文件就行了，不需要重新编译发布（可能要重启一下系统）。这就是模型Mbean 优势之所在了。
　
　细心的人会发现动态MBean和这一节的模型Mbean非常相似，但它们还是有很大不同的：动态MBean没有Hello类，它要自己实现Hello类中的方法逻辑。

哼哼 2006-08-30 10:04 发表评论

5、用Apache的commons-modeler来辅助开发JMX

哼哼 — Tue, 29 Aug 2006 03:09:00 GMT

一、前言
　
　　每一个MBean都要有一个接口，比如前面的Hello要有一个HelloMBean接口。要多维护一个接口，的确是件麻烦的事。 Apache的commons-modeler利用JMX中的动态MBean原理很好的解决了这一问题，commons-modeler使用得我们可以只写Hello，而不用写HelloMBean这个接口。不过这是有代价的，它要求我们写一个mbean的xml描述文件（唉，少了一件事，却又多出另一件事来）。但commons-modeler还是有优点的，就是它让mbean的装配更加灵活，把多个mbean的装配都集中在一个XML文件里来了。
　　开始实例之前，你需要先去apache网站下载commons-modeler，以及modeler的依赖项目commons-logging。下载网址为：http://jakarta.apache.org/site/downloads/downloads_commons.html，下载的文件是ZIP压缩包，解压后找到commons-logging.jar和commons-modeler.jar。如果在DOS下用命令行开发，则把这两个JAR包加入到classpath系统变量中。如果你用Eclipse开发，则把JAR包加入到项目属性的Libratries（库）引用中。

二、HelloWorld实例

　我们以本系统的第一篇“1、JMX的Hello World”为例，来重新实现一次。
　
1、Hello.java的代码不变（注：为了在Eclipse上和原来的Hello文件放在不同的地方，我把新Hello放到了mbean.modelbean包），如下：

package mbean.modelbean;

import mbean.standard.HelloMBean;

public class Hello implements HelloMBean {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void printHello() {
        System.out.println("Hello World, " + name);
    }
    public void printHello(String whoName) {
        System.out.println("Hello , " + whoName);
    }
}

2、MBean不用写了，但需要写一个XML描述文件。文件名任取，这里取名为：mbeans-descriptors

这里只对标签做一下说明：

    * name mbean在xml中的唯一标识，不一定要和类同名
    * description　mbean的注释说明信息
    * domain mbean所属域
    * group mbean所属组
    * type mbean的类全名（包名＋类名）
    * classname 指定实现代理功能的ModelMbean的全名，如果不指定则默认为BaseModelMBean

3、接下来改写HelloAgent

package mbean.modelbean;

import java.io.InputStream;
import javax.management.MBeanServer;
import javax.management.ObjectName;
import javax.management.modelmbean.ModelMBean;
import org.apache.commons.modeler.ManagedBean;
import org.apache.commons.modeler.Registry;
import com.sun.jdmk.comm.HtmlAdaptorServer;

public class HelloAgent {
    public static void main(String[] args) throws Exception {
        //基于xml中的信息构建一个Registry
        Registry registry = Registry.getRegistry(null, null);
        InputStream stream = HelloAgent.class.getResourceAsStream("Mbeans-descriptors.xml");
        registry.loadMetadata(stream);
        stream.close();
        //由Registry得到一个MBeanServer
        MBeanServer server = registry.getMBeanServer();

        //得到Hello在描述文件中的信息类，对应于xml文件标签的name属性。
        ManagedBean managed = registry.findManagedBean("Hello");
        //创建ObjectName
        ObjectName helloName = new ObjectName(managed.getDomain() + ":name=HelloWorld");
        //得到ModelMBean
        ModelMBean hello = managed.createMBean(new Hello());
        //注册MBean
        server.registerMBean(hello, helloName);

        ObjectName adapterName = new ObjectName("HelloAgent:name=htmladapter,port=8082");
        HtmlAdaptorServer adapter = new HtmlAdaptorServer();
        server.registerMBean(adapter, adapterName);
        adapter.start();
        System.out.println("start.....");
    }
}

　
HelloAgent是效复杂的地方，我们来和以前的HelloAgent逐步比较一下，前后有什么不同：
（1）首先，新的HelloAgent需要将xml信息读入到Registry对象中，这是旧HelloAgent所没有的。

Registry registry = Registry.getRegistry(null, null);
InputStream stream = HelloAgent.class.getResourceAsStream("Mbeans-descriptors.xml");
registry.loadMetadata(stream);
stream.close();

（2）接着创建MBeanServer的方式也不同了
现在：MBeanServer server = registry.getMBeanServer();
以前: MBeanServer server = MBeanServerFactory.createMBeanServer();
　
（3）Hello相应的ObjectName创建也略不相同。主要是域名在XML描述文件里设置好了。
现在：ManagedBean managed = registry.findManagedBean("Hello");
     ObjectName helloName = new ObjectName(managed.getDomain() + ":name=HelloWorld");
以前：ObjectName helloName = new ObjectName("chengang:name=HelloWorld")
　
（4）得到MBean的方式也不同，这里就是关键的不同点
现在：ModelMBean hello = managed.createMBean(new Hello());
以前：Hello hello = new Hello();
注意：为什么现在要比以前多一个createMbean步骤呢，就是因为现在的写法并没有写Mbean，所以需要动态才需要生成一个。而以前就直接把new Hello()注册到mbean server就可以了，server会自动找到它的HelloMBean接口文件。
　
　也就上面四点区别，其他代码完全一样。测试和查看效果的方法和以前一样，在此不累述了。

　
　commons Modeler为Hello动态生成了一个MBean接口：BaseModelBean
　
参考资料
　　用Commons Modeler 开发JMX应用

哼哼 2006-08-29 11:09 发表评论

4、动态MBean：DynamicMBean

哼哼 — Tue, 29 Aug 2006 03:07:00 GMT

一、前言
　
　　动态MBean是在运行期才定义它的属性和方法，也就是说它有什么属性和方法是可以动态改变的。动态MBean主要利用一些辅助类（构造函数类MBeanConstructorInfo、属性类MBeanAttributeInfo、方法类MBeanOperationInfo）来完成这个功能，所有的动态MBean必须实现DynamicMBean接口。DynamicMBean写好后，使用方法和第一篇文章中普通的MBean一样。
　
　　给出一个动态MBean的实例，这个实例最初动态构了一个Name属性及一个print方法，当我们执行它的print方法之后，又给此MBean新增了一个print1方法。实例的代码如下：
二、实例
1、HelloDynamic类

import java.lang.reflect.Constructor;
import java.util.Iterator;
import javax.management.Attribute;
import javax.management.AttributeList;
import javax.management.DynamicMBean;
import javax.management.MBeanAttributeInfo;
import javax.management.MBeanConstructorInfo;
import javax.management.MBeanException;
import javax.management.MBeanInfo;
import javax.management.MBeanNotificationInfo;
import javax.management.MBeanOperationInfo;
import javax.management.MBeanParameterInfo;
import javax.management.ReflectionException;

/**
* @author Sunny Peng
* @author change by Chen.Gang, add a feature for dynamic add operation
* @version 1.0
*/
public class HelloDynamic implements DynamicMBean {
    //这是我们的属性名称
    private String name;
    private MBeanInfo mBeanInfo = null;
    private String className;
    private String description;
    private MBeanAttributeInfo[] attributes;
    private MBeanConstructorInfo[] constructors;
    private MBeanOperationInfo[] operations;
    MBeanNotificationInfo[] mBeanNotificationInfoArray;

    public HelloDynamic() {
        init();
        buildDynamicMBean();
    }

    private void init() {
        className = this.getClass().getName();
        description = "Simple implementation of a dynamic MBean.";
        attributes = new MBeanAttributeInfo[1];
        constructors = new MBeanConstructorInfo[1];
        operations = new MBeanOperationInfo[1];
        mBeanNotificationInfoArray = new MBeanNotificationInfo[0];
    }

    private void buildDynamicMBean() {
        //设定构造函数
        Constructor[] thisconstructors = this.getClass().getConstructors();
        constructors[0] = new MBeanConstructorInfo("HelloDynamic(): Constructs a HelloDynamic object", thisconstructors[0]);
        //设定一个属性
        attributes[0] = new MBeanAttributeInfo("Name", "java.lang.String", "Name: name string.", true, true, false);
        //operate method 我们的操作方法是print
        MBeanParameterInfo[] params = null;//无参数
        operations[0] = new MBeanOperationInfo("print", "print(): print the name", params, "void", MBeanOperationInfo.INFO);
        mBeanInfo = new MBeanInfo(className, description, attributes, constructors, operations, mBeanNotificationInfoArray);
    }

    //动态增加一个print1方法
    private void dynamicAddOperation() {
        init();
        operations = new MBeanOperationInfo[2];//设定数组为两个
        buildDynamicMBean();
        operations[1] = new MBeanOperationInfo("print1", "print1(): print the name", null, "void", MBeanOperationInfo.INFO);
        mBeanInfo = new MBeanInfo(className, description, attributes, constructors, operations, mBeanNotificationInfoArray);
    }

    public Object getAttribute(String attribute_name) {
        if (attribute_name != null)
            return null;
        if (attribute_name.equals("Name"))
            return name;
        return null;
    }

    public void setAttribute(Attribute attribute) {
        if (attribute == null)
            return;
        String Name = attribute.getName();
        Object value = attribute.getValue();
        try {
            if (Name.equals("Name")) {
                // if null value, try and see if the setter returns any exception
                if (value == null) {
                    name = null;
                    // if non null value, make sure it is assignable to the attribute
                } else if ((Class.forName("java.lang.String")).isAssignableFrom(value.getClass())) {
                    name = (String) value;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public AttributeList getAttributes(String[] attributeNames) {
        if (attributeNames == null)
            return null;
        AttributeList resultList = new AttributeList();
        // if attributeNames is empty, return an empty result list
        if (attributeNames.length == 0)
            return resultList;
        for (int i = 0; i < attributeNames.length; i++) {
            try {
                Object value = getAttribute(attributeNames[i]);
                resultList.add(new Attribute(attributeNames[i], value));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return resultList;
    }

    public AttributeList setAttributes(AttributeList attributes) {
        if (attributes == null)
            return null;
        AttributeList resultList = new AttributeList();
        // if attributeNames is empty, nothing more to do
        if (attributes.isEmpty())
            return resultList;
        // for each attribute, try to set it and add to the result list if successfull
        for (Iterator i = attributes.iterator(); i.hasNext();) {
            Attribute attr = (Attribute) i.next();
            try {
                setAttribute(attr);
                String name = attr.getName();
                Object value = getAttribute(name);
                resultList.add(new Attribute(name, value));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return resultList;
    }

    public Object invoke(String operationName, Object params[], String signature[]) throws MBeanException, ReflectionException {
        // Check for a recognized operation name and call the corresponding operation
        if (operationName.equals("print")) {
            //具体实现我们的操作方法print
            System.out.println("Hello, " + name + ", this is HellDynamic!");
            dynamicAddOperation();
            return null;
        } else if (operationName.equals("print1")) {
            System.out.println("这是动态增加的一方法print1");
            return null;
        } else {
            // unrecognized operation name:
            throw new ReflectionException(new NoSuchMethodException(operationName), "Cannot find the operation " + operationName + " in " + className);
        }

    }

    public MBeanInfo getMBeanInfo() {
        return mBeanInfo;
    }
}

说明：

    * 实现于接口DynamicMBean
    * 借助于各种辅助类完成一个类的构造。构造函数类MBeanConstructorInfo、属性类MBeanAttributeInfo、方法类MBeanOperationInfo
    * 这里所有public方法是实现于DynamicMBean的。主要提供：setAttribute设置属性、 getAttribute取得属性、setAttributes设置一组属性、getAttributes取得一组属性、invoke方法调用、 getMBeanInfo　MBeanServer由这个方法得到关键的MBean类的构造信息。

2、HelloAgent类
　　
　　前面说了HelloDynamic和普通MBean的使用方法是一样的，因此HelloAgent和第一篇的HelloAgent基本一样，就是把Hello改成HelloDynamic而已。为了实例完整，也一并帖出来吧。

import javax.management.MBeanServerFactory;
import javax.management.ObjectName;
import com.sun.jdmk.comm.HtmlAdaptorServer;
public class HelloAgent {
    public static void main(String[] args) throws Exception {
        MBeanServer server = MBeanServerFactory.createMBeanServer();
        ObjectName helloName = new ObjectName("chengang:name=HelloDynamic");
        HelloDynamic hello = new HelloDynamic();
        server.registerMBean(hello, helloName);
        ObjectName adapterName = new ObjectName("HelloAgent:name=htmladapter,port=8082");
        HtmlAdaptorServer adapter = new HtmlAdaptorServer();
        server.registerMBean(adapter, adapterName);
        adapter.start();
        System.out.println("start.....");
    }
}

　
3、运行
　
　　先运行HelloAgent。再打开浏览器，输入网址：http://localhost:8082/。单击进入“name=HelloDynamic ”项，执行print方法后再回到上一页面你会发现又多了一个print1方法。
　
4、总结
　　动态MBean的代码稍显复杂，但对于一些特殊需求的情况，它将显示出强大威力。而且它还是模型MBeans（Model MBeans）的基础。不过在一般的项目中，动态MBean还是用得比较少，所谓利器深藏之而不用，非常时方现光芒。

哼哼 2006-08-29 11:07 发表评论

3、Notification的使用

哼哼 — Mon, 28 Aug 2006 01:30:00 GMT

一、简介
　
　　Mbean之间的通信是必不可少的，Notification就起到了在Mbean之间沟通桥梁的作用。JMX notification 由四部分组成：

    * Notification 这个相当于一个信息包，封装了需要传递的信息
    * Notification broadcaster　这相当于一个广播器，把消息广播出去
    * Notification listerner　这是一个监听器，用于监听广播出来的Notification消息
    * Notification filter　这是一个过滤器，过滤掉不需要的Notification消息

　 Notification broadcaster不需要我们实现，JMX的内部已经有了。Notification filter一般也很少用。下面的例子主要用到了Notification、Notification listerner。

二、实例
　
　　在第一篇的Hello中有一个printHello(String whoName)方法，意思根据碰到的是谁来打招呼，比如：
　
　　Jack从对面走过来，说：“hi”
　　我们回之以礼，说：“Hello, jack”
　
　　首先这需要Jack先说一个hi（相应一个操作方法），然后他说的话封装成声波（相当Notification消息包）传递出去。然后我们还要给Jakc装上一个监听器（Hello的耳朵？？^_^），这个监听器将捕捉到Jack的声波语音包，并进行相应处理，即说“Hello, jack”。
　
　　好，我们看看如何实现的：
　
1、Jack类及其相应的MBean

   我们把Jack写成一个MBean，如下：

import javax.management.Notification;
import javax.management.NotificationBroadcasterSupport;

public class Jack extends NotificationBroadcasterSupport implements JackMBean {
    private int seq = 0;
    public void hi() {
        Notification n = new Notification(//创建一个信息包
                "jack.hi",//给这个Notification起个名称
                this, //由谁发出的Notification
                ++seq,//一系列通知中的序列号,可以设任意数值
                System.currentTimeMillis(),//发出时间
                "Jack");//发出的消息文本
        //发出去
        sendNotification(n);
    }
}

说明：

    * 必需继承NotificationBroadcasterSupport
    * 此类只有一个hi方法，方法只有两句：创建一个Notification消息包，然后将包发出去
    * 如果你还要在消息包上附加其他数据，Notification还有一个setUserData方法可供使用

2、接下来是他的MBean

public interface JackMBean {
    public void hi();
}

3、创建一个Listener，监听到的Notification消息包将由此类负责处理。

import javax.management.Notification;
import javax.management.NotificationListener;
public class HelloListener implements NotificationListener {
    public void handleNotification(Notification n, Object handback) {
        System.out.println("type=" + n.getType());
        System.out.println("source=" + n.getSource());
        System.out.println("seq=" + n.getSequenceNumber());
        System.out.println("send time=" + n.getTimeStamp());
        System.out.println("message=" + n.getMessage());

        if (handback != null) {
            if (handback instanceof Hello) {
                Hello hello = (Hello) handback;
                hello.printHello(n.getMessage());
            }
        }
    }
}

4、修改HelloAgent如下（加上了红色的三句）：

import javax.management.MBeanServer;
import javax.management.MBeanServerFactory;
import javax.management.ObjectName;
import com.sun.jdmk.comm.HtmlAdaptorServer;
public class HelloAgent {
    public static void main(String args[]) throws Exception{
        MBeanServer server = MBeanServerFactory.createMBeanServer();
        ObjectName helloName = new ObjectName("chengang:name=HelloWorld");
        Hello hello=new Hello();
        server.registerMBean(hello, helloName);
        ObjectName adapterName = new ObjectName("HelloAgent:name=htmladapter,port=8082");
        HtmlAdaptorServer adapter = new HtmlAdaptorServer();
        server.registerMBean(adapter, adapterName);
        Jack jack = new Jack();
        server.registerMBean(jack, new ObjectName("HelloAgent:name=jack"));
        jack.addNotificationListener(new HelloListener(), null, hello);
        adapter.start();
        System.out.println("start.....");
    }
}

三、运行
1、先运行HelloAgent启动服务，再打开浏览器输入网址：http://localhost:8082/

2、　进入“name=jack”项，然后单击“hi”按钮来执行它。这时Eclipse的console视图
四、总结

　　Notification和Java的事件模型是一样的，另外如果你买了《Eclipse从入门到精通》，你会发现第22.4节也使用了和Notification和Java的事件模型相同的设计方式。Notification在我们的实际项目中也用到了，象我们现在的给移动做的项目中（基于JMX实现)，分散在各地方的工作站的日志，就是通过Notification方式，把每条产生的日志封装在 Notification中实时发回主控服务器的。有机会我会发这一系统的关于日志的设计方案写一下，它实现了对各地工作站的集中的、实时的监控，非常实用。

哼哼 2006-08-28 09:30 发表评论

2、JMX简介

哼哼 — Mon, 28 Aug 2006 01:28:00 GMT

一、JMX简介

　　JMX是一种JAVA的正式规范，它主要目的是让程序且有被管理的功能，那么怎么理解所谓的“被管理”呢？试想你开发了一个软件（如ＷＥＢ网站），它是在２４小时不简断运行的，那么你可能会想要“监控”这个软件的运行情况，比如收到了多少数据，有多少人登录等等。或者你又想“配置”这个软件，比如现在访问人数比较多，你想把数据连接池设置得大一些。

　　当然，你也许会专门为这些管理来开发软件，但如果你借助JMX，则会发现创建这样的管理程序是如此简单。因为你无需为管理程序来开发界面，已经有通用的JMX管理软件，如MC4J，或者是用一般都附带提供的HTML网页来管理，你要做的仅仅是将自己要被管理和监控类的按照JMX规范修改一下即可。

　　中间件软件WebLogic的管理页面就是基于JMX开发的，而JBoss则整个系统都基于JMX构架。下面将JMX的一些概念，从JMX规范转帖如下：

二、JMX构架中的各层及相关的组件

工具层（Instrumentation Level）
    (a) MBeans（标准的，动态的，开放的和模型MBeans）
    (b) 通知模型：Notification、NotificationListener等类
    (c) MBean元数据类：Attribute、Opreator等类
代理层（Agent Level）
(a) MBean Server
(b) 代理服务。如前一篇的HtmlAdaptorServer等。

　　MBean中有getter和setter的就是属性，如前一篇的Hello类中Name。如果只有getter则表示该属性只读。一共有四种MBean，如下：

标准MBeans（Standard MBeans）设计和实现是最简单的，这类MBean使用自己的方法名作为管理接口；
动态MBeans（Dynamic MBeans）必须实现一个指定的接口，由于动态MBeans在运行期间暴露它们的管理接口，因此更为灵活；
开放MBeans（Open MBeans）属于动态MBeans，这类MBean依靠基础数据类型来实现通用管理，并为友情用户进行自我声明；
模型MBeans（Model MBeans）同样也是动态MBeans，这类MBeans是完全可配置的，在运行期间进行自我声明；它们为资源动态工具提供一个一般性的，有默认行为的MBeans类。

　　在前一篇中的Hello、HelloMBean就是一个标准MBeans（Standard MBeans）。后面接下来的几篇，我们会继续介绍其他几种MBean。

哼哼 2006-08-28 09:28 发表评论

1、JMX的Hello World

哼哼 — Fri, 25 Aug 2006 02:00:00 GMT

一、JMX简介

　　什么是JMX？在一篇网文中是这样说的："JMX(Java Management Extensions)是一个为应用程序植入管理功能的框架。JMX是一套标准的代理和服务，实际上，用户可以在任何Java应用程序中使用这些代理和服务实现管理"，这句话我现在看着还是不知所云，云里雾里。

　　我们还是从JMX能给我们提供什么好处入手来理解吧。举一个应用实例：在一个系统中常常会有一些配置信息，比如服务的IP地址，端口号什么的，那么如何来写这些代码呢？

   1. 程序初哥一般是写死在程序里，到要改变时就去改程序，然后再编译发布；
   2. 程序熟手则一般把这些信息写在一个配置文件里（JAVA一般都是*.properties文件），到要改变时只要改配置文件，但还是重新启动系统，以便读取配置文件里的新值；
   3. 程序好手则会写一个段代码，把配置值缓存起来，系统在读值的时候，先看看配置文件有没有更动。如有更改则重读一遍，否则从缓存里读取值
   4. 程序高手则懂得取物为我所用，用JMX！把配置属性集中在一个类，然后写一个叫MBean的东东，再配置一下就轻松搞定了。而且JMX自动提供了一个WEB页面来给你来改变这些配置信息。

二、准备工作

　　JMX是一份规范，SUN依据这个规范在JDK（1.3、1.4、5.0）提供了JMX接口。而根据这个接口的实现则有很多种，比如Weblogic的JMX实现、MX4J、JBoss的JMX实现。在SUN自己也实现了一份，不过在JDK1.4之前，这件JMX实现（一些JAR包）是可选的，你得去它的网站上下载。JDK5.0则内嵌了进来，安装JDK5.0就可以开发基于JMX的代码了。
　　但JDK5.0并非包含所有SUN的关于JMX的代码，有一些工具类是排除在JDK5.0之外的。下面根据所使用的JDK版本情况，谈一谈开发环境的准备。
1、JDK1.3、1.4
　　去SUN网站下载SUN的JMX实现，共两个ZIP文件，下载网址：http://java.sun.com/products/JavaManagement/download.html。
（1）jmx-1_2_1-ri.zip
　　　解压后的lib目录包含：jmxri.jar、jmxtools.jar
（2）jmx_remote-1_0_1_03-ri.zip
　　　解压后的lib目录包含：jmxremote.jar、jmxremote_optional.jar、rmissl.jar
　　如果在DOS下用命令行开发，则把这五个JAR包加入到classpath系统变量中。如果你用Eclipse开发，则把JAR包加入到项目属性的Libratries（库）引用中。
2、JDK5.0
　　JDK5.0的jre\lib\rt.jar已经包含了jmxri.jar、jmxremote.jar、rmissl.jar三个包的代码。如果你用到jmxtools.jar、jmxremote_optional.jar的类，则需要将这两个类加入到classpath或 Eclipse的项目库引用中。
3、我使用的开发环境：JDK5.0 ＋ Eclipse3.2。
　　注：因为用到jmxtools.jar中的HtmlAdaptorServer类，所以将此包加入到项目库引用中。jmxremote_optional.jar暂时不用到，不管它。

三、HelloWorld实例
1、Hello是一个需要被管理的类（普通类）

/**
* @author ChenGang 2005-12-3
*/
public class Hello implements HelloMBean {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void printHello() {
        System.out.println("Hello World, " + name);
    }
    public void printHello(String whoName) {
        System.out.println("Hello , " + whoName);
    }
}

2、要管理Hello则必须创建一个相应MBean，如下：

/**
* @author ChenGang 2005-12-3
*/
public interface HelloMBean {
    public String getName();
    public void setName(String name);
    public void printHello();
    public void printHello(String whoName);
}

说明：包含在MBean中方法都将是可以被管理的。MBean起名是有规范的，就是原类名后加上MBean字样。
　
3、创建一个Agent类

import javax.management.MBeanServer;
import javax.management.MBeanServerFactory;
import javax.management.ObjectName;
import com.sun.jdmk.comm.HtmlAdaptorServer;

public class HelloAgent {

    public static void main(String[] args) throws Exception {
        MBeanServer server = MBeanServerFactory.createMBeanServer();

        ObjectName helloName = new ObjectName("chengang:name=HelloWorld");
        server.registerMBean(new Hello(), helloName);

        ObjectName adapterName = new ObjectName("HelloAgent:name=htmladapter,port=8082");
        HtmlAdaptorServer adapter = new HtmlAdaptorServer();
        server.registerMBean(adapter, adapterName);

        adapter.start();
        System.out.println("start.....");

    }
}

说明：

    * 先创建了一个MBeanServer，用来做MBean的容器
    * 将Hello这个类注入到MBeanServer中，注入需要创建一个ObjectName类
    * 创建一个AdaptorServer，这个类将决定MBean的管理界面，这里用最普通的Html型界面。AdaptorServer其实也是一个MBean。
    * chengang:name=HelloWorld的名字是有一定规则的，格式为：“域名:name=MBean名称”，域名和MBean名称都可以任意取。

4、运行HelloAgent，然后打开网页：http://localhost:8082/
    单击“name=HelloWorld”链接进入

五、总结

　　在实际系统中我们可以把name变成决定数库链接池的变量，这样我就可以对系统的运行参数进行实现的监控和配置（管理）。而且也可以对一些方法（如printHello）进行远程调用了。

哼哼 2006-08-25 10:00 发表评论

BlogJava-hengheng123456789-文章分类-JMX

利用JBossMX开发标准MBean（经典！转）

开发Jboss Mbean服务

基于JBoss来写MBean （转）

一、 HelloWorld实例

1、准备工作

2、程序代码

二、将实例部署到JBOSS

三、MBean的效果

打开网址：http://127.0.0.1:8080/jmx-console/ ，出现下图

四、其他类如何使用Messag属性

五、其他说明

六、参考资料：http://www.huihoo.com/java/jmx/jmx_base.html

7、用JDK5.0的JConsole来连接MBean

6、模型Bean：Model Bean

5、用Apache的commons-modeler来辅助开发JMX

4、动态MBean：DynamicMBean

3、Notification的使用

2、JMX简介

1、JMX的Hello World

打开网址：http://127.0.0.1:8080/jmx-console/　，出现下图

六、参考资料：http://www.huihoo.com/java/jmx/jmx_base.html　