如何通过WatchService监听文件夹中文件被覆盖的通知

Hey Stella, let's get your file overwrite notifications working! The issue with the basic WatchService example is that file overwrites often trigger a combination of events (not just MODIFY) depending on your OS, and the standard example might not be handling that correctly. Here's how to adjust your code to catch those overwrite events reliably:

First, Understand the Problem #

When you overwrite a file (like replacing A.JSON with a new version of the same name), most operating systems actually perform a delete-then-create operation behind the scenes. The basic example might only be listening for ENTRY_MODIFY, which won't catch this sequence. We need to listen for all relevant events and track this sequence.

Updated Code with Overflow Detection #

Here's a revised version of your code that specifically detects when a file is overwritten:

import java.io.IOException;
import java.nio.file.*;
import java.nio.file.WatchEvent.Kind;
import java.util.HashSet;
import java.util.Set;

public class FileOverwatch {
    public static void main(String[] args) throws IOException {
        Path targetDir = FileSystems.getDefault().getPath("/Users/XYZ/MyProjectWorkspace/MyTestProject/src");
        
        // Create a watch service and register the directory for all relevant events
        WatchService watchService = FileSystems.getDefault().newWatchService();
        targetDir.register(watchService, 
                StandardWatchEventKinds.ENTRY_CREATE,
                StandardWatchEventKinds.ENTRY_DELETE,
                StandardWatchEventKinds.ENTRY_MODIFY);

        // Track recently deleted files to detect overwrite sequences
        Set<Path> recentlyDeletedFiles = new HashSet<>();

        System.out.println("Watching directory for file overwrites: " + targetDir);

        while (true) {
            WatchKey watchKey;
            try {
                // Wait for events to occur
                watchKey = watchService.take();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return;
            }

            // Process each event
            for (WatchEvent<?> event : watchKey.pollEvents()) {
                Kind<?> eventKind = event.kind();

                // Ignore overflow events (too many events at once)
                if (eventKind == StandardWatchEventKinds.OVERFLOW) {
                    continue;
                }

                // Get the file name associated with the event
                @SuppressWarnings("unchecked")
                WatchEvent<Path> pathEvent = (WatchEvent<Path>) event;
                Path fileName = pathEvent.context();
                Path fullFilePath = targetDir.resolve(fileName);

                switch (eventKind.name()) {
                    case "ENTRY_DELETE":
                        // Add the deleted file to our tracking set
                        recentlyDeletedFiles.add(fileName);
                        break;
                    case "ENTRY_CREATE":
                        // Check if this file was just deleted (signaling an overwrite)
                        if (recentlyDeletedFiles.remove(fileName)) {
                            System.out.println("⚠️ File OVERWRITTEN: " + fileName);
                            // Add your notification logic here (email, alert, etc.)
                        } else {
                            System.out.println("✅ New file created: " + fileName);
                        }
                        break;
                    case "ENTRY_MODIFY":
                        // Some overwrite operations might trigger MODIFY (e.g., direct content replacement)
                        // You can add extra checks here (like file hash comparison) to confirm overwrite
                        System.out.println("🔄 File modified: " + fileName);
                        break;
                }
            }

            // Reset the watch key to continue listening for future events
            boolean keyIsValid = watchKey.reset();
            if (!keyIsValid) {
                System.out.println("Directory no longer exists or access denied. Stopping watch.");
                break;
            }
        }
    }
}

Key Improvements Explained #

• Listen for all critical events: By registering ENTRY_CREATE, ENTRY_DELETE, and ENTRY_MODIFY, we cover all possible ways a file overwrite can manifest across different OSes.
• Track deleted files: The recentlyDeletedFiles set lets us spot when a file is deleted and immediately recreated—this is the classic overwrite sequence.
• Handle overflow events: If too many events happen at once, the OS sends an OVERFLOW event. We ignore this to avoid breaking our logic.
• Reset the watch key: After processing events, we must call watchKey.reset() to keep receiving new events. If this returns false, the directory is gone or we lost access.

Edge Cases to Consider #

• Large file overwrites: If you're replacing a big file, you might get multiple ENTRY_MODIFY events as the file is written. You can add a check for the file's last modified time or compute a hash to confirm when the overwrite is complete.
• Permissions: Make sure your application has read/write access to the directory you're watching.
• OS-specific behavior: Windows and Unix-like systems might handle file overwrites slightly differently, so test your code on your target OS.

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