java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > JAVA监控JMX

JAVA监控JMX的使用

作者：_BugMan

Java Management Extensions(JMX)提供了一种标准化的方法来管理和监控Java应用程序,为Java应用提供了一种高效、一致的管理方式,本文就来介绍一下JMX的使用,感兴趣的可以了解一下

1.概述

什么是JMX，首先来看一段对话：

Java Management Extensions（JMX）是一种Java标准，用于管理和监控Java应用程序，特别是分布式系统。它提供了一种标准化的方式来管理应用程序的各种方面，包括性能监控、配置更改、事件通知等。目前JMX最常用的就是用来做JAVA程序的监控，市面上常见的Java 监控框架基本都是基于JMX来实现的。

JMX分为三部分：

img

JMX标准的实现通常由Java虚拟机（JVM）提供支持。Java虚拟机会实现JMX标准，以便应用程序可以利用JMX的功能。JVM会提供一个MBean服务器，应用程序可以将MBean注册到该服务器中，使其可供其他应用程序或工具访问和操作。

Java虚拟机通过提供标准的MBean服务器和相关的API，为应用程序提供了一种标准化的方式来管理和监控应用程序的各个方面。这种标准化使得开发人员可以使用相同的接口和工具来管理不同的Java应用程序，从而提高了管理的效率和一致性。

2.MBean

MBean服务器由于是JVM实现的，所以对我们应用开发者来说，最核心的其实就是MBean了，因为MBean是用来实现功能的。JMX标准中将MBean分为以下几种：

2.1.Standard MBean

所谓的Standard MBean，就是说按照JMX的命名规范来定义接口然后注册到MBean Server中，MBean就能被JMX的client端访问到。具体该MBean提供了什么功能，在这个自定义的MBean中去定义属性和方法仔细实现即可。

代码示例：

// 定义一个接口，命名约定为 YourInterfaceNameMBean
public interface HelloMBean {
    String getName();
    void setName(String name);
    void sayHello();
}
​
// 实现上述接口的类
public class Hello implements HelloMBean {
    private String name;
​
    @Override
    public String getName() {
        return name;
    }
​
    @Override
    public void setName(String name) {
        this.name = name;
    }
​
    @Override
    public void sayHello() {
        System.out.println("Hello, " + name + "!");
    }
}
​
// 主程序
public class Main {
    public static void main(String[] args) throws Exception {
        // 创建标准 MBean 实例
        HelloMBean helloMBean = new Hello();
        
        // 创建 MBeanServer
        MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
        
        // 创建 ObjectName，用于标识 MBean
        ObjectName name = new ObjectName("com.example:type=Hello");
        
        // 注册 MBean 到 MBeanServer
        mbs.registerMBean(helloMBean, name);
        
        // 等待一段时间，使得可以通过 JConsole 或者其他 JMX 客户端来操作 MBean
        Thread.sleep(Long.MAX_VALUE);
    }
}

2.2.Dynamic MBean

动态 MBean 是 Java Management Extensions (JMX) 中的一种特殊类型的 MBean，它与标准 MBean 不同之处在于，动态 MBean 允许在运行时动态地确定其属性和操作，这使得动态 MBean 能够在运行时根据需要动态地调，而不是在编译时就确定了。

说人话就是很方便动态的去修改Dynamic MBean的属性，这非常适合拿来做一些动态的功能，比如：

动态 MBean 的核心是实现 DynamicMBean 接口，该接口定义了一组方法，用于动态地获取和设置 MBean 的属性，执行 MBean 的操作，以及获取 MBean 的元数据信息。以下是 DynamicMBean 接口的几个核心方法：

代码示例：

