【Java】Oshi 硬件信息读取库
实现的功能：
用于开发服务器监控面板，获取服务器硬件参数
官方Github仓库地址：
https://github.com/oshi/oshi
Maven坐标：
<!-- https://mvnrepository.com/artifact/com.github.oshi/oshi-core -->
<dependency>
<groupId>com.github.oshi</groupId>
<artifactId>oshi-core</artifactId>
<version>6.4.0</version>
</dependency>
官方提供的测试类地址：
https://github.com/oshi/oshi/blob/master/oshi-core/src/test/java/oshi/SystemInfoTest.java
库封装的可查看信息列表：
- 操作系统
- 处理器
- 内存
- 进程
- 系统服务
- 传感器（试了，读不出有效数值...）
- 电池信息（注意是电池，不是电源）
- 磁盘存储
- 逻辑卷组（Windows平台读取不到信息）
- 文件系统
- 网络接口列表
- 网络参数
- IP统计信息
- 显示器列表（没封装属性，只能toString打印获取）
- USB设备列表（树）
- 声卡列表
- 显卡列表
自己封装的工具类：
package cn.cloud9.server.struct.util; import lombok.extern.slf4j.Slf4j;
import oshi.SystemInfo;
import oshi.hardware.*;
import oshi.software.os.*;
import oshi.util.FormatUtil; import java.net.NetworkInterface;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap; /**
* @author OnCloud9
* @description
* @project tt-server
* @date 2022年12月31日 下午 07:32
*/
@Slf4j
public class OperateSystemUtil {
private static final SystemInfo systemInfo = new SystemInfo();
private static final OperatingSystem operatingSystem = systemInfo.getOperatingSystem();
private static final HardwareAbstractionLayer hal = systemInfo.getHardware(); /**
* 读取显示器信息
* @return List<Map<String, Object>>
*/
public static List<Map<String, Object>> getDisplayInfo() {
final List<Display> displays = hal.getDisplays();
final List<Map<String, Object>> displayInfos = new ArrayList<>(displays.size());
for (int i = 0; i < displays.size(); i++) {
Map<String, Object> displayInfo = new ConcurrentHashMap<>();
displayInfo.put("index", String.valueOf(i));
final Display display = displays.get(i);
displayInfo.put("instance", display);
displayInfo.put("toString", String.valueOf(display));
displayInfos.add(displayInfo);
}
return displayInfos;
} /**
* 读取声卡信息
* @return List<Map<String, Object>>
*/
public static List<Map<String, Object>> getSoundCardInfo() {
final List<SoundCard> soundCards = hal.getSoundCards();
final List<Map<String, Object>> soundCardInfos = new ArrayList<>(soundCards.size());
for (int i = 0; i < soundCards.size(); i++) {
Map<String, Object> soundCard = new ConcurrentHashMap<>();
soundCard.put("index", String.valueOf(i));
final SoundCard soundCardInst = soundCards.get(i);
soundCard.put("toString", String.valueOf(soundCardInst));
soundCard.put("codec", soundCardInst.getCodec());
soundCard.put("name", soundCardInst.getName());
soundCard.put("driverVersion", soundCardInst.getDriverVersion());
soundCardInfos.add(soundCard);
}
return soundCardInfos;
} /**
* 读取显卡信息
* @return List<Map<String, Object>>
*/
public static List<Map<String, Object>> getGraphicsCardsInfo() {
final List<GraphicsCard> graphicsCards = hal.getGraphicsCards();
final List<Map<String, Object>> graphicsCardsInfos = new ArrayList<>(graphicsCards.size());
for (int i = 0; i < graphicsCards.size(); i++) {
Map<String, Object> gcInfo = new ConcurrentHashMap<>();
gcInfo.put("index", String.valueOf(i));
final GraphicsCard graphicsCard = graphicsCards.get(i);
gcInfo.put("toString", String.valueOf(graphicsCard));
gcInfo.put("name", graphicsCard.getName());
gcInfo.put("deviceId", graphicsCard.getDeviceId());
gcInfo.put("versionInfo", graphicsCard.getVersionInfo());
gcInfo.put("vendor", graphicsCard.getVendor());
gcInfo.put("vRam", graphicsCard.getVRam());
gcInfo.put("vRamFormat", FormatUtil.formatBytes(graphicsCard.getVRam()));
graphicsCardsInfos.add(gcInfo);
}
return graphicsCardsInfos;
} /**
* usb设备信息
* @return List<Map<String, Object>>
*/
public static List<Map<String, Object>> getUsbDevicesInfo() {
final List<UsbDevice> usbDevices = hal.getUsbDevices(true);
final List<Map<String, Object>> usbDevicesInfos = new ArrayList<>(usbDevices.size());
for (int i = 0; i < usbDevices.size(); i++) {
Map<String, Object> usbDeviceInfo = new ConcurrentHashMap<>();
usbDeviceInfo.put("index", String.valueOf(i));
final UsbDevice usbDevice = usbDevices.get(i);
usbDeviceInfo.put("toString", String.valueOf(usbDevice));
usbDeviceInfo.put("name", usbDevice.getName());
usbDeviceInfo.put("uniqueDeviceId", usbDevice.getUniqueDeviceId());
usbDeviceInfo.put("vendor", usbDevice.getVendor());
usbDeviceInfo.put("productId", usbDevice.getProductId());
usbDeviceInfo.put("serialNumber", usbDevice.getSerialNumber());
usbDeviceInfo.put("vendorId", usbDevice.getVendorId()); final List<UsbDevice> connectedDevices = usbDevice.getConnectedDevices();
usbDeviceInfo.put("connectedDevices", connectedDevices);
usbDevicesInfos.add(usbDeviceInfo);
}
return usbDevicesInfos;
} /**
* 网络参数信息
* @return Map<String, Object>
*/
public static Map<String, Object> getNetworkParamsInfo() {
Map<String, Object> networkParamsInfo = new ConcurrentHashMap<>();
final NetworkParams networkParams = operatingSystem.getNetworkParams();
networkParamsInfo.put("toString", networkParams);
networkParamsInfo.put("hostName", networkParams.getHostName());
networkParamsInfo.put("dnsServers", Arrays.asList(networkParams.getDnsServers()));
networkParamsInfo.put("domainName", networkParams.getDomainName());
networkParamsInfo.put("ipv4Gateway", networkParams.getIpv4DefaultGateway());
networkParamsInfo.put("ipv6Gateway", networkParams.getIpv6DefaultGateway());
return networkParamsInfo;
} /**
* ip信息统计
* @return Map<String, Object>
*/
public static Map<String, Object> getIpStatistics() {
final InternetProtocolStats internetProtocolStats = operatingSystem.getInternetProtocolStats();
final Map<String, Object> ipStatisticsMap = new ConcurrentHashMap<>(); /* tcpV4 */
Map<String, Object> tcpV4 = new ConcurrentHashMap<>();
final InternetProtocolStats.TcpStats tcPv4Stats = internetProtocolStats.getTCPv4Stats();
tcpV4.put("toString", String.valueOf(tcPv4Stats));
tcpV4.put("connectionFailures", tcPv4Stats.getConnectionFailures());
tcpV4.put("connectionsActive", tcPv4Stats.getConnectionsActive());
tcpV4.put("connectionsPassive", tcPv4Stats.getConnectionsPassive());
tcpV4.put("connectionsReset", tcPv4Stats.getConnectionsReset());
tcpV4.put("connectionsEstablished", tcPv4Stats.getConnectionsEstablished());
tcpV4.put("inErrors", tcPv4Stats.getInErrors());
tcpV4.put("outResets", tcPv4Stats.getOutResets());
tcpV4.put("segmentsReceived", tcPv4Stats.getSegmentsReceived());
tcpV4.put("segmentsRetransmitted", tcPv4Stats.getSegmentsRetransmitted());
tcpV4.put("segmentsSent", tcPv4Stats.getSegmentsSent());
ipStatisticsMap.put("tcpV4", tcpV4); /* tcpV6 */
Map<String, Object> tcpV6 = new ConcurrentHashMap<>();
final InternetProtocolStats.TcpStats tcPv6Stats = internetProtocolStats.getTCPv6Stats();
tcpV6.put("toString", String.valueOf(tcPv6Stats));
tcpV6.put("connectionFailures", tcPv6Stats.getConnectionFailures());
tcpV6.put("connectionsActive", tcPv6Stats.getConnectionsActive());
tcpV6.put("connectionsPassive", tcPv6Stats.getConnectionsPassive());
tcpV6.put("connectionsReset", tcPv6Stats.getConnectionsReset());
tcpV6.put("connectionsEstablished", tcPv6Stats.getConnectionsEstablished());
tcpV6.put("inErrors", tcPv6Stats.getInErrors());
tcpV6.put("outResets", tcPv6Stats.getOutResets());
tcpV6.put("segmentsReceived", tcPv6Stats.getSegmentsReceived());
tcpV6.put("segmentsRetransmitted", tcPv6Stats.getSegmentsRetransmitted());
tcpV6.put("segmentsSent", tcPv6Stats.getSegmentsSent());
ipStatisticsMap.put("tcpV6", tcpV6); /* udpV4 */
Map<String, Object> udpV4 = new ConcurrentHashMap<>();
final InternetProtocolStats.UdpStats udPv4Stats = internetProtocolStats.getUDPv4Stats();
udpV4.put("toString", String.valueOf(udPv4Stats));
udpV4.put("datagramsNoPort", udPv4Stats.getDatagramsNoPort());
udpV4.put("datagramsReceived", udPv4Stats.getDatagramsReceived());
udpV4.put("datagramsReceivedErrors", udPv4Stats.getDatagramsReceivedErrors());
udpV4.put("datagramsSent", udPv4Stats.getDatagramsSent());
ipStatisticsMap.put("udpV4", udpV4); /* udpV6 */
Map<String, Object> udpV6 = new ConcurrentHashMap<>();
final InternetProtocolStats.UdpStats udPv6Stats = internetProtocolStats.getUDPv6Stats();
udpV6.put("toString", String.valueOf(udPv6Stats));
udpV6.put("datagramsNoPort", udPv6Stats.getDatagramsNoPort());
udpV6.put("datagramsReceived", udPv6Stats.getDatagramsReceived());
udpV6.put("datagramsReceivedErrors", udPv6Stats.getDatagramsReceivedErrors());
udpV6.put("datagramsSent", udPv6Stats.getDatagramsSent());
ipStatisticsMap.put("udpV6", udpV6); /* connections */
final List<InternetProtocolStats.IPConnection> connections = internetProtocolStats.getConnections();
final List<Map<String, Object>> ipConnectionInfoList = new ArrayList<>(connections.size());
for (int i = 0; i < connections.size(); i++) {
Map<String, Object> ipConnectionInfo = new ConcurrentHashMap<>();
ipConnectionInfo.put("connectionIndex", i);
final InternetProtocolStats.IPConnection ipConnection = connections.get(i);
ipConnectionInfo.put("toString", String.valueOf(ipConnection));
ipConnectionInfo.put("foreignAddress", Arrays.toString(ipConnection.getForeignAddress()));
ipConnectionInfo.put("foreignPort", ipConnection.getForeignPort());
ipConnectionInfo.put("localAddress", Arrays.toString(ipConnection.getLocalAddress()));
ipConnectionInfo.put("state", ipConnection.getState());
ipConnectionInfo.put("type", ipConnection.getType());
ipConnectionInfo.put("localPort", ipConnection.getLocalPort());
ipConnectionInfo.put("owningProcessId", ipConnection.getowningProcessId());
ipConnectionInfo.put("receiveQueue", ipConnection.getReceiveQueue());
ipConnectionInfo.put("transmitQueue", ipConnection.getTransmitQueue());
ipConnectionInfoList.add(ipConnectionInfo);
}
ipStatisticsMap.put("ipConnections", ipConnectionInfoList);
return ipStatisticsMap;
} /**
* 网络接口信息读取
* @return List<Map<String, Object>>
*/
public static List<Map<String, Object>> getNetWorkInterfaces() {
final List<NetworkIF> networkIFs = hal.getNetworkIFs();
final List<Map<String, Object>> networkIFList = new ArrayList<>(networkIFs.size()); for (int i = 0; i < networkIFs.size(); i++) {
final Map<String, Object> networkIfMap = new ConcurrentHashMap<>();
networkIfMap.put("index", i);
final NetworkIF networkIF = networkIFs.get(i);
networkIfMap.put("toString", String.valueOf(networkIF));
networkIfMap.put("displayName", networkIF.getDisplayName());
networkIfMap.put("name", networkIF.getName());
networkIfMap.put("ifIndex", networkIF.getIndex());
networkIfMap.put("iPv4addr", networkIF.getIPv4addr());
networkIfMap.put("iPv6addr", networkIF.getIPv6addr());
networkIfMap.put("macAddr", networkIF.getMacaddr());
networkIfMap.put("speed", networkIF.getSpeed());
networkIfMap.put("subnetMasks", networkIF.getSubnetMasks());
networkIfMap.put("bytesRecv", networkIF.getBytesRecv());
networkIfMap.put("bytesSent", networkIF.getBytesSent());
networkIfMap.put("collisions", networkIF.getCollisions());
networkIfMap.put("ifAlias", networkIF.getIfAlias());
networkIfMap.put("ifOperStatus", networkIF.getIfOperStatus().name());
networkIfMap.put("ifType", networkIF.getIfType());
networkIfMap.put("inDrops", networkIF.getInDrops());
networkIfMap.put("inErrors", networkIF.getInErrors());
networkIfMap.put("mtu", networkIF.getMTU());
networkIfMap.put("ndisPhysicalMediumType", networkIF.getNdisPhysicalMediumType());
networkIfMap.put("outErrors", networkIF.getOutErrors());
networkIfMap.put("packetsRecv", networkIF.getPacketsRecv());
networkIfMap.put("packetsSent", networkIF.getPacketsSent());
networkIfMap.put("prefixLengths", networkIF.getPrefixLengths());
networkIfMap.put("timeStamp", networkIF.getTimeStamp());
networkIfMap.put("isConnectorPresent", networkIF.isConnectorPresent());
networkIfMap.put("isKnownVmMacAddr", networkIF.isKnownVmMacAddr());
final NetworkInterface networkInterface = networkIF.queryNetworkInterface();
networkIfMap.put("networkInterface", String.valueOf(networkInterface));
networkIFList.add(networkIfMap);
}
return networkIFList;
} /**
* 读取文件系统信息
* @return List<Map<String, Object>>
*/
public static Map<String, Object> getFileSystemInfo() {
final Map<String, Object> fsInfo = new ConcurrentHashMap<>();
final FileSystem fileSystem = operatingSystem.getFileSystem();
final 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()) + "%"); final List<OSFileStore> fileStores = fileSystem.getFileStores();
for (int i = 0; i < fileStores.size(); i++) {
final Map<String, Object> fileStoreInfo = new ConcurrentHashMap<>();
fileStoreInfo.put("index", i);
final OSFileStore osFileStore = fileStores.get(i);
fileStoreInfo.put("toString", String.valueOf(osFileStore));
fileStoreInfo.put("name", osFileStore.getName());
fileStoreInfo.put("description", osFileStore.getDescription());
fileStoreInfo.put("totalSpace", FormatUtil.formatBytes(osFileStore.getTotalSpace()));
fileStoreInfo.put("usedSpace", FormatUtil.formatBytes(osFileStore.getTotalSpace() - osFileStore.getUsableSpace()));
fileStoreInfo.put("usableSpace", FormatUtil.formatBytes(osFileStore.getUsableSpace()));
fileStoreInfo.put("usageRate", 100d * (osFileStore.getTotalSpace() - osFileStore.getUsableSpace()) / osFileStore.getTotalSpace());
fileStoreInfo.put("volume", osFileStore.getVolume());
fileStoreInfo.put("mount", osFileStore.getMount());
fileStoreInfo.put("logicalVolume", osFileStore.getLogicalVolume());
fileStoreInfo.put("totalInodes", FormatUtil.formatValue(osFileStore.getTotalInodes(), ""));
fileStoreInfo.put("freeInodes", FormatUtil.formatValue(osFileStore.getFreeInodes(), ""));
fileStoreInfo.put("inodesUsageRate", 100d * osFileStore.getFreeInodes() / osFileStore.getTotalInodes());
fileSystemInfos.add(fileStoreInfo);
}
fsInfo.put("fileStores", fileSystemInfos); return fsInfo;
} /**
* 逻辑卷组信息
* @return List<Map<String, Object>>
*/
public static List<Map<String, Object>> getLogicalVolumeGroupInfo() {
final List<LogicalVolumeGroup> logicalVolumeGroups = hal.getLogicalVolumeGroups();
final List<Map<String, Object>> lvgInfos = new ArrayList<>(logicalVolumeGroups.size());
for (int i = 0; i < logicalVolumeGroups.size(); i++) {
final LogicalVolumeGroup lvg = logicalVolumeGroups.get(i);
final Map<String, Object> lvgInfo = new ConcurrentHashMap<>();
lvgInfo.put("index", i);
lvgInfo.put("toString", String.valueOf(lvg));
lvgInfo.put("name", lvg.getName());
lvgInfo.put("logicalVolumes", lvg.getLogicalVolumes());
lvgInfo.put("physicalVolumes", lvg.getPhysicalVolumes());
lvgInfos.add(lvgInfo);
}
return lvgInfos;
} /**
* 磁盘存储信息读取
* @return List<Map<String, Object>>
*/
public static List<Map<String, Object>> getDiskStoreInfo() {
final List<HWDiskStore> diskStores = hal.getDiskStores();
final List<Map<String, Object>> dsList = new ArrayList<>(diskStores.size());
for (int i = 0; i < diskStores.size(); i++) {
final HWDiskStore hwDiskStore = diskStores.get(i);
final Map<String, Object> hwDsMap = new ConcurrentHashMap<>();
hwDsMap.put("index", i);
hwDsMap.put("toString", String.valueOf(hwDiskStore));
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()); final List<HWPartition> partitions = hwDiskStore.getPartitions();
final List<Map<String, Object>> partitionList = new ArrayList<>(partitions.size());
for (HWPartition partition : partitions) {
final Map<String, Object> partitionMap = new ConcurrentHashMap<>();
partitionMap.put("toString", partition);
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;
} /**
* 电源信息读取
* @return List<Map<String, Object>
*/
public static List<Map<String, Object>> getPowerSourceInfo() {
final List<PowerSource> powerSources = hal.getPowerSources();
final List<Map<String, Object>> powerSourcesList = new ArrayList<>(powerSources.size());
for (PowerSource powerSource : powerSources) {
final Map<String, Object> powerSourceMap = new ConcurrentHashMap<>();
powerSourceMap.put("toString", String.valueOf(powerSource));
powerSourceMap.put("amperage", powerSource.getAmperage());
powerSourceMap.put("name", powerSource.getName());
powerSourceMap.put("capacityUnits", powerSource.getCapacityUnits());
powerSourceMap.put("serialNumber", powerSource.getSerialNumber());
powerSourceMap.put("currentCapacity", powerSource.getCurrentCapacity());
powerSourceMap.put("deviceName", powerSource.getDeviceName());
powerSourceMap.put("manufacturer", powerSource.getManufacturer());
powerSourceMap.put("voltage", powerSource.getVoltage());
powerSourceMap.put("chemistry", powerSource.getChemistry());
powerSourceMap.put("cycleCount", powerSource.getCycleCount());
powerSourceMap.put("powerUsageRate", powerSource.getPowerUsageRate());
powerSourceMap.put("designCapacity", powerSource.getDesignCapacity());
powerSourceMap.put("maxCapacity", powerSource.getMaxCapacity());
// powerSourceMap.put("manufactureDate", powerSource.getManufactureDate());
powerSourceMap.put("temperature", powerSource.getTemperature());
powerSourceMap.put("isDischarging", powerSource.isDischarging());
powerSourceMap.put("isCharging", powerSource.isCharging());
powerSourceMap.put("isPowerOnLine", powerSource.isPowerOnLine());
powerSourceMap.put("timeRemainingInstant", powerSource.getTimeRemainingInstant());
powerSourceMap.put("timeRemainingEstimated", powerSource.getTimeRemainingEstimated());
powerSourceMap.put("remainingCapacityPercent", powerSource.getRemainingCapacityPercent());
powerSourcesList.add(powerSourceMap);
}
return powerSourcesList;
} /**
* 获取系统服务信息，服务基于系统平台决定
* @return List<Map<String, Object>>
*/
public static List<Map<String, Object>> getSystemServiceInfo() {
final List<OSService> services = operatingSystem.getServices();
final List<Map<String, Object>> systemServiceList = new ArrayList<>(services.size()); for (int i = 0; i < services.size(); i++) {
final OSService osService = services.get(i);
final Map<String, Object> osServiceMap = new ConcurrentHashMap<>();
osServiceMap.put("index", i);
osServiceMap.put("toString", String.valueOf(osService));
osServiceMap.put("state", osService.getState().name());
osServiceMap.put("pid", osService.getProcessID());
osServiceMap.put("name", osService.getName());
systemServiceList.add(osServiceMap);
}
return systemServiceList;
} /**
* 获取传感器信息
* @return String
*/
public static Map<String, Object> getSensorInfo() {
final Map<String, Object> sensorInfo = new ConcurrentHashMap<>();
final Sensors sensors = hal.getSensors();
sensorInfo.put("toString", String.valueOf(sensors));
sensorInfo.put("instance", sensors);
return sensorInfo;
} /**
* 获取进程信息
* @return Map<String, Object>
*/
public static Map<String, Object> getProcessesInfo() {
final GlobalMemory globalMemory = hal.getMemory();
final Map<String, Object> processesInfoMap = new ConcurrentHashMap<>();
processesInfoMap.put("processCount", operatingSystem.getProcessCount());
processesInfoMap.put("threadCount", operatingSystem.getThreadCount()); List<OSProcess> osProcessList = operatingSystem.getProcesses(OperatingSystem.ProcessFiltering.ALL_PROCESSES, OperatingSystem.ProcessSorting.CPU_DESC, 100);
final List<Map<String, Object>> osProcessMapList = new ArrayList<>(osProcessList.size());
for (int i = 0; i < osProcessList.size(); i++) {
final OSProcess osProcess = osProcessList.get(i);
final Map<String, Object> osProcessMap = new ConcurrentHashMap<>();
osProcessMap.put("index", i);
osProcessMap.put("toString", String.valueOf(osProcess));
osProcessMap.put("pid", osProcess.getProcessID());
osProcessMap.put("kernelTime", osProcess.getKernelTime());
osProcessMap.put("userTime", osProcess.getUserTime());
osProcessMap.put("upTime", osProcess.getUpTime());
osProcessMap.put("startTime", osProcess.getStartTime());
osProcessMap.put("bytesRead", osProcess.getBytesRead());
osProcessMap.put("bytesWritten", osProcess.getBytesWritten());
osProcessMap.put("openFiles", osProcess.getOpenFiles());
osProcessMap.put("softOpenFileLimit", osProcess.getSoftOpenFileLimit());
osProcessMap.put("hardOpenFileLimit", osProcess.getHardOpenFileLimit());
osProcessMap.put("processCpuLoadCumulative", osProcess.getProcessCpuLoadCumulative());
osProcessMap.put("processCpuLoadBetweenTicks", osProcess.getProcessCpuLoadBetweenTicks(osProcess));
osProcessMap.put("bitness", osProcess.getBitness());
osProcessMap.put("affinityMask", osProcess.getAffinityMask());
osProcessMap.put("minorFaults", osProcess.getMinorFaults());
osProcessMap.put("majorFaults", osProcess.getMajorFaults());
osProcessMap.put("priority", osProcess.getPriority());
osProcessMap.put("threadCount", osProcess.getThreadCount());
osProcessMap.put("group", osProcess.getGroup());
osProcessMap.put("groupId", osProcess.getGroupID());
osProcessMap.put("user", osProcess.getUser());
osProcessMap.put("userId", osProcess.getUserID());
osProcessMap.put("currentWorkingDirectory", osProcess.getCurrentWorkingDirectory());
osProcessMap.put("path", osProcess.getPath());
osProcessMap.put("arguments", osProcess.getArguments());
osProcessMap.put("environmentVariables", osProcess.getEnvironmentVariables());
osProcessMap.put("cpuUsageRate", 100d * (osProcess.getKernelTime() + osProcess.getUserTime()) / osProcess.getUpTime());
osProcessMap.put("memUsageRate", 100d * osProcess.getResidentSetSize() / globalMemory.getTotal());
osProcessMap.put("virtualMemSize", FormatUtil.formatBytes(osProcess.getVirtualSize()));
osProcessMap.put("residentSetSize", FormatUtil.formatBytes(osProcess.getResidentSetSize()));
osProcessMap.put("processName", osProcess.getName());
osProcessMapList.add(osProcessMap);
}
processesInfoMap.put("osProcessMapList", osProcessMapList);
return processesInfoMap;
} /**
* 获取内存信息
* @return Map<String, Object>
*/
public static Map<String, Object> getMemoryInfo() {
final GlobalMemory globalMemory = hal.getMemory();
final Map<String, Object> gmMap = new ConcurrentHashMap<>();
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("usageRate", 100d * (globalMemory.getTotal() - globalMemory.getAvailable()) / globalMemory.getTotal());
gmMap.put("pageSize", globalMemory.getPageSize()); final VirtualMemory virtualMemory = globalMemory.getVirtualMemory();
final Map<String, Object> vmMap = new ConcurrentHashMap<>();
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); final List<PhysicalMemory> physicalMemoryList = globalMemory.getPhysicalMemory();
final List<Map<String, Object>> pmInfoList = new ArrayList<>(physicalMemoryList.size());
for (PhysicalMemory pm : physicalMemoryList) {
final Map<String, Object> pmMap = new ConcurrentHashMap<>();
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;
} /**
* 获取操作系统信息
* @return Map<String, Object>
*/
public static Map<String, Object> getOperateSystemInfo() {
final Map<String, Object> osInfo = new ConcurrentHashMap<>();
osInfo.put("osName", String.valueOf(operatingSystem));
osInfo.put("booted", Instant.ofEpochSecond(operatingSystem.getSystemBootTime()));
osInfo.put("sessionList", operatingSystem.getSessions()); final ComputerSystem computerSystem = hal.getComputerSystem();
osInfo.put("computerSystem", String.valueOf(computerSystem));
osInfo.put("firmware: ", computerSystem.getFirmware());
osInfo.put("baseboard: ", computerSystem.getBaseboard());
return osInfo;
} /**
* 获取CPU信息
* @return Map<String, Object>
*/
public static Map<String, Object> getCpuInfo() {
final Map<String, Object> cpuInfo = new ConcurrentHashMap<>();
final CentralProcessor processor = hal.getProcessor();
cpuInfo.put("toString", String.valueOf(processor));
cpuInfo.put("instance", processor);
return cpuInfo;
}
}
对外开放的读取接口类：
package cn.cloud9.server.system.common.hardware; import cn.cloud9.server.struct.util.OperateSystemUtil;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController; import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap; /**
* @author OnCloud9
* @description
* @project tt-server
* @date 2023年01月01日 下午 01:28
*/
@RestController
@RequestMapping("/sys-monitor")
public class SystemMonitorController { /**
* CPU信息
* @return
*/
@GetMapping("/cpuInfo")
public Map<String, Object> getCpuInfo() {
return OperateSystemUtil.getCpuInfo();
} @GetMapping("/memoryInfo")
public Map<String, Object> getMemoryInfo() {
return OperateSystemUtil.getMemoryInfo();
} @GetMapping("/graphicsCardsInfo")
public List<Map<String, Object>> getGraphicsCardsInfo() {
return OperateSystemUtil.getGraphicsCardsInfo();
} @GetMapping("/soundCardInfo")
public List<Map<String, Object>> getSoundCardInfo() {
return OperateSystemUtil.getSoundCardInfo();
} @GetMapping("/getDisplayInfo")
public List<Map<String, Object>> getDisplayInfo() {
return OperateSystemUtil.getDisplayInfo();
} @GetMapping("/fileSystemInfo")
public Map<String, Object> getFileSystemInfo() {
return OperateSystemUtil.getFileSystemInfo();
} @GetMapping("/diskStoreInfo")
public List<Map<String, Object>> getDiskStoreInfo() {
return OperateSystemUtil.getDiskStoreInfo();
} @GetMapping("/logicalVolumeGroupInfo")
public List<Map<String, Object>> getLogicalVolumeGroupInfo() {
return OperateSystemUtil.getLogicalVolumeGroupInfo();
} @GetMapping("/usbDevicesInfo")
public List<Map<String, Object>> getUsbDevicesInfo() {
return OperateSystemUtil.getUsbDevicesInfo();
} @GetMapping("/systemServiceInfo")
public List<Map<String, Object>> getSystemServiceInfo() {
return OperateSystemUtil.getSystemServiceInfo();
} @GetMapping("/processesInfo")
public Map<String, Object> getProcessesInfo() {
return OperateSystemUtil.getProcessesInfo();
} @GetMapping("/ipStatistics")
public Map<String, Object> getIpStatistics() {
return OperateSystemUtil.getIpStatistics();
} @GetMapping("/netWorkInterfaces")
public List<Map<String, Object>> getNetWorkInterfaces() {
return OperateSystemUtil.getNetWorkInterfaces();
} @GetMapping("/networkParamsInfo")
public Map<String, Object> getNetworkParamsInfo() {
return OperateSystemUtil.getNetworkParamsInfo();
} @GetMapping("/operateSystemInfo")
public Map<String, Object> getOperateSystemInfo() {
return OperateSystemUtil.getOperateSystemInfo();
} @GetMapping("/powerSourceInfo")
public List<Map<String, Object>> getPowerSourceInfo() {
return OperateSystemUtil.getPowerSourceInfo();
} @GetMapping("/sensorInfo")
public Map<String, Object> getSensorInfo() {
return OperateSystemUtil.getSensorInfo();
}
}
在后台系统里做的功能列表
内存信息：
磁盘信息：
官方演示的GUI案例：
操作系统和基础硬件
内存占用
CPU占用折现图
磁盘存储信息
进程列表
USB设备
网络信息
2023年1月5日 22点10分 更新：
显示器的信息获取是提供了一个EDID的字节数组
Oshi库提供了一个EDID解析工具类，根据工具类的信息读取显示参数
这里照抄官方的GUI源码读取方式
/**
* 读取显示器信息
* @return List<Map<String, Object>>
*/
public static List<Map<String, Object>> getDisplayInfo() {
final List<Display> displays = hal.getDisplays();
final List<Map<String, Object>> displayInfos = new ArrayList<>(displays.size());
for (int i = 0; i < displays.size(); i++) {
Map<String, Object> displayInfo = new ConcurrentHashMap<>();
displayInfo.put("index", String.valueOf(i));
final Display display = displays.get(i);
byte[] edidBytes = display.getEdid();
displayInfo.put("manufacturerId", EdidUtil.getManufacturerID(edidBytes));
displayInfo.put("productId", EdidUtil.getProductID(edidBytes));
displayInfo.put("isDigital", EdidUtil.isDigital(edidBytes) ? "Digital" : "Analog");
displayInfo.put("serialNo", EdidUtil.getSerialNo(edidBytes));
displayInfo.put("manufacturerDate", (EdidUtil.getWeek(edidBytes) * 12 / 52 + 1) + '/' + EdidUtil.getYear(edidBytes));
displayInfo.put("version", EdidUtil.getVersion(edidBytes));
displayInfo.put("cmHeight", EdidUtil.getHcm(edidBytes));
displayInfo.put("cmWidth", EdidUtil.getVcm(edidBytes));
displayInfo.put("inHeight", EdidUtil.getHcm(edidBytes) / 2.54);
displayInfo.put("inWidth", EdidUtil.getVcm(edidBytes) / 2.54);
displayInfo.put("toString", String.valueOf(display));
byte[][] descriptorBytes = EdidUtil.getDescriptors(edidBytes);
for (byte[] bytes : descriptorBytes) {
switch (EdidUtil.getDescriptorType(bytes)) {
case 0xff:
displayInfo.put("serialNumber", EdidUtil.getDescriptorText(bytes));
break;
case 0xfe:
displayInfo.put("unspecifiedText", EdidUtil.getDescriptorText(bytes));
break;
case 0xfd:
displayInfo.put("rangeLimits", EdidUtil.getDescriptorRangeLimits(bytes));
break;
case 0xfc:
displayInfo.put("monitorName", EdidUtil.getDescriptorText(bytes));
break;
case 0xfb:
displayInfo.put("whitePointData", ParseUtil.byteArrayToHexString(bytes));
break;
case 0xfa:
displayInfo.put("standardTimingId", ParseUtil.byteArrayToHexString(bytes));
break;
default:
if (EdidUtil.getDescriptorType(bytes) <= 0x0f && EdidUtil.getDescriptorType(bytes) >= 0x00) {
displayInfo.put("manufacturerData", ParseUtil.byteArrayToHexString(bytes));
} else {
displayInfo.put("preferredTiming", EdidUtil.getTimingDescriptor(bytes));
}
}
}
displayInfos.add(displayInfo);
}
return displayInfos;
在这边文章能看到一个应用启动时间和应用运行时长：
https://blog.csdn.net/Stephanie17395/article/details/117327578b
百度之后得知是读取Bean加载完成的时间：
时长的获取就是当前时间减去启动时间
这里再装填换算时长：按天，小时，分钟，秒
/* 获取应用启动时间和运行时长 */
long startTime = ManagementFactory.getRuntimeMXBean().getStartTime();
LocalDateTime start = Instant.ofEpochMilli(startTime).atZone(ZoneOffset.ofHours(8)).toLocalDateTime();
serverSysInfo.put("startTime", start);
LocalDateTime now = LocalDateTime.now();
Duration duration = Duration.between(start, now);
final Map<String, Object> durationInfo = new ConcurrentHashMap<>();
durationInfo.put("day", duration.toDays());
durationInfo.put("hour", duration.toHours());
durationInfo.put("min", duration.toMinutes());
durationInfo.put("sec", duration.toMillis() / 1000L);
serverSysInfo.put("duration", durationInfo);
通过System.properties可以获取一些属性内容：
就当是Jvm的信息吧：
/**
* https://www.cnblogs.com/koal/p/4391127.html
* https://blog.csdn.net/Stephanie17395/article/details/117327578
* 获取操作JVM信息
* @return Map<String, Object>
*/
public static Map<String, Object> getJvmInfo() {
final Map<String, Object> jvmInfo = new ConcurrentHashMap<>();
jvmInfo.put("version", properties.getProperty("java.version"));
jvmInfo.put("classVersion", properties.getProperty("java.class.version"));
jvmInfo.put("jvmVersion", properties.getProperty("java.vm.version"));
jvmInfo.put("jvmVendor", properties.getProperty("java.vm.vendor"));
jvmInfo.put("jvmVendorUrl", properties.getProperty("java.vendor.url"));
jvmInfo.put("jvmSpecificationVendor", properties.getProperty("java.specification.vendor"));
jvmInfo.put("jvmSpecificationVersion", properties.getProperty("java.vm.specification.version"));
jvmInfo.put("jvmSpecificationName", properties.getProperty("java.vm.specification.name"));
jvmInfo.put("javaSpecificationVersion", properties.getProperty("java.specification.version"));
jvmInfo.put("javaSpecificationName", properties.getProperty("java.specification.name"));
jvmInfo.put("execCommand", properties.getProperty("sun.java.command"));
jvmInfo.put("compiler", properties.getProperty("sun.management.compiler"));
jvmInfo.put("jvmName", properties.getProperty("java.vm.name"));
jvmInfo.put("jvmMode", properties.getProperty("java.vm.info"));
jvmInfo.put("archDataModel", properties.getProperty("sun.arch.data.model"));
jvmInfo.put("runtimeVersion", properties.getProperty("java.runtime.version"));
jvmInfo.put("runtimeName", properties.getProperty("java.runtime.name"));
jvmInfo.put("home", properties.getProperty("java.home"));
jvmInfo.put("libPath", properties.getProperty("java.library.path").split(";"));
jvmInfo.put("classPath", properties.getProperty("java.class.path").split(";"));
jvmInfo.put("jreBinPath", properties.getProperty("sun.boot.library.path"));
jvmInfo.put("bootClassPath", properties.getProperty("sun.boot.class.path").split(";"));
jvmInfo.put("launcher", properties.getProperty("sun.java.launcher")); jvmInfo.put("extendsDir", properties.getProperty("java.ext.dirs").split(";"));
/* io临时目录 */
jvmInfo.put("ioTmpDir", properties.getProperty("java.io.tmpdir")); return jvmInfo;
}
获取JVM内存可以通过运行时对象得到：
获取的信息是实时的，可用来做折线图
/**
* 获取JVM内存信息
* @return Map<String, Object>
*/
public static Map<String, Object> getJvmMemory() {
final Map<String, Object> jvmMemory = new ConcurrentHashMap<>();
long totalMem = runtime.totalMemory();
long freeMem = runtime.freeMemory();
long usedMem = totalMem - freeMem;
long maxMem = runtime.maxMemory();
jvmMemory.put("total", FormatUtil.formatBytes(totalMem));
jvmMemory.put("max", FormatUtil.formatBytes(maxMem));
jvmMemory.put("free", FormatUtil.formatBytes(freeMem));
jvmMemory.put("used", FormatUtil.formatBytes(usedMem));
jvmMemory.put("usageRate", String.format("%.2f", 100D * usedMem / totalMem) + "%");
jvmMemory.put("freeRate", String.format("%.2f", 100D * freeMem / totalMem) + "%");
return jvmMemory;
}
获取系统，用户，环境变量等信息：
/* 操作系统名称 */
serverSysInfo.put("osName", properties.getProperty("os.name"));
/* 操作系统版本 */
serverSysInfo.put("osVersion", properties.getProperty("os.version"));
/* 操作系统架构 */
serverSysInfo.put("osArch", properties.getProperty("os.arch"));
/* 应用所在目录 */
serverSysInfo.put("userDir", properties.getProperty("user.dir"));
/* 当前用户主目录 */
serverSysInfo.put("userHome", properties.getProperty("user.home"));
/* 用户名 */
serverSysInfo.put("userName", properties.getProperty("user.name"));
/* 用户变量 */
serverSysInfo.put("userVariant", properties.getProperty("user.variant"));
/* 用户时区 */
serverSysInfo.put("userTimezone", properties.getProperty("user.timezone"));
/* 用户语言 */
serverSysInfo.put("userLanguage", properties.getProperty("user.language"));
/* 系统环境变量 */
serverSysInfo.put("sysEnv", System.getenv());
【Java】Oshi 硬件信息读取库的更多相关文章
- Windows系统及硬件信息读取
Windows桌面端开发常常会需要读取系统信息或硬件信息作为用户标识,比如用于确认该设配是否已经激活程序.也可以使用随机生成的UUID来作为唯一标识,但是如果重装系统或重装软件都有可能导致标识丢失,因 ...
- Java获取电脑硬件信息
package com.szht.gpy.util; import java.applet.Applet; import java.awt.Graphics; import java.io.Buffe ...
- py3nvml实现GPU相关信息读取
技术背景 随着模型运算量的增长和硬件技术的发展,使用GPU来完成各种任务的计算已经渐渐成为算法实现的主流手段.而对于运行期间的一些GPU的占用,比如每一步的显存使用率等诸如此类的信息,就需要一些比较细 ...
- Mp3文件标签信息读取和写入(Kotlin)
原文:Mp3文件标签信息读取和写入(Kotlin) - Stars-One的杂货小窝 最近准备抽空完善了自己的星之小说下载器(JavaFx应用 ),发现下载下来的mp3文件没有对应的标签 也是了解可以 ...
- java的poi技术读取Excel数据到MySQL
这篇blog是介绍java中的poi技术读取Excel数据,然后保存到MySQL数据中. 你也可以在 : java的poi技术读取和导入Excel了解到写入Excel的方法信息 使用JXL技术可以在 ...
- Web网站中利用JavaScript中ActiveXObject对象获取硬件信息（显示器数量、分辨率）从而进行单双屏跳转
前言:最近这两天工作上,要实现一个功能,在好友阿聪的帮助下,算是比较好的解决了这个需求. B/S的Web网站,需要实现点击按钮时,根据客户端连接的显示屏(监视器)数量进行,单双屏跳转显示新页面. 由于 ...
- java的poi技术读取Excel[2003-2007,2010]
这篇blog主要是讲述java中poi读取excel,而excel的版本包括:2003-2007和2010两个版本, 即excel的后缀名为:xls和xlsx. 读取excel和MySQL相关: ja ...
- java Properties 配置信息类
Properties(配置信息类):主要用于生产配置文件和读取配置文件信息. ----> 是一个集合类 继承HashTable 存值是以键-值的方式. package com.beiwo.io; ...
- Java学习-019-Properties 文件读取实例源代码
在这几天的学习过程中,有开发的朋友告知我,每个编程语言基本都有相应的配置文件支持类,像 Python 编程语言中支持的 ini 文件及其对应的配置文件读取类 ConfigParse,通过这个类,用户可 ...
- linux查看硬件信息及驱动设备相关整理
查看声卡设备:cat /proc/asound/cards 查看USB设备:cat /proc/bus/usb/devices 常用命令整理如下:用硬件检测程序kuduz探测新硬件:service k ...
随机推荐
- java中以字符分隔的字符串与字符串数组的相互转换
1.字符串数组拼接成一个以指定字符(包括空字符)分隔的字符串--String.join(),JDK8的新特性 String[] strArray = {"aaa","bb ...
- vue基础使用
传统dom操作 使用js或jquery库对html页面结构中的指定的区域输出数据 使用vue实现 在html页面中使用好vue需要完成如下步骤即可 引入vue.js文件 定义给vue.js管理的dom ...
- Easysearch 内核完善之 OOM 内存溢出优化案例一则
最近某客户在使用 Easysearch 做聚合时,报出 OOM 导致掉节点的问题,当时直接让客户试着调整 indices.breaker.request.limit ,但是不起作用,于是又看了下 Ea ...
- Grafana 开源了一款 eBPF 采集器 Beyla
eBPF 的发展如火如荼,在可观测性领域大放异彩,Grafana 近期也发布了一款 eBPF 采集器,可以采集服务的 RED 指标,本文做一个尝鲜介绍,让读者有个大概了解. eBPF 基础介绍可以参考 ...
- work06
练习题:=============================================================第七题: 1.定义方法 isSXH(int num) 功能:判断数字n ...
- 一款.NET开源、功能强大、跨平台的绘图库 - OxyPlot
前言 今天大姚给大家分享一款.NET开源(MIT License).免费.跨平台.功能强大的绘图库,支持多平台使用(包括:WPF.UWP.WinForm.Silverlight.Xamarin.iOS ...
- 燕千云 YQCloud 数智化业务服务管理平台 发布1.13版本
2022年6月10日,燕千云 YQCloud 数智化业务服务管理平台发布1.13版本.本次燕千云1.13版本新增了远程桌面.知识库多人在线协作.移动端疫苗核酸信息管理.单据委托代理.技能管理.产品自助 ...
- mysql8.0.22在centos7.6下的简单安装
如果想把mysql安装得好一些,则严重推荐使用压缩包来安装,不推荐使用rpm方式. 一般情况下,现在大部分的服务器都是x86-64,少数是arm架构的. 选择合适的版本,下载即可. 本文中,使用的是 ...
- Mysql 使用（二）
1 启动: 2 net start mysql 3 4 进入: 5 mysql -uroot -pmysql 6 7 显示数据库: 8 show databases; 9 10 使用数据库: 11 u ...
- 高通Android平台 电池 相关配置
背景 在新基线上移植有关的代码时,在log中发现有关的东西,请教了有关的同事以后,解决了这个问题. [ 12.775863] pmi632_charger: smblib_eval_chg_termi ...