我来做一回技术控，这部分内容也是简单的API调用例子而已，做一回技术控，发点小骚文，不过你看了，也许知道JConsole是怎么做出来的了，呵呵！

先不用管他干什么，代码运行后，自己改改自然知道做什么的。

例子全部应该都可以运行，使用者，拷贝回去就基本可以用了，无需其他内容的支持，有部分代码对JDK的版本有要求，例如在使用：ThreadMXBean.getThreadAllocatedBytes(id)，这个是在JDK 6 update 25中开始支持的，而且在JDK 1.6中获取出来还有问题不少。

我先写了个简单的工具类：

  1. import java.io.IOException;
  2. import java.lang.management.ManagementFactory;
  3. import java.util.Set;
  4. import javax.management.AttributeNotFoundException;
  5. import javax.management.BadAttributeValueExpException;
  6. import javax.management.BadBinaryOpValueExpException;
  7. import javax.management.BadStringOperationException;
  8. import javax.management.InstanceNotFoundException;
  9. import javax.management.IntrospectionException;
  10. import javax.management.InvalidApplicationException;
  11. import javax.management.MBeanAttributeInfo;
  12. import javax.management.MBeanException;
  13. import javax.management.MBeanInfo;
  14. import javax.management.MBeanServer;
  15. import javax.management.MBeanServerConnection;
  16. import javax.management.MalformedObjectNameException;
  17. import javax.management.ObjectInstance;
  18. import javax.management.ObjectName;
  19. import javax.management.QueryExp;
  20. import javax.management.ReflectionException;
  21. import javax.management.RuntimeMBeanException;
  22.  
  23. public class JMXUtils {
  24.  
  25. 	private final static MBeanServer DEFAULT_MBEAN_SERVER = ManagementFactory
  26. 			.getPlatformMBeanServer();
  27.  
  28. 	public static long getYongGC() {
  29. 		return getYoungGC(DEFAULT_MBEAN_SERVER);
  30. 	}
  31.  
  32. 	public static long getFullGC() {
  33. 		return getFullGC(DEFAULT_MBEAN_SERVER);
  34. 	}
  35.  
  36. 	public static long findLoadedClass() {
  37. 		return findLoadedClass(DEFAULT_MBEAN_SERVER);
  38. 	}
  39.  
  40. 	public static long getYoungGC(MBeanServerConnection mbeanServer) {
  41. 		try {
  42. 			ObjectName objectName;
  43. 			if (mbeanServer.isRegistered(new ObjectName("java.lang:type=GarbageCollector,name=ParNew"))) {
  44. 				objectName = new ObjectName("java.lang:type=GarbageCollector,name=ParNew");
  45. 			} else if (mbeanServer.isRegistered(new ObjectName("java.lang:type=GarbageCollector,name=Copy"))) {
  46. 				objectName = new ObjectName("java.lang:type=GarbageCollector,name=Copy");
  47. 			} else {
  48. 				objectName = new ObjectName("java.lang:type=GarbageCollector,name=PS Scavenge");
  49. 			}
  50. 			return (Long) mbeanServer.getAttribute(objectName , "CollectionCount");
  51. 		} catch (Exception e) {
  52. 			throw new RuntimeException(e);
  53. 		}
  54. 	}
  55.  
  56. 	public static long getFullGC(MBeanServerConnection mbeanServer) {
  57. 		try {
  58. 			ObjectName objectName;
  59. 			if (mbeanServer.isRegistered(new ObjectName("java.lang:type=GarbageCollector,name=ConcurrentMarkSweep"))) {
  60. 				objectName = new ObjectName("java.lang:type=GarbageCollector,name=ConcurrentMarkSweep");
  61. 			} else if (mbeanServer.isRegistered(new ObjectName("java.lang:type=GarbageCollector,name=MarkSweepCompact"))) {
  62. 				objectName = new ObjectName("java.lang:type=GarbageCollector,name=MarkSweepCompact");
  63. 			} else {
  64. 				objectName = new ObjectName("java.lang:type=GarbageCollector,name=PS MarkSweep");
  65. 			}
  66. 			return (Long) mbeanServer.getAttribute(objectName , "CollectionCount");
  67. 		} catch (Exception e) {
  68. 			throw new RuntimeException(e);
  69. 		}
  70. 	}
  71.  
  72. 	public static long findLoadedClass(MBeanServerConnection mBeanServer) {
  73. 		try {
  74. 			return (Long) (mBeanServer.getAttribute(new ObjectName(
  75. 					"java.lang:type=ClassLoading"), "TotalLoadedClassCount"));
  76. 		} catch (Exception e) {
  77. 			throw new RuntimeException(e);
  78. 		}
  79. 	}
  80.  
  81. 	public static void traceOneDomain(String doMain,
  82. 			MBeanServerConnection mBeanServer)
  83. 			throws MalformedObjectNameException, IntrospectionException,
  84. 			InstanceNotFoundException, AttributeNotFoundException,
  85. 			ReflectionException, MBeanException, IOException {
  86.  
  87. 		Set<ObjectInstance> set = mBeanServer.queryMBeans(new ObjectName(doMain + ":*"), new QueryExp() {
  88. 			private static final long serialVersionUID = 1L;
  89.  
  90. 			@Override
  91. 			public boolean apply(ObjectName name)
  92. 					throws BadStringOperationException,
  93. 					BadBinaryOpValueExpException,
  94. 					BadAttributeValueExpException, InvalidApplicationException {
  95. 				return true;
  96. 			}
  97.  
  98. 			@Override
  99. 			public void setMBeanServer(MBeanServer s) {}
  100. 		});
  101. 		for (ObjectInstance objectInstance : set) {
  102. 			System.out.println("\t\t\t" + objectInstance.getObjectName() + "\t"
  103. 					+ objectInstance.getClassName());
  104. 			traceMebeanInfo(mBeanServer, objectInstance.getObjectName());
  105. 		}
  106. 	}
  107.  
  108. 	public static void traceMebeanInfo(MBeanServerConnection mBeanServer,
  109. 			ObjectName objectName) throws IntrospectionException,
  110. 			InstanceNotFoundException, MalformedObjectNameException,
  111. 			ReflectionException, AttributeNotFoundException, MBeanException,
  112. 			IOException {
  113. 		MBeanInfo mBeanInfo = mBeanServer.getMBeanInfo(objectName);
  114. 		MBeanAttributeInfo[] mBeanAttributes = mBeanInfo.getAttributes();
  115.  
  116. 		System.out.println("\t\t\tMBeanInfos : ");
  117. 		for (MBeanAttributeInfo mBeanAttribute : mBeanAttributes) {
  118. 			try {
  119. 				System.out.println("\t\t\t\t\t"
  120. 						+ mBeanAttribute.getName()
  121. 						+ "\t"
  122. 						+ mBeanAttribute.getType()
  123. 						+ "\tvalue = >"
  124. 						+ mBeanServer.getAttribute(objectName,
  125. 								mBeanAttribute.getName()));
  126. 			} catch (RuntimeMBeanException e) {
  127. 				if (e.getCause() instanceof UnsupportedOperationException) {
  128. 					System.out.println("\t\t\t\t\t" + mBeanAttribute.getName()
  129. 							+ "\t" + mBeanAttribute.getType()
  130. 							+ "\tvalue = > value not supported");
  131. 				}
  132. 			}
  133.  
  134. 		}
  135. 	}
  136.  
  137. 	public static void traceAll(MBeanServerConnection mBeanServer)
  138. 			throws MalformedObjectNameException, IntrospectionException,
  139. 			InstanceNotFoundException, AttributeNotFoundException,
  140. 			ReflectionException, MBeanException, IOException {
  141. 		System.out.println("MBean count = " + mBeanServer.getMBeanCount());
  142. 		String[] domains = mBeanServer.getDomains();
  143. 		for (String domain : domains) {
  144. 			System.out.println("\tbegin trace domain -> " + domain);
  145. 			traceOneDomain(domain, mBeanServer);
  146. 		}
  147. 	}
  148. }

