JMX指南

JMX可以用来管理网络，设备，应用程序等资源，当前规范为1.1版。

JMX的结构

在JMX中共分为三层
1：Instrumentation
2：Agent
3：Distributed Services

JMX的优点：

1：可以非常容易的使应用程序具有被管理的功能
2：提供具有高度伸缩性的架构
每个JMX Agent服务可以很容易的放入到Agent中，每个JMX的实现都提供几个核心的Agent服务，你也可以自己编写服务，服务可以很容易的部署，取消部署。
3：集成了现有的一些管理解决方案，如SNMP
4：非常容易的利用其他java技术
5：主要提供接口，允许有不同的实现

在JMX的规范中，只讲述了前两部分，分布式服务并没有涉及到，jmx规范还在不断完善中

上面的这个图是jmx in action中的一副JMX的结构图，通过上面这个图，我们可以将JMX的层次分的更清楚一点。
通常我们需要写一个Bean（Managed bean，简称MBean），利用这个bean去管理资源。

基本概念：

1:MBean
通常是一个java类，它提供接口可以使这个类具有管理功能（如standard MBean，接口中定义的方法使MBean具有管理功能）。
2：MBean server
是管理MBean的一个java类，你需要向MBean server注册一个MBean后，这个MBean才会具有管理功能，MBean server还提供了查询功能和注册监听器的功能，sun提供的只是接口，不同的jmx实现中的MBean server实现也不同。
3：JMX agent
agent是为了管理一系列的MBean，而提供的一系列的服务，如上图所示，通常有MBean relationships, dynamically loading classes, simple monitoring services, timers。agent可以利用Protocol adapters（例如HTTP 和SNMP）和connectors（RMI 和Jini）使不同的客户端可以访问MBean。
4：Protocol adapters 和connectors
适配器和连接器主要使不同的协议和客户端可以使用这个agent，一个agent中可以有多个Protocol adapters 和connectors，这样管理起MBean来就更方便了（有多种类型的客户端和协议可以操作MBean）。注意，Protocol adapters 和connectors通常也是MBean。

MBean的类型

JMX1.1相对于1.0有了很大改进，在1.1中提供4种类型的MBean，3,4两种MBean都是特殊类型的dynamic MBean。
1：standard MBean
2：dynamic MBean
3：open MBean
4：model MBean

类型	描述
standard MBean	这种类型的MBean最简单，它能管理的资源（包括属性，方法，时间）必须定义在接口中，然后MBean必须实现这个接口。它的命名也必须遵循一定的规范，例如我们的MBean为Hello，则接口必须为HelloMBean。
dynamic MBean	必须实现javax.management.DynamicMBean接口，所有的属性，方法都在运行时定义
open MBean	此MBean的规范还不完善，正在改进中
model MBean	与标准和动态MBean相比，你可以不用写MBean类，只需使用javax.management.modelmbean.RequiredModelMBean即可。RequiredModelMBean实现了ModelMBean接口，而ModelMBean扩展了DynamicMBean接口，因此与DynamicMBean相似，Model MBean的管理资源也是在运行时定义的。与DynamicMBean不同的是，DynamicMBean管理的资源一般定义在DynamicMBean中（运行时才决定管理那些资源），而model MBean管理的资源并不在MBean中，而是在外部（通常是一个类），只有在运行时，才通过set方法将其加入到model MBean中。后面的例子会有详细介绍

Standard MBean编程简介

上面我们已经提到了编写这种类型MBean的规则
1：编写接口
2：编写MBean
3：编写agent
下面看接口的代码，very easy，主要定义get/get方法和其它你想使用的方法

public interface HelloWorldMBean
{
public void setGreeting( String greeting );

public String getGreeting();

public void printGreeting();
}

再看MBean的代码，跟传统的Bean非常相似，加入某个属性只有get方法，则说明这个属性是只读的，get/set都有的话，说明这个属性是可读可写的，此MBean只定义了一个属性 greeting。另外还定义了一个方法printGreeting。

public class HelloWorld implements HelloWorldMBean
{

private String greeting = null;

public HelloWorld()
{
this.greeting = "Hello World! I am a Standard MBean";
}

public HelloWorld( String greeting )
{
this.greeting = greeting;
}

public void setGreeting( String greeting )
{
this.greeting = greeting;
}

public String getGreeting()
{
return greeting;
}

public void printGreeting()
{
System.out.println( greeting );
}
}

下面编写agent
1:创建 MBeanServer
2：创建一个adapter
3：将MBean注册到MBeanServer，同时将apapter也注册到MBeanServer
4: 启动adapter

import javax.management.*;
import com.sun.jdmk.comm.*;

