JMX主要类及接口简介1.0

合集下载

JMX的概念及应用

一、JMX简单介绍Tomcat从5.0版本开始引入JMX，力图使JMX成为Tomcat未来版本的管理工具和平台。

首先，让我们来对JMX做一个简单了解。

JMX是Java Management Extension的缩写，可译为Java管理工具扩展，扩展的意思就是JMX不包含在标准的J2SE中，我们必须要另外下载JMX RI的实现。

不过，这种把JMX排除在J2SE之外的情况已经成为历史了，J2SE5.0和J2SE6.0都已经包含了JMX的标准实现。

这说明，JMX已经成为J2SE不可分割的一部分，另外一方面，JMX已经成为Java平台上管理工具的事实标准，在业界广泛使用。

例如，JBOSS就是以JMX为微内核，Web应用模块和其它功能模块都可热插拨到这个微内核，将JMX的管理功能发挥得淋漓尽致。

从当前业界使用情况看，JMX中的X(Extension，扩展)应该去掉，改名为Java Management Standard Platform (JMSP，Java管理标准平台)更加合适。

为了向下兼容，我们姑且还是称之为JMX吧。

JMX要管理的对象是什么呢，是资源。

什么是资源，资源是指企业中的的各种应用软件和平台，举例来说，一个公司内部可能有许多应用服务器、若干Web服务器、一台至多台的数据库服务器及文件服务器等等，那么，如果我们想监视数据库服务器的内存使用情况，或者我们想更改应用服务器上JDBC最大连接池的数目，但我们又不想重启数据库和应用服务器，这就是典型意义上的资源管理，即对我们的资源进行监视(Monitoring，查看)和管理(Management，更改)，这种监视和更改不妨碍当前资源的正常运行。

对资源进行适当的监测和管理，可以让我们的IT资源尽可能的平稳运行，可以为我们的客户提供真正意思上的24×7服务。

在资源耗尽或者在硬件出故障之前，我们就可以通过管理工具监测到，并通过管理工具进行热调整和插拔。

Java中的JMX监控有哪些常用指标

Java中的JMX监控有哪些常用指标在 Java 应用程序的运行和维护中，JMX（Java Management Extensions）监控是一项非常重要的技术。

通过 JMX，我们可以获取到应用程序内部的各种运行时信息，从而更好地了解应用的性能、健康状况和资源使用情况。

下面我们就来详细探讨一下 Java 中的 JMX 监控中一些常用的指标。

首先，内存相关的指标是至关重要的。

其中，“Heap Memory Usage”（堆内存使用量）是一个关键指标。

它能让我们了解到 Java 堆内存中已使用的空间和剩余的可用空间。

通过监控这个指标，我们可以及时发现是否存在内存泄漏的风险。

如果堆内存的使用量持续增长，而没有得到有效的释放，就可能意味着存在内存泄漏问题，需要进一步排查和解决。

另一个与内存相关的重要指标是“NonHeap Memory Usage”（非堆内存使用量）。

非堆内存主要包括方法区、JVM 内部数据结构等。

监控非堆内存的使用情况，可以帮助我们了解 JVM 自身的资源消耗，以及是否存在由于非堆内存不足而导致的性能问题。

线程相关的指标也是 JMX 监控中的重点。

“Thread Count”（线程数量）可以告诉我们当前应用中活跃的线程总数。

如果线程数量过多，可能会导致系统资源的竞争加剧，从而影响性能。

“Thread Blocked Count”（阻塞线程数量）则反映了当前处于阻塞状态的线程数量。

过多的阻塞线程可能意味着存在资源竞争或者死锁等问题，需要及时进行排查和处理。

“CPU Usage”（CPU 使用率）是评估应用性能的一个关键指标。

它可以让我们了解应用程序在一段时间内占用 CPU 资源的情况。

如果CPU 使用率持续处于高位，可能意味着应用程序存在计算密集型的操作，或者存在性能瓶颈，需要进一步优化算法或者调整架构。

“Class Loading and Unloading”（类的加载和卸载）指标也是值得关注的。

JMX

什么是JMX?JMX(Java Management Extensions)是一个为应用程序植入管理功能的框架。

JMX是一套标准的代理和服务，实际上，用户可以在任何Java应用程序中使用这些代理和服务实现管理。

JMX的前身是JMAPI。

JMX致力于解决分布式系统管理的问题，因此，能够适合于各种不同的环境是非常重要的。

为了能够利用功能强大的Java计算环境解决这一的问题，Sun公司扩充了Java基础类库，开发了专用的管理类库。

JMX是一种应用编程接口，可扩充对象和方法的集合体，可以用于跨越一系列不同的异构操作系统平台、系统体系结构和网络传输协议，灵活的开发无缝集成的系统、网络和服务管理应用它提供了用户界面指导、Java类和开发集成系统、网络及网络管理应用的规范。

管理对象是JMX应用程序的核心。

JMX结构包括：支持Java的Web浏览器用户接口，管理运行模块ARM(Admin Runtime Module)和应用。

这三个部件之间通过RMI（Remote Method Invocation）进行通信。

这里需要说明的是，RMI是使得一个Java虚拟机（JVM）上运行的程序可以调用远程服务器上另一个JVM总的对象。

用户接口用来发布管理操作，这些操作可以间接的通过浏览器或通过单独的应用程序来激发。