这个类写好后，我们就可以写点小测试代码了，呵呵！

那么首先来写个遍历所有的参数列表，层次结构为3层：

MBeanServer -> DoMain -> MBean -> MBeanAttributeInfo 但是写好那个Util后调用就简单了：

  1. import java.io.IOException;
  2. import java.lang.management.ManagementFactory;
  3.  
  4. import javax.management.AttributeNotFoundException;
  5. import javax.management.InstanceNotFoundException;
  6. import javax.management.IntrospectionException;
  7. import javax.management.MBeanException;
  8. import javax.management.MalformedObjectNameException;
  9. import javax.management.ReflectionException;
  10.  
  11. public class MBeanServerTest {
  12.  
  13. 	public static void main(String[] args) throws MalformedObjectNameException,
  14. 			IntrospectionException, InstanceNotFoundException,
  15. 			AttributeNotFoundException, ReflectionException, MBeanException,
  16. 			IOException {
  17. 		// System.gc();
  18. 		// System.out.println(JMXUtils.getYongGC());
  19. 		// System.out.println(JMXUtils.getFullGC());
  20.  
  21. 		JMXUtils.traceAll(ManagementFactory.getPlatformMBeanServer());
  22.  
  23. 	}
  24. }

结果很多，不同的OS，不同的JVM配置，结果也会有所区别，大家可以自己书出来看看，这里注意里面的ObjectName，通过MBeanServer直接获取里面的参数值，比较好用，尤其是RMI的时候，这个trace不太好用，因为远程可能有些类，本地没有，但是参数值是可以获取到的，所以需要知道名称是比较好的。