import javax.management.*;
import java.lang.management.ManagementFactory;
​
public class DynamicHello implements DynamicMBean {
    private String name;
​
    @Override
    public Object getAttribute(String attribute) throws AttributeNotFoundException, MBeanException, ReflectionException {
        if (attribute.equals("Name")) {
            return name;
        } else {
            throw new AttributeNotFoundException("Attribute '" + attribute + "' not found");
        }
    }
​
    @Override
    public void setAttribute(Attribute attribute) throws AttributeNotFoundException, InvalidAttributeValueException, MBeanException, ReflectionException {
        if (attribute.getName().equals("Name")) {
            name = (String) attribute.getValue();
        } else {
            throw new AttributeNotFoundException("Attribute '" + attribute.getName() + "' not found");
        }
    }
​
    @Override
    public AttributeList getAttributes(String[] attributes) {
        AttributeList attrs = new AttributeList();
        for (String attr : attributes) {
            try {
                Object value = getAttribute(attr);
                attrs.add(new Attribute(attr, value));
            } catch (Exception e) {
                // Ignore if attribute not found
            }
        }
        return attrs;
    }
​
    @Override
    public AttributeList setAttributes(AttributeList attributes) {
        AttributeList responseAttrs = new AttributeList();
        for (Attribute attr : attributes.asList()) {
            try {
                setAttribute(attr);
                responseAttrs.add(new Attribute(attr.getName(), getAttribute(attr.getName())));
            } catch (Exception e) {
                // Ignore if attribute not found or set failed
            }
        }
        return responseAttrs;
    }
​
    @Override
    public Object invoke(String actionName, Object[] params, String[] signature) throws MBeanException, ReflectionException {
        if (actionName.equals("sayHello")) {
            return "Hello, " + name + "!";
        } else {
            throw new UnsupportedOperationException("Operation '" + actionName + "' not supported");
        }
    }
​
    @Override
    public MBeanInfo getMBeanInfo() {
        MBeanAttributeInfo[] attributes = new MBeanAttributeInfo[]{
                new MBeanAttributeInfo("Name", "java.lang.String", "Name of the person", true, true, false)
        };
​
        MBeanOperationInfo[] operations = new MBeanOperationInfo[]{
                new MBeanOperationInfo("sayHello", "Say hello to the person", null, "java.lang.String", MBeanOperationInfo.ACTION)
        };
​
        return new MBeanInfo(this.getClass().getName(), "Dynamic Hello MBean", attributes, null, operations, null);
    }
​
    public static void main(String[] args) throws Exception {
        DynamicHello dynamicHello = new DynamicHello();
        MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
        ObjectName name = new ObjectName("com.example:type=DynamicHello");
        mbs.registerMBean(dynamicHello, name);
        Thread.sleep(Long.MAX_VALUE);
    }
}

在这个示例中，我们实现了 DynamicMBean 接口，并重写了它的方法来提供 MBean 的属性和操作。动态 MBean 允许在运行时确定其属性和操作，因此我们需要在实现中动态地处理属性的获取、设置和操作的调用。

在 getMBeanInfo() 方法中，我们定义了 MBean 的元数据信息，包括属性、操作和描述信息。在 main() 方法中，我们创建了 DynamicHello 的实例，并将其注册到 MBeanServer 中。然后通过 Thread.sleep(Long.MAX_VALUE) 使程序保持运行，以便通过 JConsole 或其他 JMX 客户端来操作该动态 MBean。

2.3.Model Bean

Model MBean 的核心是实现 ModelMBean 接口，该接口继承自 DynamicMBean 接口，因此具有动态 MBean 的所有特性，同时还添加了一些额外的方法用于管理描述符。以下是 ModelMBean 接口的一些重要方法：

代码示例：

import javax.management.*;
import javax.management.modelmbean.*;
import java.lang.management.ManagementFactory;
​
public class SimpleModelMBeanExample {
    public static void main(String[] args) throws Exception {
        // 创建 ModelMBeanInfo 对象
        ModelMBeanInfo modelMBeanInfo = createModelMBeanInfo();
​
        // 创建 ModelMBean 实例
        ModelMBean modelMBean = createModelMBean(modelMBeanInfo);
​
        // 创建 MBeanServer
        MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
​
        // 创建 ObjectName，用于标识 MBean
        ObjectName name = new ObjectName("com.example:type=SimpleModelMBean");
​
        // 注册 ModelMBean 到 MBeanServer
        mbs.registerMBean(modelMBean, name);
​
        // 等待一段时间，使得可以通过 JConsole 或者其他 JMX 客户端来操作 MBean
        Thread.sleep(Long.MAX_VALUE);
    }
​
    private static ModelMBeanInfo createModelMBeanInfo() throws Exception {
        // 创建属性描述符
        Descriptor nameDesc = new DescriptorSupport();
        nameDesc.setField("name", "Name");
        nameDesc.setField("descriptorType", "attribute");
​
        // 创建操作描述符
        Descriptor sayHelloDesc = new DescriptorSupport();
        sayHelloDesc.setField("name", "sayHello");
        sayHelloDesc.setField("descriptorType", "operation");
​
        // 创建属性列表
        MBeanAttributeInfo[] attributes = new MBeanAttributeInfo[]{
                new MBeanAttributeInfo("Name", "java.lang.String", "Name of the person", true, true, false, nameDesc)
        };
​
        // 创建操作列表
        MBeanOperationInfo[] operations = new MBeanOperationInfo[]{
                new MBeanOperationInfo("sayHello", "Say hello to the person", null, "java.lang.String", MBeanOperationInfo.ACTION, sayHelloDesc)
        };
​
        // 创建 ModelMBeanInfo
        ModelMBeanInfo modelMBeanInfo = new ModelMBeanInfoSupport(
                SimpleModelMBeanExample.class.getName(),
                "Simple Model MBean Example",
                attributes,
                null,
                operations,
                null
        );
​
        return modelMBeanInfo;
    }
​
    private static ModelMBean createModelMBean(ModelMBeanInfo modelMBeanInfo) throws Exception {
        // 创建 ModelMBean 实例
        RequiredModelMBean modelMBean = new RequiredModelMBean();
        modelMBean.setModelMBeanInfo(modelMBeanInfo);
​
        // 创建 MBean 实例
        ObjectName name = new ObjectName("com.example:type=SimpleModelMBean");
        SimpleModelMBean example = new SimpleModelMBean();
​
        // 设置 MBean 实例
        modelMBean.setManagedResource(example, "ObjectReference");
​
        return modelMBean;
    }
}

