增加获取系统信息相关实用类，及相关依赖

liurunyu

2024-08-03 3e4fb6b20cdb85b1bf290a88f68a4646915da78d

增加获取系统信息相关实用类，及相关依赖

 pms-parent/pms-common/pom.xml

@@ -201,6 +201,23 @@
            <version>${google.zxing.version}</version>
        </dependency>

        <!-- 获得系统信息 -->
        <dependency>
            <groupId>com.github.oshi</groupId>
            <artifactId>oshi-core</artifactId>
            <version>${com.github.oshi-core.version}</version>
        </dependency>
        <dependency>
            <groupId>net.java.dev.jna</groupId>
            <artifactId>jna</artifactId>
            <version>${net.java.dev.jna.version}</version>
        </dependency>
        <dependency>
            <groupId>net.java.dev.jna</groupId>
            <artifactId>jna-platform</artifactId>
            <version>${net.java.dev.jna.version}</version>
        </dependency>

        <!-- Hutool是一个小而全的Java工具类库(https://github.com/dromara/hutool)  -->
        <dependency>
            <groupId>cn.hutool</groupId>

 pms-parent/pms-common/src/main/java/com/dy/common/util/DoubleUtil.java

New file
@@ -0,0 +1,103 @@
package com.dy.common.util;

import java.math.BigDecimal;
import java.math.RoundingMode;

/**
 * @Author: liurunyu
 * @Date: 2024/8/2 13:58
 * @Description 精准的double计算
 */
public class DoubleUtil {
    /** 默认除法运算精度 */
    private static final int DEF_DIV_SCALE = 10;

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

    /**
     * 提供精确的加法运算。
     * @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();
    }
}

 pms-parent/pms-common/src/main/java/com/dy/common/util/IPUtils.java

New file
@@ -0,0 +1,341 @@
package com.dy.common.util;

import jakarta.servlet.http.HttpServletRequest;

import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.UnknownHostException;
import java.util.Enumeration;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 获取IP方法
 * 
 * @author liurunyu
 */
public class IPUtils {

    /**
     * 检查IP是否合法
     *
     * @param ip
     * @return
     */
    public static boolean ipValid(String ip) {
        String regex0 = "(2[0-4]\\d)" + "|(25[0-5])";
        String regex1 = "1\\d{2}";
        String regex2 = "[1-9]\\d";
        String regex3 = "\\d";
        String regex = "(" + regex0 + ")|(" + regex1 + ")|(" + regex2 + ")|(" + regex3 + ")";
        regex = "(" + regex + ").(" + regex + ").(" + regex + ").(" + regex + ")";
        Pattern p = Pattern.compile(regex);
        Matcher m = p.matcher(ip);
        return m.matches();
    }

    /**
     * 获取本地ip 适合windows与linux
     *
     * @return
     */
    public static String getLocalIP() {
        String localIP = "127.0.0.1";
        try {
            Enumeration netInterfaces = NetworkInterface.getNetworkInterfaces();
            while (netInterfaces.hasMoreElements()) {
                NetworkInterface ni = (NetworkInterface) netInterfaces.nextElement();
                InetAddress ip = ni.getInetAddresses().nextElement();
                if (!ip.isLoopbackAddress() && ip.getHostAddress().indexOf(":") == -1) {
                    localIP = ip.getHostAddress();
                    break;
                }
            }
        } catch (Exception e) {
            try {
                localIP = InetAddress.getLocalHost().getHostAddress();
            } catch (UnknownHostException e1) {
                e1.printStackTrace();
            }
        }
        return localIP;
    }
    /**
     * 获取客户端IP
     * 
     * @param request 请求对象
     * @return IP地址
     */
    public static String getClientIp(HttpServletRequest request)
    {
        if (request == null)
        {
            return "unknown";
        }
        String ip = request.getHeader("x-forwarded-for");
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip))
        {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip))
        {
            ip = request.getHeader("X-Forwarded-For");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip))
        {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip))
        {
            ip = request.getHeader("X-Real-IP");
        }

        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip))
        {
            ip = request.getRemoteAddr();
        }

        return "0:0:0:0:0:0:0:1".equals(ip) ? "127.0.0.1" : getMultistageReverseProxyIp(ip);
    }

    /**
     * 检查是否为内部IP地址
     * 
     * @param ip IP地址
     * @return 结果
     */
    public static boolean internalIp(String ip)
    {
        byte[] addr = textToNumericFormatV4(ip);
        return internalIp(addr) || "127.0.0.1".equals(ip);
    }

    /**
     * 检查是否为内部IP地址
     * 
     * @param addr byte地址
     * @return 结果
     */
    private static boolean internalIp(byte[] addr)
    {
        if (addr == null || addr.length < 2)
        {
            return true;
        }
        final byte b0 = addr[0];
        final byte b1 = addr[1];
        // 10.x.x.x/8
        final byte SECTION_1 = 0x0A;
        // 172.16.x.x/12
        final byte SECTION_2 = (byte) 0xAC;
        final byte SECTION_3 = (byte) 0x10;
        final byte SECTION_4 = (byte) 0x1F;
        // 192.168.x.x/16
        final byte SECTION_5 = (byte) 0xC0;
        final byte SECTION_6 = (byte) 0xA8;
        switch (b0)
        {
            case SECTION_1:
                return true;
            case SECTION_2:
                if (b1 >= SECTION_3 && b1 <= SECTION_4)
                {
                    return true;
                }
            case SECTION_5:
                switch (b1)
                {
                    case SECTION_6:
                        return true;
                }
            default:
                return false;
        }
    }
    /**
     * 把ip转化为整数
     *
     * @param ip
     * @return
     */
    public static long translateIP2Int(String ip) {
        String[] intArr = ip.split("\\.");
        int[] ipInt = new int[intArr.length];
        for (int i = 0; i < intArr.length; i++) {
            ipInt[i] = Integer.parseInt(intArr[i]) ;
        }
        return ipInt[0] * 256 * 256 * 256 + +ipInt[1] * 256 * 256 + ipInt[2] * 256 + ipInt[3];
    }
    /**
     * 将IPv4地址转换成字节
     * 
     * @param text IPv4地址
     * @return byte 字节
     */
    public static byte[] textToNumericFormatV4(String text)
    {
        if (text.length() == 0)
        {
            return null;
        }

        byte[] bytes = new byte[4];
        String[] elements = text.split("\\.", -1);
        try
        {
            long l;
            int i;
            switch (elements.length)
            {
                case 1:
                    l = Long.parseLong(elements[0]);
                    if ((l < 0L) || (l > 4294967295L))
                    {
                        return null;
                    }
                    bytes[0] = (byte) (int) (l >> 24 & 0xFF);
                    bytes[1] = (byte) (int) ((l & 0xFFFFFF) >> 16 & 0xFF);
                    bytes[2] = (byte) (int) ((l & 0xFFFF) >> 8 & 0xFF);
                    bytes[3] = (byte) (int) (l & 0xFF);
                    break;
                case 2:
                    l = Integer.parseInt(elements[0]);
                    if ((l < 0L) || (l > 255L))
                    {
                        return null;
                    }
                    bytes[0] = (byte) (int) (l & 0xFF);
                    l = Integer.parseInt(elements[1]);
                    if ((l < 0L) || (l > 16777215L))
                    {
                        return null;
                    }
                    bytes[1] = (byte) (int) (l >> 16 & 0xFF);
                    bytes[2] = (byte) (int) ((l & 0xFFFF) >> 8 & 0xFF);
                    bytes[3] = (byte) (int) (l & 0xFF);
                    break;
                case 3:
                    for (i = 0; i < 2; ++i)
                    {
                        l = Integer.parseInt(elements[i]);
                        if ((l < 0L) || (l > 255L))
                        {
                            return null;
                        }
                        bytes[i] = (byte) (int) (l & 0xFF);
                    }
                    l = Integer.parseInt(elements[2]);
                    if ((l < 0L) || (l > 65535L))
                    {
                        return null;
                    }
                    bytes[2] = (byte) (int) (l >> 8 & 0xFF);
                    bytes[3] = (byte) (int) (l & 0xFF);
                    break;
                case 4:
                    for (i = 0; i < 4; ++i)
                    {
                        l = Integer.parseInt(elements[i]);
                        if ((l < 0L) || (l > 255L))
                        {
                            return null;
                        }
                        bytes[i] = (byte) (int) (l & 0xFF);
                    }
                    break;
                default:
                    return null;
            }
        }
        catch (NumberFormatException e)
        {
            return null;
        }
        return bytes;
    }

    /**
     * 获取IP地址
     * 
     * @return 本地IP地址
     */
    public static String getHostIp()
    {
        try
        {
            return InetAddress.getLocalHost().getHostAddress();
        }
        catch (UnknownHostException e)
        {
        }
        return "127.0.0.1";
    }

    /**
     * 获取主机名
     * 
     * @return 本地主机名
     */
    public static String getHostName()
    {
        try
        {
            return InetAddress.getLocalHost().getHostName();
        }
        catch (UnknownHostException e)
        {
        }
        return "未知";
    }

    /**
     * 从多级反向代理中获得第一个非unknown IP地址
     *
     * @param ip 获得的IP地址
     * @return 第一个非unknown IP地址
     */
    public static String getMultistageReverseProxyIp(String ip)
    {
        // 多级反向代理检测
        if (ip != null && ip.indexOf(",") > 0)
        {
            final String[] ips = ip.trim().split(",");
            for (String subIp : ips)
            {
                if (false == isUnknown(subIp))
                {
                    ip = subIp;
                    break;
                }
            }
        }
        return ip;
    }

    /**
     * 检测给定字符串是否为未知，多用于检测HTTP请求相关
     *
     * @param checkString 被检测的字符串
     * @return 是否未知
     */
    public static boolean isUnknown(String checkString)
    {
        return isBlank(checkString) || "unknown".equalsIgnoreCase(checkString);
    }

    private static boolean isBlank(final CharSequence cs) {
        final int strLen = length(cs);
        if (strLen == 0) {
            return true;
        }
        for (int i = 0; i < strLen; i++) {
            if (!Character.isWhitespace(cs.charAt(i))) {
                return false;
            }
        }
        return true;
    }
    public static int length(final CharSequence cs) {
        return cs == null ? 0 : cs.length();
    }
}

 pms-parent/pms-common/src/main/java/com/dy/common/util/SysCpuUtil.java