远程的输出，我们简单来写一段代码：

  1. import java.io.IOException;
  2. import java.util.HashMap;
  3.  
  4. import javax.management.AttributeNotFoundException;
  5. import javax.management.InstanceNotFoundException;
  6. import javax.management.IntrospectionException;
  7. import javax.management.MBeanException;
  8. import javax.management.MBeanServerConnection;
  9. import javax.management.MalformedObjectNameException;
  10. import javax.management.ObjectName;
  11. import javax.management.ReflectionException;
  12. import javax.management.remote.JMXConnector;
  13. import javax.management.remote.JMXConnectorFactory;
  14. import javax.management.remote.JMXServiceURL;
  15.  
  16. public class MBeanServerRemoteTest {
  17.  
  18. 	/**
  19. 	 * 远程地址需要开启：
  20. 	 * -Dcom.sun.management.jmxremote
  21. 	 * -Dcom.sun.management.jmxremote.port=9000
  22. 	 * -Dcom.sun.management.jmxremote.authenticate=true
  23. 	 */
  24. 	final static String RMI_URL = "service:jmx:rmi:///jndi/rmi://xxx.xxx.xxx.xxx:9000/jmxrmi";
  25.  
  26. 	public static void main(String []args)
  27. 		throws IOException, MalformedObjectNameException, IntrospectionException,
  28. 			InstanceNotFoundException, AttributeNotFoundException, ReflectionException, MBeanException {
  29. 		JMXServiceURL serviceURL = new JMXServiceURL(RMI_URL);
  30. 		JMXConnector jmxc = JMXConnectorFactory.connect(serviceURL , new HashMap<String , Object>() {
  31. 			private static final long serialVersionUID = 1L;
  32. 			{
  33. 				put(JMXConnector.CREDENTIALS , new String[] {"controlRole" , "FUCK"});
  34. 			}
  35. 		});
  36. 		MBeanServerConnection mBeanServer = jmxc.getMBeanServerConnection();
  37. 		System.out.println("MBean count = " + mBeanServer.getMBeanCount());
  38. 		String[] domains = mBeanServer.getDomains();
  39. 		for (String doMain : domains) {
  40. 			System.out.println("============>" + doMain);
  41. 		}
  42. 		System.out.println(JMXUtils.getYoungGC(mBeanServer));
  43. 		System.out.println(JMXUtils.getFullGC(mBeanServer));
  44. 		System.out.println(mBeanServer.getAttribute(new ObjectName("JMImplementation:type=MBeanServerDelegate"), "ImplementationVersion"));
  45. 		System.out.println(mBeanServer.getAttribute(new ObjectName("java.lang:type=Runtime"), "BootClassPath"));
  46. 		//其余的可以自己遍历出来
  47. 	}
  48. }

这两个出来了，其实JMX还提供了些简单的，默认的MXBean，可以直接使用，我们简单也写下这些demo，可以拿去自己玩哈。

===》ClassLoadingMXBean：

  1. import java.lang.management.ClassLoadingMXBean;
  2. import java.lang.management.ManagementFactory;
  3.  
  4. public class ClassLoadingMXBeanTest {
  5.  
  6. 	public static void main(String []args) {
  7. 		ClassLoadingMXBean classLoadingMXBean = ManagementFactory.getClassLoadingMXBean();
  8. 		System.out.println(classLoadingMXBean.getLoadedClassCount());
  9. 		System.out.println(classLoadingMXBean.getTotalLoadedClassCount());
  10. 		System.out.println(classLoadingMXBean.getUnloadedClassCount());
  11. 		System.out.println(classLoadingMXBean.isVerbose());
  12. 	}
  13. }

