Springboot如何使用OSHI獲取和操作系統(tǒng)和硬件信息

更新時間：2023年10月25日 16:11:18 作者：旺仔001

這篇文章主要介紹了Springboot如何使用OSHI獲取和操作系統(tǒng)和硬件信息問題,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教

1、OSHI的簡介

OSHI（Operating System and Hardware Information）是一個開源的Java庫，用于獲取和操作操作系統(tǒng)和硬件信息。

它提供了一組簡單易用的API，可以用于檢索和監(jiān)控諸如操作系統(tǒng)類型、處理器信息、內(nèi)存使用情況、硬盤信息、網(wǎng)絡接口等系統(tǒng)和硬件相關的數(shù)據(jù)。

OSHI的主要功能包括：

獲取操作系統(tǒng)信息：可以獲取操作系統(tǒng)的名稱、版本、構建信息、位數(shù)等。還可以獲取操作系統(tǒng)的啟動時間、系統(tǒng)負載、當前進程數(shù)等信息。
獲取硬件信息：可以獲取處理器（CPU）的信息，包括型號、頻率、核心數(shù)、溫度等。還可以獲取內(nèi)存（RAM）的信息，包括總容量、可用容量、使用率等。此外，還可以獲取硬盤（磁盤）的信息，包括型號、容量、使用率等。還可以獲取電池、網(wǎng)卡、USB設備等硬件的信息。
獲取網(wǎng)絡信息：可以獲取網(wǎng)絡接口（網(wǎng)卡）的信息，包括名稱、IP地址、MAC地址、接收和發(fā)送的數(shù)據(jù)量等。
監(jiān)控系統(tǒng)和硬件：可以通過OSHI提供的API實時監(jiān)控和收集系統(tǒng)和硬件的數(shù)據(jù)，例如CPU使用率、內(nèi)存使用情況、網(wǎng)絡流量等。

使用OSHI非常簡單，只需將OSHI庫添加到你的Java項目的依賴項中，并使用OSHI提供的API來獲取所需的系統(tǒng)和硬件信息。

你可以根據(jù)需要選擇性地獲取和處理各種信息。

總的來說，OSHI是一個強大而易于使用的Java庫，可用于獲取和監(jiān)控操作系統(tǒng)和硬件信息，幫助你編寫更具交互性和功能性的系統(tǒng)監(jiān)控、硬件信息獲取和性能調(diào)優(yōu)的應用程序。

2、OSHI的使用

2.1 引入依賴

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

2.2 定義參數(shù)模型

我們主要關注服務器的CPU、內(nèi)存、以及所掛在的存儲盤的空間容量使用情況等信息，具體模型如下：

2.2.1 CPU

public class Cpu
{
    /**
     * 核心數(shù)
     */
    private int cpuNum;

    /**
     * CPU總的使用率
     */
    private double total;

    /**
     * CPU系統(tǒng)使用率
     */
    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 內(nèi)存

public class Mem
{
    /**
     * 內(nèi)存總量
     */
    private double total;

    /**
     * 已用內(nèi)存
     */
    private double used;

    /**
     * 剩余內(nèi)存
     */
    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;

    /**
     * 已經(jīng)使用量
     */
    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 具體實現(xiàn)

public class Server
{
    private static final int OSHI_WAIT_SECOND = 1000;
    
    /**
     * CPU相關信息
     */
    private Cpu cpu = new Cpu();

    /**
     * 內(nèi)存相關信息
     */
    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);
    }

    /**
     * 設置內(nèi)存信息
     */
    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);
            }

        }
    }
    /**
     * 字節(jié)轉換
     * 
     * @param size 字節(jié)大小
     * @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);
        }
    }
}