LinuxNetMonitor monitor = LinuxNetMonitor.builder()
    .enableLinkEvents(linkEventListener)
    .enableStatsPolling(5, TimeUnit.SECONDS, statsListener)
    .enablePing("8.8.8.8", 1000, pingListener)
    .build();
List<NetInterface> interfaces = monitor.queryInterfaces();
monitor.shutdown();

// 文件：com/example/netmonitor/LinuxNetMonitor.java
package com.example.netmonitor;
 
import java.util.*;
import java.util.concurrent.*;
import java.util.function.Consumer;
 
public class LinuxNetMonitor {
    private final NetlinkWatcher linkWatcher;
    private final StatsPoller statsPoller;
    private final PingProber pingProber;
    private final ExecutorService executor;
 
    private LinuxNetMonitor(Builder b) {
        this.executor = Executors.newCachedThreadPool();
        this.linkWatcher = b.enableLinkEvents
            ? new NetlinkWatcher(b.linkListener, executor) : null;
        this.statsPoller = b.enableStats
            ? new StatsPoller(b.statsInterval, b.statsUnit, b.statsListener, executor) : null;
        this.pingProber = b.pingTarget != null
            ? new PingProber(b.pingTarget, b.pingTimeout, b.pingUnit, b.pingListener, executor) : null;
    }
 
    public static Builder builder() { return new Builder(); }
 
    public static class Builder {
        private boolean enableLinkEvents = false;
        private LinkEventListener linkListener;
        private boolean enableStats = false;
        private long statsInterval; TimeUnit statsUnit; StatsListener statsListener;
        private String pingTarget; long pingTimeout; TimeUnit pingUnit; PingListener pingListener;
 
        public Builder enableLinkEvents(LinkEventListener l) {
            this.enableLinkEvents = true; this.linkListener = l; return this;
        }
        public Builder enableStatsPolling(long interval, TimeUnit unit, StatsListener l) {
            this.enableStats = true; this.statsInterval = interval; this.statsUnit = unit; this.statsListener = l; return this;
        }
        public Builder enablePing(String target, long timeout, TimeUnit unit, PingListener l) {
            this.pingTarget = target; this.pingTimeout = timeout; this.pingUnit = unit; this.pingListener = l; return this;
        }
        public LinuxNetMonitor build() { return new LinuxNetMonitor(this); }
    }
 
    public List<NetInterface> queryInterfaces() {
        return statsPoller == null ? Collections.emptyList() : statsPoller.getAllInterfaces();
    }
 
    public void shutdown() {
        if (linkWatcher != null) linkWatcher.shutdown();
        if (statsPoller != null) statsPoller.shutdown();
        if (pingProber != null) pingProber.shutdown();
        executor.shutdown();
    }
}
 
// 文件：com/example/netmonitor/NetlinkWatcher.java
package com.example.netmonitor;
 
import com.sun.jna.*;
import com.sun.jna.platform.linux.*;
import java.io.IOException;
import java.net.*;
import java.nio.*;
import java.util.concurrent.*;
 
public class NetlinkWatcher {
    private final LinkEventListener listener;
    private final ExecutorService exec;
    private volatile boolean running = true;
 
    public NetlinkWatcher(LinkEventListener l, ExecutorService exec) {
        this.listener = l; this.exec = exec;
        exec.submit(this::runWatcher);
    }
 
    private void runWatcher() {
        try {
            int fd = CLibrary.socket(CLibrary.AF_NETLINK, CLibrary.SOCK_RAW, CLibrary.NETLINK_ROUTE);
            CLibrary.bind(fd, CLibrary.RTMGRP_LINK | CLibrary.RTMGRP_IPV4_IFADDR | CLibrary.RTMGRP_IPV6_IFADDR);
            ByteBuffer buf = ByteBuffer.allocateDirect(4096);
            while (running) {
                int len = CLibrary.recv(fd, buf, buf.capacity(), 0);
                // 省略解析，假設(shè)解析出 ifaceName & newState
                String iface = parseIface(buf);
                boolean isUp = parseState(buf);
                listener.onLinkEvent(new LinkEvent(iface, isUp));
                buf.clear();
            }
        } catch (IOException e) {
            listener.onError(e);
        }
    }
 
    public void shutdown() { running = false; }
 
    // 偽代碼
    private String parseIface(ByteBuffer buf) { return "eth0"; }
    private boolean parseState(ByteBuffer buf) { return true; }
}
 
// 文件：com/example/netmonitor/StatsPoller.java
package com.example.netmonitor;
 
import java.io.*;
import java.nio.file.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.function.Consumer;
 
public class StatsPoller {
    private final ScheduledFuture<?> future;
    private final ConcurrentMap<String, NetInterface> cache = new ConcurrentHashMap<>();
 
    public StatsPoller(long interval, TimeUnit unit, StatsListener l, ExecutorService exec) {
        this.future = new ScheduledThreadPoolExecutor(1)
            .scheduleAtFixedRate(() -> poll(l), 0, interval, unit);
    }
 
