java 读取服务器硬件信息

已于 2023-06-01 12:00:14 修改
阅读量625 收藏
点赞数
文章标签： java 服务器 junit
于 2023-06-01 11:53:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/imouse728/article/details/130985469
版权

在类路径中包含 OSHI 及其依赖项。我们强烈建议您将 OSHI 作为依赖项添加到您的项目依赖项管理器（例如 Maven 或 Gradle）中。
创建一个新的实例SystemInfo
使用 getter fromSystemInfo访问硬件或操作系统组件，例如：

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

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

SystemInfo si = new SystemInfo();
HardwareAbstractionLayer hal = si.getHardware();
CentralProcessor cpu = hal.getProcessor();

支持的功能

计算机系统和固件、底板
操作系统和版本/构建
物理（核心）和逻辑（超线程）CPU、处理器组、NUMA 节点
系统和每个处理器负载、使用节拍计数器、中断、正常运行时间
进程正常运行时间、CPU、内存使用情况、用户/组、命令行参数、线程详细信息
使用/可用的物理和虚拟内存
挂载的文件系统（类型、可用空间和总空间、选项、读写）
磁盘驱动器（型号、序列号、大小、读写）和分区
网络接口（IP、带宽输入/输出）、网络参数、TCP/UDP 统计信息
电池状态（% 容量、剩余时间、电量使用统计）
USB 设备
连接的显示器（带有 EDID 信息）、显卡和声卡
某些硬件上的传感器（温度、风扇速度、电压）

有关示例，请参见SystemInfoTest.java。

/*
 * Copyright 2016-2022 The OSHI Project Contributors
 * SPDX-License-Identifier: MIT
 */
package oshi;

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.not;

import java.time.Instant;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.stream.Collectors;

import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import oshi.hardware.CentralProcessor;
import oshi.hardware.CentralProcessor.PhysicalProcessor;
import oshi.hardware.CentralProcessor.ProcessorCache;
import oshi.hardware.CentralProcessor.TickType;
import oshi.hardware.ComputerSystem;
import oshi.hardware.Display;
import oshi.hardware.GlobalMemory;
import oshi.hardware.GraphicsCard;
import oshi.hardware.HWDiskStore;
import oshi.hardware.HWPartition;
import oshi.hardware.HardwareAbstractionLayer;
import oshi.hardware.LogicalVolumeGroup;
import oshi.hardware.NetworkIF;
import oshi.hardware.PhysicalMemory;
import oshi.hardware.PowerSource;
import oshi.hardware.Sensors;
import oshi.hardware.SoundCard;
import oshi.hardware.UsbDevice;
import oshi.hardware.VirtualMemory;
import oshi.software.os.FileSystem;
import oshi.software.os.InternetProtocolStats;
import oshi.software.os.NetworkParams;
import oshi.software.os.OSFileStore;
import oshi.software.os.OSProcess;
import oshi.software.os.OSService;
import oshi.software.os.OSSession;
import oshi.software.os.OperatingSystem;
import oshi.software.os.OperatingSystem.ProcessFiltering;
import oshi.software.os.OperatingSystem.ProcessSorting;
import oshi.util.FormatUtil;
import oshi.util.Util;

/**
 * A demonstration of access to many of OSHI's capabilities
 */
public class SystemInfoTest { // NOSONAR squid:S5786

    private static final Logger logger = LoggerFactory.getLogger(SystemInfoTest.class);

    static List<String> oshi = new ArrayList<>();

    /**
     * Test that this platform is implemented..
     */
    @Test
    void testPlatformEnum() {
        assertThat("Unsupported OS", SystemInfo.getCurrentPlatform(), is(not(PlatformEnum.UNKNOWN)));
        // Exercise the main method
        main(null);
    }

