OSHI-操作系统和硬件信息库

本文介绍: 谈到监控，最快捷的还是使用Ja va本身进行对JVM和操作系统的监控，方便快捷又可靠。OSHI（Operati n g Sy ste m and Har d war e In format ion）是Java的免费的基于JNA的（本机）操作系统和硬件信息库。它提供了一组简单易用的API，可以用于检索和监控诸如操作系统类型、处理器信息、内存使用情况、硬盘信息、网络接口等系统和硬件相关的数据。获取操作系统信息：可以获取操作系统的名称、版本、构建信息、位数等。还可以获取操作系统的启动时间、系统负载、当前进程数等信息。

属性	子属性	类型	说明
man ufacture r		Str in g	制造商
model		Str in g	型号
s e r ialNumb e r		Str ing	序列号
Fi r war e			固件信息
	name	Str ing	固件名称
	version	Str ing	固件版本
	des cri b e	Str ing	固件描述
	manufacture r	Str ing	制造商
	releaseDate	Str ing	发行日期
Baseb o ar d			主板信息
	version	String	主板版本
	model	St ring	模型
	serialNumber	String	序列号
	manuf acturer	String	制造商

四、使用 场景

4.1 获取 CPU 信息

想要获取 CPU 信息，就需要CentralPro ce s sor 类（中央处理器）作为参数，oshi库获取CentralPro ce s sor 类步骤为：

首先实例化内置的Sy ste mInf o类，该类用于访问系统和硬件信息。
然后根据此类的内置方法获取硬件抽象层类 Har d wareAb str actionLayer 类，主要用于将硬件抽象化，允许计算机操作系统在逻辑层而不是硬件层与硬件设备交互。
最后根据Har d wareAbstractionLayer类内置方法获取CentralPro ce s sor 类，提供setCpuInf o方法参数