    private void poll(StatsListener l) {
        try {
            List<NetInterface> list = new ArrayList<>();
            for (Path p : Files.newDirectoryStream(Paths.get("/sys/class/net"))) {
                String name = p.getFileName().toString();
                NetInterface ni = readInterface(name);
                cache.put(name, ni);
                list.add(ni);
            }
            l.onStats(list);
        } catch (IOException e) {
            l.onError(e);
        }
    }
 
    private NetInterface readInterface(String name) throws IOException {
        long rx = Long.parseLong(Files.readString(Path.of("/sys/class/net", name, "statistics", "rx_bytes")));
        long tx = Long.parseLong(Files.readString(Path.of("/sys/class/net", name, "statistics", "tx_bytes")));
        String state = Files.readString(Path.of("/sys/class/net", name, "operstate")).trim();
        return new NetInterface(name, state.equals("up"), rx, tx);
    }
 
    public List<NetInterface> getAllInterfaces() { return new ArrayList<>(cache.values()); }
    public void shutdown() { future.cancel(true); }
}
 
// 文件：com/example/netmonitor/PingProber.java
package com.example.netmonitor;
 
import java.io.IOException;
import java.net.*;
import java.util.concurrent.*;
 
public class PingProber {
    private final String target;
    private final int timeout;
    private final ExecutorService exec;
    private volatile boolean running = true;
 
    public PingProber(String target, long timeout, TimeUnit unit, PingListener l, ExecutorService exec) {
        this.target = target; this.timeout = (int)unit.toMillis(timeout); this.exec = exec;
        exec.submit(() -> runPing(l));
    }
 
    private void runPing(PingListener l) {
        while (running) {
            try {
                long start = System.nanoTime();
                boolean ok = InetAddress.getByName(target).isReachable(timeout);
                long dur = System.nanoTime() - start;
                l.onPingResult(new PingResult(target, ok, dur));
                Thread.sleep(1000);
            } catch (Exception e) {
                l.onError(e);
            }
        }
    }
 
    public void shutdown() { running = false; }
}
 
// 文件：com/example/netmonitor/NetInterface.java
package com.example.netmonitor;
 
public class NetInterface {
    public final String name;
    public final boolean up;
    public final long rxBytes, txBytes;
 
    public NetInterface(String n, boolean u, long rx, long tx) {
        this.name = n; this.up = u; this.rxBytes = rx; this.txBytes = tx;
    }
}
 
// 文件：com/example/netmonitor/LinkEventListener.java
package com.example.netmonitor;
 
public interface LinkEventListener {
    void onLinkEvent(LinkEvent ev);
    void onError(Throwable t);
}
 
// 文件：com/example/netmonitor/LinkEvent.java
package com.example.netmonitor;
 
public class LinkEvent {
    public final String iface;
    public final boolean isUp;
    public LinkEvent(String i, boolean u) { this.iface = i; this.isUp = u; }
}
 
// 文件：com/example/netmonitor/StatsListener.java
package com.example.netmonitor;
 
import java.util.List;
 
public interface StatsListener {
    void onStats(List<NetInterface> list);
    void onError(Throwable t);
}
 
// 文件：com/example/netmonitor/PingListener.java
package com.example.netmonitor;
 
public interface PingListener {
    void onPingResult(PingResult r);
    void onError(Throwable t);
}
 
// 文件：com/example/netmonitor/PingResult.java
package com.example.netmonitor;
 
public class PingResult {
    public final String target;
    public final boolean reachable;
    public final long latencyNanos;
    public PingResult(String t, boolean r, long l) { this.target = t; this.reachable = r; this.latencyNanos = l; }
}
 
// 文件：com/example/netmonitor/LinuxNetMonitorTest.java
package com.example.netmonitor;
 
import org.junit.jupiter.api.Test;
import java.util.List;
import static org.junit.jupiter.api.Assertions.*;
 
public class LinuxNetMonitorTest {
 
    @Test
    public void testQueryInterfaces() {
        LinuxNetMonitor m = LinuxNetMonitor.builder()
            .enableStatsPolling(1, java.util.concurrent.TimeUnit.SECONDS, stats -> {})
            .build();
        List<NetInterface> list = m.queryInterfaces();
        assertNotNull(list);
        m.shutdown();
    }
 
    @Test
    public void testLinkEvents() throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(1);
        LinuxNetMonitor m = LinuxNetMonitor.builder()
            .enableLinkEvents(ev -> { latch.countDown(); })
            .build();
        // 人工上下線 eth0 觸發(fā)
        assertTrue(latch.await(10, java.util.concurrent.TimeUnit.SECONDS));
        m.shutdown();
    }
 
    @Test
    public void testPingProber() throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(1);
        LinuxNetMonitor m = LinuxNetMonitor.builder()
            .enablePing("8.8.8.8", 1000, java.util.concurrent.TimeUnit.MILLISECONDS,
                r -> { assertTrue(r.reachable); latch.countDown(); })
            .build();
        assertTrue(latch.await(5, java.util.concurrent.TimeUnit.SECONDS));
        m.shutdown();
    }
}