Java监控本地性能的方法和实现

乌斯托傲恩日月

已于 2022-09-08 14:33:40 修改

阅读量886

点赞数 1

文章标签： java 开发语言

于 2022-09-08 14:32:32 首次发布

本文链接：https://blog.csdn.net/qq_61781758/article/details/126763765

版权

直接开始进入正题

1.整个工具类的目录结构

2.实体类

2.1 CPU

package com.example.demo.domain.model;


import com.example.demo.domain.utils.Arith;

/**
 * CPU相关信息
 */
public class Cpu {
    /**
     * 核心数
     */
    private int cpuNum;
    /**
     * CPU总的使用率
     */
    private double total;
    /**
     * CPU系统使用率
     */
    private double sys;
    /**
     * CPU用户使用率
     */
    private double used;
    /**
     * CPU当前等待率
     */
    private double wait;
    /**
     * CPU当前空闲率
     */
    private double free;
    public int getCpuNum() {        return cpuNum;    }
    public void setCpuNum(int cpuNum) {        this.cpuNum = cpuNum;    }
    public double getTotal() {        return Arith.round(Arith.mul(total , 100), 2);    }
    public void setTotal(double total) {        this.total = total;    }
    public double getSys() {        return Arith.round(Arith.mul(sys / total, 100), 2);    }
    public void setSys(double sys) {        this.sys = sys;    }
    public double getUsed() {        return Arith.round(Arith.mul(used / total, 100), 2);    }
    public void setUsed(double used) {        this.used = used;    }
    public double getWait() {        return Arith.round(Arith.mul(wait / total, 100), 2);    }
    public void setWait(double wait) {        this.wait = wait;    }
    public double getFree() {        return Arith.round(Arith.mul(free / total, 100), 2);    }
    public void setFree(double free) {        this.free = free;    }
}

2.2 Jvm

package com.example.demo.domain.model;



import com.example.demo.domain.utils.Arith;
import com.example.demo.domain.utils.DateUtils;

import java.lang.management.ManagementFactory;

/**
 * JVM相关信息
 */
public class Jvm {
    /**
     * 当前JVM占用的内存总数(M)
     */
    private double total;
    /**
     * JVM最大可用内存总数(M)
     */
    private double max;
    /**
     * JVM空闲内存(M)
     */
    private double free;
    /**
     * JDK版本
     */
    private String version;
    /**
     * JDK路径
     */
    private String home;
    public double getTotal() {        return Arith.div(total, (1024 * 1024), 2);    }
    public void setTotal(double total) {        this.total = total;    }
    public double getMax() {        return Arith.div(max, (1024 * 1024), 2);    }
    public void setMax(double max) {        this.max = max;    }
    public double getFree() {        return Arith.div(free, (1024 * 1024), 2);    }
    public void setFree(double free) {        this.free = free;    }
    public double getUsed() {        return Arith.div(total - free, (1024 * 1024), 2);    }
    public double getUsage() {        return Arith.mul(Arith.div(total - free, total, 4), 100);    }
    /**
     * 获取JDK名称
     */
    public String getName() {        return ManagementFactory.getRuntimeMXBean().getVmName();    }
    public String getVersion() {
        return version;
    }
    public void setVersion(String version) {        this.version = version;    }
    public String getHome() {        return home;    }
    public void setHome(String home) {        this.home = home;    }
    /**
     * JDK启动时间
     */
    public String getStartTime() {        return DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, DateUtils.getServerStartDate());    }
    /**
     * JDK运行时间
     */
    public String getRunTime() {        return DateUtils.getDatePoor(DateUtils.getNowDate(), DateUtils.getServerStartDate());    }
}

2.3 Mem

package com.example.demo.domain.model;


import com.example.demo.domain.utils.Arith;

/**
 * 內存相关信息
 */
public class Mem {
    /**
     * 内存总量
     */
    private double total;
    /**
     * 已用内存
     */
    private double used;
    /**
     * 剩余内存
     */
    private double free;
    public double getTotal() {        return Arith.div(total, (1024 * 1024 * 1024), 2);    }
    public void setTotal(long total) {        this.total = total;    }
    public double getUsed() {        return Arith.div(used, (1024 * 1024 * 1024), 2);    }
    public void setUsed(long used) {        this.used = used;    }
    public double getFree() {        return Arith.div(free, (1024 * 1024 * 1024), 2);    }
    public void setFree(long free) {        this.free = free;    }
    public double getUsage() {        return Arith.mul(Arith.div(used, total, 4), 100);    }
}