    /**
     * The main method, demonstrating use of classes.
     *
     * @param args the arguments (unused)
     */
    public static void main(String[] args) {

        logger.info("Initializing System...");
        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 Logical Volume Groups ...");
        printLVgroups(hal.getLogicalVolumeGroups());

        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 (String line : oshi) {
            output.append(line);
            if (line != null && !line.endsWith("\n")) {
                output.append('\n');
            }
        }
        logger.info("Printing Operating System and Hardware Info:{}{}", '\n', output);
    }

    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());

        Map<Integer, Integer> efficiencyCount = new HashMap<>();
        int maxEfficiency = 0;
        for (PhysicalProcessor cpu : processor.getPhysicalProcessors()) {
            int eff = cpu.getEfficiency();
            efficiencyCount.merge(eff, 1, Integer::sum);
            if (eff > maxEfficiency) {
                maxEfficiency = eff;
            }
        }
        oshi.add(" Topology:");
        oshi.add(String.format("  %7s %4s %4s %4s %4s %4s", "LogProc", "P/E", "Proc", "Pkg", "NUMA", "PGrp"));
        for (PhysicalProcessor cpu : processor.getPhysicalProcessors()) {
            oshi.add(String.format("  %7s %4s %4d %4s %4d %4d",
                    processor.getLogicalProcessors().stream()
                            .filter(p -> p.getPhysicalProcessorNumber() == cpu.getPhysicalProcessorNumber())
                            .filter(p -> p.getPhysicalPackageNumber() == cpu.getPhysicalPackageNumber())
                            .map(p -> Integer.toString(p.getProcessorNumber())).collect(Collectors.joining(",")),
                    cpu.getEfficiency() == maxEfficiency ? "P" : "E", cpu.getPhysicalProcessorNumber(),
                    cpu.getPhysicalPackageNumber(),
                    processor.getLogicalProcessors().stream()
                            .filter(p -> p.getPhysicalProcessorNumber() == cpu.getPhysicalProcessorNumber())
                            .filter(p -> p.getPhysicalPackageNumber() == cpu.getPhysicalPackageNumber())
                            .mapToInt(p -> p.getNumaNode()).findFirst().orElse(0),
                    processor.getLogicalProcessors().stream()
                            .filter(p -> p.getPhysicalProcessorNumber() == cpu.getPhysicalProcessorNumber())
                            .filter(p -> p.getPhysicalPackageNumber() == cpu.getPhysicalPackageNumber())
                            .mapToInt(p -> p.getProcessorGroup()).findFirst().orElse(0)));
        }
        List<ProcessorCache> caches = processor.getProcessorCaches();
        if (!caches.isEmpty()) {
            oshi.add(" Caches:");
        }
        for (int i = 0; i < caches.size(); i++) {
            ProcessorCache cache = caches.get(i);
            boolean perCore = cache.getLevel() < 3;
            boolean pCore = perCore && i < caches.size() - 1 && cache.getLevel() == caches.get(i + 1).getLevel()
                    && cache.getType() == caches.get(i + 1).getType();
            boolean eCore = perCore && i > 0 && cache.getLevel() == caches.get(i - 1).getLevel()
                    && cache.getType() == caches.get(i - 1).getType();
            StringBuilder sb = new StringBuilder("  ").append(cache);
            if (perCore) {
                sb.append(" (per ");
                if (pCore) {
                    sb.append("P-");
                } else if (eCore) {
                    sb.append("E-");
                }
                sb.append("core)");
            }
            oshi.add(sb.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());
        // current process will never be null. Other code should check for null here
        oshi.add(
                "My PID: " + myProc.getProcessID() + " with affinity " + Long.toBinaryString(myProc.getAffinityMask()));
        oshi.add("My TID: " + os.getThreadId() + " with details " + os.getCurrentThread());

        oshi.add("Processes: " + os.getProcessCount() + ", Threads: " + os.getThreadCount());
        // Sort by highest CPU
        List<OSProcess> procs = os.getProcesses(ProcessFiltering.ALL_PROCESSES, ProcessSorting.CPU_DESC, 5);
        oshi.add("   PID  %CPU %MEM       VSZ       RSS Name");
        for (int i = 0; i < procs.size(); 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()));
        }
        OSProcess p = os.getProcess(os.getProcessId());
        oshi.add("Current process arguments: ");
        for (String s : p.getArguments()) {
            oshi.add("  " + s);
        }
        oshi.add("Current process environment: ");
        for (Entry<String, String> e : p.getEnvironmentVariables().entrySet()) {
            oshi.add("  " + e.getKey() + "=" + e.getValue());
        }
    }

    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 printLVgroups(List<LogicalVolumeGroup> list) {
        if (!list.isEmpty()) {
            oshi.add("Logical Volume Groups:");
            for (LogicalVolumeGroup lvg : list) {
                oshi.add(" " + lvg.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));
            }
        }
    }
