devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

java利用ManagementFactory获取tomcat的一些信息_如果通过java代码获取tomcat的连接使用情况

作者：羊村懒王 | 2024-03-26 21:19:38

赞

踩

如果通过java代码获取tomcat的连接使用情况

         在上一篇中已经得到了jvm,os的一些信息，那如果是web项目，它在web容器中运行，那是否可以也得到一些信息进行监控呢？本篇写了个小例子，在tomcat6，jdk6下跑，利用ManagementFactory来获取tomcat的一些信息，至于其他web容器的获取请求，暂没做实验。。。


用jconsole监控，看看


      在catalina下，发现有很多信息。。。比如上图右侧圈出的，我们可以得到http-80这端口，也就是浏览器访问，可以得到总共有多少个请求访问过，接收了多少字节，发送了多少字节等信息。。。

下面贴个小例子源码

TestMonitorServlet.java

  1. package com.fei.monitor;
  2.  
  3. import java.io.IOException;
  4. import java.io.PrintWriter;
  5.  
  6. import javax.servlet.ServletException;
  7. import javax.servlet.http.HttpServlet;
  8. import javax.servlet.http.HttpServletRequest;
  9. import javax.servlet.http.HttpServletResponse;
  10.  
  11. /**
  12.  * 测试监控
  13.  * @author weijianfei
  14.  *
  15.  */
  16. public class TestMonitorServlet extends HttpServlet {
  17. 	private static final long serialVersionUID = 1L;
  18.        
  19. 	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  20. 		this.doPost(request, response);
  21. 	}
  22.  
  23. 	
  24. 	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  25. 		StringBuffer sb = new StringBuffer();
  26. 		sb.append("<h3>========tomcatInfo========</h3><br/>");
  27. 		for(TomcatInformations info : TomcatInformations.buildTomcatInformationsList()){
  28. 			sb.append(info).append("<br/><br/>");
  29. 		}
  30. 		sb.append("<br/><br/>");
  31. 		sb.append("<h3>========threadInfo====</h3><br/>");
  32. 		for(ThreadInformations t : ThreadInformations.buildThreadInformationsList()){
  33. 			sb.append(t).append("<br/><br/>");
  34. 		}
  35. 		//输出
  36. 		outToClient(response, sb.toString());
  37. 	}
  38.  
  39. 	private void outToClient(HttpServletResponse response,String content){
  40. 		response.setContentType("text/html");
  41. 		response.setCharacterEncoding("utf-8");
  42. 		PrintWriter writer;
  43. 		try {
  44. 			writer = response.getWriter();
  45. 			writer.write(content);
  46. 			writer.flush();
  47. 			writer.close();
  48. 		} catch (IOException e) {
  49. 			e.printStackTrace();
  50. 		}
  51. 		
  52. 	}
  53. }

MBeans.java 

  1. package com.fei.monitor;
  2.  
  3. import java.lang.management.ManagementFactory;
  4. import java.util.Set;
  5.  
  6. import javax.management.JMException;
  7. import javax.management.MBeanServer;
  8. import javax.management.MalformedObjectNameException;
  9. import javax.management.ObjectName;
  10.  
  11. public class MBeans {
  12.  
  13. 	private final MBeanServer mbeanServer;
  14.  
  15. 	MBeans() {
  16. 		this(getPlatformMBeanServer());
  17. 	}
  18.  
  19. 	private MBeans(MBeanServer mbeanServer) {
  20. 		super();
  21. 		this.mbeanServer = mbeanServer;
  22. 	}
  23. 	/**
  24. 	 * 获取MBeanServer
  25. 	 * @return
  26. 	 */
  27. 	static MBeanServer getPlatformMBeanServer() {
  28. 		return ManagementFactory.getPlatformMBeanServer();
  29. 	}
  30. 	/**
  31. 	 * 获取tomcat的线程池
  32. 	 * @return
  33. 	 * @throws MalformedObjectNameException
  34. 	 */
  35. 	Set<ObjectName> getTomcatThreadPools() throws MalformedObjectNameException {
  36. 		return mbeanServer.queryNames(new ObjectName("*:type=ThreadPool,*"), null);
  37. 	}
  38.  
  39. 	Set<ObjectName> getTomcatGlobalRequestProcessors() throws MalformedObjectNameException {
  40. 		return mbeanServer.queryNames(new ObjectName("*:type=GlobalRequestProcessor,*"), null);
  41. 	}
  42.  
  43. 	Object getAttribute(ObjectName name, String attribute) throws JMException {
  44. 		return mbeanServer.getAttribute(name, attribute);
  45. 	}
  46. 	
  47. }