public class HelloAgent
{
private MBeanServer mbs = null;

public HelloAgent()
{
mbs = MBeanServerFactory.createMBeanServer( "HelloAgent" );

HtmlAdaptorServer adapter = new HtmlAdaptorServer();

HelloWorld hw = new HelloWorld();

ObjectName adapterName = null;
ObjectName helloWorldName = null;

try
{

helloWorldName = new ObjectName( "HelloAgent:name=helloWorld1" );
mbs.registerMBean( hw, helloWorldName );
adapterName = new ObjectName( "HelloAgent:name=htmladapter,port=9092" );
adapter.setPort( 9092 );
mbs.registerMBean( adapter, adapterName );
adapter.start();

}
catch( Exception e )
{
e.printStackTrace();
}

}

public static void main( String args[] )
{
System.out.println( "HelloAgent is running" );
HelloAgent agent = new HelloAgent();
}

}

上面的代码使用了sun的一个adapter：HtmlAdaptorServer，使得html客户端可以访问MBean，注意ObjectName类，它的书写规则是这样的："Domain names：key=value,key2=value2",因为createMBeanServer方法中我们使用了参数"HelloAgent",因此后面的Domain names必须为HelloAgent。
运行
将jmx的包放到classpath中，运行HelloAgent类，然后通过浏览器访问http://localhost:9092即可

使用通知（notification）

通知其实就是一个监听器，我们可以为MBean注册一个监听器，当满足一定的条件时，MBean会发消息给监听器，然后监听器进行必要的处理。
一个MBean可以通过两种方法实现notification。
1：实现javax.management.NotificationBroadcaster接口
2：扩展javax.management.NotificationBroadcasterSupport类（这个类也实现了上面的接口）
要编写监听器，必须实现javax.management。NotificationListener接口
下面看一个简单的通知的例子，利用方式2实现
MBean的代码：

import java.io.*;
import javax.management.*;

public class HelloWorld extends NotificationBroadcasterSupport
implements HelloWorldMBean
{

public HelloWorld()
{
this.greeting = "Hello World! I am a Standard MBean";
}

public HelloWorld( String greeting )
{
this.greeting = greeting;
}
public void setGreeting( String greeting )
{
this.greeting = greeting;
Notification notification = new Notification(
"jmxbook.ch2.helloWorld.test", this, -1,
System.currentTimeMillis(), greeting );
sendNotification( notification );
}

public String getGreeting()
{
return greeting;
}

public void printGreeting()
{
System.out.println( greeting );
}
private String greeting;
}

上面的代码仅仅用了一个最简单的通知类：Notification

public Notification(java.lang.String type, java.lang.Object source,
long sequenceNumber,long timeStamp,
java.lang.String message)

type用来标示通知， source为产生通知的MBean，sequenceNumber为一系列通知中的序号，timeStamp为通知创建的时间，message为具体的通知消息。
由于从javax.management.NotificationBroadcasterSupport继承，所以编写起来容易些。

下面看agent类

import javax.management.*;
import com.sun.jdmk.comm.HtmlAdaptorServer;

public class HelloAgent implements NotificationListener

{
private MBeanServer mbs = null;

public HelloAgent ( )
{
mbs = MBeanServerFactory.createMBeanServer( "HelloAgent" );
HtmlAdaptorServer adapter = new HtmlAdaptorServer();
HelloWorld hw = new HelloWorld();

ObjectName adapterName = null;
ObjectName helloWorldName = null;

try
{
adapterName = new ObjectName(
"HelloAgent:name=htmladapter,port=9092" );
mbs.registerMBean( adapter, adapterName );
adapter.start();

helloWorldName = new ObjectName(
"HelloAgent:name=helloWorld1" );
mbs.registerMBean( hw, helloWorldName );

hw.addNotificationListener( this, null, null );

}
catch( Exception e )
{
e.printStackTrace();
}

}//constructor

public void handleNotification(
Notification notif, Object handback )
{
System.out.println( "Receiving notification..." );
System.out.println( notif.getType() );
System.out.println( notif.getMessage() );
}

public static void main( String args[] )
{
HelloAgent agent = new HelloAgent();
}

}

在agent类中
hw.addNotificationListener( this, null, null );将agent作为helloworld MBean的监听器，并且agent类实现了NotificationListener 接口，方法handleNotification处理具体的通知到达的情况。

动态MBean

前面讲的标准MBean只能用来管理静态的资源，即所有要管理的资源必须是已知的。但是我们要管理的资源并不是一成不变的，随着时间的变化，我们要管理的资源也会随之而变（例如，管理的范围扩大了）。在这种情况下，标准MBean就不适合我们的要求了。在这种情况下，动态MBean就比较适合我们的要求。动态MBean要管理的资源并不是早就定义好的，而是在运行期才定义的。动态MBean主要利用一些辅助类来完成这个功能，后面的ModelMBean也是如此。所有的动态MBean必须实现javax.management.DynamicMBean 接口。下图是动态MBean的一个结构图。

