WebJMX开源项目应用与进阶

WebJMX开源项目应用与进阶
一个简单的JMX结构由以下几个步骤去完成：
① 需要一个MBeanServer作为一个容器，去装载你的MBean如下创建：MBeanServer server = MBeanServerFactory.createMBeanServer("Local");
② ObjectName,JDK文档对它的描述是如此的：表示 MBean 的对象名，或者能够与多个 MBean 名称相匹配的模式。

我们能够从字面上了解到他是干什么的了，就好比一个KEY, 当我们的MBean注入MBeanServer后总要有一个标识它，以方便我们以后通过那个KEY去找过我们的MBean.如下创建：
ObjectName manager = new ObjectName("NCS:name=scheduler");
③ 将我们需要进行治理的MBean注册到MBeanServer中，具体如下：
server.registerMBean(new IScheduler(), manager);
如此就算告一段落了，完成以上步骤后，将实现一个MBeanServer（一个容器）中拥有多个MBean(受治理的类).这确实是JMX的差不多实现。

那么假如要对MBean进行治理因此少不了一些治理机制，如SUN自己提供的HtmlAdaptorServer和Jconsole。

HtmlAdaptorServer能够通过WEB对MBean进行治理，Jconsole则是C/S结构的。

下面列举一下HtmlAdaptorServer的使用方法：
HtmlAdaptorServer adapter = new HtmlAdaptorServer();
server.registerMBean(adapter, adapterName);
以上代码片段能够看出事实上HtmlAdaptorServer 也确实是个MBean，而那个MBean可访问注册在MBeanServer的其他MBean而已。