2.4 Sys

package com.example.demo.domain.model;



/**
 * 系统相关信息
 */
public class Sys {
    /**
     * 服务器名称
     */
    private String computerName;
    /**
     * 服务器Ip
     */
    private String computerIp;
    /**
     * 项目路径
     */
    private String userDir;
    /**
     * 操作系统
     */
    private String osName;
    /**
     * 系统架构
     */
    private String osArch;
    public String getComputerName() {        return computerName;    }
    public void setComputerName(String computerName) {        this.computerName = computerName;    }
    public String getComputerIp() {        return computerIp;    }
    public void setComputerIp(String computerIp) {        this.computerIp = computerIp;    }
    public String getUserDir() {        return userDir;    }
    public void setUserDir(String userDir) {        this.userDir = userDir;    }
    public String getOsName() {        return osName;    }
    public void setOsName(String osName) {        this.osName = osName;    }
    public String getOsArch() {        return osArch;    }
    public void setOsArch(String osArch) {        this.osArch = osArch;    }
}

2.5 SysFile

package com.example.demo.domain.model;


/**
 * 系统文件相关信息
 */
public class SysFile {
    /**
     * 盘符路径
     */
    private String dirName;
    /**
     * 盘符类型
     */
    private String sysTypeName;
    /**
     * 文件类型
     */
    private String typeName;
    /**
     * 总大小
     */
    private String total;
    /**
     * 剩余大小
     */
    private String free;
    /**
     * 已经使用量
     */
    private String used;
    /**
     * 资源的使用率
     */
    private double usage;
    public String getDirName() {        return dirName;    }
    public void setDirName(String dirName) {        this.dirName = dirName;    }
    public String getSysTypeName() {        return sysTypeName;    }
    public void setSysTypeName(String sysTypeName) {        this.sysTypeName = sysTypeName;    }
    public String getTypeName() {        return typeName;    }
    public void setTypeName(String typeName) {        this.typeName = typeName;    }
    public String getTotal() {        return total;    }
    public void setTotal(String total) {        this.total = total;    }
    public String getFree() {        return free;    }
    public void setFree(String free) {        this.free = free;    }
    public String getUsed() {        return used;    }
    public void setUsed(String used) {        this.used = used;    }
    public double getUsage() {        return usage;    }
    public void setUsage(double usage) {        this.usage = usage;    }
}

3.工具类

3.1 Arith

package com.example.demo.domain.utils;
import java.math.BigDecimal;
import java.math.RoundingMode;
public class Arith {


    /**
     * 精确的浮点数运算
     */


        /**
         * 默认除法运算精度
         */
        private static final int DEF_DIV_SCALE = 10;

        /**
         * 这个类不能实例化
         */
        private Arith() {
        }

        /**
         * 提供精确的加法运算。
         *
         * @param v1 被加数
         * @param v2 加数
         * @return 两个参数的和
         */
        public static double add(double v1, double v2) {
            BigDecimal b1 = new BigDecimal(Double.toString(v1));
            BigDecimal b2 = new BigDecimal(Double.toString(v2));
            return b1.add(b2).doubleValue();
        }

        /**
         * 提供精确的减法运算。
         *
         * @param v1 被减数
         * @param v2 减数
         * @return 两个参数的差
         */
        public static double sub(double v1, double v2) {
            BigDecimal b1 = new BigDecimal(Double.toString(v1));
            BigDecimal b2 = new BigDecimal(Double.toString(v2));
            return b1.subtract(b2).doubleValue();
        }

        /**
         * 提供精确的乘法运算。
         *
         * @param v1 被乘数
         * @param v2 乘数
         * @return 两个参数的积
         */
        public static double mul(double v1, double v2) {
            BigDecimal b1 = new BigDecimal(Double.toString(v1));
            BigDecimal b2 = new BigDecimal(Double.toString(v2));
            return b1.multiply(b2).doubleValue();
        }

