Java IO API实现监控目录变化的常用方法详解

import java.nio.file.*;
import java.nio.file.attribute.*;
import java.util.*;

public class WatchDir {
    public static void main(String[] args) throws Exception {
        Path dir = Paths.get("test"); // 监控的目录
        WatchService watcher = FileSystems.getDefault().newWatchService();
        
        // 注册监控的事件类型：创建、删除、修改
        WatchKey key = dir.register(watcher, StandardWatchEventKinds.ENTRY_CREATE, 
                                        StandardWatchEventKinds.ENTRY_DELETE, 
                                        StandardWatchEventKinds.ENTRY_MODIFY);
        
        // 循环等待事件
        while (true) {
            WatchKey signal = watcher.take(); // 阻塞直到发生事件
            for (WatchEvent<?> event : signal.pollEvents()) {
                WatchEvent.Kind<?> kind = event.kind();
                Path filename = (Path) event.context();
                System.out.println("Event " + kind + " occurred on file " + filename);
            }
            boolean valid = signal.reset(); // 重置 WatchKey 以继续监听
            if (!valid) {
                break; // 如果目录被删除或无法访问，则退出循环
            }
        }
    }
}

$ java WatchDir test &

import java.io.IOException;
import java.nio.file.*;
import java.util.HashMap;
import java.util.Map;
import static java.nio.file.StandardWatchEventKinds.*;
public class RecursiveDirectoryWatcher {
    private final WatchService watchService;
    private final Map<WatchKey, Path> keyPathMap = new HashMap<>();
    private final Path rootDir;
    public RecursiveDirectoryWatcher(String rootPath) throws IOException {
        this.watchService = FileSystems.getDefault().newWatchService();
        this.rootDir = Paths.get(rootPath);
        // 递归注册根目录及其所有子目录
        registerAll(rootDir);
    }
    private void registerAll(final Path start) throws IOException {
        // 遍历文件树，对所有目录进行注册
        Files.walkFileTree(start, new SimpleFileVisitor<>() {
            @Override
            public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
                registerDirectory(dir);
                return FileVisitResult.CONTINUE;
            }
        });
    }
    private void registerDirectory(Path dir) throws IOException {
        WatchKey key = dir.register(watchService, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY);
        keyPathMap.put(key, dir);
        System.out.println("监控目录: " + dir);
    }
    private void processEvents() throws InterruptedException {
        while (true) {
            WatchKey key = watchService.take(); // 阻塞等待事件
            Path dir = keyPathMap.get(key);
            if (dir == null) {
                System.err.println("无效的 WatchKey！");
                continue;
            }
            for (WatchEvent<?> event : key.pollEvents()) {
                // 处理事件溢出
                if (event.kind() == OVERFLOW) {
                    System.err.println("事件溢出，可能有文件被错过");
                    continue;
                }
                // 获取变更的条目名
                Path name = (Path) event.context();
                Path child = dir.resolve(name);
                // 输出事件
                System.out.printf("事件：%-12s -> %s%n", event.kind().name(), child);
                // 关键：如果是新增目录，需要将其加入监控
                if (event.kind() == ENTRY_CREATE && Files.isDirectory(child)) {
                    registerAll(child);
                }
            }
            // 必须重置key，否则将不再接收新事件
            boolean valid = key.reset();
            if (!valid) {
                System.out.println("目录 " + dir + " 可能已被移除，停止监控。");
                keyPathMap.remove(key);
                if (keyPathMap.isEmpty()) {
                    break;
                }
            }
        }
    }
    public void startWatcher() throws InterruptedException {
        System.out.println("开始监控根目录: " + rootDir);
        processEvents();
    }
    public static void main(String[] args) throws IOException, InterruptedException {
        RecursiveDirectoryWatcher watcher = new RecursiveDirectoryWatcher("/path/to/watch");
        watcher.startWatcher();
    }
}

import org.apache.commons.io.monitor.FileAlterationListenerAdaptor;
import org.apache.commons.io.monitor.FileAlterationMonitor;
import org.apache.commons.io.monitor.FileAlterationObserver;
import java.io.File;
public class CommonsIOWatcher {
    public static void main(String[] args) throws Exception {
        File directory = new File("/path/to/watch");
        // 创建观察者，这里可以配合 FileFilter 来指定只监控特定类型的文件
        FileAlterationObserver observer = new FileAlterationObserver(directory);
        // 创建监听器
        observer.addListener(new FileAlterationListenerAdaptor() {
            @Override
            public void onFileCreate(File file) {
                System.out.println("文件创建: " + file.getName());
            }
            @Override
            public void onFileChange(File file) {
                System.out.println("文件变更: " + file.getName());
            }
            @Override
            public void onFileDelete(File file) {
                System.out.println("文件删除: " + file.getName());
            }
        });
        // 创建监控器，设置轮询间隔 (单位: 毫秒)
        FileAlterationMonitor monitor = new FileAlterationMonitor(5000);
        monitor.addObserver(observer);
        monitor.start();
        // 保持程序运行，避免主线程退出
        Thread.currentThread().join();
    }
}