public static Map<String, Object> getCpuInfo() throws InterruptedException {
    HardwareAbstractionLayer hardware = new SystemInfo().getHardware();
    Map<String, Object> cpuInfo = Maps.newHashMap();
    CentralProcessor processor = hardware.getProcessor();
    // 第一次获取：获取系统范围的 CPU 负载滴答计数器：
    long[] prevTicks = processor.getSystemCpuLoadTicks();
    //等待一段时间
    java.lang.Thread.sleep(1000);
    //第二次获取：获取系统范围的 CPU 负载滴答计数器：
    long[] ticks = processor.getSystemCpuLoadTicks();

    long user = ticks[CentralProcessor.TickType.USER.getIndex()] - prevTicks[CentralProcessor.TickType.USER.getIndex()];
    long nice = ticks[CentralProcessor.TickType.NICE.getIndex()] - prevTicks[CentralProcessor.TickType.NICE.getIndex()];
    long cSys = ticks[CentralProcessor.TickType.SYSTEM.getIndex()] - prevTicks[CentralProcessor.TickType.SYSTEM.getIndex()];
    long idle = ticks[CentralProcessor.TickType.IDLE.getIndex()] - prevTicks[CentralProcessor.TickType.IDLE.getIndex()];
    long ioWait = ticks[CentralProcessor.TickType.IOWAIT.getIndex()] - prevTicks[CentralProcessor.TickType.IOWAIT.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 totalCpu = user + nice + cSys + idle + ioWait + irq + softIrq + steal;
    // cpu供应商
    cpuInfo.put("cpuVendor", processor.getProcessorIdentifier().getVendor());
    //  cpu名称
    cpuInfo.put("cpuName", processor.getProcessorIdentifier().getName());
    // CPU核心数
    cpuInfo.put("cpuNum", processor.getLogicalProcessorCount());
    // CPU总的使用率
    cpuInfo.put("totalPercent", totalCpu);
    // CPU用户使用率，表示用户模式下花费的CPU时间
    cpuInfo.put("usedPercent", new DecimalFormat("#.##%").format(user * 1.0 / totalCpu));
    // CPU当前等待率，表示等待I/O操作的进程所花费的CPU时间
    cpuInfo.put("waitPercent", new DecimalFormat("#.##%").format(ioWait * 1.0 / totalCpu));
    // CPU系统使用率，表示系统进程所花费的CPU时间
    cpuInfo.put("sysPercent", new DecimalFormat("#.##%").format(cSys * 1.0 / totalCpu));
    //  CPU当前空闲率，表示空闲进程所花费的CPU时间
    cpuInfo.put("idlePercent", new DecimalFormat("#.##%").format(idle * 1.0 / totalCpu));
    // 表示在nice值为0～99之间的进程所花费的CPU时间
    cpuInfo.put("nicePercent", new DecimalFormat("#.##%").format(nice * 1.0 / totalCpu));
    // 表示处理中断的进程所花费的CPU时间
    cpuInfo.put("irqPercent", new DecimalFormat("#.##%").format(irq * 1.0 / totalCpu));
    // 表示处理软中断的进程所花费的CPU时间
    cpuInfo.put("softIrqPercent", new DecimalFormat("#.##%").format(softIrq * 1.0 / totalCpu));
    // 表示被其他线程“偷走”的CPU时间
    cpuInfo.put("stealPercent", new DecimalFormat("#.##%").format(steal * 1.0 / totalCpu));
    // 物理处理器数量
    cpuInfo.put("physicalProcessorCount", processor.getPhysicalProcessorCount());
    return cpuInfo;
}

4.2 获取内存信息

想要获取内存信息，这就需要硬件抽象层类提供的GlobalMemo ry类作为参数，通过GlobalMemo ry类的内置方法来获取内存信息。

public static Map<String, Object> getMemoryInfo() {
    HardwareAbstractionLayer hardware = new SystemInfo().getHardware();
    GlobalMemory globalMemory = hardware.getMemory();
    Map<String, Object> gmMap = Maps.newHashMap();
    // 总内存
    gmMap.put("total", FormatUtil.formatBytes(globalMemory.getTotal()));
    // 剩余【当前可用的物理内存量】
    gmMap.put("available", FormatUtil.formatBytes(globalMemory.getAvailable()));
    // 已使用
    gmMap.put("used", FormatUtil.formatBytes(globalMemory.getTotal() - globalMemory.getAvailable()));
    // 空闲率
    gmMap.put("freeRate", 100d * (globalMemory.getAvailable()) / globalMemory.getTotal());
    // 使用率
    gmMap.put("usageRate", 100d * (globalMemory.getTotal() - globalMemory.getAvailable()) / globalMemory.getTotal());
    gmMap.put("pageSize", globalMemory.getPageSize());

    VirtualMemory virtualMemory = globalMemory.getVirtualMemory();
    Map<String, Object> vmMap = Maps.newHashMap();
    vmMap.put("toString", virtualMemory);
    vmMap.put("swapTotal", FormatUtil.formatBytes(virtualMemory.getSwapTotal()));
    vmMap.put("swapUsed", FormatUtil.formatBytes(virtualMemory.getSwapUsed()));
    vmMap.put("swapUsageRate", 100d * virtualMemory.getSwapUsed() / virtualMemory.getSwapTotal());
    vmMap.put("virtualMax", FormatUtil.formatBytes(virtualMemory.getVirtualMax()));
    vmMap.put("virtualInUse", FormatUtil.formatBytes(virtualMemory.getVirtualInUse()));
    vmMap.put("virtualUsageRate", 100d * virtualMemory.getVirtualInUse() / virtualMemory.getVirtualMax());
    gmMap.put("virtualMemory", vmMap);

    List<PhysicalMemory> physicalMemoryList = globalMemory.getPhysicalMemory();
    List<Map<String, Object>> pmInfoList = new ArrayList<>(physicalMemoryList.size());
    for (PhysicalMemory pm : physicalMemoryList) {
        Map<String, Object> pmMap = Maps.newHashMap();
        pmMap.put("toString", String.valueOf(pm));
        pmMap.put("bankLabel", pm.getBankLabel());
        pmMap.put("manufacturer", pm.getManufacturer());
        pmMap.put("capacity", FormatUtil.formatBytes(pm.getCapacity()));
        pmMap.put("memoryType", pm.getMemoryType());
        pmMap.put("clockSpeed", FormatUtil.formatHertz(pm.getClockSpeed()));
        pmInfoList.add(pmMap);
    }

    gmMap.put("physicalMemoryList", pmInfoList);
    return gmMap;
}

4.3 获取服务器信息

首先调用Java 内置的System类的 getProperties() 方法，获取当前系统属性集，并作为一个Properties对象返回，并通过对该属性集通过传参查询，得到操作系统名称、系统架构、项目路径等信息。

public static Map<String, Object> getSysInfo() throws UnknownHostException {
    Map<String, Object> sysInfo = Maps.newHashMap();
    Properties props = System.getProperties();
    // 操作系统
    sysInfo.put("osName", props.getProperty("os.name"));
    // 系统架构
    sysInfo.put("osArch", props.getProperty("os.arch"));
    // 服务器名称
    sysInfo.put("computerName", InetAddress.getLocalHost().getHostName());
    // 服务器IP
    sysInfo.put("computerIp", InetAddress.getLocalHost().getHostAddress());
    // 项目路径
    sysInfo.put("userDir", props.getProperty("user.dir"));
    // 操作系统信息
    sysInfo.put("desktop", props.getProperty("sun.desktop"));
    return sysInfo;
}

4.4 获取Java虚拟机信息

首先通过System系统类获取当前系统属性集后，使用Properties对象传参查询的得到JDK版本与路径；通过获得Java内置的RunTime对象（每个Java应用程序都有一个单独的Runtime类实例，它允许应用程序与运行应用程序的环境进行接口。当前运行时可以从getRuntime方法中获得）获取Java虚拟机的总内存量、 Java 虚拟机试图使用的最大内存量、Java虚拟机中的可用内存量。

public static Map<String, Object> getJvmInfo() {
    Map<String, Object> jvmInfo = new ConcurrentHashMap<>();
    Properties props = System.getProperties();
    Runtime runtime = Runtime.getRuntime();
    long jvmTotalMemoryByte = runtime.totalMemory();
    long jvmFreeMemoryByte = runtime.freeMemory();
    long jvmUseMemoryByte = jvmTotalMemoryByte - jvmFreeMemoryByte;
    // jvm总内存
    jvmInfo.put("totalMemory", FormatUtil.formatBytes(jvmTotalMemoryByte));
    // JVM空闲内存
    jvmInfo.put("freeMemory", FormatUtil.formatBytes(jvmFreeMemoryByte));
    // Jvm已使用内存
    jvmInfo.put("usedMemory", FormatUtil.formatBytes(jvmUseMemoryByte));
    // JVM最大可用内存总数
    jvmInfo.put("maxMemory", FormatUtil.formatBytes(runtime.maxMemory()));
    // jvm内存使用率
    jvmInfo.put("useRate", new DecimalFormat("#.##%").format((jvmUseMemoryByte) * 1.0 / jvmTotalMemoryByte));
    // jvm内存空闲率
    jvmInfo.put("freeRate", new DecimalFormat("#.##%").format((jvmFreeMemoryByte) * 1.0 / jvmTotalMemoryByte));
    // Java版本
    jvmInfo.put("jdkVersion", props.getProperty("java.version"));
    // jdk安装目录
    jvmInfo.put("jdkHome", props.getProperty("java.home"));
    // java类包的路径
    props.getProperty("java.class.path");
    //java虚拟机制造商
    props.getProperty("java.vm.vendor");
    // jdk bin目录
    props.getProperty("sun.boot.library.path");
    // java运行环境版本
    props.getProperty("java.runtime.version");
    // 依赖路径
    props.getProperty("java.library.path");
    // java制造商
    props.getProperty("java.vendor");
    // java虚拟机信息
    props.getProperty("java.vm.info");
    // java虚拟机版本
    props.getProperty("java.vm.version");
    // java类版本
    props.getProperty("java.class.version");

    return jvmInfo;
}

4.5 获取系统文件 相关信息

首先通过 SystemInfo类获取当前平台操作系统的新实例，再根据 OperatingSystem.getFileSystem()方法实例化FileSystem对象，再通过 getFileStores() 获取本机上文件存储实例化OSFileStore对象列表，表示存储池、设备、分区、卷、具体的文件系统或其他实现特定的文件存储方法信息，该方法会返回OSFileStore对象列表。最后遍历此集合获取磁盘状态信息。

public static Map<String, Object> getFileSystemInfo() {
    Map<String, Object> fsInfo = new ConcurrentHashMap<>();
    FileSystem fileSystem = new SystemInfo().getOperatingSystem().getFileSystem();
    List<Map<String, Object>> fileSystemInfos = new ArrayList<>();
    // 打开文件描述符
    fsInfo.put("openFileDescriptors", fileSystem.getOpenFileDescriptors());
    // 最大文件描述符
    fsInfo.put("maxFileDescriptors", fileSystem.getMaxFileDescriptors());
    fsInfo.put("fileDescriptors", String.format("%d/%d", fileSystem.getOpenFileDescriptors(), fileSystem.getMaxFileDescriptors()));
    fsInfo.put("fdUsageRate", (100d * fileSystem.getOpenFileDescriptors() / fileSystem.getMaxFileDescriptors()) + "%");

    List<OSFileStore> fileStores = fileSystem.getFileStores();
    for (int i = 0; i < fileStores.size(); i++) {
        Map<String, Object> fileStoreInfo = Maps.newHashMap();
        fileStoreInfo.put("index", i);
        OSFileStore osFileStore = fileStores.get(i);
        // 磁盘名称
        fileStoreInfo.put("name", osFileStore.getName());
        // 文件系统的卷名
        fileStoreInfo.put("volume", osFileStore.getVolume());
        // 标签
        fileStoreInfo.put("label", osFileStore.getLabel());
        // 文件系统的逻辑卷名
        fileStoreInfo.put("logicalVolume", osFileStore.getLogicalVolume());
        // 文件系统的挂载点
        fileStoreInfo.put("mount", osFileStore.getMount());
        // 说明
        fileStoreInfo.put("description", osFileStore.getDescription());
        // 盘符类型
        fileStoreInfo.put("sysTypeName", osFileStore.getType());
        // 文件系统的选项
        fileStoreInfo.put("options", osFileStore.getOptions());
        fileStoreInfo.put("uuid", osFileStore.getUUID());

        fileStoreInfo.put("freeSpace", osFileStore.getFreeSpace());

        // 剩余大小
        fileStoreInfo.put("usableSpace", FormatUtil.formatBytes(osFileStore.getUsableSpace()));
        // 总大小
        fileStoreInfo.put("totalSpace", FormatUtil.formatBytes(osFileStore.getTotalSpace()));

        fileStoreInfo.put("freeInodes", FormatUtil.formatValue(osFileStore.getFreeInodes(), ""));
        fileStoreInfo.put("totalInodes", FormatUtil.formatValue(osFileStore.getTotalInodes(), ""));


        // 已经使用量
        fileStoreInfo.put("usedSpace", FormatUtil.formatBytes(osFileStore.getTotalSpace() - osFileStore.getUsableSpace()));


        // 使用率
        String usageRate = "0";
        if (osFileStore.getTotalSpace() > 0) {
            usageRate = new DecimalFormat("#.##%").format((osFileStore.getTotalSpace() - osFileStore.getUsableSpace()) * 1.0 / osFileStore.getTotalSpace());
        }
        fileStoreInfo.put("usageRate", usageRate);
        fileStoreInfo.put("inodesUsageRate", 100d * osFileStore.getFreeInodes() / osFileStore.getTotalInodes());

        fileSystemInfos.add(fileStoreInfo);
    }
    fsInfo.put("fileStores", fileSystemInfos);
    return fsInfo;
}

4.6 获取磁盘信息

public static List<Map<String, Object>> getDiskStoreInfo() {
    HardwareAbstractionLayer hardware = new SystemInfo().getHardware();
    List<HWDiskStore> diskStores = hardware.getDiskStores();
    List<Map<String, Object>> dsList = new ArrayList<>(diskStores.size());
    for (int i = 0; i < diskStores.size(); i++) {
        HWDiskStore hwDiskStore = diskStores.get(i);
        Map<String, Object> hwDsMap = new ConcurrentHashMap<>();
        hwDsMap.put("index", i);
        // 磁盘名称
        hwDsMap.put("name", hwDiskStore.getName());

        hwDsMap.put("currentQueueLength", hwDiskStore.getCurrentQueueLength());
        // 型号
        hwDsMap.put("model", hwDiskStore.getModel());
        // 序列号
        hwDsMap.put("serial", hwDiskStore.getSerial());
        // 大小
        hwDsMap.put("size", FormatUtil.formatBytes(hwDiskStore.getSize()));
        // 读长
        hwDsMap.put("reads", FormatUtil.formatBytes(hwDiskStore.getReads()));
        // 写长
        hwDsMap.put("writes", FormatUtil.formatBytes(hwDiskStore.getWrites()));
        // 读取字节
        hwDsMap.put("readBytes", hwDiskStore.getReadBytes());
        // 写入字节
        hwDsMap.put("writeBytes", hwDiskStore.getWriteBytes());
        // 转移时间
        hwDsMap.put("transferTime", hwDiskStore.getTransferTime());
        // 时间戳
        hwDsMap.put("timeStamp", hwDiskStore.getTimeStamp());

        List<HWPartition> partitions = hwDiskStore.getPartitions();
        List<Map<String, Object>> partitionList = new ArrayList<>(partitions.size());
        for (HWPartition partition : partitions) {
            Map<String, Object> partitionMap = Maps.newHashMap();
            // 分区大小
            partitionMap.put("size", FormatUtil.formatBytes(partition.getSize()));
            // 分区名称
            partitionMap.put("name", partition.getName());
            // 分区类型
            partitionMap.put("type", partition.getType());
            partitionMap.put("identification", partition.getIdentification());
            partitionMap.put("major", partition.getMajor());
            partitionMap.put("uuid", partition.getUuid());
            partitionMap.put("mountPoint", partition.getMountPoint());
            partitionMap.put("minor", partition.getMinor());
            partitionList.add(partitionMap);
        }
        hwDsMap.put("partitionList", partitionList);
        dsList.add(hwDsMap);
    }
    return dsList;
}