springboot-OSHI

最新推荐文章于 2023-04-07 15:19:46 发布
最新推荐文章于 2023-04-07 15:19:46 发布
阅读量1k 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/leexiehui/article/details/107807995
版权

OSHI is a free JNA-based (native) Operating System and Hardware Information library for Java. It does not require the installation of any additional native libraries and aims to provide a cross-platform implementation to retrieve system information, such as OS version, processes, memory and CPU usage, disks and partitions, devices, sensors, etc.

https://github.com/oshi/oshi

springboot添加依赖

1、oshi依赖

 <dependency>
                <groupId>com.github.oshi</groupId>
                <artifactId>oshi-core</artifactId>
                <version>5.2.2</version>
            </dependency>
2020.08.05 最新版本为5.2.2 

springboot版本为2.1.0.RELEASE 

···在springboot2.1.0.RELEASE 中默认JNA的版本是4.5.2，而我用的oshi版本是5.2.2
需要指定最新的

<dependency>
    <groupId>net.java.dev.jna</groupId>
    <artifactId>jna</artifactId>
    <version>5.6.0</version>
</dependency>
<dependency>
    <groupId>net.java.dev.jna</groupId>
    <artifactId>jna-platform</artifactId>
    <version>5.6.0</version>
</dependency>
 

测试代码：

public class ServerCollectController {

	
	protected Logger logger = LoggerFactory.getLogger(ServerCollectController.class);
	 static List<String> oshi = new ArrayList<>();
	    @RequestMapping(value = "/test", method = RequestMethod.GET)
	    @ApiOperation("获取文件系统信息列表")
	    public ServiceResult test() {
	    	oshi.clear();
	    	 SystemInfo si = new SystemInfo();

	         HardwareAbstractionLayer hal = si.getHardware();
	         OperatingSystem os = si.getOperatingSystem();

	         printOperatingSystem(os);

	         logger.info("Checking computer system...");
	         printComputerSystem(hal.getComputerSystem());

	         logger.info("Checking Processor...");
	         printProcessor(hal.getProcessor());

	         logger.info("Checking Memory...");
	         printMemory(hal.getMemory());

	         logger.info("Checking CPU...");
	         printCpu(hal.getProcessor());

	         logger.info("Checking Processes...");
	         printProcesses(os, hal.getMemory());

	         logger.info("Checking Services...");
	         printServices(os);

	         logger.info("Checking Sensors...");
	         printSensors(hal.getSensors());

	         logger.info("Checking Power sources...");
	         printPowerSources(hal.getPowerSources());

	         logger.info("Checking Disks...");
	         printDisks(hal.getDiskStores());

	         logger.info("Checking File System...");
	         printFileSystem(os.getFileSystem());

	         logger.info("Checking Network interfaces...");
	         printNetworkInterfaces(hal.getNetworkIFs());

	         logger.info("Checking Network parameters...");
	         printNetworkParameters(os.getNetworkParams());

	         logger.info("Checking IP statistics...");
	         printInternetProtocolStats(os.getInternetProtocolStats());

	         logger.info("Checking Displays...");
	         printDisplays(hal.getDisplays());

	         logger.info("Checking USB Devices...");
	         printUsbDevices(hal.getUsbDevices(true));

	         logger.info("Checking Sound Cards...");
	         printSoundCards(hal.getSoundCards());

	         logger.info("Checking Graphics Cards...");
	         printGraphicsCards(hal.getGraphicsCards());

	         StringBuilder output = new StringBuilder();
	         for (int i = 0; i < oshi.size(); i++) {
	             output.append(oshi.get(i));
	             if (oshi.get(i) != null && !oshi.get(i).endsWith("\n")) {
	                 output.append('\n');
	             }
	         }
	         logger.info("Printing Operating System and Hardware Info:{}{}", '\n', output);		 
	    	return null;
	 }
	    
	    
	    
	    private static void printOperatingSystem(final OperatingSystem os) {
	        oshi.add(String.valueOf(os));
	        oshi.add("Booted: " + Instant.ofEpochSecond(os.getSystemBootTime()));
	        oshi.add("Uptime: " + FormatUtil.formatElapsedSecs(os.getSystemUptime()));
	        oshi.add("Running with" + (os.isElevated() ? "" : "out") + " elevated permissions.");
	        oshi.add("Sessions:");
	        for (OSSession s : os.getSessions()) {
	            oshi.add(" " + s.toString());
	        }
	    }