管理运行模块用来给应用提供实例化的管理对象。

它包括Agent对象接口，通知接口和被管数据接口。

应用指的是那些被管设备单元。

JMX是一个完整的网络管理应用程序开发环境，它同时提供了：厂商需要收集的完整的特性清单，可生成资源清单表格，图形化的用户接口；访问SNMP的网络API；主机间远程过程调用；数据库访问方法。

JMX这一轻型的管理基础结构，价值在于对被管理资源的服务实现了抽象，提供了低层的基本类集合，开发人员在保证大多数的公共管理类的完整性和一致性的前提下，进行扩展以满足特定网络管理应用的需要。

JMX注重于构造管理工具的软件框架，并尽量采用已成熟的技术。

JMX使用指南

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

JMX的结构在JMX中共分为三层1：Instrumentation2：Agent3：Distributed ServicesJMX的优点：1：可以非常容易的使应用程序具有被管理的功能2：提供具有高度伸缩性的架构每个JMX Agent服务可以很容易的放入到Agent中，每个JMX的实现都提供几个核心的Agent服务，你也可以自己编写服务，服务可以很容易的部署，取消部署。

3：集成了现有的一些管理解决方案，如SNMP4：非常容易的利用其他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 agentagent是为了管理一系列的MBean，而提供的一系列的服务，如上图所示，通常有MBean relationships, dynamically loading classes, simple monitoring services, timers。

agent可以利用Protocol adapters（例如HTTP 和SNMP）和connectors（RMI 和Jini）使不同的客户端可以访问MBean。

jmx_prometheus_javaagent 指标-概述说明以及解释

jmx_prometheus_javaagent 指标-概述说明以及解释1.引言1.1 概述概述部分的内容：JMX（Java Management Extensions）是一种Java平台的管理和监控技术，它为开发者提供了一套标准API，用于监控和管理Java应用程序的可管理资源。

然而，JMX的指标数据在默认情况下通常无法直接被Prometheus这样的开源监控系统采集和处理。

为了解决这个问题，社区开发了一个开源的中间件工具，名为jmx_prometheus_javaagent。

jmx_prometheus_javaagent是一个Java代理程序，能够帮助我们将JMX的指标数据转换为Prometheus所能接受的格式，并将其暴露给Prometheus服务器进行采集和监控。

它通过在Java应用程序启动时作为Java代理（Java Agent）进行加载，并与Java虚拟机（JVM）进行交互，将JMX的指标数据以HTTP接口形式供Prometheus进行采集。

本文将详细介绍jmx_prometheus_javaagent的概念、使用方法以及其所具有的优势。

我们将首先简要介绍该工具的背景和目的，之后会深入探讨它的使用方法和配置选项。

随后，我们将重点讨论jmx_prometheus_javaagent相较于其他JMX数据采集工具的优势和特点，以及它在实际应用中的潜在价值。

通过研究和使用jmx_prometheus_javaagent，我们可以更方便、高效地将JMX的指标数据与Prometheus进行集成，为我们的应用程序提供强大的监控和管理能力。

在这篇文章中，我们将全面介绍jmx_prometheus_javaagent的使用和优势，帮助读者更好地理解和应用这个强大的工具，并为其在未来的发展提供展望。

1.2 文章结构文章结构部分应该包含以下内容：文章结构部分主要介绍本篇文章的整体结构和组织方式，让读者了解文章从头到尾的逻辑流程。

JMX介绍