New file
@@ -0,0 +1,110 @@
package com.dy.common.util;

import lombok.Data;
import oshi.hardware.CentralProcessor;
import oshi.util.Util;

/**
 * @Author: liurunyu
 * @Date: 2024/8/2 11:17
 * @Description
 */
public class SysCpuUtil {

    private static final int OSHI_WAIT_SECOND = 1000;
    /**
     * 得到CPU信息
     */
    public static CpuInfoVo info(CentralProcessor processor){
        /**
         * 获取系统范围内的CPU负载计数器。返回一个包含八个元素的数组，表示在用户（0）、尼斯（1）、系统（2）、空闲（3）、
         * IOwait（4）、硬件中断（IRQ）（5）、软件中断/DPC（SoftIRQ））（6）或窃取（7）状态下花费的毫秒数。使用
         * {@link-shi.hardware.TickType#getIndex（）}检索相应的索引。通过测量一个时间间
         * 隔内滴答声之间的差异，可以计算出该时间间隔内的CPU负载。
         * 在某些逻辑处理器数量可变的操作系统上，此阵列的大小可能会发生变化，并且可能与其他每处理器方法不一致。
         * 请注意，虽然滴答计数器以毫秒为单位，但它们可能会随着（依赖于平台的）时钟滴答声以更大的增量前进。例如，默认
         * 情况下，Windows时钟节拍为1/64秒（约15或16毫秒），Linux时钟节拍取决于分布和配置，但通常为1/100秒（10
         * 毫秒）。
         * Windows上没有Nice和IOWait信息，macOS上没有IOWait和IRQ信息，因此这些标记将始终为零。
         * 要使用此方法计算总空闲时间，请同时包括Idle和IOWait标记。同样，应将IRQ、SoftIRQ和Steal标记添加到系统值
         * 中以获得总和。系统计时还包括执行其他虚拟主机（窃取）的时间。
         * *
         * @return一个由8个长值组成的数组，表示在User、Nice、System、Idle、IOwait、IRQ、SoftIRQ和Steal状态下花费的时间。
         */
        long[] prevTicks = processor.getSystemCpuLoadTicks();
        Util.sleep(OSHI_WAIT_SECOND);
        long[] ticks = processor.getSystemCpuLoadTicks();
        long nice = ticks[1] - prevTicks[1];
        long irq = ticks[5] - prevTicks[5];
        long softIrq = ticks[6] - prevTicks[6];
        long steal = ticks[7] - prevTicks[7];
        long cSys = ticks[2] - prevTicks[2];
        long user = ticks[0] - prevTicks[0];
        long ioWait = ticks[4] - prevTicks[4];
        long idle = ticks[3] - prevTicks[3];

        /*
        long nice = ticks[TickType.NICE.getIndex()] - prevTicks[TickType.NICE.getIndex()];
        long irq = ticks[TickType.IRQ.getIndex()] - prevTicks[TickType.IRQ.getIndex()];
        long softIrq = ticks[TickType.SOFTIRQ.getIndex()] - prevTicks[TickType.SOFTIRQ.getIndex()];
        long steal = ticks[TickType.STEAL.getIndex()] - prevTicks[TickType.STEAL.getIndex()];
        long cSys = ticks[TickType.SYSTEM.getIndex()] - prevTicks[TickType.SYSTEM.getIndex()];
        long user = ticks[TickType.USER.getIndex()] - prevTicks[TickType.USER.getIndex()];
        long ioWait = ticks[TickType.IOWAIT.getIndex()] - prevTicks[TickType.IOWAIT.getIndex()];
        long idle = ticks[TickType.IDLE.getIndex()] - prevTicks[TickType.IDLE.getIndex()];
        */

        long totalCpu = user + nice + cSys + idle + ioWait + irq + softIrq + steal;

        CpuInfoVo vo = new CpuInfoVo() ;
        vo.cores = processor.getLogicalProcessorCount() ;
        vo.totalRate = totalCpu ;
        vo.sysRate = cSys ;
        vo.userRate = user ;
        vo.waitRate = ioWait ;
        vo.freeRate = idle ;
        return vo ;
    }