在这个示例中，我们首先创建了一个 ModelMBeanInfo 对象，该对象描述了 Model MBean 的元数据信息，包括属性和操作。然后，我们创建了一个 ModelMBean 实例，并将 ModelMBeanInfo 设置到该实例中。接着，我们创建了一个 ObjectName 对象，用于标识 MBean，然后将 ModelMBean 实例注册到了 MBeanServer 中。

同时，我们还定义了一个 SimpleModelMBean 类，该类实现了 Model MBean 管理的资源对象。在这个类中，我们可以定义属性和操作的具体实现逻辑。

2.4.Dynamic MBean和Model Bean的区别

其实Model Bean本来就是继承自Dynamic MBean的，所以后者有的特点，前者也有，其二者本质的区别在于使用场景上：

2.5.MXBean

在 Java 中，一切都被视为对象，而 JMX 则提供了一种标准化的方式来监控和管理 Java 程序的运行时状态、性能指标以及运行环境。而MXBean其实就是专门用于管理和监控这其中一些标准化类型的对象的。什么叫标准化的类型对象？其实就是一些定量的指标，例如内存使用情况、线程信息、操作系统属性等。这些MBean是拿来即用的。

Java 平台中有一些预定义的 MXBean，例如 MemoryMXBean、ThreadMXBean、OperatingSystemMXBean 等，用于管理和监控 JVM 的内存、线程、操作系统属性等。

代码示例：

import java.lang.management.ManagementFactory;
import java.lang.management.MemoryMXBean;
import java.lang.management.MemoryUsage;
​
public class MXBeanExample {
    public static void main(String[] args) {
        // 获取 MemoryMXBean 实例
        MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
​
        // 获取堆内存使用情况
        MemoryUsage heapMemoryUsage = memoryMXBean.getHeapMemoryUsage();
        System.out.println("Heap Memory Usage:");
        System.out.println("    Init: " + heapMemoryUsage.getInit() / (1024 * 1024) + " MB");
        System.out.println("    Used: " + heapMemoryUsage.getUsed() / (1024 * 1024) + " MB");
        System.out.println("    Committed: " + heapMemoryUsage.getCommitted() / (1024 * 1024) + " MB");
        System.out.println("    Max: " + heapMemoryUsage.getMax() / (1024 * 1024) + " MB");
​
        // 获取非堆内存使用情况
        MemoryUsage nonHeapMemoryUsage = memoryMXBean.getNonHeapMemoryUsage();
        System.out.println("Non-Heap Memory Usage:");
        System.out.println("    Init: " + nonHeapMemoryUsage.getInit() / (1024 * 1024) + " MB");
        System.out.println("    Used: " + nonHeapMemoryUsage.getUsed() / (1024 * 1024) + " MB");
        System.out.println("    Committed: " + nonHeapMemoryUsage.getCommitted() / (1024 * 1024) + " MB");
        System.out.println("    Max: " + nonHeapMemoryUsage.getMax() / (1024 * 1024) + " MB");
    }
}

可以自定义MXBean吗？当然可以。

自定义 MXBean 主要包括两个步骤：

代码示例：

// 定义 MXBean 接口
public interface MyMXBean {
    // 属性：名称
    String getName();
    void setName(String name);
    
    // 操作：打印消息
    void printMessage(String message);
}
​
// 实现类
public class MyMXBeanImpl implements MyMXBean {
    private String name;
    
    // 实现属性的 getter 和 setter 方法
    @Override
    public String getName() {
        return name;
    }
    
    @Override
    public void setName(String name) {
        this.name = name;
    }
    
