16、jdk内嵌方法监控服务器

目录

• jdk内嵌方法监控服务器
  • 1、增加工具类
    • 增加po
      • HeapMemoryInfoVo.java
      • MemoryInfoVo.java
      • MonitorResVo.java
      • MonitorVo.java
      • OsInfoVo.java
    • 增加工具类
      • RuntimeUtils

jdk内嵌方法监控服务器

1、增加工具类

增加po

HeapMemoryInfoVo.java

package com.platform.gis.admin.monitor.vo;
 
/**
 * 堆与非堆的信息
 *
 * @author lgx
 *
 */
public class HeapMemoryInfoVo {
    // 非堆初始内存
    private Double initNonHeapMemory;
    // 非堆最大内存
    private Double maxNonHeapMemory;
    // 非堆已用内存
    private Double usedNonHeapMemory;
    // 非堆可用内存
    private Double availableNonHeapMemory;
    // 堆初始内存
    private Double initHeapMemory;
    // 堆最大内存
    private Double maxHeapMemory;
    // 堆已用内存
    private Double usedHeapMemory;
    // 堆可用内存
    private Double availableHeapMemory;
 
    public Double getInitNonHeapMemory() {
        return initNonHeapMemory;
    }
 
    public void setInitNonHeapMemory(Double initNonHeapMemory) {
        this.initNonHeapMemory = initNonHeapMemory;
    }
 
    public Double getMaxNonHeapMemory() {
        return maxNonHeapMemory;
    }
 
    public void setMaxNonHeapMemory(Double maxNonHeapMemory) {
        this.maxNonHeapMemory = maxNonHeapMemory;
    }
 
    public Double getUsedNonHeapMemory() {
        return usedNonHeapMemory;
    }
 
    public void setUsedNonHeapMemory(Double usedNonHeapMemory) {
        this.usedNonHeapMemory = usedNonHeapMemory;
    }
 
    public Double getAvailableNonHeapMemory() {
        return availableNonHeapMemory;
    }
 
    public void setAvailableNonHeapMemory(Double availableNonHeapMemory) {
        this.availableNonHeapMemory = availableNonHeapMemory;
    }
 
    public Double getInitHeapMemory() {
        return initHeapMemory;
    }
 
    public void setInitHeapMemory(Double initHeapMemory) {
        this.initHeapMemory = initHeapMemory;
    }
 
    public Double getMaxHeapMemory() {
        return maxHeapMemory;
    }
 
    public void setMaxHeapMemory(Double maxHeapMemory) {
        this.maxHeapMemory = maxHeapMemory;
    }
 
    public Double getUsedHeapMemory() {
        return usedHeapMemory;
    }
 
    public void setUsedHeapMemory(Double usedHeapMemory) {
        this.usedHeapMemory = usedHeapMemory;
    }
 
    public Double getAvailableHeapMemory() {
        return availableHeapMemory;
    }
 
    public void setAvailableHeapMemory(Double availableHeapMemory) {
        this.availableHeapMemory = availableHeapMemory;
    }
}

MemoryInfoVo.java

package com.platform.gis.admin.monitor.vo;
 
/**
 * 物理内存和jvm内存信息
 *
 * @author lgx
 *
 */
public class MemoryInfoVo {
    // 总内存
    private Double totalMemory;
    // 已使用内存
    private Double usedMemory;
    // 剩余内存
    private Double remainingMemory;
    // 内存使用率
    private Double memoryUsage;
    // jvm总内存
    private Double jvmTotalMemory;
    // jvm已使用内存
    private Double jvmUsedMemory;
    // jvm剩余内存
    private Double jvmRemainingMemory;
    // jvm内存使用率
    private Double jvmMemoryUsage;
 
    public Double getTotalMemory() {
        return totalMemory;
    }
 
    public void setTotalMemory(Double totalMemory) {
        this.totalMemory = totalMemory;
    }
 
    public Double getUsedMemory() {
        return usedMemory;
    }
 