        /**
         * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
         * 小数点以后10位，以后的数字四舍五入。
         *
         * @param v1 被除数
         * @param v2 除数
         * @return 两个参数的商
         */
        public static double div(double v1, double v2) {
            return div(v1, v2, DEF_DIV_SCALE);
        }

        /**
         * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
         * 定精度，以后的数字四舍五入。
         *
         * @param v1    被除数
         * @param v2    除数
         * @param scale 表示表示需要精确到小数点以后几位。
         * @return 两个参数的商
         */
        public static double div(double v1, double v2, int scale) {
            if (scale < 0) {
                throw new IllegalArgumentException(
                        "The scale must be a positive integer or zero");
            }
            BigDecimal b1 = new BigDecimal(Double.toString(v1));
            BigDecimal b2 = new BigDecimal(Double.toString(v2));
            if (b1.compareTo(BigDecimal.ZERO) == 0) {
                return BigDecimal.ZERO.doubleValue();
            }
            return b1.divide(b2, scale, RoundingMode.HALF_UP).doubleValue();
        }

        /**
         * 提供精确的小数位四舍五入处理。
         *
         * @param v     需要四舍五入的数字
         * @param scale 小数点后保留几位
         * @return 四舍五入后的结果
         */
        public static double round(double v, int scale) {
            if (scale < 0) {
                throw new IllegalArgumentException(
                        "The scale must be a positive integer or zero");
            }
            BigDecimal b = new BigDecimal(Double.toString(v));
            BigDecimal one = BigDecimal.ONE;
            return b.divide(one, scale, RoundingMode.HALF_UP).doubleValue();
        }

}

3.2 Convert

package com.example.demo.domain.utils;

import org.apache.commons.lang3.ArrayUtils;

import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;

/**
 * 类型转换器
 */
public class Convert {

    /**
     * 将对象转为字符串<br>
     */
    public static String utf8Str(Object obj) {
        return str(obj, StandardCharsets.UTF_8);
    }

    /**
     * 将对象转为字符串<br>
     */
    public static String str(Object obj, Charset charset) {
        if (null == obj) {
            return null;
        }
        if (obj instanceof String) {
            return (String) obj;
        } else if (obj instanceof byte[]) {
            return str((byte[]) obj, charset);
        } else if (obj instanceof Byte[]) {
            byte[] bytes = ArrayUtils.toPrimitive((Byte[]) obj);
            return str(bytes, charset);
        } else if (obj instanceof ByteBuffer) {
            return str((ByteBuffer) obj, charset);
        }
        return obj.toString();
    }

    /**
     * 解码字节码
     */
    public static String str(byte[] data, Charset charset) {
        if (data == null) {
            return null;
        }
        if (null == charset) {
            return new String(data);
        }
        return new String(data, charset);
    }

    /**
     * 将编码的byteBuffer数据转换为字符串
     */
    public static String str(ByteBuffer data, Charset charset) {
        if (null == charset) {
            charset = Charset.defaultCharset();
        }
        return charset.decode(data).toString();
    }

}

3.3 DateUtils

package com.example.demo.domain.utils;
import java.lang.management.ManagementFactory;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 时间工具类
 */
public class DateUtils extends org.apache.commons.lang3.time.DateUtils {

    public static String YYYY_MM_DD = "yyyy-MM-dd";

    public static String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";

    /**
     * 获取当前Date型日期
     */
    public static Date getNowDate() {
        return new Date();
    }

    /**
     * 获取当前日期, 默认格式为yyyy-MM-dd
     */
    public static String getDate() {
        return dateTimeNow(YYYY_MM_DD);
    }

    public static final String getTime() {
        return dateTimeNow(YYYY_MM_DD_HH_MM_SS);
    }


    public static final String dateTimeNow(final String format) {
        return parseDateToStr(format, new Date());
    }


    public static final String parseDateToStr(final String format, final Date date) {
        return new SimpleDateFormat(format).format(date);
    }

    /**
     * 获取服务器启动时间
     */
    public static Date getServerStartDate() {
        long time = ManagementFactory.getRuntimeMXBean().getStartTime();
        return new Date(time);
    }