1、JMX的Hello World
一、JMX简介
什么是JMX？在一篇网文中是这样说的："JMX(Java Management Extensions)是一个为应用程序植入管理功能的框架。JMX是一套标准的代理和服务，实际上，用户可以在任何Java应用程序中使用这些代理和服务实现管理"，这句话我现在看着还是不知所云，云里雾里。
13. MBeanServer server = ManagementFactory.getPlatformMBeanServer();
14. ObjectName helloName = new ObjectName("chengang:name=HelloWorld");
4.
5. import javax.management.MBeanServer;
6. import javax.management.ObjectName;
7.
8. import m.HtmlAdaptorServer;
9.
3、我使用的开发环境：JDK5.0 ＋ Eclipse3.2。
注：因为用到jmxtools.jar中的HtmlAdaptorServer类，所以将此包加入到项目库引用中。jmxremote_optional.jar暂时不用到，不管它。
三、HelloWorld实例
1、Hello是一个需要被管理的类（普通类）
10. public class HelloAgent {
11. public static void main(String[] args) throws Exception {
12. // MBeanServer server = MBeanServerFactory.createMBeanServer();

kafka jmx原理

Kafka JMX（Java Management Extensions）是一种用于监控和管理Kafka 系统的框架。

它利用Java 虚拟机（JVM）内置的JMX 技术，提供了一组用于收集和公开Kafka 监控指标的接口和工具。

JMX 是一种用于监控和管理Java 应用程序的标准化方案，通过MBean（Managed Bean）提供对应用程序的监控和管理功能。

Kafka 默认支持JMX，内部提供了一组MBean 来公开Kafka 的监控指标。

Kafka JMX 的工作原理如下：1. 启用JMX：在Kafka 的启动脚本或配置文件中，配置JMX 端口和相关参数，以启用JMX 技术。

2. MBean 注册：Kafka 在启动时会创建一组MBean，用于收集和公开各种监控指标。

这些MBean 代表了Kafka 的不同组件和功能，如Broker、Topic、Consumer Group 等。

3. JMX 连接：使用JMX 客户端工具（如JConsole、JVisualVM）或编程方式，与Kafka 的JMX 端口建立连接。

4. 检索监控指标：一旦与Kafka 建立了JMX 连接，可以使用JMX 客户端工具或编程方式，获取Kafka 的各种监控指标。

这些指标包括Broker 的吞吐量、延迟、磁盘使用情况，Topic 的分区状态、偏移量等。

5. 监控和管理：获取到Kafka 的监控指标后，可以使用各种工具和方式对Kafka 进行监控和管理。

例如，可以设置警报规则，当指标达到或超过某个阈值时发送通知；也可以进行性能分析和故障排查等操作。

需要注意的是，Kafka JMX 的性能会受到监控频率和监控数据量的影响。

监控过程中频繁获取大量的监控指标可能会对Kafka 的性能产生一定的影响。

因此，在配置Kafka JMX 时需要根据具体的需求和系统资源进行综合考虑和调整。

hbase jmx指标

hbase jmx指标HBase JMX指标是一种用于监控和管理HBase集群的工具。

在大规模的数据存储和处理中，了解系统的运行状况对于保证数据的可靠性和性能至关重要。

通过使用HBase JMX指标，管理员可以获取关于HBase集群的各种性能指标，从而实时监控和管理系统。

在本文中，我们将一步一步地回答有关HBase JMX指标的问题，并探讨这些指标如何帮助我们了解和优化HBase集群的性能。

第一步：什么是JMX？JMX是Java管理扩展的缩写，是一种用于监控和管理Java应用程序的标准API。

它提供了一种统一的方式来监控应用程序的运行状况和性能，并且可以与各种监控工具和管理工具集成。

JMX通过使用MBean（管理对象）来公开应用程序的内部状态和操作，并通过使用远程JMX协议进行通信。

第二步：什么是HBase？HBase是一个构建在Hadoop文件系统（HDFS）上的分布式、可扩展的面向列的NoSQL数据库。

它提供了实时读写访问大规模数据集的功能，并具有高可靠性和可伸缩性。

HBase的设计目标是能够处理大量的数据，并提供快速的读写操作。

第三步：为什么需要监控HBase集群？在一个大规模的HBase集群中，有许多复杂的组件和进程在工作，包括主节点、区域服务器和协处理器。

为了确保系统的稳定性和性能，我们需要实时监控集群中各个组件的运行状况。

监控HBase集群可以帮助我们及时发现和解决潜在的故障和性能瓶颈，从而确保系统的可靠性和高效性。

第四步：什么是HBase JMX指标？HBase JMX指标是一系列用于监控和管理HBase集群的指标。

这些指标反映了HBase集群的各个组件的状态和性能，如主节点、区域服务器、协处理器等。

通过使用HBase JMX指标，管理员可以实时获取关于集群的各种信息，如读写请求的数量、处理时间、错误日志等。

第五步：如何使用HBase JMX指标？要使用HBase JMX指标，我们首先需要启动HBase集群，并确保JMX 监控已启用。

jmx入门

JMX入门JMX越来越多得出现在各种技术杂志、以及社区，如ibm的developerworks和bea的dev2dev。

不仅仅是SUN，许多厂商都宣布已经或是准备支持这一技术。

IBM、BEA、HP、Marcomedia(JRun)这些大的厂商，而且还有许多小的软件公司和开源项目也都加入了这一行列。

为什么JMX那么受欢迎，JMX到底有那些优势只得人们去学习和理解，本文从JMX的基本架构、hellowold jmx以及spring对JMX的支持讲起，希望大家能通过本文对JMX有个基础的认识，并能通过本文为今后学习JMX打个基础JMX中的术语：∙MBean：是Managed Bean的简称。

在JMX中MBean代表一个被管理的资源实例，通过MBean暴露一系列方法和属性，外界可以获取被管理的资源的状态和操纵MBean 的行为。

事实上，MBean就是一个Java Object，同JavaBean模型一样，外界使用反射来获取Object的值和调用Object的方法，只是MBean提供了更加容易操作的反射的使用。

Mbean 包括4种类型：标准MBean、动态MBean、开放MBean、模型MBe an。

∙MBeanServer：MBeanServer是MBean 的容器。

MBeanServer管理这些MBean，并且通过代理外界对它们的访问。

MBeanServer提供了一种注册机制，通过注册Adaptor 和Connector，以及MBean到MBeanServer，并且通过代理外界对它们的访问。

外界可以通过名字来得到相应的MBean实例。

∙JMX Agent：Agent只是一个Java进程，它包括这个MBeanServer和一系列附加的M beanService。

当然这些Service也是通过MBean的形式来发布。

∙Protocol Adapters and ConnectorsJMX Agent通过各种各样的Adapter和Connector来与外界(JVM之外)进行通信。

JMX-JAVA进程监控利器

JMX-JAVA进程监控利器管理扩展（Java Management Extension，JMX）是从jdk1.4开始的，但从1.5时才加到jdk⾥⾯，并把API放到ng.management包⾥⾯。

如果⼀个 Java 对象可以由⼀个遵循 JMX 规范的管理器应⽤管理，那么这个Java 对象就可以称为⼀个可由 JMX 管理的资源。

要使⼀个 Java 对象可管理，则必须创建相应的 MBean 对象，并通过这些 MBean 对象管理相应的 Java 对象。

当拥有 MBean 类后，需要将其实例化并注册到 MBeanServer 上。

⼀共有四种类型的 MBean ，分别是标准类型 MBean，动态类型 MBean，开放类型 MBean 和模型类型 MBean。

注：1. ⼀个java进程⾥⾯可以有多个不同名字的mBeanServer ，每个mbs都是⼀个独⽴的容器，⽤了管理mbean2. 每个mbs都可以注册多个rmi port，http port等3. platformMBeanServer 是由jvm创建的，并添加了⼀些系统的mbean，如cpu，内存，⽹络，线程等等1、本机使⽤当我们启动java进程后，经常会使⽤jps，jinfo，jmap，jstat等jdk⾃带的命令去查询进程的状态，这其中的原理就是，当java进程启动后，会创建⼀个⽤于本机连接的“localConnectorAddress”放到当前⽤户⽬录下，当使⽤jps等连接时，会到当前⽤户⽬录下取到“localConnectorAddress”并连接。

package com.dxz.study;import java.io.IOException;import java.util.List;import java.util.Map;import java.util.Properties;import java.util.Set;import javax.management.MBeanServerConnection;import javax.management.ObjectName;import javax.management.remote.JMXConnector;import javax.management.remote.JMXConnectorFactory;import javax.management.remote.JMXServiceURL;import org.junit.Test;import com.sun.tools.attach.VirtualMachine;import com.sun.tools.attach.VirtualMachineDescriptor;public class JmxTest {@Testpublic void test1() {List<VirtualMachineDescriptor> vms = VirtualMachine.list();for (VirtualMachineDescriptor desc : vms) {VirtualMachine vm;try {System.out.println("desc:" + desc);System.out.println("进程id:"+desc.id());vm = VirtualMachine.attach(desc);} catch (Exception e) {e.printStackTrace();continue;}JMXConnector connector = null;try {Properties props = vm.getAgentProperties();for (Map.Entry<Object, Object> entry : props.entrySet()) {System.out.println(entry.getKey() + "->" + entry.getValue());}String connectorAddress = props.getProperty("com.sun.management.jmxremote.localConnectorAddress");if (connectorAddress == null) {System.out.println("connectorAddress is null");continue;}System.out.println("conn:" + connectorAddress);//以下代码⽤于连接指定的jmx，本地或者远程JMXServiceURL url = new JMXServiceURL(connectorAddress);//JMXServiceURL url = new JMXServiceURL("service:jmx:rmi:///jndi/rmi://localhost:1099/TestJMXServer");connector = JMXConnectorFactory.connect(url);MBeanServerConnection mbeanConn = connector.getMBeanServerConnection();Set<ObjectName> beanSet = mbeanConn.queryNames(null, null);// ...} catch (Exception e) {e.printStackTrace();} finally {try {if (connector != null) connector.close();break;} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}}}pom.xml<project xmlns="/POM/4.0.0" xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.dxz</groupId><artifactId>study</artifactId><version>0.0.1-SNAPSHOT</version><packaging>jar</packaging><name>study</name><url></url><properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding></properties><dependencies><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.1</version><scope>test</scope></dependency><dependency><groupId>org.glassfish.external</groupId><artifactId>opendmk_jdmkrt_jar</artifactId><version>1.0-b01-ea</version></dependency><dependency><groupId>org.jmockit</groupId><artifactId>jmockit</artifactId><version>1.24</version></dependency></dependencies></project>上⾯代码有时候取不到本地连接地址，这个时候需要尝试让agent加载management-agent.jar，完整代码如下：package com.dxz.study;import java.io.File;import java.io.IOException;import ng.reflect.Method;import .URL;import .URLClassLoader;import java.util.List;import java.util.Properties;public class AbstractJmxCommand {private static final String CONNECTOR_ADDRESS = "com.sun.management.jmxremote.localConnectorAddress";public static String getJVM() {return System.getProperty("java.vm.specification.vendor");}public static boolean isSunJVM() {// need to check for Oracle as that is the name for Java7 onwards.return getJVM().equals("Sun Microsystems Inc.") || getJVM().startsWith("Oracle");}public static void main(String[] args) {if (args == null || args.length == 0) {System.out.println("Usage: pid");return;}int pid = Integer.valueOf(args[0]);System.out.println(new AbstractJmxCommand().findJMXUrlByProcessId(pid));}/*** Finds the JMX Url for a VM by its process id** @param pid* The process id value of the VM to search for.** @return the JMX Url of the VM with the given pid or null if not found.*/// @SuppressWarnings({ "rawtypes", "unchecked" })protected String findJMXUrlByProcessId(int pid) {if (isSunJVM()) {try {// Classes are all dynamically loaded, since they are specific// to Sun VM// if it fails for any reason default jmx url will be used// tools.jar are not always included used by default class// loader, so we// will try to use custom loader that will try to load tools.jarString javaHome = System.getProperty("java.home");String tools = javaHome + File.separator + ".." + File.separator + "lib" + File.separator + "tools.jar";URLClassLoader loader = new URLClassLoader(new URL[] { new File(tools).toURI().toURL() });Class virtualMachine = Class.forName("com.sun.tools.attach.VirtualMachine", true, loader);Class virtualMachineDescriptor = Class.forName("com.sun.tools.attach.VirtualMachineDescriptor", true, loader);Method getVMList = virtualMachine.getMethod("list", (Class[]) null);Method attachToVM = virtualMachine.getMethod("attach", String.class);Method getAgentProperties = virtualMachine.getMethod("getAgentProperties", (Class[]) null);Method getVMId = virtualMachineDescriptor.getMethod("id", (Class[]) null);List allVMs = (List) getVMList.invoke(null, (Object[]) null);for (Object vmInstance : allVMs) {String id = (String) getVMId.invoke(vmInstance, (Object[]) null);if (id.equals(Integer.toString(pid))) {Object vm = attachToVM.invoke(null, id);Properties agentProperties = (Properties) getAgentProperties.invoke(vm, (Object[]) null);String connectorAddress = agentProperties.getProperty(CONNECTOR_ADDRESS);if (connectorAddress != null) {return connectorAddress;} else {break;}}}// 上⾯的尝试都不成功，则尝试让agent加载management-agent.jarMethod getSystemProperties = virtualMachine.getMethod("getSystemProperties", (Class[]) null);Method loadAgent = virtualMachine.getMethod("loadAgent", String.class, String.class);Method detach = virtualMachine.getMethod("detach", (Class[]) null);for (Object vmInstance : allVMs) {String id = (String) getVMId.invoke(vmInstance, (Object[]) null);if (id.equals(Integer.toString(pid))) {Object vm = attachToVM.invoke(null, id);Properties systemProperties = (Properties) getSystemProperties.invoke(vm, (Object[]) null);String home = systemProperties.getProperty("java.home");// Normally in ${java.home}/jre/lib/management-agent.jar// but might// be in ${java.home}/lib in build environments.String agent = home + File.separator + "jre" + File.separator + "lib" + File.separator+ "management-agent.jar";File f = new File(agent);if (!f.exists()) {agent = home + File.separator + "lib" + File.separator + "management-agent.jar";f = new File(agent);if (!f.exists()) {throw new IOException("Management agent not found");}}agent = f.getCanonicalPath();loadAgent.invoke(vm, agent, "com.sun.management.jmxremote");Properties agentProperties = (Properties) getAgentProperties.invoke(vm, (Object[]) null);String connectorAddress = agentProperties.getProperty(CONNECTOR_ADDRESS);// detach 这个vmdetach.invoke(vm, (Object[]) null);if (connectorAddress != null) {return connectorAddress;} else {break;}}}} catch (Exception ignore) {ignore.printStackTrace();}}return null;}}2、远程连接毫⽆疑问，若想远程连接访问，肯定需要mBeanServer注册⼀个或多个端⼝，如rmi端⼝，http端⼝等。

JMX架构

JMX架构的了解板桥里人 2002/12/26JMX应该说是关于网络应用管理的的框架，如果你开发了一个比较复杂的系统，无疑你要提供这个系统的自身管理系统，JMX更多应用是体现在Server上，如果你要使用java开发一个自己Server或复杂的应用系统，那么推荐你基于JMX架构来开发， JBoss 3.0 weblogic等就是基于JMX开发的符合J2EE规范的服务器软件。

了解JMX可以使你深入了解J2EE服务器，为什么我们平时说 "EJB"是个比较"Weight"的方案选择，其中一个原因是J2EE服务器软件本身也是你的系统中一部分，它作为你系统的容器，对你的系统有至关重要的作用，如果无法直接介入管理或“调教”它，那么无疑你的系统本身存在着隐含的危险，现在，通过JMX，你现在可以深入到你J2EE容器内部的管理了。

(好像国内出现了第一个自己J2ee服务器，不知道那是不是基于JMX开发的?)J2EE并不能概括所有的应用领域，比如对速度和性能要求极高的游戏或股票行情等系统就需要自己直接来开发Server，如果是能够基于JMX开发，那么可以说就大大提高编写管理程序的效率，可以将你的模块变成JMX的MBean，可以通过Agent在程序内部或者通过 WEB管理页面对你的MBean模块进行初始化重启以及参数设置。

JMX的好处还有：可以方便整合连接现有的Java技术，如JNDI JDBC JTS及其它。

特别是能够使用Jini的查询发现机制以及协议，我们知道,Jini提供了一种服务的查询和发现机制，这些services都可以通过JMX 来实现管理。

现在我们开始JMX的了解：1.到首页的JMX页面，下载JMX的规定说明和Samples程序。

2.按照JMX的说明进行一次Tutorial，了解如何加入删除配置一个MBean，Tutorial中是以SimpleMBean为例，那么我们能否建立一个自己的MBean?我们来做一个Hello 的MBean，这里有一个小关键点，你的class取名有个规则，需要以MBean为结尾，如这里我们取名为HelloMbean:public interface HelloMBean {// management attributespublic String getName();public void setName(String name);// management operationspublic void print();}在这个Class里，有一个隐含attributes: name, 提供了set和get的方法，同时有一个操作方法print()：再定义一个concrete类:public class Hello implements HelloMBean {private String name = "";public String getName() {return name;}public void setName(String name) { = name;}public void print() {System.out.println("Hello, " + name + "!!" );}}这样一个简单的MBean就做好了，我们可以通过admin界面加入这个Hello，再按 Tutorial启动BaseAgent，在Agent Administration中参考Simple填入：Domain: Standard_Hello_MBeansKeys : name=Hello,number=1Java Class: Hello将出现Create Successful信息。

JAVA中的JMX框架机制_01

最近关注了下JAVA中的JMX框架机制，把附带的例子调试运行了下，把调试中遇到的问题拿出来，供大家分享吧。

1首先定一个接口类，必须以Mbean结尾，遵守框架的命名规范package com.example.mbeans;public interface HelloMBean {// operationspublic void sayHello();public int add(int x, int y);// attributes// a read-only attribute called Name of type Stringpublic String getName();// a read-write attribute called CacheSize of type intpublic int getCacheSize();public void setCacheSize(int size);}2.定义实现类，实现上面定义的接口package com.example.mbeans;import javax.management.AttributeChangeNotification;import javax.management.MBeanNotificationInfo;import javax.management.Notification;import javax.management.NotificationBroadcasterSupport;public class Hello extends NotificationBroadcasterSupport implements HelloMBean {public void sayHello() {System.out.println("hello, world");}public int add(int x, int y) {return x + y;}/** Getter for the Name attribute. The pattern shown here is frequent: the* getter returns a private field representing the attribute value. In our* case, the attribute value never changes, but for other attributes it* might change as the application runs. Consider an attribute representing * statistics such as uptime or memory usage, for example. Being read-only * just means that it can't be changed through the management interface. */public String getName() {return ;}/** Getter for the CacheSize attribute. The pattern shown here is frequent: * the getter returns a private field representing the attribute value, and* the setter changes that field.*/public int getCacheSize() {return this.cacheSize;}/** Setter for the CacheSize attribute. To avoid problems with stale values * in multithreaded situations, it is a good idea for setters to be* synchronized.*/public synchronized void setCacheSize(int size) {int oldSize = this.cacheSize;this.cacheSize = size;/** In a real application, changing the attribute would typically have* effects beyond just modifying the cacheSize field. For example,* resizing the cache might mean discarding entries or allocating new* ones. The logic for these effects would be here.*/System.out.println("Cache size now " + this.cacheSize);/** Construct a notification that describes the change. The "source" of a* notification is the ObjectName of the MBean that emitted it. But an* MBean can put a reference to itself ("this") in the source, and the* MBean server will replace this with the ObjectName before sending the* notification on to its clients.** For good measure, we maintain a sequence number for each notification* emitted by this MBean.** The oldValue and newValue parameters to the constructor are of type* Object, so we are relying on Tiger's autoboxing here.*/Notification n = new AttributeChangeNotification(this, sequenceNumber++, System.currentTimeMillis(),"CacheSize changed", "CacheSize", "int", oldSize, this.cacheSize);/** Now send the notification using the sendNotification method inherited* from the parent class NotificationBroadcasterSupport.*/sendNotification(n);}@Overridepublic MBeanNotificationInfo[] getNotificationInfo() {String[] types = new String[] { AttributeChangeNotification.ATTRIBUTE_CHANGE }; String name = AttributeChangeNotification.class.getName();String description = "An attribute of this MBean has changed"; MBeanNotificationInfo info = new MBeanNotificationInfo(types, name, description); return new MBeanNotificationInfo[] { info };}private final String name = "Reginald";private int cacheSize = DEFAULT_CACHE_SIZE;private static final int DEFAULT_CACHE_SIZE = 200;private long sequenceNumber = 1;}3.运行上面的代码package com.example.mbeans;import ng.management.ManagementFactory;import javax.management.MBeanServer;import javax.management.ObjectName;public class Main {/** For simplicity, we declare "throws Exception". Real programs will usually* want finer-grained exception handling.*/// throws MalformedObjectNameException, NullPointerException,// InstanceAlreadyExistsException, MBeanRegistrationException,// NotCompliantMBeanException, InterruptedExceptionpublic static void main(String[] args) throws Exception {// Get the Platform MBean ServerMBeanServer mbs = ManagementFactory.getPlatformMBeanServer();// Construct the ObjectName for the MBean we will registerObjectName name = new ObjectName("com.example.mbeans:type=Hello");// Create the Hello World MBeanHello mbean = new Hello();// Register the Hello World MBeanmbs.registerMBean(mbean, name);ObjectName name1 = new ObjectName("com.example.mbeans:type=Hello1"); Hello mbean1 = new Hello();mbs.registerMBean(mbean1, name1);// Wait foreverSystem.out.println("Waiting forever...");mbean.setCacheSize(300);mbean1.setCacheSize(400);Thread.sleep(Long.MAX_VALUE);}public static void main1(String[] args) throws Exception {// Get the Platform MBean ServerMBeanServer mbs = ManagementFactory.getPlatformMBeanServer();// Construct the ObjectName for the MBean we will registerObjectName name = new ObjectName("com.example.mbeans:type=Hello");// Create the Hello World MBeanHello mbean = new Hello();// Register the Hello World MBeanmbs.registerMBean(mbean, name);ObjectName name1 = new ObjectName("com.example.mbeans:type=Hello1");Hello mbean1 = new Hello();mbs.registerMBean(mbean1, name1);// Wait foreverSystem.out.println("Waiting forever...");Thread.sleep(Long.MAX_VALUE);}}我们可以使用Jconsole连接上面的运行时JVM，在启动时设置配置属性：-Dcom.sun.management.jmxremote=true -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false，然后启动Jconsole，新建连接：在本地进程中，我们可以看到有我们运行的类名，动态的分配了一个进程号5344，点击进入连接：我们可以看到运行的Mbean有两个Hello，Hello1。

jmx

图2. MBean的分类
标准(Standard)MBean
标准MBean适用于描述那些数据稳定且可被事先准确定义的资源。标准MBean就是一个普通Java Bean， MBean服务器通过Java的内省(Introspection)机制来获知标准MBean的属性、事件和方法，只是这里内省所遵循的命名规定是JMX特有的命名约定。这种类型的MBean最简单，它能管理的资源（包括属性，方法，时间）必须定义在接口中，然后MBean必须实现这个接口。而且这个MBean实现类中，必须至少有一个 public的构造函数。类中的getter和setter函数必须遵守命名标准。类的命名也必须遵循一定的规范，例如我们的 MBean为Hello，则接口必须为HelloMBean，而且是大小写敏感的。如果不这么做，可能会有 javax.management.NotCompliantMBeanException抛出。
JMX 的体系结构和操作模型
JMX 的体系结构和操作模型旨在满足下列目标：
• 可伸缩性：适应从管理少数设备或服务到管理
因特时代的企业可能拥有的数万个可管理端点的能力
• 旧系统集成和兼容性：与现有 NMS 或 EMS
解决方案以及与可能不支持 JMX 的旧的可管理端点协作的能力轻松地将 JMX 兼容性设计到现有软件产品和设备中
当配置的阈值参数与被观测属性类型不相同时计数器监视程序或测量值监视程序产生该通知定时器服务时间服务可以在制定的时间和日期发出通告也可以定期的周期性的发出通告依赖于管理应用程序的配置
JMX技术介绍
2010.12.16 王璐
目录
概述设备层代理层分布式服务层
JMX：网络管理规范
JMX(Java Management Extension Instrumentation and Agent Specification) 是业界广泛合作创建一套规范的成果，它描述可扩展的体系结构、API 和一组使用 Java 编程语言用于网络管理的分布式服务，它利用了 Java 平台的网络管理能力。最新的规范是 1.4

JMX主要类及接口简介1.0

JMX 接口及类简介编写徐萌 2004 年 4 月25日版本修订记录目录1.概述1.1编写目的本文用于引导读者对于JMX管理框架的主要类及接口的学习，1.2标准概况本文内容符合J2EE 1.4标准，请参考/j2ee本文内容符合JMX1.0标准 JMX Remote标准1.3术语和缩略语J2EE : Java 2 Platform Enterprise Edition，J2EEXML: Extensible Markup LanguageJMX： java management extensions1.4参考文献1.Java Management Extensions J.Steven Perry2.Java™ and JMX: Building Manageable Systems By Heather Kreger, Ward Harold, Leigh Williamson3.Java TM Management Extensions (JMX TM) Remote API 1.0 Specification2.JMX概述JMX--Java Management Extensions，即Java管理扩展,是一个为应用程序、设备、系统等植入管理功能的框架。

JMX可以跨越一系列异构操作系统平台、系统体系结构和网络传输协议，灵活的开发无缝集成的系统、网络和服务管理应用。

通过JMX可以对资源进行管理，还可以通过java对其它技术资源进行管理，如SNMP，TMN和CIM 。

如下图，可以看到JMX管理框架在一个基于web的应用系统的管理系统中的位置。

.JMX体系结构分为以下四个层次：1.设备层（Instrumentation Level）：主要定义了信息模型。

在JMX中，各种管理对象以管理构件的形式存在，需要管理时，向MBean服务器进行注册。

该层还定义了通知机制以及一些辅助元数据类。

2.代理层（Agent Level）：主要定义了各种服务以及通信模型。

JMX 规范介绍

目录1.1 JMX架构的优点 (2)1.2本规范所涉及的范围 (3)1.2.1 参考实现 (3)1.2.2 兼容度测试套件（CTS） (3)1.2.3 JMX API是java平台的一部分 (3)1.3 架构概览 (4)1.3.1 监测层 (4)1.3.2 Agent层 (5)1.3.3 分布式服务层 (5)1.4 组件概览 (6)1.4.1 监测层组件 (6)1.4.1.1 MBeans (6)1.4.1.2 通知模型 (7)1.4.1.3 MBean元数据类集 (7)1.4.2 Agent层组件 (8)1.4.2.1 MBean Server (8)1.4.2.2 Agent服务组件 (8)1.5 JMX 远程API (9)1.6 本版本变化 (9)JMX 规范介绍java管理扩展（The Java Management extensions ）也叫做JMX规范,定义了一个java网络管理、监控和应用程序服务的架构，以及其中的设计模式和API。

这个章节将介绍所有这些内容，并展示JMX涉及的广阔领域。

JMX规范适用于准备监测java代码、创建强大的java代理以及开发分布式管理（监控）中间件或管理器的所有行业的java开发者。

另外，JMX规范已被很多正式的管理、监控技术引用。

JMX架构分为三个层：1、检测（Instrumentation）层2、Agent层3、分布式服务层这个章节将对这些层以及它们的基础组件做介绍。

1.1 JMX架构的优点在JMX规范的实现中，JMX架构有以下优点：●使java应用程序能成本较低的被管理起来JMX架构依赖于一个充当管理（监控）代理者角色、并且能运行在大多数支持java的设备的核心对象管理服务。

这能够使java程序在完全不破坏既有设计的前提下被监控和管理起来。

仅需要做的就是：让java程序嵌入对象管理服务，并且使程序中的一些功能作为可用的被管理对象（MBean）注册到核心对象管理服务上。

JMX超详细解读

JMX超详细解读⼀、JMX的定义 JMX(Java Management Extensions)是⼀个为应⽤程序植⼊管理功能的框架。

JMX是⼀套标准的代理和服务，实际上，⽤户可以在任何Java应⽤程序中使⽤这些代理和服务实现管理。

这是官⽅⽂档上的定义，我看过很多次也⽆法很好的理解。

我个⼈的理解是JMX让程序有被管理的功能，例如你开发⼀个WEB⽹站，它是在24⼩时不间断运⾏，那么你肯定会对⽹站进⾏监控，如每天的UV、PV是多少；⼜或者在业务⾼峰的期间，你想对接⼝进⾏限流，就必须去修改接⼝并发的配置值。

应⽤场景：中间件软件WebLogic的管理页⾯就是基于JMX开发的，⽽JBoss则整个系统都基于JMX构架。

对于⼀些参数的修改，⽹上有⼀段描述还是⽐较形象的：1、程序初哥⼀般是写死在程序中，到要改变的时候就去修改代码，然后重新编译发布。

2、程序熟⼿则配置在⽂件中（JAVA⼀般都是properties⽂件），到要改变的时候只要修改配置⽂件，但还是必须重启系统，以便读取配置⽂件⾥最新的值。

3、程序好⼿则会写⼀段代码，把配置值缓存起来，系统在获取的时候，先看看配置⽂件有没有改动，如有改动则重新从配置⾥读取，否则从缓存⾥读取。

4、程序⾼⼿则懂得物为我所⽤，⽤JMX把需要配置的属性集中在⼀个类中，然后写⼀个MBean，再进⾏相关配置。

另外JMX还提供了⼀个⼯具页，以⽅便我们对参数值进⾏修改。

⼆、JMX架构图：从图中我们可以看到，JMX的结构⼀共分为三层：1、基础层：主要是MBean，被管理的资源。

MBean分为如下四种，我接下来主要介绍standard MBean类型描述standard MBean这种类型的MBean最简单，它能管理的资源（包括属性，⽅法，时间）必须定义在接⼝中，然后MBean必须实现这个接⼝。

它的命名也必须遵循⼀定的规范，例如我们的MBean为Hello，则接⼝必须为HelloMBean。

JMX技术基础

JMX技术基础private ic final Logger LOG =Logger.getLogger(MyObject.class); private long id;private String name; public MyObject(){ per(); } public MyObject(long id, String name) { super(); this.id = id; = name; } public long getId() { returnid; } public void setId(long id) { this.id = id; } public String getName() { return name; } public void setName(String name){ = name; } public String show() { StringBuffer sb = newStringBuffer().append(\"id=\").append(id).append(\",name=\") .append(name); (\"show()=\" + sb.toString()); return sb.toString(); } } 可以看到，管理接口中裸露了4个办法，可以查看但不能修改id，可以查看并修改name，可以调用show办法。

需要注重的是，对于标准MBean，假如MBean管理接口定义为xxxMBean，则实现一定为xxx，否则就无法通过MBean Server查找到对应的资源。

2、代理层代理层为待管理对象（照实现标准MBean管理接口的Java对象）提供了一个容器，其中惟独满足要求并注册到容器中对象才干实现JMX管理。

代理层最主要的组件就是MBean Server，它在我们的应用系统中充当一个管理功能的代理。

JMX协议——精选推荐

JMX协议
JMX
⽅式说明：JMX在Java编程语⾔中定义了应⽤程序以及⽹络管理和监控的体系结构、设计模式、应⽤程序接⼝以及服务。

通常使⽤JMX来监控系统的运⾏状态或管理系统的某些⽅⾯，⽐如清空缓存、重新加载配置⽂件等
使⽤前提：应⽤⽀持JMX的连接，⼀般可以通过web页⾯进⾏查看或者通过登录到服务器后使⽤指定的命令查看相关数据，且监听端⼝可达。

使⽤协议和端⼝：⼀般使⽤TCP协议，端⼝根据实际的应⽤不同⽽不同
取值⽅式：通过java程序调⽤⼚家给出的⽀持JMX协议的第三⽅包，第三⽅执⾏JMX协议将取到的值反馈给RIIL进⾏处理、展现。

数据处理：RIIL接收到所取到的数据后，通过提取有效数据和计算的⽅式将数据进⾏整理后即为指标对应的值。

适应范围：⽬前多数的J2EE应⽤及中间层都是采⽤该协议进⾏监控，⽐如websphere系列、JBOSS、weblogic等。

jmx教程(无图)

1、JMX的Hello World一、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文件，下载网址：/products/JavaManagement/download.html。