冰鑫999
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java获取系统、硬件、设备相关信息
02-02
java 1. 使用wmic相关命令获取windows硬件相关信息。 2. 使用shell相关的dmidecode/fdisk/ifconfig命令获取Linux硬件和系统相关信息
Java 连接远程Linux 服务器执行 shell 脚本查看 CPU、内存、硬盘信息
2.wa
09-02 6998
pom jar 包支持 代码
java实现远程监控linux服务器内存，cup，硬盘等信息,或者在远程服务器中部署采集程序，采集内存，CPU，硬盘信息
JMHJAVA的专栏
09-05 3234
正在研究java实现远程监控linux服务器内存，cup，硬盘等信息,或者在远程服务器中部署采集程序，采集内存，CPU，硬盘信。搜集了一些思路正在整理测试中，有经验的朋友可以留言分享经验。 第一种方法 采用java实现远程监控linux服务器内存，cup，硬盘等信息。 1）此法，采用执行shell脚本获取，服务器中内存，cpu，硬盘等。 2）定期更新中..... 第二种方法，...
java程序读取并控制串口设备
左直拳的马桶_日用桶
01-31 1129
监听串口，接收它们发过来的数据，进行处理。
java sigar 远程_java利用sigar.jar获取服务器运行时CPU、内存、网络等信息
weixin_32205867的博客
02-13 539
开源项目：https://github.com/yangengzhe/sigar-system_runtime介绍利用java程序检查服务器或主机的运行时信息，包括操作系统、CPU使用情况、内存使用情况、硬盘使用情况以及网卡、网络信息。主要的办法有两种：第一种，使用jdk1.6以上自动的功能，实现数据的获取，但是该方法局限性较大，而且获得的数据也比较少，尤其是内存信息不够准确。所以，在此不讨论该方...
java ipmi 获取服务器硬件信息（温度，风扇转速，内存数，硬盘数等等）
03-27
java ipmi 获取服务器硬件信息（温度，风扇转速，内存数，硬盘数等等），vxipmi.jar，ipmi2.0 ipmi1.5支持 a) raw：发送一个原始的IPMI请求，并且打印回复信息。 b) lan：配置网络（lan）信道(channel) c) chassis ：查看底盘的状态和配置电源 d) event：向BMC发送一个已定义的事件（event），可用于测试配置的SNMP是否成功 e) mc： 查看MC（Management Contollor）状态和各种允许的项 f) sdr：打印传感器仓库中的任何监控项和从传感器读取到的值。 g) sensor：打印周详的传感器信息。 h) Fru：打印内建的Field Replaceable Unit (FRU)信息 i) sel： 打印 System Event Log (SEL) j) pef： 配置 Platform Event Filtering (PEF)，事件过滤平台用于在监控系统发现有event时候，用PEF中的策略进行事件过滤，然后看是否需要报警。
java读取服务器硬件信息（windowx+linux+Mac OS）
09-25
java 读取 各平台 服务器硬件信息（windowx+linux+Mac OS） 案例............。
java得到当前服务器信息,java获取远程服务器硬件信息
weixin_42405890的博客
08-05 601
java获取远程服务器硬件信息 内容精选换一换分析辅助软件是一款支持部署到多台服务器目标环境上，实现对整个业务集群的数据采集和优化的组件。已成功登录Java性能分析。待安装分析辅助软件的服务器已开启sshd。已安装JDK并配置环境变量。打开“添加目标环境”界面，如图1所示，参数如表1所示。添加目标环境添加目标环境参数说明参数说明服务器IP地址输入待安装分析辅助软件的远程服务器的IP地已成功登录Ja...
java使用siger 获取服务器硬件信息（CPU 内存 网络 io等）
04-19
java使用siger 获取服务器硬件信息（CPU 内存 网络 io等）
java获取服务器硬件信息_使用java获取linux服务器的配置信息
weixin_39677870的博客
02-12 985
使用java获取linux服务器的配置信息星期五, 七月 6, 20180服务器提供商以及其他人员可能需要时常查看服务器配置，例如服务器的系统版本、内存大小、磁盘大小等等。人为地去执行不同的命令查看服务器配置，必须熟悉系统指令的人员才方便查看，费时又费力，效率比较低下。所以，如果有方法能让使用者输入账号、密码、地址，就能查询到服务器信息的工具，那么非专业人员也能迅速获取到所需的数据。一方面提高了效...
java 获取硬件,java 获取硬件的信息
weixin_42449583的博客
03-20 551
1.(主板序列号)Motherboard serial numberimport java.io.File;import java.io.FileWriter;import java.io.BufferedReader;import java.io.InputStreamReader;public class MiscUtils {private MiscUtils() { }public st...
java获取电脑的硬件信息代码
07-23
本程序通过java准确获取电脑的硬件信息，中间用到第三方包，也一并放在本压缩文件中，里面有两个DLL动态链接库问价，要把这两个文件放在系统盘的SYSTEM32文件夹下面，合理配置第三方包就可以运行这个程序来获得电脑的硬件信息！！！
java使用udp协议和硬件进行数据收发处理
09-20
java使用udp协议进行数据收发处理，java使用udp协议进行数据收发处理
Java 读取服务器IP工具类
05-28
Java 读取服务器IP工具类，该工具用于读取项目运行的ip地址，内网IP，请求IP，开箱即用。
Java实现获取cpu、内存、硬盘、网络等信息的方法示例
08-27
主要介绍了Java实现获取cpu、内存、硬盘、网络等信息的方法,涉及java使用第三方jar包针对本机硬件的cpu、内存、硬盘、网络信息等的读取相关操作技巧,需要的朋友可以参考下
ipmi 获取服务器硬件信息（温度，风扇转速，内存数，硬盘数等等）
07-17
java ipmi 获取服务器硬件信息（温度，风扇转速，内存数，硬盘数等等）
JAVA上百实例源码以及开源项目
01-03
　基于JAVA的UDP服务器模型源代码，内含UDP服务器端模型和UDP客户端模型两个小程序，向JAVA初学者演示UDP C/S结构的原理。 简单聊天软件CS模式 2个目标文件 一个简单的CS模式的聊天软件,用socket实现,比较简单。 ...
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 956
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
Day25-Java基础之常用类1
最新发布
m0_46053885的博客
04-27 895
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
java websocket rxtxcomm
07-08
### 回答1： Java WebSocket是一种用于在网络上实现双向通信的技术，而RXTXComm是Java中用于串行通信的库。 Java WebSocket允许客户端和服务器之间进行实时的、低延迟的通信。通过WebSocket协议，客户端和服务器可以在建立一次连接后保持长时间的通信。这种通信方式对于需要实时更新数据的应用程序非常有用，比如在线聊天应用、实时股票报价系统等。Java提供了WebSocket API，使得开发者可以轻松地在Java应用程序中使用WebSocket。 另一方面，RXTXComm是一个Java库，它提供了串行通信的功能，即通过串行端口与外部设备进行通信。这在与硬件设备交互的应用中非常有用，比如通过串口与传感器、电机等通信。RXTXComm库提供了简单易用的API，使得开发者可以方便地读取和写入串行端口。 如果将Java WebSocket和RXTXComm结合起来使用，可以实现一些更为复杂的应用。例如，可以将传感器与Java应用程序进行连接，并通过WebSocket将传感器的数据实时推送到客户端。这样客户端就可以实时地获取传感器的数据并进行处理。这种应用场景非常适合需要实时监控和控制的环境，比如智能家居系统、工业自动化等。 总之，Java WebSocket和RXTXComm都是Java技术中用于通信的工具。Java WebSocket用于实现网络上的实时双向通信，而RXTXComm用于与串行设备进行通信。它们可以分别单独使用，也可以结合起来使用来实现更为复杂和实时的应用。 ### 回答2： Java WebSocket和RXTXComm是两个不同的技术。 Java WebSocket是用于在Web浏览器和服务器之间进行实时双向通信的标准。它允许通过一个长时间保持的连接，在实时性要求较高的应用中进行双向数据传输。使用Java WebSocket，可以轻松地创建基于WebSocket的应用程序，以实现即时聊天、实时数据传输等功能。 RXTXComm是一个用于在Java中进行串口通信的库。它提供了一组API，用于与串口设备进行通信，例如Arduino、传感器等。使用RXTXComm，可以在Java应用程序中方便地进行串口数据的读取和写入。它提供了与串口设备进行交互所需的必要功能，如打开串口、设置波特率、读取和写入数据等。 在某些情况下，Java WebSocket和RXTXComm可以同时使用。例如，如果需要将传感器数据实时传输到Web浏览器中进行可视化，可以使用RXTXComm从传感器读取数据，然后使用Java WebSocket将数据发送到Web浏览器中。这样，可以实现从传感器到Web浏览器的实时数据传输和显示。 总之，Java WebSocket和RXTXComm是两种不同的技术，分别用于实现Web浏览器和服务器之间的实时双向通信以及Java应用程序与串口设备之间的数据交互。在某些情况下，它们可以一起使用，以实现特定需求下的实时数据传输和显示。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值