使用WatchService忽略文件事件（创建、修改、删除）

Question

对于我当前的项目，我需要利用WatchService来跟踪给定目录中的事件。我的代码主要基于Oracles WatchService教程示例

但是，我需要将其限制为仅文件夹事件（例如ENTRY_CREATE C:\temp\folder_a）。

我试图做的是对目录的内容进行初始快照，并将每个内容路径存储到dirCache或fileCache中

如果注册了新事件，则应检查：

• 事件上下文是文件缓存中的文件还是

因此，应丢弃新文件事件或缓存中已存在的文件中的事件。

但是打印出事件会产生

条目_DELETE:C:\temp\k.txt

对于文件，但没有ENTRY_CREATE或ENTRY_MODIFY。

我做错了什么？我是不是没有正确检查缓存，还是缓存完全不同？

这是当前的代码库：

public class Main {
    public static void main(String[] args) {
        try {
            new DirectoryWatcher(Paths.get("C:\\temp")).processEvents();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

DirectoryWatcher类

package service;

import static java.nio.file.StandardWatchEventKinds.ENTRY_CREATE;
import static java.nio.file.StandardWatchEventKinds.ENTRY_DELETE;
import static java.nio.file.StandardWatchEventKinds.ENTRY_MODIFY;
import static java.nio.file.StandardWatchEventKinds.OVERFLOW;

import java.io.IOException;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.WatchEvent;
import java.nio.file.WatchEvent.Kind;
import java.nio.file.WatchKey;
import java.nio.file.WatchService;
import java.util.HashMap;
import java.util.Map;

/**
 * Slightly modified version of Oracle
 * example file WatchDir.java
 * /

public class DirectoryWatcher {
    private final Path path;
    private final WatchService watcher;
    private final Map<WatchKey,Path> keys;
    private PathSnapshot pathSnapshot;
    private boolean trace = false;

@SuppressWarnings("unchecked")
static <T> WatchEvent<T> cast(WatchEvent<?> event) {
    return (WatchEvent<T>)event;
}

/**
 * Register the given directory with the WatchService
 */
private void register(Path dir) throws IOException {
    WatchKey key = dir.register(watcher, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY);
    if (trace) {
        Path prev = keys.get(key);
        if (prev == null) {
            System.out.format("register: %s\n", dir);
        } else {
            if (!dir.equals(prev)) {
                System.out.format("update: %s -> %s\n", prev, dir);
            }
        }
    }
    keys.put(key, dir);
}

public DirectoryWatcher(Path dir) throws IOException {
    this.watcher = FileSystems.getDefault().newWatchService();
    this.keys = new HashMap<WatchKey,Path>();
    this.path = dir;
    this.pathSnapshot = new PathSnapshot(dir);

    register(dir);
    // enable trace after initial registration
    this.trace = true;
}

/**
 * Process all events for keys queued to the watcher
 */
void processEvents() {
    for (;;) {

        // wait for key to be signaled
        WatchKey key;
        try {
            key = watcher.take();
        } catch (InterruptedException x) {
            return;
        }

        Path dir = keys.get(key);
        if (dir == null) {
            System.err.println("WatchKey not recognized!!");
            continue;
        }

        for (WatchEvent<?> event: key.pollEvents()) {
            Kind<?> kind = event.kind();

            // TBD - provide example of how OVERFLOW event is handled
            if (kind == OVERFLOW) {
                continue;
            }

            // Context for directory entry event is the file name of entry
            WatchEvent<Path> ev = cast(event);
            Path name = ev.context();
            Path child = dir.resolve(name);
            this.updateDirContent();
            /*
             * currently: creating file events are neglected 
             * but deleting a file creates an event which is printed
             * TODO: disregard delete event if sent from file
             */
            boolean isFile = Files.isRegularFile(child);
            if (pathSnapshot.isInFileCache(child)|| isFile) {
                //disregard the event if file
                event = null;
            } else {
                // print out event
                System.out.format("%s: %s\n", event.kind().name(), child);
            }
        }

        // reset key and remove from set if directory no longer accessible
        boolean valid = key.reset();
        if (!valid) {
            keys.remove(key);
            // all directories are inaccessible
            if (keys.isEmpty()) {
                break;
            }
        }
    }
}

private void updateDirContent() {
    this.pathSnapshot = pathSnapshot.updateSnapshot(path);

}
}

路径快照类

package service;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.stream.Stream;

public class PathSnapshot {
    public ArrayList<Path> dirCache = new ArrayList<Path>();
    public ArrayList<Path> fileCache = new ArrayList<Path>();

    public PathSnapshot(Path dir) {
        try {
            Stream<Path> rawDirContent = Files.walk(
                    dir, 1);

            Object[] dirContent = rawDirContent.toArray();
            rawDirContent.close();

            sortIntoCache(dirContent, dir);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void sortIntoCache(Object[] dirContent, Path rootdir) {
        for (Object object : dirContent) {
            //create path from element
            Path objectPath = Paths.get(object.toString());
            //skip start path / the root directory
            if (object.equals(rootdir)) {
                continue;
            } else if (Files.isRegularFile(objectPath)) {
                fileCache.add(objectPath);
            } else if (Files.isDirectory(objectPath)) {
                dirCache.add(objectPath);
            }
        } 
    }

    public boolean isInFileCache(Path path) {
        if (fileCache.contains(path)) {
            return true;
        } else {
            return false;
        }
    }

    public boolean isInDirCache(Path path) {
        if (dirCache.contains(path)) {
            return true;
        } else {
            return false;
        }
    }

    public PathSnapshot updateSnapshot(Path dir){
        return new PathSnapshot(dir);
    }
}

Answer 1

您正在监听文件系统中所有可能的事件，因此没有更多的要求。如果操作系统没有提供更多事件和更详细的信息，Java什么也做不了。一些复杂的文件系统操作并不是由一个事件而是由一系列基本事件表示的。因此，您必须充分利用这些事件，并且必须解释一系列事件的实际含义。