===》CompilationMXBean

  1. import java.lang.management.CompilationMXBean;
  2. import java.lang.management.ManagementFactory;
  3.  
  4. public class CompilationMXBeanTest {
  5.  
  6. 	public static void main(String []args) {
  7. 		CompilationMXBean mxBean = ManagementFactory.getCompilationMXBean();
  8. 		System.out.println(mxBean.getTotalCompilationTime());
  9. 		System.out.println(mxBean.getName());
  10. 		System.out.println(mxBean.isCompilationTimeMonitoringSupported());
  11. 	}
  12. }

===》MemoryManagerMXBean

  1. import java.lang.management.ManagementFactory;
  2. import java.lang.management.MemoryManagerMXBean;
  3. import java.util.List;
  4.  
  5. import javax.management.AttributeNotFoundException;
  6. import javax.management.InstanceNotFoundException;
  7. import javax.management.IntrospectionException;
  8. import javax.management.MBeanAttributeInfo;
  9. import javax.management.MBeanException;
  10. import javax.management.MBeanInfo;
  11. import javax.management.MBeanServer;
  12. import javax.management.ReflectionException;
  13.  
  14. public class MemoryManagerMXBeanTest {
  15.  
  16. 	public static void main(String []args) throws IntrospectionException, InstanceNotFoundException, ReflectionException, AttributeNotFoundException, MBeanException {
  17. 		MBeanServer mBeanServer = ManagementFactory.getPlatformMBeanServer();
  18. 		System.gc();
  19.  
  20. 		List<MemoryManagerMXBean> list = ManagementFactory.getMemoryManagerMXBeans();
  21. 		for(MemoryManagerMXBean memoryManagerMXBean : list) {
  22. 			System.out.println(memoryManagerMXBean.getName());
  23. 			System.out.println(memoryManagerMXBean.getObjectName());
  24. 			MBeanInfo mBeanInfo = mBeanServer.getMBeanInfo(memoryManagerMXBean.getObjectName());
  25.  
  26. 			MBeanAttributeInfo[] mBeanAttributes = mBeanInfo.getAttributes();
  27. 			for(MBeanAttributeInfo mBeanAttribute : mBeanAttributes) {
  28. 				System.out.println("=============>" + mBeanAttribute.getName() + "\t" + mBeanAttribute.getType());
  29. 				System.out.println("=============value = >" + mBeanServer.getAttribute(memoryManagerMXBean.getObjectName(), mBeanAttribute.getName()));
  30. 			}
  31.  
  32. 			/*String []poolNames = memoryManagerMXBean.getMemoryPoolNames();
  33. 			for(String poolName : poolNames) {
  34. 				System.out.println("\t" + poolName);
  35. 			}*/
  36. 		}
  37. 	}
  38. }

===》MemoryMXBean

  1. import java.lang.management.ManagementFactory;
  2. import java.lang.management.MemoryMXBean;
  3.  
  4. public class MemoryMXBeanTest {
  5.  
  6. 	public static void main(String []args) {
  7. 		MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
  8. 		//memoryMXBean.gc();
  9. 		System.out.println(memoryMXBean.getHeapMemoryUsage());
  10. 		System.out.println(memoryMXBean.getObjectPendingFinalizationCount());
  11. 		System.out.println(memoryMXBean.getNonHeapMemoryUsage());
  12. 	}
  13. }

===》MemoryPoolMXBean

  1. import java.lang.management.ManagementFactory;
  2. import java.lang.management.MemoryPoolMXBean;
  3. import java.util.List;
  4.  
  5. public class MemoryPoolMXBeanTest {
  6.  
  7. 	public static void main(String[] args) {
  8. 		List<MemoryPoolMXBean> list = ManagementFactory.getMemoryPoolMXBeans();
  9. 		for (MemoryPoolMXBean memoryPoolMXBean : list) {
  10. 			System.out.println(memoryPoolMXBean.getName()
  11. 					+ memoryPoolMXBean.getCollectionUsage()
  12. 					+ "\n\nPeakUsage:\t\t" + memoryPoolMXBean.getPeakUsage()
  13. 					+ "\n\nUsage:\t\t" + memoryPoolMXBean.getUsage());
  14. 			/*
  15. 			 * + memoryPoolMXBean.getUsageThreshold() + "\t" +
  16. 			 * memoryPoolMXBean.getUsageThresholdCount() +
  17. 			 * "\t\n\nCollectionUsage:\t\t"
  18. 			 *
  19. 			 * + memoryPoolMXBean.getType() + "\t"
  20. 			 */
  21. 			// memoryPoolMXBean.getCollectionUsageThreshold() + "\t"
  22. 			// memoryPoolMXBean.getCollectionUsageThresholdCount() + "\t" );
  23. 			// String []memoryManagerNames =
  24. 			// memoryPoolMXBean.getMemoryManagerNames();
  25. 			/*
  26. 			 * for(String memoryManagerName : memoryManagerNames) {
  27. 			 * System.out.println("\t\t\t\t" + memoryManagerName); }
  28. 			 */
  29.  
  30. 		}
  31. 	}
  32. }