    public void setUsedMemory(Double usedMemory) {
        this.usedMemory = usedMemory;
    }
 
    public Double getRemainingMemory() {
        return remainingMemory;
    }
 
    public void setRemainingMemory(Double remainingMemory) {
        this.remainingMemory = remainingMemory;
    }
 
    public Double getMemoryUsage() {
        return memoryUsage;
    }
 
    public void setMemoryUsage(Double memoryUsage) {
        this.memoryUsage = memoryUsage;
    }
 
    public Double getJvmTotalMemory() {
        return jvmTotalMemory;
    }
 
    public void setJvmTotalMemory(Double jvmTotalMemory) {
        this.jvmTotalMemory = jvmTotalMemory;
    }
 
    public Double getJvmUsedMemory() {
        return jvmUsedMemory;
    }
 
    public void setJvmUsedMemory(Double jvmUsedMemory) {
        this.jvmUsedMemory = jvmUsedMemory;
    }
 
    public Double getJvmRemainingMemory() {
        return jvmRemainingMemory;
    }
 
    public void setJvmRemainingMemory(Double jvmRemainingMemory) {
        this.jvmRemainingMemory = jvmRemainingMemory;
    }
 
    public Double getJvmMemoryUsage() {
        return jvmMemoryUsage;
    }
 
    public void setJvmMemoryUsage(Double jvmMemoryUsage) {
        this.jvmMemoryUsage = jvmMemoryUsage;
    }
 
}

MonitorResVo.java

package com.platform.gis.admin.monitor.vo;
 
/**
 * 响应给页面的信息
 *
 * @author lgx
 *
 */
public class MonitorResVo {
 
    private OsInfoVo osInfo;
 
    private HeapMemoryInfoVo heapMemoryInfo;
 
    private MemoryInfoVo memoryInfo;
 
    private VirtualInfoVo virtualInfo;
 
    public OsInfoVo getOsInfo() {
        return osInfo;
    }
    public void setOsInfo(OsInfoVo osInfo) {
        this.osInfo = osInfo;
    }
    public HeapMemoryInfoVo getHeapMemoryInfo() {
        return heapMemoryInfo;
    }
    public void setHeapMemoryInfo(HeapMemoryInfoVo heapMemoryInfo) {
        this.heapMemoryInfo = heapMemoryInfo;
    }
    public MemoryInfoVo getMemoryInfo() {
        return memoryInfo;
    }
    public void setMemoryInfo(MemoryInfoVo memoryInfo) {
        this.memoryInfo = memoryInfo;
    }
    public VirtualInfoVo getVirtualInfo() {
        return virtualInfo;
    }
    public void setVirtualInfo(VirtualInfoVo virtualInfo) {
        this.virtualInfo = virtualInfo;
    }
 
}

MonitorVo.java

package com.platform.gis.admin.monitor.vo;
 
public class MonitorVo {
    /**
     * jvm使用率
     */
    private Double jvmUsage;
 
    /**
     * 物理内存使用率
     */
    private Double physicalUsage;
 
    /**
     * cpu使用率
     */
    private Double cpuUsage;
 
    private MonitorResVo monitorRes;
 
    public Double getJvmUsage() {
        return jvmUsage;
    }
 
    public void setJvmUsage(Double jvmUsage) {
        this.jvmUsage = jvmUsage;
    }
 
    public Double getPhysicalUsage() {
        return physicalUsage;
    }
 
    public void setPhysicalUsage(Double physicalUsage) {
        this.physicalUsage = physicalUsage;
    }
 
    public Double getCpuUsage() {
        return cpuUsage;
    }
 
    public void setCpuUsage(Double cpuUsage) {
        this.cpuUsage = cpuUsage;
    }
 
    public MonitorResVo getMonitorRes() {
        return monitorRes;
    }
 
    public void setMonitorRes(MonitorResVo monitorRes) {
        this.monitorRes = monitorRes;
    }
}

OsInfoVo.java

package com.platform.gis.admin.monitor.vo;
 