    /**
     * 计算两个时间差
     */
    public static String getDatePoor(Date endDate, Date nowDate) {
        long nd = 1000 * 24 * 60 * 60;
        long nh = 1000 * 60 * 60;
        long nm = 1000 * 60;
        // long ns = 1000;
        // 获得两个时间的毫秒时间差异
        long diff = endDate.getTime() - nowDate.getTime();
        // 计算差多少天
        long day = diff / nd;
        // 计算差多少小时
        long hour = diff % nd / nh;
        // 计算差多少分钟
        long min = diff % nd % nh / nm;
        // 计算差多少秒//输出结果
        // long sec = diff % nd % nh % nm / ns;
        return day + "天" + hour + "小时" + min + "分钟";
    }
}

3.4 EscapeUtil

package com.example.demo.domain.utils;

import cn.hutool.http.HTMLFilter;

public class EscapeUtil {

    private static final char[][] TEXT = new char[64][];

    static {
        for (int i = 0; i < 64; i++) {
            TEXT[i] = new char[]{(char) i};
        }
        // special HTML characters
        TEXT['\''] = "&#039;".toCharArray(); // 单引号
        TEXT['"'] = "&#34;".toCharArray(); // 双引号
        TEXT['&'] = "&#38;".toCharArray(); // &符
        TEXT['<'] = "&#60;".toCharArray(); // 小于号
        TEXT['>'] = "&#62;".toCharArray(); // 大于号
    }

    /**
     * 转义文本中的HTML字符为安全的字符
     *
     * @param text 被转义的文本
     * @return 转义后的文本
     */
    public static String escape(String text) {
        return encode(text);
    }

    /**
     * 还原被转义的HTML特殊字符
     *
     * @param content 包含转义符的HTML内容
     * @return 转换后的字符串
     */
    public static String unescape(String content) {
        return decode(content);
    }

    /**
     * 清除所有HTML标签，但是不删除标签内的内容
     *
     * @param content 文本
     * @return 清除标签后的文本
     */
    public static String clean(String content) {
        return new HTMLFilter().filter(content);
    }

    /**
     * Escape编码
     *
     * @param text 被编码的文本
     * @return 编码后的字符
     */
    private static String encode(String text) {
        if (ServerStringUtils.isEmpty(text)) {
            return ServerStringUtils.EMPTY;
        }

        final StringBuilder tmp = new StringBuilder(text.length() * 6);
        char c;
        for (int i = 0; i < text.length(); i++) {
            c = text.charAt(i);
            if (c < 256) {
                tmp.append("%");
                if (c < 16) {
                    tmp.append("0");
                }
                tmp.append(Integer.toString(c, 16));
            } else {
                tmp.append("%u");
                if (c <= 0xfff) {
                    // issue#I49JU8@Gitee
                    tmp.append("0");
                }
                tmp.append(Integer.toString(c, 16));
            }
        }
        return tmp.toString();
    }

    /**
     * Escape解码
     *
     * @param content 被转义的内容
     * @return 解码后的字符串
     */
    public static String decode(String content) {
        if (ServerStringUtils.isEmpty(content)) {
            return content;
        }

        StringBuilder tmp = new StringBuilder(content.length());
        int lastPos = 0, pos = 0;
        char ch;
        while (lastPos < content.length()) {
            pos = content.indexOf("%", lastPos);
            if (pos == lastPos) {
                if (content.charAt(pos + 1) == 'u') {
                    ch = (char) Integer.parseInt(content.substring(pos + 2, pos + 6), 16);
                    tmp.append(ch);
                    lastPos = pos + 6;
                } else {
                    ch = (char) Integer.parseInt(content.substring(pos + 1, pos + 3), 16);
                    tmp.append(ch);
                    lastPos = pos + 3;
                }
            } else {
                if (pos == -1) {
                    tmp.append(content.substring(lastPos));
                    lastPos = content.length();
                } else {
                    tmp.append(content.substring(lastPos, pos));
                    lastPos = pos;
                }
            }
        }
        return tmp.toString();
    }
}

3.5 IpUtils

package com.example.demo.domain.utils;

import java.net.InetAddress;
import java.net.UnknownHostException;