    @Data
    public static class CpuInfoVo{
        /**
         * 核心数
         */
        public int cores;
        /**
         * CPU总的使用率
         */
        public double totalRate;
        /**
         * CPU系统使用率
         */
        public double sysRate;
        /**
         * CPU用户使用率
         */
        public double userRate;
        /**
         * CPU当前等待率
         */
        public double waitRate;
        /**
         * CPU当前空闲率
         */
        public double freeRate;

        public String toString(){
            StringBuilder sb = new StringBuilder() ;
            sb.append("   CPU信息：\n");
            sb.append("      核心数：" + cores + "\n");
            sb.append("      CPU总的使用率：" + totalRate + "\n");
            sb.append("      CPU系统使用率：" + sysRate + "\n");
            sb.append("      CPU用户使用率：" + userRate + "\n");
            sb.append("      CPU当前等待率：" + waitRate + "\n");
            sb.append("      CPU当前空闲率：" + freeRate + "\n");

            return sb.toString() ;
        }

    }
}

 pms-parent/pms-common/src/main/java/com/dy/common/util/SysFileSysUtil.java

New file
@@ -0,0 +1,113 @@
package com.dy.common.util;

import lombok.Data;
import oshi.software.os.FileSystem;
import oshi.software.os.OSFileStore;
import oshi.software.os.OperatingSystem;