最后启动HtmlAdaptorServer ：
adapter.start();
完整代码片段：
//XXX()自定义方法名吧！
public void XXX(){
try {
// create MBSERVER name is WUBINSERVER
List l = MBeanServerFactory.findMBeanServer(null);
if (l.size() > 0) {
server = (MBeanServer) l.get(0);
} else {
server = MBeanServerFactory.createMBeanServer("Local");
}
// Register HtmlAdaptorserver port is 8082.
ObjectName adapterName = new ObjectName(
"ManagerAgent:name=htmladapter,port=8082");
HtmlAdaptorServer adapter = new HtmlAdaptorServer();
server.registerMBean(adapter, adapterName);
// your self objectname register.
ObjectName manager = new ObjectName("NCS:name=scheduler");
server.registerMBean(new IScheduler(), manager);
ObjectName manager2 = new ObjectName("NCS:name=scheduler2");
server.registerMBean(new IScheduler(), manager2);
// ObjectName manager = new ObjectName("NCS:name=scheduler1"); // server.registerMBean(new JobManagerMBeanImpl(), manager);
adapter.start();
System.out.println("start.....");
} catch (MalformedObjectNameException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InstanceAlreadyExistsException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (MBeanRegistrationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NotCompliantMBeanException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NullPointerException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
当我们访问本地的8082后就能够看到HtmlAdaptorServer 所提供的治理界面，但如此的治理界面专门不人性化，（那么丑，如何见人呢？）那下面我郑重介绍的确实是WebJMX！！！他能帮我们解决治理界面的问题，让我们可自编写自己的治理界面。

WebJMX Tag Library Project
第一下载WEBJMX
:///project/showfiles.php?group_id=58769&release_id=102257
（建议下1.2a版本）
那在DOWNLOADING...的时候我来说一下WEBJMX的缺陷。

（是不是开门一棒，呵呵，那个我必须先告诉大伙儿一声，不然你发觉假如WEBJMX并不适合你的工程那下来也没什么意义了。

）
缺陷：
1、WEBJMX在2002年之后就再也没有更新过，最后一个版本是1.3。

专门遗憾，有可能以后都可不能有新的更新，假如你觉得这点无法同意，我能够介绍给你其他--------MX4J，只是那个东西专门苦恼，假如有爱好自己去找找资料吧。

2、WEBJMX是中标签，其他确实是利用标签库进行VIEW。

虽说标签已属于过去式，但不代表没有人用它嘛，象我如此的老人家还在用呢！：）
3、WEBJMX部署纷乱，资料较缺。

这点没有什么方法，因此我建议大伙儿下WEBJMX1.2a版本，那个1.3版本的必须用ANT部署才行，而且里面有专门多需要在环境变量里配置的东西，比如TOMCATHOME啊STRUTSHOME啊等等HOME。

而且我发觉在那ANT脚本里本提到有个JMX.war包在TEMP名目下，结果去查找也没找到~~~作者的失败之处……
4、WEBJMX用的JDK是1.4的，但不要紧也支持1.5
好了，废话过后相信你的WEBJMX工程也该下好了，把开始我们的WEBJMX旅程吧，我期望它是轻松愉快的。

小女子才疏学浅，假如有错误也期望得到批判，但不要象XX人在我的留言版中一样骂我，说偶的BLOG是垃圾BLOG，即便是垃圾BLOG也苦恼留点所谓的垃圾评语（为虾米垃圾）啊，否则就太不知所为了。

我举荐的部署方式并不是用他提供的ANT脚本，而是我们自己的部署手段。

我们先用MYECLIPSE创建一个WEB的PROJECT。

叫WEBJMX，然后将WEBJMX名目下的org整个名目拷贝到我们的新建的工程的src名目下，然后我们会看到好多红叉叉。

不用可怕，这都算少的了……
然后导入几个包包，那个包包有MX4J的、STRUTS的、QUICK的还有JMX自己的。

由于WEBJMX
是使用1.4的JDK。

因此当时SUN公司还没有将JMX放到JDK中，.1.5就没事了。

导完后差不多如下图那么多。

有可能在org部署的时候会遇到enum这是因为WEBJMX使用的JDK是1.4的，而我们现在差不多使用1.5以上的版本，只要用户自己随便改改变量名就能够了，别用enum那个变量名。

以下展现了两幅图：
这是HtmlAdaptorServer 的治理界面（여기에서간단한 HTML 공용영역이 JMX 참고실시로오는HTMLAdaptor 분대에의하여제공한）
而这确实是WEBJMX实例的治理界面，是不是比上面那个人性化的多呢？（여기에서WbJMX를사용하여 JSP에서동일한 MBeanServer의전망에의하여표를붙이는）
结构（건축술）
WEBJMX标签包括这些部分（JMX 꼬리표도서관은이분대이루어져있다）
＊一套JSP标签和描述标签句法的TLD的Java类。

（꼬리표통어론의일 JSP 꼬리표그리고 TLD 묘사를하는Java 클래스의세트）
＊由一个SERVLET同意页面上表单提交过来的数据。

事实上在这表单的数据是WebJMX标记修改后生成的。

那个表单类似于如此（페이지에 SERVLET에의하여모양이복종시키는자료를받아들인다. 실제로이모양 &#39 후에; s 자료는 WebJMX 표교정생성한다이다. 이모양은유사하다이것을좋아하기위하여）：
<jmx:formMBean name="changeschedulername" mbean="mbean" invoke="rescheduleJob" label="调用">于我们常见的FORM专门不同。

＊通过使用JSP标签和Servlet调用AdapterFactory能够得到MBeanServers 。

（MBeanServers를얻기위하여가능한용도를통해 Servlet JSP 상표및이동 AdapterFactory）
结构图：
（구조그림）：
我们能够从上图中看到，WEBJMX是如何工作的（尽管不是流程图，但事实上一目了然！）。

用户通过WEB扫瞄器通过 request 触发ACTION（JMXACTION SERVLET）然后通过JMXSerivceAdapter访问MBEANSERVER（能访问MBEANSERVER 也以为着能治理SERVER中的MBEAN啦！），那JMXSerivceAdapter事实上是种适配器，我们之前介绍过的HTMLAdapter也是适配器。

好！下面就开始看看我们的例子来真正认识一下WEBJMX。

第一作为一个WEB程序最重要的因此是WEB.xml啦，那我们就从它开始……
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN" " ://java.sun /j2ee/dtds/web-app_2_2.dtd">
<web-app>
<!-- register the JMX Action URL as an application parameter-->
<context-param>
<param-name>jmxAction</param-name>
<param-value>jmxAction</param-value>
<description>Default mapping to the JMXAction
servlet.</description>
</context-param>
<!-- JMX Action Servlet Configuration -->
<servlet>
<servlet-name>agent</servlet-name>
<servlet-class>org.webjmx.example.AgentServlet</servlet-class> <init-param>
<param-name>locator0</param-name>
<param-value>local</param-value>
</init-param>
<load-on-startup />
</servlet>
<servlet>
<servlet-name>jmxAction</servlet-name>
<servlet-class>org.webjmx.servlet.JMXAction</servlet-class>
<load-on-startup />
</servlet>
<servlet>
<servlet-name>action</servlet-name>
<servlet-class>org.apache.struts.action.ActionServlet</servlet -class>
<init-param>
<param-name>config</param-name>
<param-value>/WEB-INF/struts-config.xml</param-value> </init-param>
<init-param>
<param-name>debug</param-name>
<param-value>3</param-value>
</init-param>
<init-param>
<param-name>detail</param-name>
<param-value>3</param-value>
</init-param>
<load-on-startup>0</load-on-startup>
</servlet>
<!-- JMX Action Servlet Mapping -->
<servlet-mapping>
<servlet-name>jmxAction</servlet-name>
<url-pattern>/jmxAction</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
<!-- The Welcome File List -->
<welcome-file-list>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
<!-- JMX Tag Library Descriptor -->
<taglib>
<taglib-uri>/WEB-INF/jmx.tld</taglib-uri>
<taglib-location>/WEB-INF/jmx.tld</taglib-location>
</taglib>
<!-- Struts Tag Library Descriptor -->
<taglib>
<taglib-uri>/WEB-INF/struts-bean.tld</taglib-uri>
<taglib-location>/WEB-INF/struts-bean.tld</taglib-location>
</taglib>
<taglib>
<taglib-uri>/WEB-INF/struts-logic.tld</taglib-uri>
<taglib-location>/WEB-INF/struts-logic.tld</taglib-location> </taglib>
</web-app>
专门关键的一个片段：
……
<servlet>
<servlet-name>agent</servlet-name>
<servlet-class>org.webjmx.example.AgentServlet</servlet-class> <init-param>
<param-name>locator0</param-name>
<param-value>local</param-value>
</init-param>
<load-on-startup />
</servlet>
……
我们能够看到有一个叫agent的servlet被声明了。

那在TOMCAT启动的时候同时也被加载了。

然后我们来跟踪一下那个servlet的内容。

AgentServlet.java
先来看看他的init（）
public void init(ServletConfig config) throws ServletException { super.init(config);
doInit();
}
专门明显，他在初始化的时候调用了doInit()，然后我们再看看doInit()
/**
* instanitate some test MBeans.
*/
public void doInit() throws ServletException {
if (Boolean.getBoolean(DEBUG_PROP))
log("AgentServlet init()");
List l = MBeanServerFactory.findMBeanServer(null);
if (Boolean.getBoolean(DEBUG_PROP))
log("MBeanServer count:" + l.size());
if (l.size() > 0)
server = (MBeanServer) l.get(0);
else
server = MBeanServerFactory.createMBeanServer("Local");
if (Boolean.getBoolean(DEBUG_PROP))
log("initalizing local server instance: " + server);
HtmlAdaptorServer html = new HtmlAdaptorServer(8086);
ObjectName ob_name = null;
try {
ob_name = new ObjectName("Adaptor:name=html,port=8086");
if (Boolean.getBoolean(DEBUG_PROP))
log("OBJECT NAME: " + ob_name);
server.registerMBean(html, ob_name);
Enumeration e = getServletConfig().getInitParameterNames();
while (e.hasMoreElements()) {
String paramName = (String) e.nextElement();
if (!paramName.startsWith("locator"))
continue;
String locator =
getServletConfig().getInitParameter(paramName);
l = AdapterFactory.findMBeanServer(locator);
if (Boolean.getBoolean(DEBUG_PROP))
log("server list: " + l);
if (l.size() == 0)
return;
if (Boolean.getBoolean(DEBUG_PROP))
log("initalizing local server instance: " + server);
server = (MBeanServer) l.get(0);
if (Boolean.getBoolean(DEBUG_PROP))
log("server: " + server);
ob_name = new ObjectName("MBeanInfo", "name", "SimpleStandard");
if (Boolean.getBoolean(DEBUG_PROP))
log("OBJECT NAME: " + ob_name);
//
server.createMBean("org.webjmx.example.SimpleStandard",ob_name);
server.registerMBean(new SimpleStandard(), ob_name);
ob_name = new ObjectName("MBeanInfo", "name", "SimpleDynamic");
if (Boolean.getBoolean(DEBUG_PROP))
log("OBJECT NAME: " + ob_name);
server.registerMBean(new SimpleDynamic(), ob_name);
// server.createMBean("org.webjmx.example.SimpleDynamic",
// ob_name);
}
/*
* ObjectName sname = new
* ObjectName("JMImplementation:type=MBeanServerDelegate");
* MBeanInfo minfo = server.getMBeanInfo(sname); MBeanAttributeInfo
* attrs[] = minfo.getAttributes(); System.out.println("attribute * count: " +attrs.length); for(int i = 0; i < attrs.length; i++) * System.out.println(attrs[i].getName() +" : "
* +server.getAttribute(sname, attrs[i].getName()));
*/
} catch (Exception e) {
log("\t!!! Could not create the HTML adaptor !!!");
e.printStackTrace();
return;
}
html.start();
}
在方法开头就有注释，告诉你那个方法是干什么的了（instanitate some test MBeans.）初始化一些测试的MBEN，那个那个还不完全，在方法的内容我们能够看到，不仅仅是初始化了一些MBEAN，更重要的是实例了一个MBEANSERVER并将适配器和需要治理的MBEAN都加载到里面去了。

创建MBEANSERVER：
List l = MBeanServerFactory.findMBeanServer(null);
事实上那个方法更适合去查找MBEANSERVER，但假如没有找到，则会返回一个默认的MBEANSERVER，
创建一个Adaptor:
HtmlAdaptorServer html = new HtmlAdaptorServer(8086);
ob_name = new ObjectName("Adaptor:name=html,port=8086");
注册那个适配器到MBEANSERVER中
server.registerMBean(html, ob_name);
好，下面是注册我们自己的MBEAN到MBEANSERVER中去。

ob_name = new ObjectName("MBeanInfo", "name", "SimpleStandard");
事实上那个3参的构造方法跟ob_name= new
ObjectName(“MBeanInfo:name=SimpleStandard”);是同理的。

注册：
server.registerMBean(new SimpleStandard(), ob_name);
如此，我们的MBEAN就被注册到了MBEANSERVER中去了。

然后确实是启动我们的适配器，让我们的用户能够通过适配器去访问我们的MBEANSERVER了。

html.start();
如此，都WEB.XML和必要的servlet都差不多写好了。

然后就该在我们的页面上运用我们的标记进行访问我们的MBEAN了。

在例子的差不多页面index.html
细节我就些了，我们看关键的东西
<a
href="server1.jsp?locator=local&domain=Local&name=Local"> ://hi.ba idu /kekemao1</a>
能够看到那个超连接是跳转到server1.jsp并带了几个重要的参数。

locator=local,domain=Local还有name=Local。

哎？！什么缘故看起来那么想我们的ObjectName的参数？没错！后面两个参数确实是ObjectName的参数所用的,确实是new ObjectName(Local:name=Local)。

而locator=local那个是WEBJMX特定的，local是指本地的MBEANSERVER访问方式，还有remote方式。

在那个地点我们临时不说这两种方式，我回在回复栏里细说这两个参数倒底是干什么用的。

然后我们看看server1.jsp的内容:
头部分：
标记的声明
<%@ page import="java.util.*, javax.management.*" %>
<%@ taglib uri="/WEB-INF/struts-logic.tld" prefix="logic" %>
<%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean" %>
<%@ taglib uri="/WEB-INF/jmx.tld" prefix="jmx" %>
变量的声明，这些变量专门重要，
<bean:parameter id="locator" name="locator"/>
<bean:parameter id="domain" name="domain"/>
<bean:parameter id="serverName" name="name"/>
<jmx:getMBeanServer id="server" attribute="locator"/>
<jmx:getMBeanServer id="server" attribute="locator"/>那个变量也就类似我们获得了之前在我们的servlet中声明好的MBeanServer,可能你会想，那那个MBeanServer是哪来的啊？事实上当我们使用<jmx:getMBeanServer>的时候他会依照后面的attribute元素的值去内存中找那个名叫locator的MBeanServer的实例，就好比
MBeanServerFactory.findMBeanServer(“locator")。

体部分：
<jmx:queryNames id="names"
server="server">MBeanInfo:name=SimpleStandard</jmx:queryNames>
以名为MBeanInfo:name=SimpleStandard为条件，到server(之前声明好的MBEANSERVER对象)中去找那个ObjectName所对应的MBean，事实上ObjectName 和MBean是1对1的关系，一个ObjectName对应一个MBean，就好比我们的Map 类，一个KEY对应一个Value，用Key找Value一样。

他返回的是一个List（事实上我个人觉得没必要返回LIST）。

获得单个MBean：
<logic:iterate id="n" name="names" length="1">
再下去的内容我就不说了，没什么用。

接下去我们就自己来做个一HelloWorld 吧.
新建一个WEB OBJECT（我那个地点使用了MYECLIPSE，东西差不多上自动就加载的，假如你用其他的编译器那只好你自己看着大致去做了），然后导入STRUTS LIBS（MYECLIPSE自动生成）。

接着在WEB-INF名目中放下几个WEBJMX重要的文件AdapterFactoryInit.qjml，AdapterFactoryInit.xml，jmx.tld，QJML.dtd。

这些文件在WEBJMX开源项目1.2a中都有。

然后是我们的web.xml,内容如下：
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns=" ://java.sun /xml/ns/javaee"
xmlns:xsi=" :// /2001/XMLSchema-instance" version="2.5" xsi:schemaLocation=" ://java.sun
/xml/ns/javaee ://java.sun
/xml/ns/javaee/web-app_2_5.xsd">
<!-- register the JMX Action URL as an application parameter-->
<context-param>
<param-name>jmxAction</param-name>
<param-value>jmxAction</param-value>
</context-param>
<servlet>
<servlet-name>action</servlet-name>
<servlet-class>
org.apache.struts.action.ActionServlet
</servlet-class>
<init-param>
<param-name>config</param-name>
<param-value>/WEB-INF/struts-config.xml</param-value> </init-param>
<init-param>
<param-name>debug</param-name>
<param-value>3</param-value>
</init-param>
<init-param>
<param-name>detail</param-name>
<param-value>3</param-value>
</init-param>
<load-on-startup>0</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<!-- JMX Action Servlet Configuration -->
<servlet>
<servlet-name>agent</servlet-name>
<servlet-class>
com.kekemao1.jmxexample.servlet.AgentServlet
</servlet-class>
<init-param>
<param-name>locator0</param-name>
<param-value>local</param-value>
</init-param>
<load-on-startup />
</servlet>
<servlet>
<servlet-name>jmxAction</servlet-name>
<servlet-class>org.webjmx.servlet.JMXAction</servlet-class>
<load-on-startup />
</servlet>
<!-- JMX Action Servlet Mapping -->
<servlet-mapping>
<servlet-name>jmxAction</servlet-name>
<url-pattern>/jmxAction</url-pattern>
</servlet-mapping>
</web-app>
大伙儿看到事实上和我先前介绍的例子的XML没什么区别，事实上这些是必要的。

写好WEB.XML后，我们来完成servlet部分，如上描述的那样，我们有一个com.kekemao1.jmxexample.servlet.AgentServlet需要去实现：
com.kekemao1.jmxexample.servlet.AgentServlet内容如下：
package com.kekemao1.jmxexample.servlet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import javax.management.InstanceAlreadyExistsException;
import javax.management.MBeanRegistrationException;
import javax.management.MBeanServer;
import javax.management.MBeanServerFactory;
import javax.management.MalformedObjectNameException;
import javax.management.NotCompliantMBeanException;
import javax.management.ObjectName;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet. . Servlet;
import javax.servlet. . ServletRequest;
import javax.servlet. . ServletResponse;
import org.webjmx.tags.JMXTaglibConstants;
import com.kekemao1.jmxexample.mbeans.Kekemao;
import com.sun.jdmk m.HtmlAdaptorServer;
public class AgentServlet extends Servlet implements JMXTaglibConstants {
/**
*
*/
private static final long serialVersionUID = -5092348467994419208L;
private MBeanServer server = null;
/**
* Initializes the servlet.
*/
public void init(ServletConfig config) throws ServletException { super.init(config);
try {
doInit();
} catch (MalformedObjectNameException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InstanceAlreadyExistsException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (MBeanRegistrationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NotCompliantMBeanException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NullPointerException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
private void doInit() throws MalformedObjectNameException, NullPointerException, InstanceAlreadyExistsException,
MBeanRegistrationException, NotCompliantMBeanException { // TODO Auto-generated method stub
// create MBSERVER name is WUBINSERVER
List l = MBeanServerFactory.findMBeanServer(null);
if (l.size() > 0) {
server = (MBeanServer) l.get(0);
} else {
server = MBeanServerFactory.createMBeanServer("Local");
}
ObjectName adapterName = new ObjectName(
"ManagerAgent:name=htmladapter,port=8083");
HtmlAdaptorServer adapter = new HtmlAdaptorServer();
server.registerMBean(adapter, adapterName);
// your self objectname register.
ObjectName manager = new ObjectName("KEKEMAO:name=miaomiao");
server.registerMBean(new Kekemao(), manager);
adapter.start();
}
* Destroys the servlet.
*/
public void destroy() {
if (server != null)
MBeanServerFactory.releaseMBeanServer(server);
}
/**
* Processes requests for both <code>GET</code> and
<code>POST</code>
* methods.
*
* @param request
* servlet request
* @param response
* servlet response
*/
protected void processRequest( ServletRequest request, ServletResponse response) throws ServletException,
java.io.IOException {
response.setContentType("text/html");
java.io.PrintWriter out = response.getWriter();
// output your page here
out.println("<html>");
out.println("<head>");
out.println("<title>Servlet</title>");
out.println("</head>");
out.println("<body>");
List l = MBeanServerFactory.findMBeanServer(null);
for (int i = 0; i < l.size(); i++) {
MBeanServer s = (MBeanServer) l.get(i);
out.println("Server: " + s + "<br>");
Iterator it = ((Set) s.queryNames(null, null)).iterator();
while (it.hasNext())
out.println("<li>MBean: " + it.next() + "<br>");
out.println("<hr>");
}
out.println("</body>");
out.println("</html>");
out.close();
}
* Handles the <code>GET</code> method.
*
* @param request
* servlet request
* @param response
* servlet response
*/
protected void doGet( ServletRequest request,
ServletResponse response) throws ServletException,
java.io.IOException {
processRequest(request, response);
}
/**
* Handles the <code>POST</code> method.
*
* @param request
* servlet request
* @param response
* servlet response
*/
protected void doPost( ServletRequest request,
ServletResponse response) throws ServletException,
java.io.IOException {
processRequest(request, response);
}
/**
* Returns a short description of the servlet.
*/
public String getServletInfo() {
return "Short description";
}
}
这也跟上面的例子没什么不同，声明一个叫KEKEMAO:name=miaomiao的OBJECTNAME并对应Kekemao的对象，然后注册到MBEANSERVER中去。

就这么简单，同时启动了代理。

注意：在上面的 HtmlAdaptorServer 的端口不要重用了。

接下来确实是我们的MBEAN了
我简单的写了个MBEAN，差不多的MBEAN有2个类组成的，一个是接口，一个是它的实现类。

WEBJMX加载MBEAN的方式是动态MBEAN。

因此必须有个接口，而且那个MBEAN是有规范的。

MBean的接口必须以MBean为最后几个字。

而实现类就拿前几个字母。

比如XXXMBean，然后实现类就叫XXX。

那个还期望大伙儿认真遵循。

接口KekemaoMBean ：
package com.kekemao1.jmxexample.mbeans;
public interface KekemaoMBean {
/**
* 返回属性用的BEAN方法
*
*/
public String getName();
/**
* 没有参数的方法
*
*/
public void sayMiao();
/**
* 带一个参数的方法
* @param miao
*/
public void sayMiaoMiao(String miao);
/**
* Bean 的Set方法
*
*/
public void setName(String name);
}
类Kekemao：
package com.kekemao1.jmxexample.mbeans;
public class Kekemao implements KekemaoMBean {
private String name = "miaomiao";
public String getName() {
// TODO Auto-generated method stub
return ;
}
public void sayMiao() {
// TODO Auto-generated method stub
System.out.println("简单方法被调用");
}
public void sayMiaoMiao(String miao) {
// TODO Auto-generated method stub
System.out.println("带参数的方法被调用，参数的值是" + miao);
}
public void setName(String name) {
// TODO Auto-generated method stub
System.out.println("MBEAN中的Name被SET！");
= name;
}
}
能够从上面的接口KekemaoMBean和他的实现类Kekemao中看到，MBean不仅仅是一般的JAVABEAN，而且他其中还夹杂这一些方法，只要是MBean中的方法都能够被调用被治理。

专门爽吧！！
下面我们最后一步，也是最重要的一步了VIEW层：
第一是欢迎页面，里头仅仅有个超连接，该超连接跳转到我们的MBEAN治理页面，在跳转的过程做夹带了几个参数，locator=local，domain=KEKEMAO，
name=KEKEMAO。

index.html
<%@ page language="java" import="java.util.*"
pageEncoding="ISO-8859-1"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme() + "://"
+ request.getServerName() + ":" + request.getServerPort()
+ path + "/";
%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<base href="<%=basePath%>">
<title>My JSP 'index.jsp' starting page</title>
<meta -equiv="pragma" content="no-cache">
<meta -equiv="cache-control" content="no-cache">
<meta -equiv="expires" content="0">
<meta -equiv="keywords" content="keyword1,keyword2,keyword3"> <meta -equiv="description" content="This is my page">
<!--
<link rel="stylesheet" type="text/css" href="styles.css">
-->
</head>
<body>
<table bgcolor="#000000" width="100%" cellspacing="5"
cellpadding="10">
<tr>
<td background="images/background.gif">
<table>
<tr>
<td valign="middle" width="0">
<img src="images/samplelogo.gif" alt="Logo Image" align="top"> </td>
<td valign="middle">
<big align="center"
style="color:#ffffff;font-weight:bold;font-size:16pt">
NCS Remote Management Console</big>
</td>
</tr>
</table>
</td>
</tr>
<tr>
<td bgcolor="#ffffff">
<h3>
Production Servers
</h3>
<li>
<a
href="test1.jsp?locator=local&domain=KEKEMAO&name=KEKEMAO">Local
Server [Web Interface 1]</a>
</li>
</td>
</tr>
</table>
</body>
</html>
test1.jsp
<%@ page language="java" import="java.util.*" pageEncoding="GB2312"%> <%@ page import="java.util.*,javax.management.*"%>
<%@ taglib uri="/WEB-INF/struts-logic.tld" prefix="logic"%>
<%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean"%>
<%@ taglib uri="/WEB-INF/jmx.tld" prefix="jmx"%>
<bean:parameter id="locator" name="locator" />
<bean:parameter id="domain" name="domain" />
<bean:parameter id="serverName" name="name" />
<jmx:getMBeanServer id="server" attribute="locator" />
String path = request.getContextPath();
String basePath = request.getScheme() + "://"
+ request.getServerName() + ":" + request.getServerPort()
+ path + "/";
%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<base href="<%=basePath%>">
<title>My JSP 'test1.jsp' starting page</title>
<meta -equiv="pragma" content="no-cache">
<meta -equiv="cache-control" content="no-cache">
<meta -equiv="expires" content="0">
<meta -equiv="keywords" content="keyword1,keyword2,keyword3"> <meta -equiv="description" content="This is my page">
<!--
<link rel="stylesheet" type="text/css" href="styles.css">
-->
</head>
<body>
<table bgcolor="#000000" width="100%" cellspacing="5"
cellpadding="10">
<tr>
<td background="images/background.gif">
<table>
<tr>
<td valign="middle" width="0">
<img src="images/samplelogo.gif" alt="Logo Image" align="top"> </td>
<td valign="middle">
<big align="center"
style="color:#ffffff;font-weight:bold;font-size:16pt"> 服务器: <bean:write name="serverName" /> </big>
</td>
</tr>
</table>
</td>
</tr>
<tr>
<td bgcolor="#ffffff">
<h3>
"
<bean:write name="domain" />
"中的MBeans
</h3>
<table cellpadding="6" cellspacing="6" width="100%"> <tr>
<th valign="Top">
objectname
</th>
<th valign="Top">
描述
</th>
<th valign="Top">
MBean中name属性的值
</th>
<th>
无参的方法调用
</th>
<th>
用参数的方法调用
</th>
<th>
属性设置
</th>。