下面看一下DynamicMBean接口的定义：

packagejavax.management;
publicinterfaceDynamicMBean{
publicObjectgetAttribute(Stringattribute)throwsAttributeNotFoundException,MBeanException,ReflectionException;

publicvoidsetAttribute(Attributeattribute)throwsAttributeNotFoundException,InvalidAttributeValueException,MBeanException,ReflectionException;

publicAttributeListgetAttributes(String[]attributes);

publicAttributeListsetAttributes(AttributeListattributes);

publicObjectinvoke(StringactionName,Object[]params,String[]signature)throwsMBeanException,ReflectionExceptionn

publicMBeanInfogetMBeanInfo();
}

上面的前5个方法用于操作属性，方法，构建器等，getMBeanInfo方法用于提供给agent一个关于此MBean的描述，MBeanInfo类是一个基本的辅助类，用于容纳MBean的各种信息。
注意invoke方法：actionName为方法名，params为参数值，signature为参数的类型（例如java,lang.String）.
至于辅助类MBeanInfo这里就不说了,还有其他很多辅助类,可以参见jmx规范.
下面看一个简单的动态MBean,这是sun参考实现中的一个例子

importjava.lang.reflect.Constructor;
importjava.util.Iterator;
importjavax.management.*;

/**//**
*简单动态MBean-"State"属性:可读可写-"NbChanges"属性:只读-"reset()":方法注意:动态MBean必须定义一个public的构建器,且必须通过MBeanInfo来管理
*/

publicclassSimpleDynamicimplementsDynamicMBean{

publicSimpleDynamic(){

//建立辅助信息
//
buildDynamicMBeanInfo();
}

publicObjectgetAttribute(Stringattribute_name)throwsAttributeNotFoundException,MBeanException,ReflectionException{

//检查属性是否为空
if(attribute_name==null){
thrownewRuntimeOperationsException(newIllegalArgumentException("Attributenamecannotbenull"),
"Cannotinvokeagetterof"+dClassName+"withnullattributename");
}
//检查已知属性,调用已知方法
if(attribute_name.equals("State")){
returngetState();
}
if(attribute_name.equals("NbChanges")){
returngetNbChanges();
}
//如果属性不可识别,抛出异常
throw(newAttributeNotFoundException("Cannotfind"+attribute_name+"attributein"+dClassName));
}

publicvoidsetAttribute(Attributeattribute)throwsAttributeNotFoundException,InvalidAttributeValueException,MBeanException,
ReflectionException{
if(attribute==null){
thrownewRuntimeOperationsException(newIllegalArgumentException("Attributecannotbenull"),"Cannotinvokeasetterof"
+dClassName+"withnullattribute");
}
Stringname=attribute.getName();
Objectvalue=attribute.getValue();

if(name==null){
thrownewRuntimeOperationsException(newIllegalArgumentException("Attributenamecannotbenull"),
"Cannotinvokethesetterof"+dClassName+"withnullattributename");
}

if(name.equals("State")){
if(value==null){
try{
setState(null);
}catch(Exceptione){
throw(newInvalidAttributeValueException("Cannotsetattribute"+name+"tonull"));
}
}else{
try{
if((Class.forName("java.lang.String")).isAssignableFrom(value.getClass())){
setState((String)value);
}else{
throw(newInvalidAttributeValueException("Cannotsetattribute"+name+"toa"+value.getClass().getName()
+"object,Stringexpected"));
}
}catch(ClassNotFoundExceptione){
e.printStackTrace();
}
}
}
//由于"NbChanges"属性是只读的,所以抛出异常
elseif(name.equals("NbChanges")){
throw(newAttributeNotFoundException("Cannotsetattribute"+name+"becauseitisread-only"));
}else{
throw(newAttributeNotFoundException("Attribute"+name+"notfoundin"+this.getClass().getName()));
}
}

publicAttributeListgetAttributes(String[]attributeNames){
if(attributeNames==null){
thrownewRuntimeOperationsException(newIllegalArgumentException("attributeNames[]cannotbenull"),
"Cannotinvokeagetterof"+dClassName);
}
AttributeListresultList=newAttributeList();

if(attributeNames.length==0)
returnresultList;

for(inti=0;i<attributeNames.length;i++){
try{
Objectvalue=getAttribute((String)attributeNames[i]);
resultList.add(newAttribute(attributeNames[i],value));
}catch(Exceptione){
e.printStackTrace();
}
}
return(resultList);
}

-