import java.util.LinkedList;
import java.util.List;

/**
 * @Author: liurunyu
 * @Date: 2024/8/2 13:54
 * @Description
 */
public class SysFileSysUtil {
    /**
     * 磁盘信息
     */
    public static LinkedList<SysFile> info(OperatingSystem os)  {
        LinkedList<SysFile> sysFiles = new LinkedList<SysFile>();
        FileSystem fileSystem = os.getFileSystem();
        List<OSFileStore> fsArray = 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(DoubleUtil.mul(DoubleUtil.div(used, total, 4), 100));
            sysFiles.add(sysFile);
        }
        return sysFiles ;
    }

    /**
     * 字节转换
     *
     * @param size 字节大小
     * @return 转换后值
     */
    public static 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);
        }
    }
    @Data
    public static class SysFile{
        /**
         * 盘符路径
         */
        public String dirName;

        /**
         * 盘符类型
         */
        public String sysTypeName;

        /**
         * 文件类型
         */
        public String typeName;

        /**
         * 总大小
         */
        public String total;

        /**
         * 剩余大小
         */
        public String free;

        /**
         * 已经使用量
         */
        public String used;

        /**
         * 资源的使用率
         */
        public double usage;

        public String toString(){
            StringBuilder sb = new StringBuilder() ;
            sb.append("   磁盘" + dirName + "\n");
            sb.append("      盘符类型：" + sysTypeName + "\n");
            sb.append("      文件类型：" + typeName + "\n");
            sb.append("      总大小：" + total + "\n");
            sb.append("      剩余大小：" + free + "\n");
            sb.append("      已经使用量：" + used + "\n");
            sb.append("      资源使用率：" + usage + "\n");

            return sb.toString() ;
        }
    }
}

 pms-parent/pms-common/src/main/java/com/dy/common/util/SysJvmUtil.java

