【0】README 1）本文部分文字描述轉自：“深入剖析tomcat”，旨在學習“tomcat(20)基于JMX的管理”?的相關知識； 2）晚輩我在tomcat上部署web 項目以測試JMX管理 tomcat 容器bean的效果，結果運行不成功，詳情參見文末圖片； 3）for complete source code, please visit ?https://github.com/pacosonTang/HowTomcatWorks/tree/master/chapter20
【1】JMX 簡介 1）intro：JMX == Java Management Extensions == JMX規范 == JMX管理擴展； 2）既然ContainerServlet接口已經有利用Manager應用程序訪問Catalina的內部對象，那么為什么還要用 JMX呢？ 因為JMX 提供了比 ContainerServlet接口更靈活的方法來管理tomcat。許多基于服務器的應用程序（如tomcat， JBoss，JONAS，Geronimo等），都使用了JMX 技術來管理各自的資源； 3）JMX規范定義了管理java 對象的的公開標準。如，tomcat 4 ?和 tomcat5 都使用JMX 來啟用 servlet容器中的各種對象（如 Server對象， Host對象，Context對象，Valve對象等）； 4）可由JMX 管理的資源：如果一個java對象可以由一個遵循JMX 規范的管理器應用程序管理，那么這個java對象稱為一個可由JMX 管理的資源；（干貨——可由JMX 管理的資源） 實際上，一個可由JMX 管理的資源可以是一個應用程序，一種實現，一個服務，一個設備，一個用戶等。一個可由JMX管理的資源也可以由 java 編寫，并提供一個相應的java包裝； 4.1）若要使一個java對象成為一個可由JMX 管理的資源，則必須創建Managed Bean 或 MBean對象；（干貨——引入了MBean） 4.2）MBean會提供它所管理的一些java對象的屬性和方法供管理應用程序使用；管理應用程序本身并不能直接訪問托管的java對象，因此，可以選擇java對象 的哪些屬性和和方法可以由管理應用程序使用； 4.3）當擁有了一個MBean類后，需要將其實例化，并將其注冊到另一個作為 MBean服務器的java對象中；MBean 服務器中保存了應用程序中注冊的所有MBean。管理應用程序通過MBean服務器來訪問 MBean實例；（干貨——MBean 服務器中保存了應用程序中注冊的所有MBean。管理應用程序通過MBean服務器來訪問 MBean實例） 4.4）管理應用程序好比web 瀏覽器； 而MBean 服務器好比 servlet容器； 5）共有4種類型的MBean：標準類型，動態類型， 開放類型，模型類型：我們對模型類型尤其感興趣，因為 Catalina中就使用了 模型類型的MBean； 6）從結構上講，JMX 規范分為3層： 設備層，代理層 和 分布式服務層； 6.1）MBean服務器位于代理層：MBean 位于設備層，分布式服務層會在 JMX 規范將來的版本中涉及； 6.2）設備層規范：定義了編寫可由JMX 管理的資源的標準，即如何編寫MBean； 6.3）代理層定義了：創建代理的規范；代理封裝了 MBean服務器，提供了處理MBean的服務；代理和它所管理的MBean 通常都位于同一個java 虛擬機中。由于JMX 規范附帶了一個參考實現，所以并不需要自己編寫MBean 服務器； Attention）可以從下面的地址中下載JMX 規范和參考實現；http://www.oracle.com/technetwork/java/javase/tech/javamanagement-140525.html, MX4J是一個開源版本的JMX，下載地址為：http://mx4j.sourceforge.net/
【2】JMX API 1）JMX的參考實現包含一個核心java庫:這個庫位于 javax.management 包 和 JMX 編程中具有特定功能的其他包下；
【2.1】 MBeanServer類（是 javax.management.MBeanServer 接口的實例） 1）要創建一個?MBeanServer的實例：只需要調用?javax.management.MBeanServerFactory 類的 createMBean()方法； 2）要將一個 MBean注冊到 MBean服務器中，可以調用 MBeanServer.registerMBean()方法；下面是?registerMBean()方法的簽名： public interface MBeanServer extends MBeanServerConnection { //javax.management.loading.ClassLoaderRepository.MBeanServerpublic ObjectInstance registerMBean(Object object, ObjectName name)throws InstanceAlreadyExistsException, MBeanRegistrationException,NotCompliantMBeanException; } 對以上代碼的分析（Analysis）： A1）要調用registerMBean方法，需要傳入一個待注冊的MBean實例和一個?ObjectName?實例； A2）ObjectName實例與 HashMap中的鍵類似，它可以唯一標識一個 MBean實例； A3）registerMBean方法返回一個ObjectInstance?實例。java.management.ObjectInstance 類封裝了一個 MBean實例的對象名稱和它的類名； public class ObjectInstance implements Serializable {private static final long serialVersionUID = -4099952623687795850L;private ObjectName name;private String className; public ObjectInstance(String objectName, String className)throws MalformedObjectNameException {this(new ObjectName(objectName), className);} public ObjectInstance(ObjectName objectName, String className) {if (objectName.isPattern()) {final IllegalArgumentException iae =new IllegalArgumentException("Invalid name->"+objectName.toString());throw new RuntimeOperationsException(iae);}this.name= objectName;this.className= className;} public boolean equals(Object object) {if (!(object instanceof ObjectInstance)) {return false;}ObjectInstance val = (ObjectInstance) object;if (! name.equals(val.getObjectName())) return false;if (className == null)return (val.getClassName() == null);return className.equals(val.getClassName());}public int hashCode() {final int classHash = ((className==null)?0:className.hashCode());return name.hashCode() ^ classHash;} public ObjectName getObjectName() {return name;} public String getClassName() {return className;} public String toString() {return getClassName() + "[" + getObjectName() + "]";}} 3）要想獲取 MBean 實例或匹配某個模式的一組MBean實例，可以使用 MBeanServer接口提供的兩個方法，分別是 queryNames()方法和 queryMBeans()方法； 3.1）queryNames()方法： 返回一個java.util.Set 實例，其中包含了匹配某個指定模式對象名稱的一組MBean 實例的對象名稱；其方法簽名為： public Set<ObjectName> queryNames(ObjectName name, QueryExp query); 對以上代碼的分析（Analysis）： A1）參數query 指定了過濾條件； A2）若參數name為null 或者沒有域，而且指定了key 屬性，那么會返回已經注冊的MBean實例的所有 ObjectName實例。如果參數 queyr為null，則不會對查找對象進行過濾； 3.2）queryMBeans()方法：其方法簽名如下： public Set<ObjectInstance> queryMBeans(ObjectName name, QueryExp query); 對以上代碼的分析（Analysis）：一旦獲得了所需要 的MBean實例的對象名稱，就可以操作托管資源在 MBean 實例中提供的屬性或調用其方法；
4）可以通過調用MBeanServer.invoke()方法 調用已經注冊的 MBean實例的任何方法。 4.1）MBeanServer.getAttribute()方法 和 setAttribute()方法：用于獲取或設置已經注冊的 MBean實例的屬性； 【2.2】ObjectName屬性 1）intro：MBean實例注冊于 MBean服務器中。MBean 服務器中的每個MBean實例都通過一個對象名稱來唯一地標識，就好像是 HashMap 中都每個條目都通過一個鍵來表示一樣；（干貨——ObjectName屬性的作用，作為標識類型） 2）名稱對象：是 javax.management.ObjectName 類的實例。對象名稱由兩部分組成：域和一個鍵值對； public class ObjectName implements Comparable<ObjectName>, QueryExp { //javax.management.ObjectName 3）鍵與其值是由等號分割的，鍵值對之間由 分號分割，如，下面是一個有效的對象名稱，包含兩個鍵： myDomain:type=Car,color=blue； 4）ObjectName 實例也表示在 MBean服務器中搜索 MBean實例的屬性模式； 4.1）ObjectName實例可以在域部分或鍵值對部分使用通配符來表示模式，作為模式的 ObjectName實例可以有0個或多個鍵；
【3】 標準MBean 1）intro： 標準MBean 是最簡單的MBean類型。要想通過標準MBean來管理一個java對象，需要執行以下steps： step1）創建一個接口，該接口的命名規范為： java類名+MBean后綴；如想要管理的java類名為Car，則需要創建命名為 CarMBean的接口； step2）修改java類，讓其實現剛剛創建的 CarMBean接口； step3）創建一個代理，該代理類必須包含一個 MBeanServer實例； step4）為MBean創建 ObjectName 實例； step5）實例化 MBeanServer類； step6）將 MBean注冊到 MBeanServer 中； 2）看個荔枝：下面是一個標準MBean的例子，JMX可管理的類是Car； 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 car.");} } 2.1）修改Car類，使其實現CarMBean接口； public interface CarMBean {public String getColor();public void setColor(String color);public void drive(); } 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 car.");} } 對以上代碼的分析（Analysis）：要在接口中聲明Car 類中所要提供的所有方法；在CarMBean 接口中聲明了 Car類的所有方法； 2.2）給出用來創建標準MBean實例和管理Car 對象的代理類 StandardAgent的定義； public class StandardAgent {private MBeanServer mBeanServer = null;public StandardAgent() {mBeanServer = MBeanServerFactory.createMBeanServer();}public MBeanServer getMBeanServer() {return mBeanServer;}public ObjectName createObjectName(String name) {ObjectName objectName = null;try {objectName = new ObjectName(name);} catch (Exception e) {}return objectName;}private void createStandardBean(ObjectName objectName,String managedResourceClassName) {try {mBeanServer.createMBean(managedResourceClassName, objectName);} catch (Exception e) {}}public static void main(String[] args) {StandardAgent agent = new StandardAgent(); // 創建標準類型MBean的代理.MBeanServer mBeanServer = agent.getMBeanServer(); // 創建MBean服務器String domain = mBeanServer.getDefaultDomain(); // 設置域String managedResourceClassName = "com.tomcat.chapter20.standardmbeantest.Car"; // 設置要管理的類的全限定名.ObjectName objectName = agent.createObjectName(domain + ":type="+ managedResourceClassName); // 創建 ObjectName 對象.(用于標識MBean)agent.createStandardBean(objectName, managedResourceClassName); //創建標準類型的MBean.// manage MBeantry {Attribute colorAttribute = new Attribute("Color", "blue");mBeanServer.setAttribute(objectName, colorAttribute); // 為該MBean設置屬性.System.out.println(mBeanServer.getAttribute(objectName, "Color")); // 獲取該MBean的屬性.mBeanServer.invoke(objectName, "drive", null, null); // 調用該MBean的drive方法.} catch (Exception e) {e.printStackTrace();}} } 對以上代碼的分析（Analysis）： A1）StandardAgent類是一個代理類：用來實例化 MBean服務器，并使用MBean服務器注冊CarMBean實例； A2）首先要注意的是變量mBeanServer，StandardAgent類的構造函數會將一個 MBeanServer實例賦值給變量 MBeanServer。構造函數會調用MBeanServerFactory.createMBeanServer()方法創建一個MBean服務器實例；

A3）StandardAgent.createObjectName()會根據傳入的字符串參數返回一個 ObjectName實例； public ObjectName createObjectName(String name) {ObjectName objectName = null;try {objectName = new ObjectName(name);} catch (Exception e) {}return objectName;}A4）StandardAgent.createStandardMBean()方法會調用 MBeanServer.createMBean()方法；createMBean()方法接收托管資源的類名和一個 ObjectName實例，該 ObjectName實例唯一地標識了為托管資源創建的MBean實例。createMBean()方法也會將創建的 MBean實例注冊到 MBeanServer中；由于標準MBean 實例遵循了特定的命名規則，因此不需要為 createMBean()方法提供MBean的類名。如果托管資源的 類名是 Car，則創建的 MBean 的類名是 CarMBean； private void createStandardBean(ObjectName objectName,String managedResourceClassName) {try {mBeanServer.createMBean(managedResourceClassName, objectName);} catch (Exception e) {}} 3）StandardAgent.main()方法首先會創建 StandardAgent類的一個實例，調用其getMBeanServer()方法，以得到 StandardAgent 中對 MBeanServer實例的一次引用； StandardAgent agent = new StandardAgent();MBeanServer mBeanServer = agent.getMBeanServer(); 4）然后，它會為 CarMbean實例的創建一個 OBjectgName實例；MBeanServer實例的默認域會作為 ObjectName 實例的域使用。一個名為 type 的鍵會被添加到域后面。鍵type 的值是托管資源的完全限定名： String domain = mBeanServer.getDefaultDomain();String managedResourceClassName = "com.tomcat.chapter20.standardmbeantest.Car";ObjectName objectName = agent.createObjectName(domain + ":type="+ managedResourceClassName);5）然后，main()方法會調用 createStandardBean()方法，并傳入對象名稱和托管資源的類名； agent.createStandardBean(objectName, managedResourceClassName); 6）接著，main()方法就可以通過CarMBean實例來管理Car對象。它會創建一個名為 colorAttribute 的 Attribute類型的對象，用來表示 Car類的 Color屬性，并設置其值為 blue；然后，它再調用 setAttribute()方法，接著，它會通過調用 MBeanServer.invoke()方法來嗲用Car.drive()方法； // manage MBeantry {Attribute colorAttribute = new Attribute("Color", "blue");mBeanServer.setAttribute(objectName, colorAttribute);System.out.println(mBeanServer.getAttribute(objectName, "Color"));mBeanServer.invoke(objectName, "drive", null, null);} 7）運行結果 blue Baby you can drive my car. Attention） A1）我們很想知道，到底為什么需要使用 JMX 來管理 java對象呢？ A2）上面的荔枝中，我們可以通過 StandardAgent 類來直接訪問Car對象了；這里的關鍵問題是可以選擇哪些功能需要暴露出來，哪些方法需要對外隱藏；（干貨——這里的關鍵問題是可以選擇哪些功能需要暴露出來，哪些方法需要對外隱藏）
【4】模型MBean 1）intro：相比于標準MBean，模型MBean具有更大的靈活性；如果不能修改已有的java類，那么使用模型MBean是不錯 的選擇；（不再需要為可管理的對象修改java類了 ） 2）模型MBean和標準MBean的區別：（干貨——模型MBean和標準MBean的區別） 2.1）在使用標準MBean管理資源時，需要定義一個接口；然后讓托管資源實現該接口；而使用模型MBean時，不需要定義接口；相反，可以使用 javax.management.modelmbean.ModelMBean 接口來表示模型MBean，只需要實現該接口； 2.2）在JMX 的參考實現中有一個 javax.management.modelmbean.RequiredModelMBean類，是ModelMBean接口的默認實現， 可以實例化 RequiredModelMBean 類或其子類； 3）編寫一個模型MBean 的最大挑戰是 告訴 ModelMBean對象托管資源的哪些屬性和方法可以暴露給代理；可以通過創建 javax.management.modelmbean.ModelMBeanInfo對象來完成這個任務； 4）javax.management.modelmbean.ModelMBeanInfo對象（干貨——ModelMBeanInfo對象的作用） 4.1）ModelMBeanInfo對象描述了將會暴露給代理的構造函數，屬性，操作甚至是監聽器；
5）使用 RequiredModelMBean類作為 ModelMBean的實現，有兩種方法可以將 ModelMBean對象與 ModelMBeanInfo對象相關聯： method1）傳入一個 ModelMBeanInfo 對象到 RequiredModelBean 對象的構造函數中 ； method2）調用 RequiredModelMBean 對象的 setModelMBeanInfo()方法，并傳入一個 ModelMBeanInfo對象； 6）在創建了 ModelMBean對象后，需要調用ModelMBean接口的 setManagedResource()方法將其與托管資源相關聯，該方法的簽名如下： public void setManagedResource(Object mr, String mr_type) throws MBeanException, RuntimeOperationsException, InstanceNotFoundException, InvalidTargetObjectTypeException ; 【4.1】MBeanInfo 接口與 ModelMBeanInfo接口 1）javax.management.modelmbean.ModelMBeanInfo 定義源碼如下： public interface ModelMBeanInfo{ public Descriptor[] getDescriptors(String inDescriptorType)throws MBeanException, RuntimeOperationsException; public void setDescriptors(Descriptor[] inDescriptors)throws MBeanException, RuntimeOperationsException; public Descriptor getDescriptor(String inDescriptorName, String inDescriptorType)throws MBeanException, RuntimeOperationsException; public Descriptor getMBeanDescriptor()throws MBeanException, RuntimeOperationsException; public void setMBeanDescriptor(Descriptor inDescriptor)throws MBeanException, RuntimeOperationsException; public ModelMBeanAttributeInfo getAttribute(String inName)throws MBeanException, RuntimeOperationsException;public ModelMBeanOperationInfo getOperation(String inName)throws MBeanException, RuntimeOperationsException;public ModelMBeanNotificationInfo getNotification(String inName)throws MBeanException, RuntimeOperationsException;public java.lang.Object clone(); public MBeanAttributeInfo[] getAttributes(); public java.lang.String getClassName(); public MBeanConstructorInfo[] getConstructors(); public java.lang.String getDescription(); public MBeanNotificationInfo[] getNotifications(); public MBeanOperationInfo[] getOperations(); } 2）intro to ModelMBeanInfo接口：該接口描述了要通過MOdelMBean 暴露給代理層的構造函數，屬性，方法和監聽器；（干貨——ModelMBeanInfo接口的作用，JMX提供的默認實現類是ModelMBeanInfoSupport） 2.1）構造函數是 javax.management.modelmbean.ModelMBeanConstructorInfo 類的實例，屬性是?javax.management.modelmbean.MOdelMBeanAttributeInfo 類的實例，方法是?javax.management.modelmbean.ModelMBeanOperationInfo 類的實例，監聽器是? javax.management.modelmbean.ModelMBeanNotificationInfo 類的實例； 2.2）JMX 提供了ModelMBeanInfo接口的默認實現，即 javax.management.modelmbean.ModelMBeanInfoSupport類； public class ModelMBeanInfoSupport extends MBeanInfo implements ModelMBeanInfo { // javax.management.modelmbean.ModelMBeanInfoSupportpublic ModelMBeanInfoSupport(String className,String description,ModelMBeanAttributeInfo[] attributes,ModelMBeanConstructorInfo[] constructors,ModelMBeanOperationInfo[] operations,ModelMBeanNotificationInfo[] notifications) {this(className, description, attributes, constructors,operations, notifications, null);} } 【4.2】ModelMBean實例 1）看個荔枝： 該荔枝展示了如何使用模型MBean管理Car對象。 1.1）Car 類的源碼定義 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 car.");} } 1.2）對于模型MBean，不需要像使用標準MBean那樣，編寫一個接口。只需要實例化RequiredMBean類； public class ModelAgent {private String MANAGED_CLASS_NAME = "com.tomcat.chapter20.modelmbeantest1.Car";private MBeanServer mBeanServer = null;public ModelAgent() {mBeanServer = MBeanServerFactory.createMBeanServer();}public MBeanServer getMBeanServer() {return mBeanServer;}private ObjectName createObjectName(String name) {ObjectName objectName = null;try {objectName = new ObjectName(name);} catch (MalformedObjectNameException e) {e.printStackTrace();}return objectName;}private ModelMBean createMBean(ObjectName objectName, String mbeanName) {ModelMBeanInfo mBeanInfo = createModelMBeanInfo(objectName, mbeanName);RequiredModelMBean modelMBean = null;try {modelMBean = new RequiredModelMBean(mBeanInfo);} catch (Exception e) {e.printStackTrace();}return modelMBean;}private ModelMBeanInfo createModelMBeanInfo(ObjectName inMbeanObjectName,String inMbeanName) {ModelMBeanInfo mBeanInfo = null;ModelMBeanAttributeInfo[] attributes = new ModelMBeanAttributeInfo[1];ModelMBeanOperationInfo[] operations = new ModelMBeanOperationInfo[3];try {attributes[0] = new ModelMBeanAttributeInfo("Color","java.lang.String", "the color.", true, true, false, null);operations[0] = new ModelMBeanOperationInfo("drive","the drive method", null, "void",MBeanOperationInfo.ACTION, null);operations[1] = new ModelMBeanOperationInfo("getColor","get color attribute", null, "java.lang.String",MBeanOperationInfo.ACTION, null);Descriptor setColorDesc = new DescriptorSupport(new String[] {"name=setColor", "descriptorType=operation","class=" + MANAGED_CLASS_NAME, "role=operation" });MBeanParameterInfo[] setColorParams = new MBeanParameterInfo[] { (new MBeanParameterInfo("new color", "java.lang.String", "new Color value")) };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(); // 創建模型MBean代理. MBeanServer mBeanServer = agent.getMBeanServer(); // 創建MBean 服務器.Car car = new Car();String domain = mBeanServer.getDefaultDomain(); // 創建 域 String managedResourceClassName = "com.tomcat.chapter20.modelmbeantest1.Car"; // 設置要管理的類的全限定名. ObjectName objectName = agent.createObjectName(domain + ":type=" + managedResourceClassName); // 創建 ObjectName 對象.(用于標識MBean) String mBeanName = "myMBean";ModelMBean modelMBean = agent.createMBean(objectName, mBeanName); //創建模型類型的MBean. try {modelMBean.setManagedResource(car, "ObjectReference"); // 為該模型MBean 設置資源類型mBeanServer.registerMBean(modelMBean, objectName); // 將該模型MBean 注冊到 MBean 服務器.} catch (Exception e) {}// manage the beantry {Attribute attribute = new Attribute("Color", "green");mBeanServer.setAttribute(objectName, attribute); String color = (String) mBeanServer.getAttribute(objectName,"Color");System.out.println("Color:" + color); // 設置屬性->獲取屬性->打印屬性 attribute = new Attribute("Color", "blue");mBeanServer.setAttribute(objectName, attribute);color = (String) mBeanServer.getAttribute(objectName, "Color");System.out.println("Color:" + color); // 設置屬性->獲取屬性->打印屬性 mBeanServer.invoke(objectName, "drive", null, null); // 調用MBean 服務器中表示為 objectName的MBean對象的drive方法 } catch (Exception e) {e.printStackTrace();}} } public class Car {public Car() {System.out.println("Car constructor");}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 car.");} } 1.3）Console info ： Color:green Color:blue Baby you can drive my car. 【5】 Commons Modeler庫 1）intro：該庫是Apache 的 Jakarta項目的一部分，目的是 使編寫模型MBean更加方便；實際上，最大的幫助是 不需要再寫代碼創建 ModelMBeanInfo對象了；（干貨——Commons Modeler庫的目的） 2）problem+solution： 2.1）problem：在前面的荔枝中，創建RequiredModelMBean?對象?，需要創建一個對象ModelMBeanInfo?對象，并將其傳遞給?RequiredModelMBean 的構造函數?，（ModelMBeanInfo?對象：描述了將要由 MBean實例暴露出的屬性和方法；） private ModelMBean createMBean(ObjectName objectName, String mbeanName) {ModelMBeanInfo mBeanInfo = createModelMBeanInfo(objectName, mbeanName);RequiredModelMBean modelMBean = null;try {modelMBean = new RequiredModelMBean(mBeanInfo);} //.......2.2）solution： 使用Commons Modeler 庫，就不再需要創建 ModelMBeanInfo對象了；相反，對模型MBean的描述被封裝在一個 org.apache.catalina.modeler.ManagedBean對象中。不需要編寫代碼在MBean中暴露屬性和方法。只需要編寫一個mbean的描述符文件（一個XML文檔），列出想要創建的 MBean。 3）對于每個MBean，需要寫出MBean類和托管資源類的完全限定名，此外還有由 ?MBean暴露的屬性和方法。然后，使用 org.apache.commons.modeler.Registry 實例讀取這個XML 文檔，并創建一個 MBeanServer實例，在按照mbean描述符文件中的XML 元素創建所有的ManagedBean實例； 3.1）然后，調用MAnagedBean.createMBean()方法創建模型MBean。這之后就是普通的流程了。 3.2）下面介紹mbean描述符文件的格式， 然后討論Modeler庫中的3個重要的類，分別是 Registry類，ManagedBean類 和 BaseModelMBean類；
【5.1】MBean描述符 1）intro：MBean描述符是一個XML文檔，該文檔描述了 將會由 MBean服務器管理的模型MBean的實例，MBean描述符以下面的頭信息開始：
1.1）<mbeans-descriptors>根元素： 在<mbeans-descriptors>標簽內部是 mbean元素，每個mbean標簽表示一個模型MBean。mbean元素包含了分別用來表示屬性，方法，構造函數和通知的元素； 看個荔枝）car-mbean-descriptor.xml 代碼定義如下： <?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><mbean name="myMBean"className="javax.management.modelmbean.RequiredModelMBean"description="The ModelMBean that manages our Car object"type="com.tomcat.chapter20.modelmbeantest2.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> 對以上代碼的分析（Analysis）： A1）mbean元素：該元素描述一個模型 MBean，包含創建對應 ModelMBeanInfo 對象 的信息。mbean元素的定義如下所示： <!Element mmean (descriptor?, attribute*, constructor*, notification*, operation*)> A1.1）mbean元素可以有如下屬性（property）： property1）name：唯一標識模型MBean的名稱；一般case下，會使用相關服務器組件的基類名； property2）domain：在創建ModelMBean的ObjectName時，托管的 bean 創建的 ModelMBean 實例被注冊到的 MBean服務器的域名； property3）description：對該 mbean的 簡單描述； property4）group；組分類的可選名，用來選擇具有相似MBean 實現類的組； property5）type：托管資源實現類的完全限定的java類名； property6）className：實現ModelMBean接口的 java類的完全限定名，若該屬性未賦值，則默認使用 org.apache.commons.modeler.BaseModelMBean類； A2）attribute元素：使用attribute元素 描述 MBean的 JavaBean屬性。有如下屬性： property1）description：該屬性的簡單描述； property2）displayName：該屬性的顯示名稱； property3）getMethod：由 attribute元素表示的屬性的 getter()方法； property4）is：一個布爾值，指明該屬性是否是一個布爾值，是否有 getter()方法，默認case下，該屬性值為false； property5）name：該java bean屬性的名稱； property6）readable：一個布爾值，指定該屬性對管理應用程序來說是否可讀，該屬性值默認為true； property7）setMethod：由 attribute 元素表示的屬性的 setter()方法； property8）type：該屬性的完全限定的java類名； property9）writeable：一個布爾值，表明該屬性對管理應用程序來說是否可寫，該屬性默認為 true； A3）operation元素：該元素描述了模型 MBean中要暴露給管理應用程序的公共方法，它可以有0個或多個 parameter 子元素和如下 的屬性： property1）description：方法的簡單描述； property2）impact：指明方法的影響，可選值為，ACTION, ACTION-INFO, INFO 或 UNKNOWN； property3）name：公共方法名稱； property4）returnType：方法返回值的完全限定的 java類名； A4）parameter元素：該元素描述了將要傳遞給 構造函數或方法的參數，有如下屬性； property1）description：該參數的簡單描述； property2）name：參數名； property3）type：參數的完全限定名的java類名；
【5.2】mbena元素示例 1）在catalina的mbean-descriptors.xml 文件中聲明了一系列模型 MBean，該文件包位于 org.apache.catalina.mbeans 包下；其源代碼如下：??<mbean name="MBeanFactory"type="org.apache.catalina.mbeans.MBeanFactory"description="Factory for MBeans and corresponding components"domain="Catalina"><!-- IMPLEMENTATION NOTE - all of the createXxxxx methods create a new --><!-- component and attach it to Catalina's component tree. The return --><!-- value is the object name of the corresponding MBean for the new --><!-- component. --><operation name="createAccessLoggerValve"description="Create a new AccessLoggerValve"impact="ACTION"returnType="java.lang.String"><parameter name="parent"description="MBean Name of the associated parent component"type="java.lang.String"/></operation> //...... </mbean> 對以上代碼的分析（Analysis）：mbean元素聲明了一個模型MBean，其唯一標識是 MBeanFactory，該MBeanFactory是 org.apache.catalina.mbeans.MBeanFactory 類的一個對象；
【5.3】自己編寫一個模型MBean類 1）intro：使用Commons Modeler庫，需要在 mbean元素的className屬性中指明自定義的模型MBean的類型。默認case下，Commons Modeler庫 使用 org.apache.commons.modeler.BaseModelMBean類； 2）有兩種cases，其中可能對 BaseModelMBean類進行擴展： case1）需要覆蓋托管資源的屬性或方法； case2）需要添加在托管資源中沒有定義的屬性或方法；
【5.4】Registry類（org.apche.commons.modeler.Registry） 1）該類定了很多方法，如下： method1）獲取javax.management.MBeanServer 類的一個實例，所以不再需要調用 javax.management.MBeanServerFactory.createMBeanServer()方法了； method2）使用 loadRegistry() 方法讀取 MBean 的描述符文件； method3）創建一個 ManagedBean 對象，用于創建模型 MBean的實例；
【5.5】ManagedBean 1）intro：ManagedBean 對象：描述了一個模型MBean，該類用于取代 javax.management.MBeanInfo 對象 ；
【5.6】BaseModelMBean 1）org.apache.commons.modeler.BaseModelMBean 類實現了 javax.management.modelmbean.ModelMBean 接口。使用這個類，就不需要用 javax.management.modelmbean.RequiredModelMBean類了； 2）該類用了 resource字段：該字段表示該模型 MBean管理的資源； public class BaseModelMBean implements ModelMBean, MBeanRegistration { // org.apache.commons.modeler.BaseModelMBean protected Object resource = null; } 【5.7】使用 Modeler庫API 1）Car類的定義源碼 package com.tomcat.chapter20.modelmbeantest2; public class Car {public Car() {System.out.println("Car constructor");}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 car.");} } 2）使用 Commons Modeler庫，不需要使用硬編碼的方式，將托管對象的所有屬性和方法都寫在代碼中。相反，可以將他們寫在一個 XML文檔中，作為 MBean 的描述符文件； 2.1）MBean的描述符文件為 car-mbean-descriptor.xml 文件，其代碼定義如下： <?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><mbean name="myMBean"className="javax.management.modelmbean.RequiredModelMBean"description="The ModelMBean that manages our Car object"type="com.tomcat.chapter20.modelmbeantest2.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> 2.2）需要一個代理類 ModelAgent.java，具體定義如下：（干貨——這里不需要創建ModelMBeanInfo 對象） public class ModelAgent {private Registry registry;private MBeanServer mBeanServer;public ModelAgent() {registry = createRegistry();try {mBeanServer = Registry.getServer();} catch (Throwable t) {t.printStackTrace(System.out);System.exit(1);}}public MBeanServer getMBeanServer() {return mBeanServer;}public Registry createRegistry() {Registry registry = null;try {URL url = ModelAgent.class.getResource("/com/tomcat/chapter20/modelmbeantest2/car-mbean-descriptor.xml");InputStream stream = url.openStream();Registry.loadRegistry(stream);stream.close();registry = Registry.getRegistry();} catch (Throwable t) {System.out.println(t.toString());}return (registry);}public ModelMBean createModelMBean(String mBeanName) throws Exception {ManagedBean managed = registry.findManagedBean(mBeanName);if (managed == null) {System.out.println("ManagedBean null");return null;}ModelMBean mbean = managed.createMBean();ObjectName objectName = createObjectName();return mbean;}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(); // 創建模型MBean代理.MBeanServer mBeanServer = agent.getMBeanServer(); // 創建MBean 服務器.Car car = new Car();System.out.println("Creating ObjectName");ObjectName objectName = agent.createObjectName(); // 創建 ObjectName，作為MBean的標識對象.try {ModelMBean modelMBean = agent.createModelMBean("myMBean"); // 創建模型MBean. modelMBean.setManagedResource(car, "ObjectReference"); // 對象引用資源.mBeanServer.registerMBean(modelMBean, objectName); // 注冊模型MBean 到 MBean 服務器.(objectName 是標識符)} catch (Exception e) {System.out.println(e.toString());}// manage the beantry {Attribute attribute = new Attribute("Color", "green"); mBeanServer.setAttribute(objectName, attribute); // 創建屬性并設置到 MBean服務器中標識為objectName的MBean.String color = (String) mBeanServer.getAttribute(objectName,"Color");System.out.println("Color:" + color); // 獲取屬性并打印.attribute = new Attribute("Color", "blue");mBeanServer.setAttribute(objectName, attribute);color = (String) mBeanServer.getAttribute(objectName, "Color");System.out.println("Color:" + color); // 設置屬性->獲取屬性->打印屬性mBeanServer.invoke(objectName, "drive", null, null); // 調用MBean 服務器中表示為 objectName的MBean對象的drive方法} catch (Exception e) {e.printStackTrace();}} }// 打印結果. Car constructor Creating ObjectName Color:green Color:blue Baby you can drive my car.<span style="font-family: SimSun; background-color: rgb(255, 255, 255);"> </span> 【6】Catalina中的 MBean 1）intro：catalina在org.apache.catalina.mbeans 包中提供了一系列 MBean類；這些 MBean類都直接或間接繼承自 org.apache.commons.modeler.BaseModelMBean類； 2）本小姐會討論tomcat4中的3個最重要的 MBean，分別是 ClassNameMBena類， StandardServerMBean類 和 MBeanFactory類；（干貨——tomcat4中最重要的3個MBean）
【6.1】ClassNameMBena類（org.apache.catalina.mbeans.ClassNameMBean） public class ClassNameMBean extends BaseModelMBean { // org.apache.catalina.mbeans.ClassNameMBean public ClassNameMBean()throws MBeanException, RuntimeOperationsException {super();}public String getClassName() {return (this.resource.getClass().getName());}} 對以上代碼的分析（Analysis）： ClassNameMBena類是 BaseModelMBena的子類，其只寫屬性 className 在托管資源中不可見；mbeans-descriptors.xml 文件中的很多mbean元素使用該類作為其模型MBean的模型；
【6.2】StandardServerMBean類 public class StandardServerMBean extends BaseModelMBean {private static MBeanServer mserver = MBeanUtils.createServer();public StandardServerMBean()throws MBeanException, RuntimeOperationsException {super();}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");}}} } 對以上代碼的分析（Analysis）：StandardServerMBena類是一種模型MBean，繼承自 BaseModelMBean類，并重寫了 托管資源的一個方法；
【6.3】MBenaFactory類 public class MBeanFactory extends BaseModelMBean { //org.apache.catalina.mbeans.MBeanFactory. 1）intro：MBenaFactory類的實例是一個工廠對象：?用于創建管理 tomcat 中 各種資源的所有模型mbean；MBeanFactory類還提供 了刪除這些MBean的方法； Attention）org.apache.catalina.mbeans.MBeanFactory 的源碼定義會在文末 po出，有興趣朋友的可以直接跳到文末，該類的方法還是比較重要的，所以po 之；
【6.4】MBeanUtil（org.apache.catlaina.mbeans.MBeanUtil） 1）intro：MBeanUtil類是一個工具類，提供了一些靜態方法用于創建各種管理 catalina對象的MBean，刪除MBean，以及創建 ObjectName 實例等； 2）看個荔枝：?MBeanUtil.createMBean()方法用于創建一個管理 org.apache.catalina.Server 對象的模型MBean； public static ModelMBean createMBean(Connector connector) //org.apache.ccatlaina.mbeans.MBeanUtil.createMBean().throws Exception {String mname = createManagedName(connector);ManagedBean managed = registry.findManagedBean(mname);if (managed == null) {Exception e = new Exception("ManagedBean is not found with "+mname);throw new MBeanException(e);}String domain = managed.getDomain();if (domain == null)domain = mserver.getDefaultDomain();ModelMBean mbean = managed.createMBean(connector);ObjectName oname = createObjectName(domain, connector);mserver.registerMBean(mbean, oname);return (mbean);} 【7】創建catalina的MBean 1）下面介紹一下如何創建 Catalina中的 模型MBean，并使用它們來管理 Catalina中的托管資源； 2）在tomcat的配置文件 server.xml 中，在 Server元素里面定義了如下所示的Listener元素： <Server port="8005" shutdown="SHUTDOWN"><!-- Security listener. Documentation at /docs/config/listeners.html<Listener className="org.apache.catalina.security.SecurityListener" />--><!--APR library loader. Documentation at /docs/apr.html --><Listener className="org.apache.catalina.core.AprLifecycleListener" SSLEngine="on" /><!--Initialize Jasper prior to webapps are loaded. Documentation at /docs/jasper-howto.html --><Listener className="org.apache.catalina.core.JasperListener" /><!-- Prevent memory leaks due to use of particular java/javax APIs--><Listener className="org.apache.catalina.core.JreMemoryLeakPreventionListener" /><Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" /><Listener className="org.apache.catalina.core.ThreadLocalLeakPreventionListener" /> //...... 對以上代碼的分析（Analysis）： A1）這里為服務器組件 org.apache.catalina.core.StandardServer 類的實例添加了一個 org.apache.catalina.mbeans.ServerLifecycleListener 類型的監聽器。當StandardServer實例啟動時，它會觸發START_EVENT 事件，如 StandardServer.start()方法如下所示： public void start() throws LifecycleException { // org.apache.catalina.core.StandardServer.start().// Validate and update our current component stateif (started)throw new LifecycleException(sm.getString("standardServer.start.started"));// Notify our interested LifecycleListenerslifecycle.fireLifecycleEvent(BEFORE_START_EVENT, null);lifecycle.fireLifecycleEvent(START_EVENT, null);started = true;// Start our defined Servicessynchronized (services) {for (int i = 0; i < services.length; i++) {if (services[i] instanceof Lifecycle)((Lifecycle) services[i]).start();}}// Notify our interested LifecycleListenerslifecycle.fireLifecycleEvent(AFTER_START_EVENT, null);} A2）而當 StandardServer對象關閉時，會觸發 STOP_EVENT事件，如 StandardServer類定義的stop方法； A3）而這些時間會執行 ServerLifecycleListener.lifecycleEvnet()方法，其源代碼定義如下： public void lifecycleEvent(LifecycleEvent event) { //org.apache.catalina.mbeans.ServerLifecycleListener.lifecycleEvent().Lifecycle lifecycle = event.getLifecycle();if (Lifecycle.START_EVENT.equals(event.getType())) {if (lifecycle instanceof Server) {// Loading additional MBean descriptorsloadMBeanDescriptors();createMBeans();}// We are embedded.if( lifecycle instanceof Service ) {if( debug > 0 )log( "Starting embeded" + lifecycle);try {MBeanFactory factory = new MBeanFactory();createMBeans(factory);loadMBeanDescriptors();createMBeans((Service)lifecycle);} catch( Exception ex ) {log("Error registering the service", ex);}}/*// Ignore events from StandardContext objects to avoid// reregistering the contextif (lifecycle instanceof StandardContext)return;createMBeans();*/} else if (Lifecycle.STOP_EVENT.equals(event.getType())) {if (lifecycle instanceof Server) {destroyMBeans();}} else if (Context.RELOAD_EVENT.equals(event.getType())) {// Give context a new handle to the MBean server if the// context has been reloaded since reloading causes the// context to lose its previous handle to the serverif (lifecycle instanceof StandardContext) {// If the context is privileged, give a reference to it// in a servlet context attributeStandardContext context = (StandardContext)lifecycle;if (context.getPrivileged()) {context.getServletContext().setAttribute(Globals.MBEAN_REGISTRY_ATTR,MBeanUtils.createRegistry());context.getServletContext().setAttribute(Globals.MBEAN_SERVER_ATTR,MBeanUtils.createServer());}}}} 3）在Catalina中，createMBeans()方法用來創建所有的MBean實例。該方法首先會創建 MBeanFactory類的一個實例，也是一個 模型 MBean實例；方法源碼定義如下： protected void createMBeans() { // org.apache.catalina.mbeans.ServerLifecycleListener.createMBeans().try {MBeanFactory factory = new MBeanFactory();createMBeans(factory);createMBeans(ServerFactory.getServer());}//......} 對以上代碼的分析（Analysis） A1）第一個?createMBeans方法：會使用MBeanUtil類為 MBeanFactory實例創建一個 ObjectName，然后將其注冊到 MBean服務器中； protected void createMBeans(MBeanFactory factory) throws Exception {// Create the MBean for the MBeanFactoryif (debug >= 2)log("Creating MBean for MBeanFactory " + factory);MBeanUtils.createMBean(factory);}A2）第二個?createMBeans方法：該方法接收一個 org.apache.catalina.Server 對象，為其創建一個模型 MBean； protected void createMBeans(Server server) throws Exception {// Create the MBean for the Server itselfif (debug >= 2)log("Creating MBean for Server " + server);MBeanUtils.createMBean(server);if (server instanceof StandardServer) {((StandardServer) server).addPropertyChangeListener(this);}// Create the MBeans for the global NamingResources (if any)NamingResources resources = server.getGlobalNamingResources();if (resources != null) {createMBeans(resources);}// Create the MBeans for each child ServiceService services[] = server.findServices();for (int i = 0; i < services.length; i++) {// FIXME - Warp object hierarchy not currently supportedif (services[i].getContainer().getClass().getName().equals("org.apache.catalina.connector.warp.WarpEngine")) {if (debug >= 1) {log("Skipping MBean for Service " + services[i]);}continue;}createMBeans(services[i]);}} Attention）上述createMbeans(Server server)方法調用for 循環中下面的語句遍歷 StandardServer實例中所有的Service對象； for (int i = 0; i < services.length; i++) {// FIXME - Warp object hierarchy not currently supportedif (services[i].getContainer().getClass().getName().equals("org.apache.catalina.connector.warp.WarpEngine")) {if (debug >= 1) {log("Skipping MBean for Service " + services[i]);}continue;}createMBeans(services[i]); //highlight line.} 對createMBeans(services[i]) 方法的分析（Analysis）：? A1）該方法為每個Service對象創建 MBean，然后，為每個Service對象中所有的連接器和Engine對象調用createMBean() 方法 創建 MBean實例； protected void createMBeans(Service service) throws Exception {// Create the MBean for the Service itselfif (debug >= 2)log("Creating MBean for Service " + service);MBeanUtils.createMBean(service);if (service instanceof StandardService) {((StandardService) service).addPropertyChangeListener(this);}// Create the MBeans for the corresponding ConnectorsConnector connectors[] = service.findConnectors();for (int j = 0; j < connectors.length; j++) {createMBeans(connectors[j]);}// Create the MBean for the associated Engine and friendsEngine engine = (Engine) service.getContainer();if (engine != null) {createMBeans(engine);}} A2）createMBean(engine) 會調用 createMBean(Engine engine) 方法為每個Host實例創建MBean； protected void createMBeans(Engine engine) throws Exception { //org.apache.catalina.mbeans.ServerLifecycleListener.createMBeans().// Create the MBean for the Engine itselfif (debug >= 2) {log("Creating MBean for Engine " + engine);}MBeanUtils.createMBean(engine);engine.addContainerListener(this);if (engine instanceof StandardEngine) {((StandardEngine) engine).addPropertyChangeListener(this);} //....... A3）createMBean(host) 會調用 createMBean(Host host) 方法為每個Context實例創建MBean； protected void createMBeans(Host host) throws Exception { //org.apache.catalina.mbeans.ServerLifecycleListener.createMBeans(Host host).//......MBeanUtils.createMBean(host);//......Container contexts[] = host.findChildren();for (int k = 0; k < contexts.length; k++) {createMBeans((Context) contexts[k]);}//...... } A4）createMBean(Context context) 方法的實現如下所示： protected void createMBeans(Context context) throws Exception { //org.apache.catalina.mbeans.ServerLifecycleListener.createMBeans(Context context).//.......MBeanUtils.createMBean(context);context.addContainerListener(this);if (context instanceof StandardContext) {((StandardContext) context).addPropertyChangeListener(this);((StandardContext) context).addLifecycleListener(this);}if (context.getPrivileged()) {context.getServletContext().setAttribute(Globals.MBEAN_REGISTRY_ATTR,MBeanUtils.createRegistry());context.getServletContext().setAttribute(Globals.MBEAN_SERVER_ATTR,MBeanUtils.createServer());}//...... } 對以上代碼的分析（Analysis）： A1）如果Context實例的 privileged 屬性為true，則會為 web 應用程序添加兩個屬性，并將其存儲在 ServletContext對象中；兩個屬性的鍵名分別是 Globals.MBEAN_REGISTRY_ATTR 和?Globals.MBEAN_SERVER_ATTR， 定義如下： public static final String MBEAN_REGISTRY_ATTR ="org.apache.catalina.Registry";public static final String MBEAN_SERVER_ATTR = "org.apache.catalina.MBeanServer";A2）MBeanUtils.createRegistry() 方法：返回一個 Registry實例，而createServer()方法返回一個 javax.management.MBeanServer 實例。Catalina中所有的MBean 都注冊于 MBeanServer實例中； A3）換句話說：當privileged==true時，才可以從一個web 應用程序中獲取 Registry 類 和 MBeanServer類的對象；
【8】 應用程序 1）intro：該應用程序是用來管理 tomcat 的web 應用程序。雖然它很simple，但已足夠說明如何使用 Catalina暴露出的MBean。可以列出 Catalina 中所有 ObjectName 實例，以及當前正在運行的所有 Context實例，并刪除其中任意一個；
2）利用JMX 管理tomcat 中bean 的應用程序構造 step1）為該web 應用程序創建描述符文件，如下所示：（該文件放到 %CATALINA_HOME%/webapps 目錄下） <!-- myadmin.xml --> <?xml version="1.0" encoding="UTF-8"?> <Context path="/myadmin" docBase="./webapps/myadmin" debug="8"privileged="true" reloadable="true"> </Context> Attention）Context元素的privileged 必須為 true，docBase屬性指定了web 應用程序的文件路徑； step2）該web 應用程序包含一個servlet，代碼如下： public class MyAdminServlet extends HttpServlet{private Registry registry;private MBeanServer mBeanServer;@Overridepublic void init() throws ServletException {registry = (Registry)getServletContext().getAttribute("org.apache.catalina.Registry");if(registry == null) {System.out.println("registry not available");return ;}mBeanServer = (MBeanServer)getServletContext().getAttribute("org.apache.catalina.MBeanServer");if(mBeanServer == null) {System.out.println("mBeanServer not available");return ;}}@Overrideprotected void doGet(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {response.setContentType("text/html");PrintWriter out = response.getWriter();if(registry == null) {System.out.println("registry not available");return ;}out.println("<html><head></head><body>");String action = request.getParameter("action");if("listAllManagedBeans".equals(action)) {listAllManagedBeans(out);} else if("listAllContexts".equals(action)) {listAllContexts(out);}else if ("removeContext".equals(action)) {String contextObjectName = request.getParameter("contextObjectName");removeContext(contextObjectName, out);} else {out.println("invalid commands.");}out.println("</body></html>");}private void listAllManagedBeans(PrintWriter out) {String[] managedBeanNames = registry.findManagedBeans();for (int i = 0; i < managedBeanNames.length; i++) {out.print(managedBeanNames[i] + "<br/>");}}private void listAllContexts(PrintWriter out) {try {ObjectName objName = new ObjectName("Catalina:type=Context,*");Set set = mBeanServer.queryNames(objName, null);Iterator it = set.iterator();while(it.hasNext()) {ObjectName obj = (ObjectName)it.next();out.print(obj +" <a href=?action=removeContext&contextObjectName=" + URLEncoder.encode(obj.toString(), "UTF-8") + ">remove</a><br/>");}} catch (Exception e) {out.print(e.toString());}}private void removeContext(String contextObjectName, PrintWriter out) {try {ObjectName mBeanFactoryOBjectName = new ObjectName("Catalina:type=MBeanFactory");if(mBeanFactoryOBjectName != null) {String operation = "removeContext";String[] params = new String[1];params[0] = contextObjectName;String signature[] = {"java.lang.String"};try {mBeanServer.invoke(mBeanFactoryOBjectName, operation, params, signature);out.print("context removed");} catch (Exception e) {out.print(e.toString());}}} catch (Exception e) {}} } step3）需要一個應用程序部署描述符文件。web.xml 代碼如下： <?xml version="1.0" encoding="ISO-8859-1"?> <!--Licensed to the Apache Software Foundation (ASF) under one or morecontributor license agreements. See the NOTICE file distributed withthis work for additional information regarding copyright ownership.The ASF licenses this file to You under the Apache License, Version 2.0(the "License"); you may not use this file except in compliance withthe License. You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, softwaredistributed under the License is distributed on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.See the License for the specific language governing permissions andlimitations under the License. --> <web-app xmlns="http://java.sun.com/xml/ns/javaee"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://java.sun.com/xml/ns/javaeehttp://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"version="3.0"metadata-complete="true"><servlet><servlet-name>myAdmin</servlet-name><servlet-class>myadmin.MyAdminServlet</servlet-class></servlet><servlet-mapping><servlet-name>myAdmin</servlet-name><url-pattern>/myAdmin</url-pattern></servlet-mapping> </web-app> 3）訪問效果

總結

以上是生活随笔為你收集整理的tomcat(20)基于JMX的管理的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。