/**
 * 操作系统信息
 *
 * @author lgx
 */
public class OsInfoVo {
    // 个数
    private Integer number;
    // 操作系统的架构
    private String arch;
    // 操作系统
    private String name;
    // 系统负载平均值
    private Double systemLoadAverage;
 
    public Integer getNumber() {
        return number;
    }
 
    public void setNumber(Integer number) {
        this.number = number;
    }
 
    public String getArch() {
        return arch;
    }
 
    public void setArch(String arch) {
        this.arch = arch;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public Double getSystemLoadAverage() {
        return systemLoadAverage;
    }
 
    public void setSystemLoadAverage(Double systemLoadAverage) {
        this.systemLoadAverage = systemLoadAverage;
    }
 
}

增加工具类

RuntimeUtils

package com.platform.gis.admin.util;
 
import com.platform.gis.admin.monitor.vo.HeapMemoryInfoVo;
import com.platform.gis.admin.monitor.vo.MemoryInfoVo;
import com.platform.gis.admin.monitor.vo.OsInfoVo;
import com.platform.gis.admin.monitor.vo.VirtualInfoVo;
import com.sun.management.OperatingSystemMXBean;
 
import java.lang.management.ManagementFactory;
import java.lang.management.MemoryMXBean;
import java.lang.management.MemoryUsage;
import java.lang.management.RuntimeMXBean;
import java.text.SimpleDateFormat;
import java.util.concurrent.TimeUnit;
 
public class RuntimeUtils {
 
    private static final OperatingSystemMXBean SYSTEMMXBEAN = (OperatingSystemMXBean) ManagementFactory
            .getOperatingSystemMXBean();
 
    private static final MemoryMXBean MEMORY = ManagementFactory.getMemoryMXBean();
 
    private static final RuntimeMXBean RUNTIMEMBEAN = ManagementFactory.getRuntimeMXBean();
 
    private static final Runtime RUNTIME = Runtime.getRuntime();
 
    private static final int FAULTLENGTH = 10;
 
    // 字节转为GB
    private static final Double GB_UNIT = (double) (1024 * 1024 * 1024);
 
    // 字节转为MB
    private static final Double MB_UNIT = (double) (1024 * 1024);
 
    // 不设置堆/非堆初始内存是物理内存的1/64
    private static final Double INIT_PERM_SIZE = 0.015625;
 
    // 不设置堆/非堆最大内存是物理内存的1/4
    private static final Double MAX_PERM_SIZE = 0.25;
 
    /**
     * 获取物理内存总大小
     *
     * @return
     */
    public static Double getTotalPhysicalMemorySize() {
 
        return format(SYSTEMMXBEAN.getTotalPhysicalMemorySize() / GB_UNIT, 2);
    }
 
    /**
     * 获取物理内存剩余大小
     *
     * @return
     */
    public static Double getFreePhysicalMemorySize() {
        return format(SYSTEMMXBEAN.getFreePhysicalMemorySize() / GB_UNIT, 2);
    }
 
    /**
     * 获取物理内存已使用大小
     *
     * @return
     */
    public static Double getUsedPhysicalMemorySize() {
        return format(((SYSTEMMXBEAN.getTotalPhysicalMemorySize() - SYSTEMMXBEAN.getFreePhysicalMemorySize()) / GB_UNIT), 2);
    }
 
    /**
     * 获取 Swap 总大小
     *
     * @return
     */
    public static long getTotalSwapSpaceSize() {
        return SYSTEMMXBEAN.getTotalSwapSpaceSize();
    }
 
    /**
     * 获取 Swap 剩余大小
     *
     * @return
     */
    public static long getFreeSwapSpaceSize() {
        return SYSTEMMXBEAN.getFreeSwapSpaceSize();
    }
 
    /**
     * 获取 Swap 已使用大小
     *
     * @return
     */
    public static long getUsedSwapSpaceSize() {
        return SYSTEMMXBEAN.getTotalSwapSpaceSize() - SYSTEMMXBEAN.getFreeSwapSpaceSize();
    }
 