</pre><pre name="code" class="java">


  1. package com.fei.monitor;
  2.  
  3. import java.lang.management.ManagementFactory;
  4. import java.lang.management.RuntimeMXBean;
  5.  
  6. final public class PID {
  7.  
  8. 	/**
  9. 	 * 获取当前进程id
  10. 	 * @return
  11. 	 */
  12. 	public static String getPID(){
  13. 		final RuntimeMXBean rtb = ManagementFactory.getRuntimeMXBean();
  14. 		//pid@host
  15. 		return rtb.getName().split("@")[0];
  16. 	}
  17. }



TomcatInformations.java 

  1. package com.fei.monitor;
  2.  
  3. import java.io.Serializable;
  4. import java.util.ArrayList;
  5. import java.util.Collections;
  6. import java.util.List;
  7.  
  8. import javax.management.AttributeNotFoundException;
  9. import javax.management.InstanceNotFoundException;
  10. import javax.management.JMException;
  11. import javax.management.MalformedObjectNameException;
  12. import javax.management.ObjectName;
  13.  
  14. final class TomcatInformations implements Serializable {
  15.  
  16. 	private static final boolean TOMCAT_USED = System.getProperty("catalina.home") != null;
  17.  
  18. 	private static final long serialVersionUID = -6145865427461051370L;
  19.  
  20. 	@SuppressWarnings("all")
  21. 	private static final List<ObjectName> THREAD_POOLS = new ArrayList<ObjectName>();
  22. 	@SuppressWarnings("all")
  23. 	private static final List<ObjectName> GLOBAL_REQUEST_PROCESSORS = new ArrayList<ObjectName>();
  24.  
  25. 	private final String name;
  26. 	private final int maxThreads;
  27. 	private final int currentThreadCount;
  28. 	private final int currentThreadsBusy;
  29. 	private final long bytesReceived;
  30. 	private final long bytesSent;
  31. 	private final int requestCount;
  32. 	private final int errorCount;
  33. 	private final long processingTime;
  34. 	private final long maxTime;
  35.  
  36. 	private TomcatInformations(MBeans mBeans, ObjectName threadPool) throws JMException {
  37. 		super();
  38. 		name = threadPool.getKeyProperty("name");
  39. 		maxThreads = (Integer) mBeans.getAttribute(threadPool, "maxThreads");
  40. 		currentThreadCount = (Integer) mBeans.getAttribute(threadPool, "currentThreadCount");
  41. 		currentThreadsBusy = (Integer) mBeans.getAttribute(threadPool, "currentThreadsBusy");
  42. 		ObjectName grp = null;
  43. 		for (final ObjectName globalRequestProcessor : GLOBAL_REQUEST_PROCESSORS) {
  44. 			if (name.equals(globalRequestProcessor.getKeyProperty("name"))) {
  45. 				grp = globalRequestProcessor;
  46. 				break;
  47. 			}
  48. 		}
  49. 		if (grp != null) {
  50. 			bytesReceived = (Long) mBeans.getAttribute(grp, "bytesReceived");
  51. 			bytesSent = (Long) mBeans.getAttribute(grp, "bytesSent");
  52. 			requestCount = (Integer) mBeans.getAttribute(grp, "requestCount");
  53. 			errorCount = (Integer) mBeans.getAttribute(grp, "errorCount");
  54. 			processingTime = (Long) mBeans.getAttribute(grp, "processingTime");
  55. 			maxTime = (Long) mBeans.getAttribute(grp, "maxTime");
  56. 		} else {
  57. 			bytesReceived = 0;
  58. 			bytesSent = 0;
  59. 			requestCount = 0;
  60. 			errorCount = 0;
  61. 			processingTime = 0;
  62. 			maxTime = 0;
  63. 		}
  64. 	}
  65.  
  66. 	public static List<TomcatInformations> buildTomcatInformationsList() {
  67. 		if (!TOMCAT_USED) {
  68. 			return Collections.emptyList();
  69. 		}
  70. 		try {
  71. 			synchronized (THREAD_POOLS) {
  72. 				if (THREAD_POOLS.isEmpty() || GLOBAL_REQUEST_PROCESSORS.isEmpty()) {
  73. 					initMBeans();
  74. 				}
  75. 			}
  76. 			final MBeans mBeans = new MBeans();
  77. 			final List<TomcatInformations> tomcatInformationsList = new ArrayList<TomcatInformations>(
  78. 					THREAD_POOLS.size());
  79. 			for (final ObjectName threadPool : THREAD_POOLS) {
  80. 				tomcatInformationsList.add(new TomcatInformations(mBeans, threadPool));
  81. 			}
  82. 			return tomcatInformationsList;
  83. 		} catch (final InstanceNotFoundException e) {
  84. 			return Collections.emptyList();
  85. 		} catch (final AttributeNotFoundException e) {
  86. 			return Collections.emptyList();
  87. 		} catch (final JMException e) {
  88. 			throw new IllegalStateException(e);
  89. 		}
  90. 	}
  91.  
  92. 	private static void initMBeans() throws MalformedObjectNameException {
  93. 		final MBeans mBeans = new MBeans();
  94. 		THREAD_POOLS.clear();
  95. 		GLOBAL_REQUEST_PROCESSORS.clear();
  96. 		THREAD_POOLS.addAll(mBeans.getTomcatThreadPools());
  97. 		GLOBAL_REQUEST_PROCESSORS.addAll(mBeans.getTomcatGlobalRequestProcessors());
  98. 	}
  99.  
  100. 	String getName() {
  101. 		return name;
  102. 	}
  103.  
  104. 	int getMaxThreads() {
  105. 		return maxThreads;
  106. 	}
  107.  
  108. 	int getCurrentThreadCount() {
  109. 		return currentThreadCount;
  110. 	}
  111.  
  112. 	int getCurrentThreadsBusy() {
  113. 		return currentThreadsBusy;
  114. 	}
  115.  
  116. 	long getBytesReceived() {
  117. 		return bytesReceived;
  118. 	}
  119.  
  120. 	long getBytesSent() {
  121. 		return bytesSent;
  122. 	}
  123.  
  124. 	int getRequestCount() {
  125. 		return requestCount;
  126. 	}
  127.  
  128. 	int getErrorCount() {
  129. 		return errorCount;
  130. 	}
  131.  
  132. 	long getProcessingTime() {
  133. 		return processingTime;
  134. 	}
  135.  
  136. 	long getMaxTime() {
  137. 		return maxTime;
  138. 	}
  139.  
  140. 	/** {@inheritDoc} */
  141. 	@Override
  142. 	public String toString() {
  143. 		return getClass().getSimpleName() + "[端口名name=" + getName() + ", 最大线程数maxThreads="
  144. 				+ getMaxThreads() + ",当前线程数 currentThreadCount=" + getCurrentThreadCount()
  145. 				+ ", 当前活动线程数currentThreadsBusy=" + getCurrentThreadsBusy() + ",接收字节数 bytesReceived="
  146. 				+ getBytesReceived() + ",发送字节数 bytesSent=" + getBytesSent() + ",请求数 requestCount="
  147. 				+ getRequestCount() + ", 错误数errorCount=" + getErrorCount() + ", 处理时间processingTime="
  148. 				+ getProcessingTime() + ", 最大处理时间maxTime=" + getMaxTime() + ']';
  149. 	}
  150. }

