Jconsole 监控tomcat

通过jconsole监控可以获取监控tomcat的相关的数据信息

如何通过代码来获取其中的线程和内存状况呢？

首先要配置好jconsole监控的相关配置，一搜基本就是那一个，

配置配不好的话接下来的工作就做不好了，所有要先配置好，然后可以上代码了：

package one;

import java.io.IOException;
import java.lang.management.MemoryMXBean;
import java.lang.management.MemoryUsage;
import java.lang.management.ThreadMXBean;

import java.lang.reflect.*;
import java.util.*;

import javax.management.*;
import javax.management.remote.*;

//mxbean_name constant
import static java.lang.management.ManagementFactory.*;

public class MyJconsole {
    
    private SnapshotMBeanServerConnection server = null;
    private String jmxURL = null;
    private MBeanServerConnection mbsc = null;
    private JMXConnector connector = null;
    
    private JMXServiceURL serviceURL;
    private Map<String, String[]> map;
    private boolean hasPlatformMXBeans = false;
    
    private ThreadMXBean     threadMBean = null;
    private MemoryMXBean    memoryMBean = null;
    
    public interface SnapshotMBeanServerConnection
    extends MBeanServerConnection {
    /**
     * Flush all cached values of attributes.
     */
    public void flush();
    }

    public static class Snapshot {
        private Snapshot() {
        }
        public static SnapshotMBeanServerConnection
            newSnapshot(MBeanServerConnection mbsc) {
            final InvocationHandler ih = new SnapshotInvocationHandler(mbsc);
            return (SnapshotMBeanServerConnection) Proxy.newProxyInstance(
                    Snapshot.class.getClassLoader(),
                    new Class[] {SnapshotMBeanServerConnection.class},
                    ih);
        }
    }
    
    public synchronized ThreadMXBean getThreadMXBean() throws IOException {
        if (hasPlatformMXBeans && threadMBean == null) {
            threadMBean =
                newPlatformMXBeanProxy(server, THREAD_MXBEAN_NAME,
                                       ThreadMXBean.class);
        }
        return threadMBean;
    }
    
    public synchronized MemoryMXBean getMemoryMXBean() throws IOException {
        if (hasPlatformMXBeans && memoryMBean == null) {
            memoryMBean =
                newPlatformMXBeanProxy(server, MEMORY_MXBEAN_NAME,
                                       MemoryMXBean.class);
        }
        return memoryMBean;
    }
    
    public MyJconsole(){
        jmxURL = "service:jmx:rmi:///jndi/rmi://127.0.0.1:8999/jmxrmi";
        map = new HashMap<String, String[]>();
        String[] credentials = new String[] { "monitorRole", "tomcat" };
        map.put("jmx.remote.credentials", credentials);
    }
    
    public void tryConnect() throws IOException {
        try {
            serviceURL = new JMXServiceURL(jmxURL);
            connector = JMXConnectorFactory.connect(serviceURL,map);
            mbsc = connector.getMBeanServerConnection();
            server = Snapshot.newSnapshot(mbsc);
            ObjectName on = new ObjectName(THREAD_MXBEAN_NAME);
            hasPlatformMXBeans = server.isRegistered(on);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args){
        try {
            MyJconsole mjc = new MyJconsole();
            mjc.tryConnect();
            ThreadMXBean tmBean = mjc.getThreadMXBean();
            MemoryMXBean memoryBean  = mjc.getMemoryMXBean();
            int tlCount = tmBean.getThreadCount();
            int tdCount = tmBean.getDaemonThreadCount();
            int tpCount = tmBean.getPeakThreadCount();
            long ttCount = tmBean.getTotalStartedThreadCount();
            System.out.println("活动线程个数： "+tlCount);                //当前线程数
            System.out.println("峰值: " + tpCount);
            System.out.println("守护线程数: " + tdCount);
            System.out.println("启动线程数总数：" + ttCount);
            MemoryUsage u = memoryBean.getHeapMemoryUsage();
            long memUsed = u.getUsed();
            long memMax = u.getMax();
            long memCommited = u.getCommitted();
            System.out.println("堆内存使用大小："+ memUsed/1024+"Kb"); //堆内存；
            System.out.println("当前堆大小： " + memUsed + "Kb");
            System.out.println("最大堆大小：" + memMax + "Kb");
            
        } catch (IOException e) {
            e.printStackTrace();
        }
        
    }
    
    static class SnapshotInvocationHandler implements InvocationHandler {

        private final MBeanServerConnection conn;
        private Map<ObjectName, NameValueMap> cachedValues = newMap();
        private Map<ObjectName, Set<String>> cachedNames = newMap();

        @SuppressWarnings("serial")
        private static final class NameValueMap
                extends HashMap<String, Object> {}

        SnapshotInvocationHandler(MBeanServerConnection conn) {
            this.conn = conn;
        }

        synchronized void flush() {
            cachedValues = newMap();
        }

        public Object invoke(Object proxy, Method method, Object[] args)
                throws Throwable {
            final String methodName = method.getName();
            if (methodName.equals("getAttribute")) {
                return getAttribute((ObjectName) args[0], (String) args[1]);
            } else if (methodName.equals("getAttributes")) {
                return getAttributes((ObjectName) args[0], (String[]) args[1]);
            } else if (methodName.equals("flush")) {
                flush();
                return null;
            } else {
                try {
                    return method.invoke(conn, args);
                } catch (InvocationTargetException e) {
                    throw e.getCause();
                }
            }
        }

        private Object getAttribute(ObjectName objName, String attrName)
                throws MBeanException, InstanceNotFoundException,
                AttributeNotFoundException, ReflectionException, IOException {
            final NameValueMap values = getCachedAttributes(
                    objName, Collections.singleton(attrName));
            Object value = values.get(attrName);
            if (value != null || values.containsKey(attrName)) {
                return value;
            }
            // Not in cache, presumably because it was omitted from the
            // getAttributes result because of an exception.  Following
            // call will probably provoke the same exception.
            return conn.getAttribute(objName, attrName);
        }

        private AttributeList getAttributes(
                ObjectName objName, String[] attrNames) throws
                InstanceNotFoundException, ReflectionException, IOException {
            final NameValueMap values = getCachedAttributes(
                    objName,
                    new TreeSet<String>(Arrays.asList(attrNames)));
            final AttributeList list = new AttributeList();
            for (String attrName : attrNames) {
                final Object value = values.get(attrName);
                if (value != null || values.containsKey(attrName)) {
                    list.add(new Attribute(attrName, value));
                }
            }
            return list;
        }

        private synchronized NameValueMap getCachedAttributes(
                ObjectName objName, Set<String> attrNames) throws
                InstanceNotFoundException, ReflectionException, IOException {
            NameValueMap values = cachedValues.get(objName);
            if (values != null && values.keySet().containsAll(attrNames)) {
                return values;
            }
            attrNames = new TreeSet<String>(attrNames);
            Set<String> oldNames = cachedNames.get(objName);
            if (oldNames != null) {
                attrNames.addAll(oldNames);
            }
            values = new NameValueMap();
            final AttributeList attrs = conn.getAttributes(
                    objName,
                    attrNames.toArray(new String[attrNames.size()]));
            for (Attribute attr : attrs.asList()) {
                values.put(attr.getName(), attr.getValue());
            }
            cachedValues.put(objName, values);
            cachedNames.put(objName, attrNames);
            return values;
        }

        // See http://www.artima.com/weblogs/viewpost.jsp?thread=79394
        private static <K, V> Map<K, V> newMap() {
            return new HashMap<K, V>();
        }
    }

}