Springboot使用OSHI获取和操作操作系统和硬件信息

一时失言乱红尘 2024-03-17 11:08 60阅读 0赞

## 1、OSHI的简介 ##

[OSHI][]（Operating System and Hardware Information）是一个开源的Java库，用于获取和操作操作系统和硬件信息。它提供了一组简单易用的API，可以用于检索和监控诸如操作系统类型、处理器信息、内存使用情况、硬盘信息、网络接口等系统和硬件相关的数据。

OSHI的主要功能包括：

1.  获取操作系统信息：可以获取操作系统的名称、版本、构建信息、位数等。还可以获取操作系统的启动时间、系统负载、当前进程数等信息。
2.  获取硬件信息：可以获取处理器（CPU）的信息，包括型号、频率、核心数、温度等。还可以获取内存（RAM）的信息，包括总容量、可用容量、使用率等。此外，还可以获取硬盘（磁盘）的信息，包括型号、容量、使用率等。还可以获取电池、网卡、USB设备等硬件的信息。
3.  获取网络信息：可以获取网络接口（网卡）的信息，包括名称、IP地址、MAC地址、接收和发送的数据量等。
4.  监控系统和硬件：可以通过OSHI提供的API实时监控和收集系统和硬件的数据，例如CPU使用率、内存使用情况、网络流量等。

使用OSHI非常简单，只需将OSHI库添加到你的Java项目的依赖项中，并使用OSHI提供的API来获取所需的系统和硬件信息。你可以根据需要选择性地获取和处理各种信息。

总的来说，OSHI是一个强大而易于使用的Java库，可用于获取和监控操作系统和硬件信息，帮助你编写更具交互性和功能性的系统监控、硬件信息获取和性能调优的应用程序。

## 2、OSHI的使用 ##

### 2.1 引入依赖 ###

<dependency>
                    <groupId>com.github.oshi</groupId>
                    <artifactId>oshi-core</artifactId>
                    <version>6.4.0</version>
                </dependency>

### 2.2 定义参数模型 ###

我们主要关注服务器的CPU、内存、以及所挂在的存储盘的空间容量使用情况等信息，具体模型如下：

#### 2.2.1 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.2 内存 ####

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.2.3 硬盘 ####

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;
        }
    }

#### 2.2.4 具体实现 ####

public class Server
    {
        
        private static final int OSHI_WAIT_SECOND = 1000;
        
        /**
         * CPU相关信息
         */
        private Cpu cpu = new Cpu();
    
        /**
         * 內存相关信息
         */
        private Mem mem = new Mem();
    
        /**
         * 磁盘相关信息
         */
        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 List<SysFile> getSysFiles()
        {
        
            return sysFiles;
        }
    
        public void setSysFiles(List<SysFile> sysFiles)
        {
        
            this.sysFiles = sysFiles;
        }
    
        public void copyTo() throws Exception
        {
        
            SystemInfo si = new SystemInfo();
            HardwareAbstractionLayer hal = si.getHardware();
    
            setCpuInfo(hal.getProcessor());
    
            setMemInfo(hal.getMemory());
    
            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[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;
            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 setSysFiles(OperatingSystem os)
        {
        
            FileSystem fileSystem = os.getFileSystem();
            List<OSFileStore> fsArray = fileSystem.getFileStores();
            for (OSFileStore fs : fsArray)
            {
        
                if (fs.getType().equals("ext4") || fs.getType().equals("nfs4")){
        
                    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);
            }
        }
    }

[OSHI]: https://github.com/oshi/oshi