    // 实现操作的方法
    @Override
    public void printMessage(String message) {
        System.out.println(message);
    }
}
​
// 在管理应用程序中注册和使用自定义的 MXBean
public class MyMXBeanRegistration {
    public static void main(String[] args) throws Exception {
        // 创建 MXBean 实例
        MyMXBean mxBean = new MyMXBeanImpl();
        
        // 注册 MXBean 到 MBeanServer
        MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
        ObjectName name = new ObjectName("com.example:type=MyMXBean");
        mbs.registerMBean(mxBean, name);
        
        // 等待一段时间，使得可以通过 JConsole 或者其他 JMX 客户端来操作 MXBean
        Thread.sleep(Long.MAX_VALUE);
    }
}

在这个示例中，我们定义了一个名为 MyMXBean 的接口，包含了一个属性 name 和一个操作 printMessage。然后，我们编写了一个实现类 MyMXBeanImpl，实现了这个接口，并提供了属性和操作的具体实现逻辑。最后，我们在管理应用程序中注册和使用了这个自定义的 MXBean。

2.6.Open Bean

与传统的 Standard MBean 和 Dynamic MBean 不同，Open MBean 不需要预先定义接口，而是使用开放式的数据类型和操作来描述 MBean 的管理接口，使得可以更灵活地适应各种场景和需求。

代码示例：

import javax.management.*;
import javax.management.openmbean.*;
​
public class OpenMBeanExample {
    public static void main(String[] args) throws Exception {
        // 创建 OpenType
        OpenType<String> stringType = SimpleType.STRING;
        OpenType<Integer> integerType = SimpleType.INTEGER;
​
        // 创建 OpenMBeanAttributeInfo
        OpenMBeanAttributeInfoSupport nameAttrInfo = new OpenMBeanAttributeInfoSupport(
                "Name",
                "Name of the person",
                stringType,
                true,
                false,
                false
        );
        OpenMBeanAttributeInfoSupport ageAttrInfo = new OpenMBeanAttributeInfoSupport(
                "Age",
                "Age of the person",
                integerType,
                true,
                false,
                false
        );
​
        // 创建 OpenMBeanOperationInfo
        OpenMBeanParameterInfo[] params = new OpenMBeanParameterInfo[]{};
        OpenMBeanOperationInfoSupport sayHelloOpInfo = new OpenMBeanOperationInfoSupport(
                "sayHello",
                "Say hello to the person",
                params,
                stringType,
                OpenMBeanOperationInfo.ACTION
        );
​
        // 创建 OpenMBeanInfo
        OpenMBeanInfoSupport mbeanInfo = new OpenMBeanInfoSupport(
                SimpleOpenMBean.class.getName(),
                "Simple Open MBean Example",
                new OpenMBeanAttributeInfo[]{nameAttrInfo, ageAttrInfo},
                null,
                new OpenMBeanOperationInfo[]{sayHelloOpInfo},
                null
        );
​
        // 创建 OpenMBean 实例
        SimpleOpenMBean mbean = new SimpleOpenMBean("John", 30);
​
        // 创建 MBeanServer
        MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
​
        // 创建 ObjectName，用于标识 MBean
        ObjectName name = new ObjectName("com.example:type=SimpleOpenMBean");
​
        // 注册 OpenMBean 到 MBeanServer
        mbs.registerMBean(mbean, name);
​
        // 等待一段时间，使得可以通过 JConsole 或者其他 JMX 客户端来操作 MBean
        Thread.sleep(Long.MAX_VALUE);
    }
}
​
// 实现 OpenMBean
public class SimpleOpenMBean implements OpenMBean {
    private String name;
    private int age;
​
    public SimpleOpenMBean(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    @Override
    public Object getAttribute(String attribute) throws AttributeNotFoundException, MBeanException, ReflectionException {
        if (attribute.equals("Name")) {
            return name;
        } else if (attribute.equals("Age")) {
            return age;
        } else {
            throw new AttributeNotFoundException("Attribute " + attribute + " not found");
        }
    }
​
    @Override
    public void setAttribute(Attribute attribute) throws AttributeNotFoundException, InvalidAttributeValueException, MBeanException, ReflectionException {
        throw new UnsupportedOperationException("setAttribute not supported");
    }
​
    @Override
    public Object invoke(String actionName, Object[] params, String[] signature) throws MBeanException, ReflectionException {
        if (actionName.equals("sayHello")) {
            return "Hello, " + name + "!";
        } else {
            throw new UnsupportedOperationException("Operation " + actionName + " not supported");
        }
    }
​
    @Override
    public MBeanInfo getMBeanInfo() {
        // 实现 OpenMBean 接口的 getMBeanInfo 方法，返回 MBean 的元数据信息
        return null;
    }
}

3.控制台

JDK自带了一个JMX的控制台JConsole，启动后选择进程，就能看到相应程序中的MBean。

到此这篇关于JAVA监控JMX的使用的文章就介绍到这了,更多相关JAVA监控JMX内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！ 

您可能感兴趣的文章:
阅读全文