/**
 * 获取IP方法
 */
public class IpUtils {

    public static String getHostIp() {
        try {
            return InetAddress.getLocalHost().getHostAddress();
        } catch (UnknownHostException e) {
        }
        return "127.0.0.1";
    }

    public static String getHostName() {
        try {
            return InetAddress.getLocalHost().getHostName();
        } catch (UnknownHostException e) {
        }
        return "未知";
    }
}

3.6 ServerStringUtils

package com.example.demo.domain.utils;

import java.util.Collection;
import java.util.Map;

/**
 * 字符串工具类
 */
public class ServerStringUtils extends org.apache.commons.lang3.StringUtils {
    /**
     * 空字符串
     */
    private static final String NULLSTR = "";

    /**
     * * 判断一个Collection是否为空， 包含List，Set，Queue
     */
    public static boolean isEmpty(Collection<?> coll) {
        return isNull(coll) || coll.isEmpty();
    }

    /**
     * * 判断一个对象数组是否为空
     */
    public static boolean isEmpty(Object[] objects) {
        return isNull(objects) || (objects.length == 0);
    }

    /**
     * * 判断一个Map是否为空
     */
    public static boolean isEmpty(Map<?, ?> map) {
        return isNull(map) || map.isEmpty();
    }

    /**
     * * 判断一个字符串是否为空串
     */
    public static boolean isEmpty(String str) {
        return isNull(str) || NULLSTR.equals(str.trim());
    }

    /**
     * * 判断一个对象是否为空
     */
    public static boolean isNull(Object object) {
        return object == null;
    }

    /**
     * 截取字符串
     */
    public static String substring(final String str, int start) {
        if (str == null) {
            return NULLSTR;
        }
        if (start < 0) {
            start = str.length() + start;
        }
        if (start < 0) {
            start = 0;
        }
        if (start > str.length()) {
            return NULLSTR;
        }
        return str.substring(start);
    }

    /**
     * 截取字符串
     */
    public static String substring(final String str, int start, int end) {
        if (str == null) {
            return NULLSTR;
        }

        if (end < 0) {
            end = str.length() + end;
        }
        if (start < 0) {
            start = str.length() + start;
        }

        if (end > str.length()) {
            end = str.length();
        }

        if (start > end) {
            return NULLSTR;
        }

        if (start < 0) {
            start = 0;
        }
        if (end < 0) {
            end = 0;
        }
        return str.substring(start, end);
    }

}

3.7 StrFormatter

package com.example.demo.domain.utils;

/**
 * 字符串格式化
 */
public class StrFormatter {
    public static final String EMPTY_JSON = "{}";
    public static final char C_BACKSLASH = '\\';
    public static final char C_DELIM_START = '{';
    public static final char C_DELIM_END = '}';

    /**
     * 格式化字符串<br>
     * 此方法只是简单将占位符 {} 按照顺序替换为参数<br>
     * 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>
     * 例：<br>
     * 通常使用：format("this is {} for {}", "a", "b") -> this is a for b<br>
     * 转义{}： format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>
     * 转义\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>
     *
     * @param strPattern 字符串模板
     * @param argArray   参数列表
     * @return 结果
     */
    public static String format(final String strPattern, final Object... argArray) {
        if (ServerStringUtils.isEmpty(strPattern) || ServerStringUtils.isEmpty(argArray)) {
            return strPattern;
        }
        final int strPatternLength = strPattern.length();

        // 初始化定义好的长度以获得更好的性能
        StringBuilder sbuf = new StringBuilder(strPatternLength + 50);

        int handledPosition = 0;
        int delimIndex;// 占位符所在位置
        for (int argIndex = 0; argIndex < argArray.length; argIndex++) {
            delimIndex = strPattern.indexOf(EMPTY_JSON, handledPosition);
            if (delimIndex == -1) {
                if (handledPosition == 0) {
                    return strPattern;
                } else { // 字符串模板剩余部分不再包含占位符，加入剩余部分后返回结果
                    sbuf.append(strPattern, handledPosition, strPatternLength);
                    return sbuf.toString();
                }
            } else {
                if (delimIndex > 0 && strPattern.charAt(delimIndex - 1) == C_BACKSLASH) {
                    if (delimIndex > 1 && strPattern.charAt(delimIndex - 2) == C_BACKSLASH) {
                        // 转义符之前还有一个转义符，占位符依旧有效
                        sbuf.append(strPattern, handledPosition, delimIndex - 1);
                        sbuf.append(Convert.utf8Str(argArray[argIndex]));
                        handledPosition = delimIndex + 2;
                    } else {
                        // 占位符被转义
                        argIndex--;
                        sbuf.append(strPattern, handledPosition, delimIndex - 1);
                        sbuf.append(C_DELIM_START);
                        handledPosition = delimIndex + 1;
                    }
                } else {
                    // 正常占位符
                    sbuf.append(strPattern, handledPosition, delimIndex);
                    sbuf.append(Convert.utf8Str(argArray[argIndex]));
                    handledPosition = delimIndex + 2;
                }
            }
        }
        // 加入最后一个占位符后所有的字符
        sbuf.append(strPattern, handledPosition, strPattern.length());

        return sbuf.toString();
    }
}