	    private static void printComputerSystem(final ComputerSystem computerSystem) {
	        oshi.add("System: " + computerSystem.toString());
	        oshi.add(" Firmware: " + computerSystem.getFirmware().toString());
	        oshi.add(" Baseboard: " + computerSystem.getBaseboard().toString());
	    }

	    private static void printProcessor(CentralProcessor processor) {
	        oshi.add(processor.toString());
	    }

	    private static void printMemory(GlobalMemory memory) {
	        oshi.add("Physical Memory: \n " + memory.toString());
	        VirtualMemory vm = memory.getVirtualMemory();
	        oshi.add("Virtual Memory: \n " + vm.toString());
	        List<PhysicalMemory> pmList = memory.getPhysicalMemory();
	        if (!pmList.isEmpty()) {
	            oshi.add("Physical Memory: ");
	            for (PhysicalMemory pm : pmList) {
	                oshi.add(" " + pm.toString());
	            }
	        }
	    }

	    private static void printCpu(CentralProcessor processor) {
	        oshi.add("Context Switches/Interrupts: " + processor.getContextSwitches() + " / " + processor.getInterrupts());

	        long[] prevTicks = processor.getSystemCpuLoadTicks();
	        long[][] prevProcTicks = processor.getProcessorCpuLoadTicks();
	        oshi.add("CPU, IOWait, and IRQ ticks @ 0 sec:" + Arrays.toString(prevTicks));
	        // Wait a second...
	        Util.sleep(1000);
	        long[] ticks = processor.getSystemCpuLoadTicks();
	        oshi.add("CPU, IOWait, and IRQ ticks @ 1 sec:" + Arrays.toString(ticks));
	        long user = ticks[TickType.USER.getIndex()] - prevTicks[TickType.USER.getIndex()];
	        long nice = ticks[TickType.NICE.getIndex()] - prevTicks[TickType.NICE.getIndex()];
	        long sys = ticks[TickType.SYSTEM.getIndex()] - prevTicks[TickType.SYSTEM.getIndex()];
	        long idle = ticks[TickType.IDLE.getIndex()] - prevTicks[TickType.IDLE.getIndex()];
	        long iowait = ticks[TickType.IOWAIT.getIndex()] - prevTicks[TickType.IOWAIT.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 totalCpu = user + nice + sys + idle + iowait + irq + softirq + steal;

	        oshi.add(String.format(
	                "User: %.1f%% Nice: %.1f%% System: %.1f%% Idle: %.1f%% IOwait: %.1f%% IRQ: %.1f%% SoftIRQ: %.1f%% Steal: %.1f%%",
	                100d * user / totalCpu, 100d * nice / totalCpu, 100d * sys / totalCpu, 100d * idle / totalCpu,
	                100d * iowait / totalCpu, 100d * irq / totalCpu, 100d * softirq / totalCpu, 100d * steal / totalCpu));
	        oshi.add(String.format("CPU load: %.1f%%", processor.getSystemCpuLoadBetweenTicks(prevTicks) * 100));
	        double[] loadAverage = processor.getSystemLoadAverage(3);
	        oshi.add("CPU load averages:" + (loadAverage[0] < 0 ? " N/A" : String.format(" %.2f", loadAverage[0]))
	                + (loadAverage[1] < 0 ? " N/A" : String.format(" %.2f", loadAverage[1]))
	                + (loadAverage[2] < 0 ? " N/A" : String.format(" %.2f", loadAverage[2])));
	        // per core CPU
	        StringBuilder procCpu = new StringBuilder("CPU load per processor:");
	        double[] load = processor.getProcessorCpuLoadBetweenTicks(prevProcTicks);
	        for (double avg : load) {
	            procCpu.append(String.format(" %.1f%%", avg * 100));
	        }
	        oshi.add(procCpu.toString());
	        long freq = processor.getProcessorIdentifier().getVendorFreq();
	        if (freq > 0) {
	            oshi.add("Vendor Frequency: " + FormatUtil.formatHertz(freq));
	        }
	        freq = processor.getMaxFreq();
	        if (freq > 0) {
	            oshi.add("Max Frequency: " + FormatUtil.formatHertz(freq));
	        }
	        long[] freqs = processor.getCurrentFreq();
	        if (freqs[0] > 0) {
	            StringBuilder sb = new StringBuilder("Current Frequencies: ");
	            for (int i = 0; i < freqs.length; i++) {
	                if (i > 0) {
	                    sb.append(", ");
	                }
	                sb.append(FormatUtil.formatHertz(freqs[i]));
	            }
	            oshi.add(sb.toString());
	        }
	    }

	    private static void printProcesses(OperatingSystem os, GlobalMemory memory) {
	        OSProcess myProc = os.getProcess(os.getProcessId());
	        oshi.add(
	                "My PID: " + myProc.getProcessID() + " with affinity " + Long.toBinaryString(myProc.getAffinityMask()));
	        oshi.add("Processes: " + os.getProcessCount() + ", Threads: " + os.getThreadCount());
	        // Sort by highest CPU
	        List<OSProcess> procs = os.getProcesses(5, ProcessSort.CPU);
	        oshi.add("   PID  %CPU %MEM       VSZ       RSS Name");
	        for (int i = 0; i < procs.size() && i < 5; i++) {
	            OSProcess p = procs.get(i);
	            oshi.add(String.format(" %5d %5.1f %4.1f %9s %9s %s", p.getProcessID(),
	                    100d * (p.getKernelTime() + p.getUserTime()) / p.getUpTime(),
	                    100d * p.getResidentSetSize() / memory.getTotal(), FormatUtil.formatBytes(p.getVirtualSize()),
	                    FormatUtil.formatBytes(p.getResidentSetSize()), p.getName()));
	        }
	    }

	    private static void printServices(OperatingSystem os) {
	        oshi.add("Services: ");
	        oshi.add("   PID   State   Name");
	        // DO 5 each of running and stopped
	        int i = 0;
	        for (OSService s : os.getServices()) {
	            if (s.getState().equals(OSService.State.RUNNING) && i++ < 5) {
	                oshi.add(String.format(" %5d  %7s  %s", s.getProcessID(), s.getState(), s.getName()));
	            }
	        }
	        i = 0;
	        for (OSService s : os.getServices()) {
	            if (s.getState().equals(OSService.State.STOPPED) && i++ < 5) {
	                oshi.add(String.format(" %5d  %7s  %s", s.getProcessID(), s.getState(), s.getName()));
	            }
	        }
	    }

	    private static void printSensors(Sensors sensors) {
	        oshi.add("Sensors: " + sensors.toString());
	    }

	    private static void printPowerSources(List<PowerSource> list) {
	        StringBuilder sb = new StringBuilder("Power Sources: ");
	        if (list.isEmpty()) {
	            sb.append("Unknown");
	        }
	        for (PowerSource powerSource : list) {
	            sb.append("\n ").append(powerSource.toString());
	        }
	        oshi.add(sb.toString());
	    }

	    private static void printDisks(List<HWDiskStore> list) {
	        oshi.add("Disks:");
	        for (HWDiskStore disk : list) {
	            oshi.add(" " + disk.toString());

	            List<HWPartition> partitions = disk.getPartitions();
	            for (HWPartition part : partitions) {
	                oshi.add(" |-- " + part.toString());
	            }
	        }

	    }

	    private static void printFileSystem(FileSystem fileSystem) {
	        oshi.add("File System:");

	        oshi.add(String.format(" File Descriptors: %d/%d", fileSystem.getOpenFileDescriptors(),
	                fileSystem.getMaxFileDescriptors()));

	        for (OSFileStore fs : fileSystem.getFileStores()) {
	            long usable = fs.getUsableSpace();
	            long total = fs.getTotalSpace();
	            oshi.add(String.format(
	                    " %s (%s) [%s] %s of %s free (%.1f%%), %s of %s files free (%.1f%%) is %s "
	                            + (fs.getLogicalVolume() != null && fs.getLogicalVolume().length() > 0 ? "[%s]" : "%s")
	                            + " and is mounted at %s",
	                    fs.getName(), fs.getDescription().isEmpty() ? "file system" : fs.getDescription(), fs.getType(),
	                    FormatUtil.formatBytes(usable), FormatUtil.formatBytes(fs.getTotalSpace()), 100d * usable / total,
	                    FormatUtil.formatValue(fs.getFreeInodes(), ""), FormatUtil.formatValue(fs.getTotalInodes(), ""),
	                    100d * fs.getFreeInodes() / fs.getTotalInodes(), fs.getVolume(), fs.getLogicalVolume(),
	                    fs.getMount()));
	        }
	    }

	    private static void printNetworkInterfaces(List<NetworkIF> list) {
	        StringBuilder sb = new StringBuilder("Network Interfaces:");
	        if (list.isEmpty()) {
	            sb.append(" Unknown");
	        } else {
	            for (NetworkIF net : list) {
	                sb.append("\n ").append(net.toString());
	            }
	        }
	        oshi.add(sb.toString());
	    }

	    private static void printNetworkParameters(NetworkParams networkParams) {
	        oshi.add("Network parameters:\n " + networkParams.toString());
	    }

	    private static void printInternetProtocolStats(InternetProtocolStats ip) {
	        oshi.add("Internet Protocol statistics:");
	        oshi.add(" TCPv4: " + ip.getTCPv4Stats());
	        oshi.add(" TCPv6: " + ip.getTCPv6Stats());
	        oshi.add(" UDPv4: " + ip.getUDPv4Stats());
	        oshi.add(" UDPv6: " + ip.getUDPv6Stats());
	    }

	    private static void printDisplays(List<Display> list) {
	        oshi.add("Displays:");
	        int i = 0;
	        for (Display display : list) {
	            oshi.add(" Display " + i + ":");
	            oshi.add(String.valueOf(display));
	            i++;
	        }
	    }

	    private static void printUsbDevices(List<UsbDevice> list) {
	        oshi.add("USB Devices:");
	        for (UsbDevice usbDevice : list) {
	            oshi.add(String.valueOf(usbDevice));
	        }
	    }

	    private static void printSoundCards(List<SoundCard> list) {
	        oshi.add("Sound Cards:");
	        for (SoundCard card : list) {
	            oshi.add(" " + String.valueOf(card));
	        }
	    }

	    private static void printGraphicsCards(List<GraphicsCard> list) {
	        oshi.add("Graphics Cards:");
	        if (list.isEmpty()) {
	            oshi.add(" None detected.");
	        } else {
	            for (GraphicsCard card : list) {
	                oshi.add(" " + String.valueOf(card));
	            }
	        }
	    }
	    

}

 

 

<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.3.10</version>
</dependency> 

对oshi的进一步封装。https://www.hutool.cn/   该版本oshi为5.2.0

 

https://ruoyi.vip/ 开源地址

leexiehui
关注
【项目实战】SpringBoot整合Oshi实现访问计算机硬件和操作系统信息
本本本添哥
04-09 1530
Oshi是一个免费且开源的Java库，提供了一种访问计算机硬件和操作系统信息的方式。它支持多种操作系统，包括Windows、Linux、macOS和Solaris。Java可以通过oshi获取系统和硬件信息本项目主要使用第开源jar包：https://github.com/oshi/oshi。
Springboot使用OSHI获取和操作操作系统和硬件信息
最新发布
haoyunpeng123的博客
07-22 146
OSHI（Operating System and Hardware Information）是一个开源的Java库，用于获取和操作操作系统和硬件信息。它提供了一组简单易用的API，可以用于检索和监控诸如操作系统类型、处理器信息、内存使用情况、硬盘信息、网络接口等系统和硬件相关的数据。OSHI的主要功能包括：获取操作系统信息：可以获取操作系统的名称、版本、构建信息、位数等。还可以获取操作系统的启动时间、系统负载、当前进程数等信息。
SpringBoot进行系统监控（通过OSHI）
nikolas的博客
04-07 2532
SpringBoot通过OSHI进行系统监控
资源监控+springboot + oshi
10-13
基于（OSHI）开发的SpringBoot项目，java获取服务器信息 该项目为 Java监控本机 运行前提是 有Jvm环境，集成了Swagger接口 oshi支持的功能 计算机系统和固件各信息查询； 参考网络git开源代码以及各网址
SpringBoot集成oshi---监控服务器状态（maven依赖显示红色波浪线问题）
reality_fei的专栏
01-13 2603
1、先引入依赖包 <!-- 获取系统信息 --> <dependency> <groupId>com.github.oshi</groupId> <artifactId>oshi-core</artifactId> <version>3.9.1</version> </dependency> <dependency> <groupId>net
springboot OSHI
02-03
<artifactId>oshi-core <version>5.7.4 ``` 然后，你可以在Spring Boot应用程序中使用OSHI提供的API来获取系统信息。例如，你可以使用`SystemInfo`类来获取操作系统信息，使用`HardwareAbstractionLayer`类来...
oshi - 服务器及应用监控库 - 简介与使用
热门推荐
Stephanie17395的博客
05-27 1万+
by @Claudia 文章目录简介特性相关资料运行具体使用源码分析SetCpuInfoSetMemInfoSetSysInfoSetJvmInfoSetSysFilesWhy oshi？竞品分析总结 简介 oshi是Java的免费基于JNA的（本机）操作系统和硬件信息库。它不需要安装任何其他本机库，并且旨在提供一种跨平台的实现来检索系统信息，例如操作系统版本，进程，内存和CPU使用率，磁盘和分区，设备，传感器等。本文主要介绍 SpringBoot 集成 oshi 实现对服务器及应用的监控。 特性 使用o.
springboot使用oshi监控应用系统
zlliuh的博客
11-04 811
引入依赖 <dependency> <groupId>com.github.oshi</groupId> <artifactId>oshi-core</artifactId> <version>3.9.1</version> </dependency> <dependency> .
Spring Boot 使用oshi监控服务器数据
ksaar_的博客
07-11 1104
1,导入依赖 <!--服务器监控包--> <dependency> <groupId>com.github.oshi</groupId> <artifactId>oshi-core</artifactId> <version>3.9.1</version> </dependency> 2,导入文件包 链接：https://pan.baidu.com/s/1TfLP8-m
SpringBoot系统监控，oshi版
weixin_43627706的博客
04-02 1172
文章目录前言1.构建maven2.代码示例3.结果返回(前端展示需要自己开发，oshi只提供数据) 前言 今日访问mybatis-plus 官网偶然看到一个爱组搭广告，出于好奇点进去看了一下 1.构建maven <dependency> <groupId>com.aizuda</groupId> <artifactId>aizuda-monitor</artifactId> <version>1.0.0</v
springboot sigar 监控 服务器_SpringBoot集成oshi实现对服务器及应用的监控
weixin_39966941的博客
11-26 1244
OSHI是Java的免费基于JNA的（本机）操作系统和硬件信息库。它不需要安装任何其他本机库，并且旨在提供一种跨平台的实现来检索系统信息，例如操作系统版本，进程，内存和CPU使用率，磁盘和分区，设备，传感器等。使用OSHI我们可以对应用程序进行监控，可以对应用程序所在的服务器资源进行监控，可以监控到很多的指标，如下：1、计算机系统和固件，底板 2、操作系统和版本/内部版本 3、物理（核心）和逻辑（...
获取系统信息（oshi-core）
qq_40495860的博客
12-11 1747
maven com.github.oshi oshi-core 3.5.0 API 对象 方法 描述 SystemInfo getOperatingSystem() 获取操作系统信息，OperatingSystem getHardware() 获取硬件信息，HardwareAbstractionLayer OperatingSystem getFamily() 获取操作系统名称，例如 Windows getManufacturer() 获取供货商，例如 Microsoft getVersion() 获.
oshi-spring-boot-starter 为服务监控而生
百年孤独的博客
01-09 700
sys-spring-boot-starter UI动态展示系统参数, 基于spring boot，bootstrap4 run as a stand alone app or a dependency of any spring boot based application. run with docker run within docker by execute script below. ...
springboot 基于IDEA排查脏jar
ajax_yan的博客
12-29 477
查看springboot maven相关依赖 IDEA右上角m,执行命令： dependency:tree，控制台打印结果： com.xzff:bigdata-system:jar:2.6 [INFO] +- com.xzff:bigdata-qt:jar:2.4:compile [INFO] | +- com.xzff:bigdata-generator:jar:2.6:compile [INFO] | | +- org.springframework.boot:spring-boot-st.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值