如何使用Java WatchService API监听所有驱动器及文件夹

Nice start with your basic WatchService implementation! The main limitations right now are that you're only registering a single drive (C:\) and not handling WatchKey resets or recursive folder monitoring. Let's revamp this to monitor all available drives and their subfolders properly.

Key Improvements We'll Make #

• Enumerate all available root drives on the system
• Recursively register every subfolder under each drive
• Properly handle WatchKey lifecycle (wait for keys, process events, reset keys)
• Handle edge cases like deleted directories

Modified Implementation #

import java.io.IOException;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.HashMap;
import java.util.Map;

public class DriveWatcher {
    // Map to track which WatchKey corresponds to which directory
    private static final Map<WatchKey, Path> keyToDirMap = new HashMap<>();

    public static void main(String[] args) throws IOException {
        WatchService watchService = FileSystems.getDefault().newWatchService();

        // Step 1: Fetch all available root drives (e.g., C:\, D:\, etc.)
        FileSystem fs = FileSystems.getDefault();
        for (Path root : fs.getRootDirectories()) {
            if (Files.isDirectory(root)) {
                System.out.println("Starting monitoring for drive: " + root);
                // Recursively register this drive and all its subfolders
                registerAll(root, watchService);
            }
        }

        // Step 2: Continuously process events from all registered keys
        while (true) {
            WatchKey key;
            try {
                // Block until a key signals an event
                key = watchService.take();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return;
            }

            Path dir = keyToDirMap.get(key);
            if (dir == null) {
                System.out.println("Unknown WatchKey received!");
                continue;
            }

            // Process each event for the triggered key
            for (WatchEvent<?> event : key.pollEvents()) {
                WatchEvent.Kind<?> kind = event.kind();

                // Skip OVERFLOW events (indicates missed events due to high volume)
                if (kind == StandardWatchEventKinds.OVERFLOW) {
                    continue;
                }

                // Get the path that triggered the event
                WatchEvent<Path> pathEvent = (WatchEvent<Path>) event;
                Path child = dir.resolve(pathEvent.context());
                System.out.println("Event Type: " + kind.name());
                System.out.println("Affected Path: " + child);
                try {
                    System.out.println("Last Modified: " + Files.getLastModifiedTime(child));
                } catch (IOException e) {
                    System.err.println("Could not retrieve modified time for: " + child);
                }

                // If a new directory is created, register it and its subfolders
                if (kind == StandardWatchEventKinds.ENTRY_CREATE && Files.isDirectory(child)) {
                    try {
                        registerAll(child, watchService);
                    } catch (IOException e) {
                        System.err.println("Failed to register new directory: " + child);
                    }
                }
            }

            // Reset the key to continue receiving future events
            boolean valid = key.reset();
            if (!valid) {
                // Key is invalid (directory was deleted), remove it from our tracking map
                keyToDirMap.remove(key);
                System.out.println("Stopped monitoring: " + dir);
                // Exit loop if no more directories are being monitored
                if (keyToDirMap.isEmpty()) {
                    break;
                }
            }
        }
    }

    // Recursively register a directory and all its subdirectories
    private static void registerAll(Path startDir, WatchService watchService) throws IOException {
        // Register the starting directory
        WatchKey key = startDir.register(watchService,
                StandardWatchEventKinds.ENTRY_CREATE,
                StandardWatchEventKinds.ENTRY_DELETE,
                StandardWatchEventKinds.ENTRY_MODIFY);
        keyToDirMap.put(key, startDir);

        // Traverse all subdirectories and register them
        Files.walkFileTree(startDir, new SimpleFileVisitor<Path>() {
            @Override
            public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
                if (!dir.equals(startDir)) { // Skip the root dir we already registered
                    WatchKey subKey = dir.register(watchService,
                            StandardWatchEventKinds.ENTRY_CREATE,
                            StandardWatchEventKinds.ENTRY_DELETE,
                            StandardWatchEventKinds.ENTRY_MODIFY);
                    keyToDirMap.put(subKey, dir);
                    System.out.println("Monitoring subdirectory: " + dir);
                }
                return FileVisitResult.CONTINUE;
            }
        });
    }
}

Key Details to Note #

1. Drive Enumeration: We use FileSystem.getRootDirectories() to automatically detect all available drives, so you don't have to hardcode paths like C:\.
2. Recursive Registration: The registerAll method uses Files.walkFileTree to traverse every subdirectory under a drive and register each one with the WatchService. The keyToDirMap ensures we can link each triggered WatchKey back to its directory.
3. Event Handling: Instead of relying on a single hardcoded WatchKey, we use watchService.take() to wait for any registered key to signal an event. We also handle new directory creation by registering them on the fly.
4. Key Reset & Cleanup: After processing events, we call key.reset() to keep the key active for future events. If a directory is deleted, the key becomes invalid, so we remove it from our map to avoid unnecessary processing.

Practical Considerations #

• Permissions: Ensure your program has read access to all drives and folders you're monitoring—system directories might throw exceptions if you lack permissions.
• Performance: Monitoring every folder on all drives can be resource-heavy on systems with large storage. Consider adding filters if you only need to monitor specific types of directories.
• Error Handling: The code includes basic error handling, but you might want to expand it based on your use case (e.g., logging instead of printing to console).

内容的提问来源于stack exchange，提问作者Dhruv Patil