4.最后的实现类ServerInfo

package com.example.demo.domain;




import com.example.demo.domain.model.*;
import com.example.demo.domain.utils.Arith;
import com.example.demo.domain.utils.IpUtils;
import oshi.SystemInfo;
import oshi.hardware.CentralProcessor;
import oshi.hardware.GlobalMemory;
import oshi.hardware.HardwareAbstractionLayer;
import oshi.software.os.FileSystem;
import oshi.software.os.OSFileStore;
import oshi.software.os.OperatingSystem;
import oshi.util.Util;

import java.net.UnknownHostException;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.Properties;

/**
 * 服务器相关信息
 */
public class ServerInfo {
    private static final int OSHI_WAIT_SECOND = 1000;

    /**
     * CPU相关信息
     */
    private Cpu cpu = new Cpu();

    /**
     * 內存相关信息
     */
    private Mem mem = new Mem();

    /**
     * JVM相关信息
     */
    private Jvm jvm = new Jvm();

    /**
     * 服务器相关信息
     */
    private Sys sys = new Sys();

    /**
     * 磁盘相关信息
     */
    private List<SysFile> sysFiles = new LinkedList<SysFile>();

    public Cpu getCpu() {
        return cpu;
    }

    public void setCpu(Cpu cpu) {
        this.cpu = cpu;
    }

    public Mem getMem() {
        return mem;
    }

    public void setMem(Mem mem) {
        this.mem = mem;
    }

    public Jvm getJvm() {
        return jvm;
    }

    public void setJvm(Jvm jvm) {
        this.jvm = jvm;
    }

    public Sys getSys() {
        return sys;
    }

    public void setSys(Sys sys) {
        this.sys = sys;
    }

    public List<SysFile> getSysFiles() {
        return sysFiles;
    }

    public void setSysFiles(List<SysFile> sysFiles) {
        this.sysFiles = sysFiles;
    }

    public void copyInfo() throws Exception {
        SystemInfo si = new SystemInfo();
        HardwareAbstractionLayer hal =si.getHardware() ;
        OperatingSystem os=si.getOperatingSystem();
        setCpuInfo(hal.getProcessor());
        setMemInfo(hal.getMemory());
        setSysInfo();
        setJvmInfo();
        setSysFiles(si.getOperatingSystem());
    }
    /**
     * 设置CPU信息
     */
    private void setCpuInfo(CentralProcessor processor) {
        // CPU信息
        long[] prevTicks = processor.getSystemCpuLoadTicks();
        Util.sleep(OSHI_WAIT_SECOND);
        long[] ticks = processor.getSystemCpuLoadTicks();
        long nice = ticks[CentralProcessor.TickType.NICE.getIndex()] - prevTicks[CentralProcessor.TickType.NICE.getIndex()];
        long irq = ticks[CentralProcessor.TickType.IRQ.getIndex()] - prevTicks[CentralProcessor.TickType.IRQ.getIndex()];
        long softirq = ticks[CentralProcessor.TickType.SOFTIRQ.getIndex()] - prevTicks[CentralProcessor.TickType.SOFTIRQ.getIndex()];
        long steal = ticks[CentralProcessor.TickType.STEAL.getIndex()] - prevTicks[CentralProcessor.TickType.STEAL.getIndex()];
        long cSys = ticks[CentralProcessor.TickType.SYSTEM.getIndex()] - prevTicks[CentralProcessor.TickType.SYSTEM.getIndex()];
        long user = ticks[CentralProcessor.TickType.USER.getIndex()] - prevTicks[CentralProcessor.TickType.USER.getIndex()];
        long iowait = ticks[CentralProcessor.TickType.IOWAIT.getIndex()] - prevTicks[CentralProcessor.TickType.IOWAIT.getIndex()];
        long idle = ticks[CentralProcessor.TickType.IDLE.getIndex()] - prevTicks[CentralProcessor.TickType.IDLE.getIndex()];
        long totalCpu = user + nice + cSys + idle + iowait + irq + softirq + steal;
        cpu.setCpuNum(processor.getLogicalProcessorCount());
        cpu.setTotal(totalCpu);
        cpu.setSys(cSys);
        cpu.setUsed(user);
        cpu.setWait(iowait);
        cpu.setFree(idle);
    }