===》OperatingSystemMXBean

  1. import java.lang.management.ManagementFactory;
  2. import java.lang.management.OperatingSystemMXBean;
  3.  
  4. public class OperatingSystemMXBeanTest {
  5.  
  6. 	public static void main(String []args) {
  7. 		OperatingSystemMXBean mxBean = ManagementFactory.getOperatingSystemMXBean();
  8. 		System.out.println(mxBean.getArch());
  9. 		System.out.println(mxBean.getAvailableProcessors());
  10. 		System.out.println(mxBean.getName());
  11. 		System.out.println(mxBean.getSystemLoadAverage());
  12. 		System.out.println(mxBean.getVersion());
  13. 	}
  14. }

===》RuntimeMXBean

  1. import java.lang.management.ManagementFactory;
  2. import java.lang.management.RuntimeMXBean;
  3.  
  4. public class RuntimeMXBeanTest {
  5.  
  6. 	public static void main(String []args) {
  7. 		RuntimeMXBean runTimeMXBean = ManagementFactory.getRuntimeMXBean();
  8. 		System.out.println(runTimeMXBean.getBootClassPath());
  9. 		System.out.println(runTimeMXBean.getClassPath());
  10. 		System.out.println(runTimeMXBean.getLibraryPath());
  11. 		System.out.println(runTimeMXBean.getManagementSpecVersion());
  12. 		System.out.println(runTimeMXBean.getName());
  13. 		System.out.println(runTimeMXBean.getSpecName());
  14. 		System.out.println(runTimeMXBean.getSpecVendor());
  15. 		System.out.println(runTimeMXBean.getStartTime());
  16. 		System.out.println(runTimeMXBean.getUptime());
  17. 		System.out.println(runTimeMXBean.getVmName());
  18. 		System.out.println(runTimeMXBean.getVmVendor());
  19. 		System.out.println(runTimeMXBean.getVmVersion());
  20. 		System.out.println(runTimeMXBean.getInputArguments());
  21. 		System.out.println(runTimeMXBean.getSystemProperties());
  22. 	}
  23. }

===》ThreadMXBean

  1. import java.lang.management.ManagementFactory;
  2. import java.lang.management.ThreadInfo;
  3.  
  4. import com.sun.management.ThreadMXBean;
  5. //import sun.management.VMOptionCompositeData;
  6. //import com.sun.management.VMOption;
  7. //import java.lang.management.ManagementFactory;
  8.  
  9. public class ThreadMXBeanTest {
  10.  
  11. 	public static void main(String []args) {
  12. 		ThreadMXBean thredMXBean = (ThreadMXBean) ManagementFactory.getThreadMXBean();
  13. 		long []ids = thredMXBean.getAllThreadIds();
  14. 		for(long id : ids) {
  15. 			System.out.println(id + "\t" + thredMXBean.getThreadAllocatedBytes(id) + "\t" + thredMXBean.getThreadInfo(id));
  16. 		}
  17. 		System.out.println(thredMXBean.getCurrentThreadCpuTime());
  18. 		System.out.println(thredMXBean.getCurrentThreadUserTime());
  19. 		System.out.println(thredMXBean.getDaemonThreadCount());
  20. 		System.out.println(thredMXBean.getPeakThreadCount());
  21. 		System.out.println(thredMXBean.getThreadCount());
  22. 		System.out.println(thredMXBean.getTotalStartedThreadCount());
  23. 		System.out.println("==========================>");
  24. 		displayThreadInfos(thredMXBean , ids);
  25. 	}
  26.  
  27. 	private static void displayThreadInfos(ThreadMXBean thredMXBean , long []ids) {
  28. 		ThreadInfo []threadInfos = thredMXBean.getThreadInfo(ids);
  29. 		for(ThreadInfo thread : threadInfos) {
  30. 			System.out.println(thread.getThreadName() + "\t"
  31. 					+ thread.getLockOwnerId() + "\t" + thread.getThreadState()
  32. 					+ "\t" + thread.getBlockedCount() + "\t" + thread.getBlockedTime() );
  33.  
  34. 		}
  35. 	}
  36. }