    /**
     * 获取 JVM 最大内存
     *
     * @return
     */
    public static Double getJvmMaxMemory() {
        return format(RUNTIME.maxMemory() / MB_UNIT, 2);
    }
 
    /**
     * 获取 JVM 内存总大小
     *
     * @return
     */
    public static Double getJvmTotalMemory() {
        return format(RUNTIME.totalMemory() / MB_UNIT, 2);
    }
 
    /**
     * 获取 JVM 内存剩余大小
     *
     * @return
     */
    public static Double getJvmFreeMemory() {
        return format(RUNTIME.freeMemory() / MB_UNIT, 2);
    }
 
    /**
     * 获取 JVM 内存已使用大小
     *
     * @return
     */
    public static Double getJvmUsedMemory() {
        return format(((RUNTIME.totalMemory() - RUNTIME.freeMemory()) / MB_UNIT), 2);
    }
 
    /**
     * 获取系统 CPU 使用率
     *
     * @return
     */
    public static double getSystemCpuLoad() {
//		long t = System.currentTimeMillis();
//		double systemCpuLoad = -2;
        double systemCpuLoad = SYSTEMMXBEAN.getSystemCpuLoad();
        return format(systemCpuLoad * 100, 2);
    }
 
    /**
     * 获取系统 CPU 使用率
     *
     * @return
     */
    public static double getSystemCpuLoad2() {
        long t = System.currentTimeMillis();
        double systemCpuLoad = -2;
        while (System.currentTimeMillis() < t + 2000) {
            systemCpuLoad = SYSTEMMXBEAN.getSystemCpuLoad();
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        return format(systemCpuLoad * 100, 2);
    }
 
    /**
     * 获取 JVM 进程 CPU 使用率
     *
     * @return
     */
    public static double getProcessCpuLoad() {
//		long t = System.currentTimeMillis();
//		double systemCpuLoad = -2;
        double systemCpuLoad = SYSTEMMXBEAN.getProcessCpuLoad();
        return format(systemCpuLoad * 100, 2);
    }
 
    /**
     * 获取jvm的使用率
     *
     * @return
     */
    public static double getJvmUsage() {
        return format(getJvmUsedMemory() / getJvmTotalMemory() * 100, 2);
    }
 
    /**
     * 获取物理内存的使用率
     *
     * @return
     */
    public static double getPhysicalUsage() {
        return format(
                (getUsedPhysicalMemorySize() / getTotalPhysicalMemorySize()) * 100, 2);
    }
 
    /**
     * 获取cpu信息
     *
     * @return
     */
    public static OsInfoVo getCpuInfo() {
        OsInfoVo osInfoVo = new OsInfoVo();
        osInfoVo.setNumber(RUNTIME.availableProcessors());
        osInfoVo.setArch(System.getProperty("os.arch"));
        osInfoVo.setName(SYSTEMMXBEAN.getName());
        osInfoVo.setSystemLoadAverage(SYSTEMMXBEAN.getSystemLoadAverage());
        return osInfoVo;
    }
 
    /**
     * 获取内存和jvm内存使用情况
     *
     * @return
     */
    public static MemoryInfoVo getMemoryInfo() {
        MemoryInfoVo memoryInfoVo = new MemoryInfoVo();
        memoryInfoVo.setTotalMemory(getTotalPhysicalMemorySize());
        memoryInfoVo.setUsedMemory(getUsedPhysicalMemorySize());
        memoryInfoVo.setRemainingMemory(getFreePhysicalMemorySize());
        memoryInfoVo.setMemoryUsage(getPhysicalUsage());
        memoryInfoVo.setJvmTotalMemory(getJvmTotalMemory());
        memoryInfoVo.setJvmUsedMemory(getJvmUsedMemory());
        memoryInfoVo.setJvmRemainingMemory(getJvmFreeMemory());
        memoryInfoVo.setJvmMemoryUsage(getJvmUsage());
        return memoryInfoVo;
    }
 
    /**
     * 获取堆栈内存信息
     *
     * @return
     */
    public static HeapMemoryInfoVo getHeapMemoryInfo() {
        HeapMemoryInfoVo heapMemoryInfoVo = new HeapMemoryInfoVo();
        // 获取堆内存使用情况
        MemoryUsage heapMemoryUsage = MEMORY.getHeapMemoryUsage();
        // 获取非堆内存使用情况
        MemoryUsage nonHeapMemoryUsage = MEMORY.getNonHeapMemoryUsage();
        Double initHeapMemory = 0.0;
        if (heapMemoryUsage.getInit() == -1) {
            initHeapMemory = SYSTEMMXBEAN.getTotalPhysicalMemorySize() * INIT_PERM_SIZE;
        } else {
            initHeapMemory = Double.valueOf(heapMemoryUsage.getInit());
        }
        heapMemoryInfoVo.setInitHeapMemory(initHeapMemory / MB_UNIT);
        Double maxHeapMemory = 0.0;
        if (heapMemoryUsage.getMax() == -1) {
            maxHeapMemory = SYSTEMMXBEAN.getTotalPhysicalMemorySize() * MAX_PERM_SIZE;
        } else {
            maxHeapMemory = Double.valueOf(heapMemoryUsage.getMax());
        }
        heapMemoryInfoVo.setMaxHeapMemory(maxHeapMemory / MB_UNIT);
        heapMemoryInfoVo.setUsedHeapMemory(heapMemoryUsage.getUsed() / MB_UNIT);
        heapMemoryInfoVo.setAvailableHeapMemory((heapMemoryUsage.getMax() - heapMemoryUsage.getUsed()) / MB_UNIT);
 
        Double initNonHeapMemory = 0.0;
        if (nonHeapMemoryUsage.getInit() == -1) {
            initNonHeapMemory = SYSTEMMXBEAN.getTotalPhysicalMemorySize() * INIT_PERM_SIZE;
        } else {
            initNonHeapMemory = Double.valueOf(nonHeapMemoryUsage.getInit());
        }
        heapMemoryInfoVo.setInitNonHeapMemory(initNonHeapMemory / MB_UNIT);
        Double maxNonHeapMemory = 0.0;
        if (nonHeapMemoryUsage.getMax() == -1) {
            maxNonHeapMemory = SYSTEMMXBEAN.getTotalPhysicalMemorySize() * MAX_PERM_SIZE;
        } else {
            maxNonHeapMemory = Double.valueOf(nonHeapMemoryUsage.getMax());
        }
        heapMemoryInfoVo.setMaxNonHeapMemory(maxNonHeapMemory / MB_UNIT);
        heapMemoryInfoVo.setUsedNonHeapMemory(nonHeapMemoryUsage.getUsed() / MB_UNIT);
        heapMemoryInfoVo.setAvailableNonHeapMemory((maxNonHeapMemory - nonHeapMemoryUsage.getUsed()) / MB_UNIT);
        return heapMemoryInfoVo;
    }
 
    public static VirtualInfoVo getVirtualInfo() {
        VirtualInfoVo virtualInfoVo = new VirtualInfoVo();
        virtualInfoVo.setVmName(RUNTIMEMBEAN.getVmName());
        virtualInfoVo.setVmVersion(RUNTIMEMBEAN.getVmVersion());
        virtualInfoVo.setVmVendor(RUNTIMEMBEAN.getVmVendor());
        SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        virtualInfoVo.setStartTime(sd.format(RUNTIMEMBEAN.getStartTime()));
        virtualInfoVo.setRunningTime(RUNTIMEMBEAN.getUptime());
        virtualInfoVo.setLibPath(System.getProperty("java.home"));
        virtualInfoVo.setStartParameter(RUNTIMEMBEAN.getInputArguments());
        return virtualInfoVo;
    }
 
    private static Double format(Object obj, int i) {
        String format = String.format("%." + i + "f", Double.valueOf(obj.toString()));
        return Double.valueOf(format);
    }
}