    /**
     * 设置内存信息
     */
    private void setMemInfo(GlobalMemory memory) {
        mem.setTotal(memory.getTotal());
        mem.setUsed(memory.getTotal() - memory.getAvailable());
        mem.setFree(memory.getAvailable());
    }

    /**
     * 设置服务器信息
     */
    private void setSysInfo() {
        Properties props = System.getProperties();
        sys.setComputerName(IpUtils.getHostName());
        sys.setComputerIp(IpUtils.getHostIp());
        sys.setOsName(props.getProperty("os.name"));
        sys.setOsArch(props.getProperty("os.arch"));
        sys.setUserDir(props.getProperty("user.dir"));
    }

    /**
     * 设置Java虚拟机
     */
    private void setJvmInfo() throws UnknownHostException {
        Properties props = System.getProperties();
        jvm.setTotal(Runtime.getRuntime().totalMemory());
        jvm.setMax(Runtime.getRuntime().maxMemory());
        jvm.setFree(Runtime.getRuntime().freeMemory());
        jvm.setVersion(props.getProperty("java.version"));
        jvm.setHome(props.getProperty("java.home"));
    }

    /**
     * 设置磁盘信息
     */
    private void setSysFiles(OperatingSystem os) {
        FileSystem fileSystem = os.getFileSystem();
        List<OSFileStore> fsArray = Arrays.asList(fileSystem.getFileStores());
        for (OSFileStore fs : fsArray) {
            long free = fs.getUsableSpace();
            long total = fs.getTotalSpace();
            long used = total - free;
            SysFile sysFile = new SysFile();
            sysFile.setDirName(fs.getMount());
            sysFile.setSysTypeName(fs.getType());
            sysFile.setTypeName(fs.getName());
            sysFile.setTotal(convertFileSize(total));
            sysFile.setFree(convertFileSize(free));
            sysFile.setUsed(convertFileSize(used));
            sysFile.setUsage(Arith.mul(Arith.div(used, total, 4), 100));
            sysFiles.add(sysFile);
        }
    }

    /**
     * 字节转换
     *
     * @param size 字节大小
     * @return 转换后值
     */
    public String convertFileSize(long size) {
        long kb = 1024;
        long mb = kb * 1024;
        long gb = mb * 1024;
        if (size >= gb) {
            return String.format("%.1f GB", (float) size / gb);
        } else if (size >= mb) {
            float f = (float) size / mb;
            return String.format(f > 100 ? "%.0f MB" : "%.1f MB", f);
        } else if (size >= kb) {
            float f = (float) size / kb;
            return String.format(f > 100 ? "%.0f KB" : "%.1f KB", f);
        } else {
            return String.format("%d B", size);
        }
    }
}

最后在controller里面调用ServerInfo

@PostMapping("bb")
    public ServerInfo bb() throws Exception {
        ServerInfo info = new ServerInfo();
        info.copyInfo();
        return  (info);
    }

大功告成

前端页面设计好后，展示的结果就是这样的

乌斯托傲恩日月

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