JMX操作实例--做一回技术控
我来做一回技术控，这部分内容也是简单的API调用例子而已，做一回技术控，发点小骚文，不过你看了，也许知道JConsole是怎么做出来的了，呵呵！
先不用管他干什么，代码运行后，自己改改自然知道做什么的。
例子全部应该都可以运行，使用者，拷贝回去就基本可以用了，无需其他内容的支持，有部分代码对JDK的版本有要求，例如在使用：ThreadMXBean.getThreadAllocatedBytes(id)，这个是在JDK 6 update 25中开始支持的，而且在JDK 1.6中获取出来还有问题不少。
我先写了个简单的工具类：
import java.io.IOException;
import java.lang.management.ManagementFactory;
import java.util.Set;
import javax.management.AttributeNotFoundException;
import javax.management.BadAttributeValueExpException;
import javax.management.BadBinaryOpValueExpException;
import javax.management.BadStringOperationException;
import javax.management.InstanceNotFoundException;
import javax.management.IntrospectionException;
import javax.management.InvalidApplicationException;
import javax.management.MBeanAttributeInfo;
import javax.management.MBeanException;
import javax.management.MBeanInfo;
import javax.management.MBeanServer;
import javax.management.MBeanServerConnection;
import javax.management.MalformedObjectNameException;
import javax.management.ObjectInstance;
import javax.management.ObjectName;
import javax.management.QueryExp;
import javax.management.ReflectionException;
import javax.management.RuntimeMBeanException;
public class JMXUtils {
private final static MBeanServer DEFAULT_MBEAN_SERVER = ManagementFactory
.getPlatformMBeanServer();
public static long getYongGC() {
return getYoungGC(DEFAULT_MBEAN_SERVER);
}
public static long getFullGC() {
return getFullGC(DEFAULT_MBEAN_SERVER);
}
public static long findLoadedClass() {
return findLoadedClass(DEFAULT_MBEAN_SERVER);
}
public static long getYoungGC(MBeanServerConnection mbeanServer) {
try {
ObjectName objectName;
if (mbeanServer.isRegistered(new ObjectName("java.lang:type=GarbageCollector,name=ParNew"))) {
objectName = new ObjectName("java.lang:type=GarbageCollector,name=ParNew");
} else if (mbeanServer.isRegistered(new ObjectName("java.lang:type=GarbageCollector,name=Copy"))) {
objectName = new ObjectName("java.lang:type=GarbageCollector,name=Copy");
} else {
objectName = new ObjectName("java.lang:type=GarbageCollector,name=PS Scavenge");
}
return (Long) mbeanServer.getAttribute(objectName , "CollectionCount");
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static long getFullGC(MBeanServerConnection mbeanServer) {
try {
ObjectName objectName;
if (mbeanServer.isRegistered(new ObjectName("java.lang:type=GarbageCollector,name=ConcurrentMarkSweep"))) {
objectName = new ObjectName("java.lang:type=GarbageCollector,name=ConcurrentMarkSweep");
} else if (mbeanServer.isRegistered(new ObjectName("java.lang:type=GarbageCollector,name=MarkSweepCompact"))) {
objectName = new ObjectName("java.lang:type=GarbageCollector,name=MarkSweepCompact");
} else {
objectName = new ObjectName("java.lang:type=GarbageCollector,name=PS MarkSweep");
}
return (Long) mbeanServer.getAttribute(objectName , "CollectionCount");
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static long findLoadedClass(MBeanServerConnection mBeanServer) {
try {
return (Long) (mBeanServer.getAttribute(new ObjectName(
"java.lang:type=ClassLoading"), "TotalLoadedClassCount"));
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static void traceOneDomain(String doMain,
MBeanServerConnection mBeanServer)
throws MalformedObjectNameException, IntrospectionException,
InstanceNotFoundException, AttributeNotFoundException,
ReflectionException, MBeanException, IOException {
Set<ObjectInstance> set = mBeanServer.queryMBeans(new ObjectName(doMain + ":*"), new QueryExp() {
private static final long serialVersionUID = 1L;
@Override
public boolean apply(ObjectName name)
throws BadStringOperationException,
BadBinaryOpValueExpException,
BadAttributeValueExpException, InvalidApplicationException {
return true;
}
@Override
public void setMBeanServer(MBeanServer s) {}
});
for (ObjectInstance objectInstance : set) {
System.out.println("\t\t\t" + objectInstance.getObjectName() + "\t"
+ objectInstance.getClassName());
traceMebeanInfo(mBeanServer, objectInstance.getObjectName());
}
}
public static void traceMebeanInfo(MBeanServerConnection mBeanServer,
ObjectName objectName) throws IntrospectionException,
InstanceNotFoundException, MalformedObjectNameException,
ReflectionException, AttributeNotFoundException, MBeanException,
IOException {
MBeanInfo mBeanInfo = mBeanServer.getMBeanInfo(objectName);
MBeanAttributeInfo[] mBeanAttributes = mBeanInfo.getAttributes();
System.out.println("\t\t\tMBeanInfos : ");
for (MBeanAttributeInfo mBeanAttribute : mBeanAttributes) {
try {
System.out.println("\t\t\t\t\t"
+ mBeanAttribute.getName()
+ "\t"
+ mBeanAttribute.getType()
+ "\tvalue = >"
+ mBeanServer.getAttribute(objectName,
mBeanAttribute.getName()));
} catch (RuntimeMBeanException e) {
if (e.getCause() instanceof UnsupportedOperationException) {
System.out.println("\t\t\t\t\t" + mBeanAttribute.getName()
+ "\t" + mBeanAttribute.getType()
+ "\tvalue = > value not supported");
}
}
}
}
public static void traceAll(MBeanServerConnection mBeanServer)
throws MalformedObjectNameException, IntrospectionException,
InstanceNotFoundException, AttributeNotFoundException,
ReflectionException, MBeanException, IOException {
System.out.println("MBean count = " + mBeanServer.getMBeanCount());
String[] domains = mBeanServer.getDomains();
for (String domain : domains) {
System.out.println("\tbegin trace domain -> " + domain);
traceOneDomain(domain, mBeanServer);
}
}
}
这个类写好后，我们就可以写点小测试代码了，呵呵！
那么首先来写个遍历所有的参数列表，层次结构为3层：
MBeanServer -> DoMain -> MBean -> MBeanAttributeInfo 但是写好那个Util后调用就简单了：
import java.io.IOException;
import java.lang.management.ManagementFactory;
import javax.management.AttributeNotFoundException;
import javax.management.InstanceNotFoundException;
import javax.management.IntrospectionException;
import javax.management.MBeanException;
import javax.management.MalformedObjectNameException;
import javax.management.ReflectionException;
public class MBeanServerTest {
public static void main(String[] args) throws MalformedObjectNameException,
IntrospectionException, InstanceNotFoundException,
AttributeNotFoundException, ReflectionException, MBeanException,
IOException {
// System.gc();
// System.out.println(JMXUtils.getYongGC());
// System.out.println(JMXUtils.getFullGC());
JMXUtils.traceAll(ManagementFactory.getPlatformMBeanServer());
}
}
结果很多，不同的OS，不同的JVM配置，结果也会有所区别，大家可以自己书出来看看，这里注意里面的ObjectName，通过MBeanServer直接获取里面的参数值，比较好用，尤其是RMI的时候，这个trace不太好用，因为远程可能有些类，本地没有，但是参数值是可以获取到的，所以需要知道名称是比较好的。
远程的输出，我们简单来写一段代码：
import java.io.IOException;
import java.util.HashMap;
import javax.management.AttributeNotFoundException;
import javax.management.InstanceNotFoundException;
import javax.management.IntrospectionException;
import javax.management.MBeanException;
import javax.management.MBeanServerConnection;
import javax.management.MalformedObjectNameException;
import javax.management.ObjectName;
import javax.management.ReflectionException;
import javax.management.remote.JMXConnector;
import javax.management.remote.JMXConnectorFactory;
import javax.management.remote.JMXServiceURL;
public class MBeanServerRemoteTest {
/**
* 远程地址需要开启：
* -Dcom.sun.management.jmxremote
* -Dcom.sun.management.jmxremote.port=9000
* -Dcom.sun.management.jmxremote.authenticate=true
*/
final static String RMI_URL = "service:jmx:rmi:///jndi/rmi://xxx.xxx.xxx.xxx:9000/jmxrmi";
public static void main(String []args)
throws IOException, MalformedObjectNameException, IntrospectionException,
InstanceNotFoundException, AttributeNotFoundException, ReflectionException, MBeanException {
JMXServiceURL serviceURL = new JMXServiceURL(RMI_URL);
JMXConnector jmxc = JMXConnectorFactory.connect(serviceURL , new HashMap<String , Object>() {
private static final long serialVersionUID = 1L;
{
put(JMXConnector.CREDENTIALS , new String[] {"controlRole" , "FUCK"});
}
});
MBeanServerConnection mBeanServer = jmxc.getMBeanServerConnection();
System.out.println("MBean count = " + mBeanServer.getMBeanCount());
String[] domains = mBeanServer.getDomains();
for (String doMain : domains) {
System.out.println("============>" + doMain);
}
System.out.println(JMXUtils.getYoungGC(mBeanServer));
System.out.println(JMXUtils.getFullGC(mBeanServer));
System.out.println(mBeanServer.getAttribute(new ObjectName("JMImplementation:type=MBeanServerDelegate"), "ImplementationVersion"));
System.out.println(mBeanServer.getAttribute(new ObjectName("java.lang:type=Runtime"), "BootClassPath"));
//其余的可以自己遍历出来
}
}
这两个出来了，其实JMX还提供了些简单的，默认的MXBean，可以直接使用，我们简单也写下这些demo，可以拿去自己玩哈。
===》ClassLoadingMXBean：
import java.lang.management.ClassLoadingMXBean;
import java.lang.management.ManagementFactory;
public class ClassLoadingMXBeanTest {
public static void main(String []args) {
ClassLoadingMXBean classLoadingMXBean = ManagementFactory.getClassLoadingMXBean();
System.out.println(classLoadingMXBean.getLoadedClassCount());
System.out.println(classLoadingMXBean.getTotalLoadedClassCount());
System.out.println(classLoadingMXBean.getUnloadedClassCount());
System.out.println(classLoadingMXBean.isVerbose());
}
}
===》CompilationMXBean
import java.lang.management.CompilationMXBean;
import java.lang.management.ManagementFactory;
public class CompilationMXBeanTest {
public static void main(String []args) {
CompilationMXBean mxBean = ManagementFactory.getCompilationMXBean();
System.out.println(mxBean.getTotalCompilationTime());
System.out.println(mxBean.getName());
System.out.println(mxBean.isCompilationTimeMonitoringSupported());
}
}
===》MemoryManagerMXBean
import java.lang.management.ManagementFactory;
import java.lang.management.MemoryManagerMXBean;
import java.util.List;
import javax.management.AttributeNotFoundException;
import javax.management.InstanceNotFoundException;
import javax.management.IntrospectionException;
import javax.management.MBeanAttributeInfo;
import javax.management.MBeanException;
import javax.management.MBeanInfo;
import javax.management.MBeanServer;
import javax.management.ReflectionException;
public class MemoryManagerMXBeanTest {
public static void main(String []args) throws IntrospectionException, InstanceNotFoundException, ReflectionException, AttributeNotFoundException, MBeanException {
MBeanServer mBeanServer = ManagementFactory.getPlatformMBeanServer();
System.gc();
List<MemoryManagerMXBean> list = ManagementFactory.getMemoryManagerMXBeans();
for(MemoryManagerMXBean memoryManagerMXBean : list) {
System.out.println(memoryManagerMXBean.getName());
System.out.println(memoryManagerMXBean.getObjectName());
MBeanInfo mBeanInfo = mBeanServer.getMBeanInfo(memoryManagerMXBean.getObjectName());
MBeanAttributeInfo[] mBeanAttributes = mBeanInfo.getAttributes();
for(MBeanAttributeInfo mBeanAttribute : mBeanAttributes) {
System.out.println("=============>" + mBeanAttribute.getName() + "\t" + mBeanAttribute.getType());
System.out.println("=============value = >" + mBeanServer.getAttribute(memoryManagerMXBean.getObjectName(), mBeanAttribute.getName()));
}
/*String []poolNames = memoryManagerMXBean.getMemoryPoolNames();
for(String poolName : poolNames) {
System.out.println("\t" + poolName);
}*/
}
}
}
===》MemoryMXBean
import java.lang.management.ManagementFactory;
import java.lang.management.MemoryMXBean;
public class MemoryMXBeanTest {
public static void main(String []args) {
MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
//memoryMXBean.gc();
System.out.println(memoryMXBean.getHeapMemoryUsage());
System.out.println(memoryMXBean.getObjectPendingFinalizationCount());
System.out.println(memoryMXBean.getNonHeapMemoryUsage());
}
}
===》MemoryPoolMXBean
import java.lang.management.ManagementFactory;
import java.lang.management.MemoryPoolMXBean;
import java.util.List;
public class MemoryPoolMXBeanTest {
public static void main(String[] args) {
List<MemoryPoolMXBean> list = ManagementFactory.getMemoryPoolMXBeans();
for (MemoryPoolMXBean memoryPoolMXBean : list) {
System.out.println(memoryPoolMXBean.getName()
+ memoryPoolMXBean.getCollectionUsage()
+ "\n\nPeakUsage:\t\t" + memoryPoolMXBean.getPeakUsage()
+ "\n\nUsage:\t\t" + memoryPoolMXBean.getUsage());
/*
* + memoryPoolMXBean.getUsageThreshold() + "\t" +
* memoryPoolMXBean.getUsageThresholdCount() +
* "\t\n\nCollectionUsage:\t\t"
*
* + memoryPoolMXBean.getType() + "\t"
*/
// memoryPoolMXBean.getCollectionUsageThreshold() + "\t"
// memoryPoolMXBean.getCollectionUsageThresholdCount() + "\t" );
// String []memoryManagerNames =
// memoryPoolMXBean.getMemoryManagerNames();
/*
* for(String memoryManagerName : memoryManagerNames) {
* System.out.println("\t\t\t\t" + memoryManagerName); }
*/
}
}
}
===》OperatingSystemMXBean
import java.lang.management.ManagementFactory;
import java.lang.management.OperatingSystemMXBean;
public class OperatingSystemMXBeanTest {
public static void main(String []args) {
OperatingSystemMXBean mxBean = ManagementFactory.getOperatingSystemMXBean();
System.out.println(mxBean.getArch());
System.out.println(mxBean.getAvailableProcessors());
System.out.println(mxBean.getName());
System.out.println(mxBean.getSystemLoadAverage());
System.out.println(mxBean.getVersion());
}
}
===》RuntimeMXBean
import java.lang.management.ManagementFactory;
import java.lang.management.RuntimeMXBean;
public class RuntimeMXBeanTest {
public static void main(String []args) {
RuntimeMXBean runTimeMXBean = ManagementFactory.getRuntimeMXBean();
System.out.println(runTimeMXBean.getBootClassPath());
System.out.println(runTimeMXBean.getClassPath());
System.out.println(runTimeMXBean.getLibraryPath());
System.out.println(runTimeMXBean.getManagementSpecVersion());
System.out.println(runTimeMXBean.getName());
System.out.println(runTimeMXBean.getSpecName());
System.out.println(runTimeMXBean.getSpecVendor());
System.out.println(runTimeMXBean.getStartTime());
System.out.println(runTimeMXBean.getUptime());
System.out.println(runTimeMXBean.getVmName());
System.out.println(runTimeMXBean.getVmVendor());
System.out.println(runTimeMXBean.getVmVersion());
System.out.println(runTimeMXBean.getInputArguments());
System.out.println(runTimeMXBean.getSystemProperties());
}
}
===》ThreadMXBean
import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import com.sun.management.ThreadMXBean;
//import sun.management.VMOptionCompositeData;
//import com.sun.management.VMOption;
//import java.lang.management.ManagementFactory;
public class ThreadMXBeanTest {
public static void main(String []args) {
ThreadMXBean thredMXBean = (ThreadMXBean) ManagementFactory.getThreadMXBean();
long []ids = thredMXBean.getAllThreadIds();
for(long id : ids) {
System.out.println(id + "\t" + thredMXBean.getThreadAllocatedBytes(id) + "\t" + thredMXBean.getThreadInfo(id));
}
System.out.println(thredMXBean.getCurrentThreadCpuTime());
System.out.println(thredMXBean.getCurrentThreadUserTime());
System.out.println(thredMXBean.getDaemonThreadCount());
System.out.println(thredMXBean.getPeakThreadCount());
System.out.println(thredMXBean.getThreadCount());
System.out.println(thredMXBean.getTotalStartedThreadCount());
System.out.println("==========================>");
displayThreadInfos(thredMXBean , ids);
}
private static void displayThreadInfos(ThreadMXBean thredMXBean , long []ids) {
ThreadInfo []threadInfos = thredMXBean.getThreadInfo(ids);
for(ThreadInfo thread : threadInfos) {
System.out.println(thread.getThreadName() + "\t"
+ thread.getLockOwnerId() + "\t" + thread.getThreadState()
+ "\t" + thread.getBlockedCount() + "\t" + thread.getBlockedTime() );
}
}
}