New file
@@ -0,0 +1,78 @@
package com.dy.common.util;

import lombok.Data;

import java.net.UnknownHostException;
import java.text.DecimalFormat;
import java.util.Properties;

/**
 * @Author: liurunyu
 * @Date: 2024/8/2 13:52
 * @Description
 */
public class SysJvmUtil {

    /**
Java虚拟机信息
     */
    public static JvmInfoVo info() throws UnknownHostException {
        JvmInfoVo vo = new JvmInfoVo() ;
        Properties props = System.getProperties();
        vo.setTotal(toMbytes(Runtime.getRuntime().totalMemory()));
        vo.setMax(toMbytes(Runtime.getRuntime().maxMemory()));
        vo.setFree(toMbytes(Runtime.getRuntime().freeMemory()));
        vo.setVersion(props.getProperty("java.version"));
        vo.setHome(props.getProperty("java.home"));
        return vo ;
    }

    private static double toMbytes(double value){
        return value/1000000.0 ;
    }

    @Data
    public static class JvmInfoVo {
        /**
    当前JVM占用的内存总数(M)
         */
        public double total;

        /**
    JVM最大可用内存总数(M)
         */
        public double max;

        /**
    JVM空闲内存(M)
         */
        public double free;

        /**
    JDK版本
         */
        public String version;

        /**
    JDK路径
         */
        public String home;


        public String toString(){
            DecimalFormat df = new DecimalFormat("#.####"); // 设定格式
            StringBuilder sb = new StringBuilder() ;
            sb.append("   JVM信息：\n");
            sb.append("      JVM最大可用内存总数(M)：" + df.format(max) + "\n");
            sb.append("      JVM占用的内存数(M)：" + df.format(total) + "\n");
            sb.append("      JVM空闲内存数(M)：" + df.format(free) + "\n");
            sb.append("      JDK版本：" + version + "\n");
            sb.append("      JDK路径：" + home + "\n");

            return sb.toString() ;
        }
    }



}

 pms-parent/pms-common/src/main/java/com/dy/common/util/SysMemoryUtil.java

New file
@@ -0,0 +1,58 @@
package com.dy.common.util;

import lombok.Data;
import oshi.hardware.GlobalMemory;

import java.text.DecimalFormat;

/**
 * @Author: liurunyu
 * @Date: 2024/8/2 13:42
 * @Description
 */
public class SysMemoryUtil {

    /**
     * 内存信息
     */
    public static MemInfoVo info(GlobalMemory memory) {
        MemInfoVo vo = new MemInfoVo() ;
        vo.setTotal(toGbytes(memory.getTotal()));
        vo.setUsed(toGbytes(memory.getTotal() - memory.getAvailable()));
        vo.setFree(toGbytes(memory.getAvailable()));
        return vo ;
    }

    private static double toGbytes(double value){
        return value/1000000000.0 ;
    }

    @Data
    public static class MemInfoVo {
        /**
         * 内存总量
         */
        public double total;

        /**
         * 已用内存
         */
        public double used;

        /**
         * 剩余内存
         */
        public double free;

        public String toString(){
            DecimalFormat df = new DecimalFormat("#.####"); // 设定格式
            StringBuilder sb = new StringBuilder() ;
            sb.append("   内存信息：\n");
            sb.append("      内存总量(G)：" + df.format(total) + "\n");
            sb.append("      已用内存(G)：" + df.format(used) + "\n");
            sb.append("      剩余内存(G)：" + df.format(free) + "\n");

            return sb.toString() ;
        }
    }
}

 pms-parent/pms-common/src/main/java/com/dy/common/util/SysSysUtil.java

New file
@@ -0,0 +1,68 @@
package com.dy.common.util;

import lombok.Data;

import java.util.Properties;

/**
 * @Author: liurunyu
 * @Date: 2024/8/2 13:46
 * @Description
 */
public class SysSysUtil {

    /**
     * 设置服务器信息
     */
    public static SysInfoVo info() {
        SysInfoVo vo = new SysInfoVo() ;
        Properties props = System.getProperties();
        vo.setComputerName(IPUtils.getHostName());
        vo.setComputerIp(IPUtils.getHostIp());
        vo.setOsName(props.getProperty("os.name"));
        vo.setOsArch(props.getProperty("os.arch"));
        vo.setUserDir(props.getProperty("user.dir"));
        return vo ;
    }