ThreadInformations.java 

  1. package com.fei.monitor;
  2.  
  3. import java.io.Serializable;
  4. import java.lang.management.ManagementFactory;
  5. import java.lang.management.ThreadMXBean;
  6. import java.net.InetAddress;
  7. import java.net.UnknownHostException;
  8. import java.util.ArrayList;
  9. import java.util.Arrays;
  10. import java.util.Collections;
  11. import java.util.List;
  12. import java.util.Map;
  13.  
  14.  
  15.  
  16. class ThreadInformations implements Serializable {
  17. 	private static final long serialVersionUID = 3604281253550723654L;
  18. 	
  19. 	
  20. 	private final String name;//线程名称
  21. 	private final long id;//线程id
  22. 	private final int priority;//线程有限度
  23. 	private final boolean daemon;//是不是守护线程
  24. 	private final Thread.State state;//线程状态
  25. 	private final long cpuTimeMillis;//返回指定 ID 的线程的总 CPU 时间
  26. 	private final long userTimeMillis;//返回指定 ID 的线程在用户模式中执行的 CPU 时间
  27. 	private final boolean deadlocked;//是否死锁
  28. 	private final String globalThreadId;//全局线程id名称
  29. 	private final List<StackTraceElement> stackTrace;
  30.  
  31. 	private ThreadInformations(Thread thread, List<StackTraceElement> stackTrace, long cpuTimeMillis,
  32. 			long userTimeMillis, boolean deadlocked, String hostAddress) {
  33. 		super();
  34.  
  35. 		this.name = thread.getName();
  36. 		this.id = thread.getId();
  37. 		this.priority = thread.getPriority();
  38. 		this.daemon = thread.isDaemon();
  39. 		this.state = thread.getState();
  40. 		this.stackTrace = stackTrace;
  41. 		this.cpuTimeMillis = cpuTimeMillis;
  42. 		this.userTimeMillis = userTimeMillis;
  43. 		this.deadlocked = deadlocked;
  44. 		this.globalThreadId = buildGlobalThreadId(thread, hostAddress);
  45. 	}
  46.  
  47. 	public static List<ThreadInformations> buildThreadInformationsList() {
  48. 		final ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
  49. 		final Map<Thread, StackTraceElement[]> stackTraces = Thread.getAllStackTraces();
  50. 		final List<Thread>	threads = new ArrayList<Thread>(stackTraces.keySet());
  51.  
  52. 		//虚拟机是否允许测量所有线程的cup时间
  53. 		 //isThreadCpuTimeSupported() 方法可用于确定 Java 虚拟机是否支持测量任何线程的 CPU 时间。
  54. 		//isCurrentThreadCpuTimeSupported() 方法可用于确定 Java 虚拟机是否支持测量当前线程的 CPU 时间。
  55. 		//支持任何线程 CPU 时间测量的 Java 虚拟机实现也支持当前线程的 CPU 时间测量
  56. 		final boolean cpuTimeEnabled = threadBean.isThreadCpuTimeSupported() && threadBean.isThreadCpuTimeEnabled();
  57. 		//获取所有死锁线程的id
  58. 		final long[] deadlockedThreads = getDeadlockedThreads(threadBean);
  59. 		final List<ThreadInformations> threadInfosList = new ArrayList<ThreadInformations>(threads.size());
  60. 		
  61. 		String hostAddress;
  62. 		try {
  63. 			hostAddress = InetAddress.getLocalHost().getHostAddress();
  64. 		} catch (UnknownHostException e) {
  65. 			hostAddress = "unknown";
  66. 		}
  67. 		
  68. 		for (final Thread thread : threads) {
  69. 			final StackTraceElement[] stackTraceElements = stackTraces.get(thread);
  70. 			final List<StackTraceElement> stackTraceElementList = stackTraceElements == null ? null
  71. 					: new ArrayList<StackTraceElement>(Arrays.asList(stackTraceElements));
  72. 			final long cpuTimeMillis;//返回指定 ID 的线程的总 CPU 时间（以毫微秒为单位）。
  73. 			final long userTimeMillis;//返回指定 ID 的线程在用户模式中执行的 CPU 时间（以毫微秒为单位）。
  74. 			if (cpuTimeEnabled) {
  75. 				cpuTimeMillis = threadBean.getThreadCpuTime(thread.getId()) / 1000000;
  76. 				userTimeMillis = threadBean.getThreadUserTime(thread.getId()) / 1000000;
  77. 			} else {
  78. 				cpuTimeMillis = -1;
  79. 				userTimeMillis = -1;
  80. 			}
  81. 			final boolean deadlocked = deadlockedThreads != null
  82. 					&& Arrays.binarySearch(deadlockedThreads, thread.getId()) >= 0;
  83. 			threadInfosList.add(new ThreadInformations(thread, stackTraceElementList,
  84. 					cpuTimeMillis, userTimeMillis, deadlocked, hostAddress));
  85. 		}
  86. 		return threadInfosList;
  87. 	}
  88. 	/**
  89. 	 * 获取所有的死锁线程id
  90. 	 * @param threadBean
  91. 	 * @return
  92. 	 */
  93. 	private static long[] getDeadlockedThreads(ThreadMXBean threadBean) {
  94. 		final long[] deadlockedThreads;
  95. 		//这方法是jdk1.6才提供的，简单点，在这就不做检查了，
  96. 		if (threadBean.isSynchronizerUsageSupported()) {
  97. 			deadlockedThreads = threadBean.findDeadlockedThreads();
  98. 		} else {
  99. 			deadlockedThreads = threadBean.findMonitorDeadlockedThreads();
  100. 		}
  101. 		if (deadlockedThreads != null) {
  102. 			Arrays.sort(deadlockedThreads);
  103. 		}
  104. 		return deadlockedThreads;
  105. 	}
  106. 	
  107.  
  108. 	String getName() {
  109. 		return name;
  110. 	}
  111.  
  112. 	long getId() {
  113. 		return id;
  114. 	}
  115.  
  116. 	int getPriority() {
  117. 		return priority;
  118. 	}
  119.  
  120. 	boolean isDaemon() {
  121. 		return daemon;
  122. 	}
  123.  
  124. 	Thread.State getState() {
  125. 		return state;
  126. 	}
  127.  
  128. 	List<StackTraceElement> getStackTrace() {
  129. 		if (stackTrace != null) {
  130. 			return Collections.unmodifiableList(stackTrace);
  131. 		}
  132. 		return stackTrace;
  133. 	}
  134.  
  135. 	String getExecutedMethod() {
  136. 		final List<StackTraceElement> trace = stackTrace;
  137. 		if (trace != null && !trace.isEmpty()) {
  138. 			return trace.get(0).toString();
  139. 		}
  140. 		return "";
  141. 	}
  142.  
  143. 	long getCpuTimeMillis() {
  144. 		return cpuTimeMillis;
  145. 	}
  146.  
  147. 	long getUserTimeMillis() {
  148. 		return userTimeMillis;
  149. 	}
  150.  
  151. 	boolean isDeadlocked() {
  152. 		return deadlocked;
  153. 	}
  154.  
  155. 	String getGlobalThreadId() {
  156. 		return globalThreadId;
  157. 	}
  158.  
  159. 	private static String buildGlobalThreadId(Thread thread, String hostAddress) {
  160. 		return PID.getPID() + '_' + hostAddress + '_' + thread.getId();
  161. 	}
  162.  
  163. 	/** {@inheritDoc} */
  164. 	@Override
  165. 	public String toString() {
  166. 		StringBuffer sb = new StringBuffer();
  167. 		sb.append("[线程id=" + getId() 
  168. 				+",线程具体id(pid_host_tid)="+getGlobalThreadId()
  169. 				+ ",线程名称 name=" + getName() 
  170. 				+ ", 是否是守护线程daemon="+ isDaemon() 
  171. 				+ ",线程优先度 priority=" + getPriority() 
  172. 				+ ",是不是死锁 deadlocked=" + isDeadlocked()
  173. 				+ ", 运行状态state=" + getState() 
  174. 				+",线程使用CPU时间(毫秒)="+getCpuTimeMillis()
  175. 				+",线程在用户模式下使用CPU时间(毫秒)="+getUserTimeMillis()
  176. 		        +",执行的方法="+getExecutedMethod());
  177. 		if(getStackTrace() != null && !getStackTrace().isEmpty()){
  178. 			sb.append("<br/>栈信息:");
  179. 			for(StackTraceElement s : getStackTrace()){
  180. 				sb.append("<br/>").append(s.toString());
  181. 			}
  182. 		}
  183. 		sb.append( ']');
  184. 		
  185. 		return sb.toString();
  186. 	}
  187. }
  http://127.0.0.1/testweb/TestMonitorServlet访问，查看结果




源码下载


声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/319766
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号