JMX操作实例--做一回技术控的更多相关文章

  1. oracle 单实例DG(闪回技术四)

    一,flashback Oracle Flashback技术是一组数据库特性,它可以让你查看数据库对象的过去状态,或者将数据库对象返回到以前的状态,而无需使用基于时间点的介质恢复.根据数据库的变化,闪 ...

  2. Oracle的闪回技术--闪回错误的DML操作

    提交DML操作后,该操作使用的还原段就可以被其它对象使用了,为了保证闪回操作时这些数据仍然被保存在还原段中,可能需要重新设置undo_retention参数,表示一个事务提交后,该事务的数据必须保存在 ...

  3. Oracle 六闪回技术，flashback

    Flashback 技术基于Undo segment基于内容的, 因此,限制UNDO_RETENTON参数. 要使用flashback 特征,您必须启用自己主动撤销管理表空间. 在Oracle 11g ...

  4. （4.11）mysql备份还原——mysql闪回技术（基于binlog）

    0.闪回技术与工具简介 mysql闪回工具比较流行三大类: [0.1]官方的mysqlbinlog:支持数据库在线/离线,用脚本处理binlog的输出,转化成对应SQL再执行.通用性不好,对正则.se ...

  5. OCP读书笔记(10) - 使用闪回技术I

    使用闪回技术查询数据 闪回查询:就是查询表在过去某个时间点的数据,所用到的技术就是undo数据 SQL> conn scott/tiger 创建测试表 SQL> create table ...

  6. Oracle闪回技术

    (一)闪回技术概要 闪回技术是数据库备份与恢复的重要补充手段,主要包括以下7种特性: 特性 原理 数据库支持 闪回查询(Flashback Query) 利用undo表空间中的回退信息,查询过去某个时 ...

  7. oracle-闪回技术1

    http://blog.csdn.net/lqx0405/article/details/44776737  Oracle Study案例之--基于表空间的时间点恢复(TSPITR) DBPITR 数 ...

  8. SQL Fundamentals: 表的创建和管理（表的基本操作，闪回技术flashback，表结构修改）

    SQL Fundamentals || Oracle SQL语言 1.表的基本操作 (CREATE TABLE, DROP TABLE,TRUNCATE TABLE, RENAME tablename ...

  9. Oracle 的闪回技术 --flashback

    SQL Fundamentals: 表的创建和管理 如何开启数据库闪回? SQL> shutdown immediate; ORA-01109: database not open Databa ...

随机推荐

  1. linux设置时区同步时间

    linux设置时区同步时间 一.运行tzselect sudo tzselect 在这里我们选择亚洲 Asia,确认之后选择中国(China),最后选择北京(Beijing) 如图:   二.复制文件 ...

  2. cpu几种架构区别

    转自:http://smilejay.com/2012/07/intel-procssor-architecture/ (1)x86 (IA-32,i386,x86-32,x32) x86是指基于In ...

  3. Java Web 远程调试

    Java Web 远程 调试 Tomcat 下载压缩版服务器 环境:Tomcat.Eclipse,做远程调试我们并不需要其他特殊插件 1.配置Tomcat/bin/startup.bat 在前面增加代 ...

  4. html 简单学习

    通过记事本,依照以下四步来创建您的第一张网页. 步骤一:启动记事本 如何启动记事本: 开始    所有程序        附件            记事本 步骤二:用记事本来编辑 HTML 在记事本 ...

  5. leetcode 之trap water（8）

    这题不太好想.可以先扫描找到最高的柱子,然后分别处理两边:记录下当前的局部最高点,如果当前点小于局部最高点,加上, 反则,替换当前点为局部最高点. int trapWater(int A[], int ...

  6. gentoo emerge unable to sync

    gentoo emerge unable to sync Author: Tubo After setting SYNC to customized URL: SYNC="rsync://m ...

  7. webapi调用post时自动匹配参数

    [HttpPost] public async Task<string> Post() { dynamic model = await Request.Content.ReadAsAsyn ...

  8. go中操作json

    package main import ( "encoding/json" "fmt" ) type Server struct { ServerName st ...

  9. springboot1.5.4 idea 自动保存编译更新

    maven dependencies增加 <dependency> <groupId>org.springframework.boot</groupId> < ...

  10. js获取json对象中的key和value,并组成新数组

    //比如有一个json var json = {"name" : "Tom", "age" : 18}; //想分别获取它的key 和 va ...