    @Data
    public static class  SysInfoVo{
        /**
         * 服务器名称
         */
        public String computerName;

        /**
         * 服务器Ip
         */
        public String computerIp;

        /**
         * 项目路径
         */
        public String userDir;

        /**
         * 操作系统
         */
        public String osName;

        /**
         * 系统架构
         */
        public String osArch;

        public String toString(){
            StringBuilder sb = new StringBuilder() ;
            sb.append("   系统信息：\n");
            sb.append("      主机名称：" + computerName + "\n");
            sb.append("      主机IP：" + computerIp + "\n");
            sb.append("      项目路径：" + userDir + "\n");
            sb.append("      操作系统：" + osName + "\n");
            sb.append("      系统架构：" + osArch + "\n");

            return sb.toString() ;
        }
    }
}

 pms-parent/pms-common/src/main/java/com/dy/common/util/SysUtil.java

New file
@@ -0,0 +1,63 @@
package com.dy.common.util;

import lombok.Data;
import oshi.SystemInfo;
import oshi.hardware.HardwareAbstractionLayer;

import java.util.LinkedList;

/**
 * @Author: liurunyu
 * @Date: 2024/8/2 15:37
 * @Description
 */
public class SysUtil {

    public static InfoVo info() throws Exception {
        InfoVo vo = new InfoVo() ;
        SystemInfo si = new SystemInfo();
        HardwareAbstractionLayer hal = si.getHardware();

        vo.cpuInfoVo = SysCpuUtil.info(hal.getProcessor());

        vo.memInfoVo = SysMemoryUtil.info(hal.getMemory());

        vo.sysInfoVo = SysSysUtil.info();

        vo.jvmInfoVo = SysJvmUtil.info();

        vo.sysFiles = SysFileSysUtil.info(si.getOperatingSystem());

        return vo ;
    }

    @Data
    public static class InfoVo {
        public SysCpuUtil.CpuInfoVo cpuInfoVo ;
        public SysJvmUtil.JvmInfoVo jvmInfoVo ;
        public SysMemoryUtil.MemInfoVo memInfoVo ;
        public LinkedList<SysFileSysUtil.SysFile> sysFiles ;
        public SysSysUtil.SysInfoVo sysInfoVo ;

        public String toString(){
            StringBuilder sb = new StringBuilder() ;
            sb.append("系统信息：\n");
            sb.append("  " + (cpuInfoVo != null?cpuInfoVo.toString():"") + "\n");
            sb.append("  " + (jvmInfoVo != null?jvmInfoVo.toString():"") + "\n");
            sb.append("  " + (memInfoVo != null?memInfoVo.toString():"") + "\n");
            if(sysFiles != null && sysFiles.size() > 0){
                for(SysFileSysUtil.SysFile f : sysFiles){
                    sb.append("  " + f.toString() + "\n");
                }
            }
            sb.append("  " + (sysInfoVo != null?sysInfoVo.toString():"") + "\n");

            return sb.toString() ;
        }
    }

    public static void main(String[] args) throws Exception{
        InfoVo vo = SysUtil.info() ;
        System.out.println(vo.toString());
    }
}

 pms-parent/pom.xml

@@ -62,6 +62,10 @@
        <!-- google zxing 生成二维码 -->
        <google.zxing.version>3.5.3</google.zxing.version>

        <!-- 获得系统信息 -->
        <com.github.oshi-core.version>6.6.2</com.github.oshi-core.version>
        <net.java.dev.jna.version>5.12.1</net.java.dev.jna.version>

        <spring-boot-maven-plugin.version>3.2.0</spring-boot-maven-plugin.version>
        <maven-jar-plugin-plugin.version>3.3.0</maven-jar-plugin-plugin.version>
        <maven-dependency-plugin.version>3.5.0</maven-dependency-plugin.version>
@@ -319,6 +323,30 @@
                <scope>import</scope>
            </dependency>


            <!-- 获得系统信息 -->
            <dependency>
                <groupId>com.github.oshi</groupId>
                <artifactId>oshi-core</artifactId>
                <version>${com.github.oshi-core.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>net.java.dev.jna</groupId>
                <artifactId>jna</artifactId>
                <version>${net.java.dev.jna.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>net.java.dev.jna</groupId>
                <artifactId>jna-platform</artifactId>
                <version>${net.java.dev.jna.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!-- Hutool是一个小而全的Java工具类库(https://github.com/dromara/hutool)  -->
            <dependency>
                <groupId>cn.hutool</groupId>