Java 如何监控文件目录的变化

JavaSE 1.7提供了相关的API，去监视文件或者文件夹的变动，主要的API都在java.nio.file下面，其大概流程如下：

package org.xdemo.superutil.j2se.filewatch

 

import static java.nio.file.LinkOption.NOFOLLOW_LINKS

 

import java.io.File

import java.io.IOException

import java.nio.file.FileSystems

import java.nio.file.FileVisitResult

import java.nio.file.Files

import java.nio.file.Path

import java.nio.file.Paths

import java.nio.file.SimpleFileVisitor

import java.nio.file.StandardWatchEventKinds

import java.nio.file.WatchEvent

import java.nio.file.WatchEvent.Kind

import java.nio.file.WatchKey

import java.nio.file.WatchService

import java.nio.file.attribute.BasicFileAttributes

import java.util.HashMap

import java.util.Map

 

/**

 * 文件夹监控

 * 

 * @author Goofy <a href="http://www.xdemo.org/">http://www.xdemo.org/</a>

 * @Date 2015年7月3日 上午9:21:33

 */

public class WatchDir {

 

    private final WatchService watcher

    private final Map<WatchKey, Path> keys

    private final boolean subDir

 

    /**

     * 构造方法

     * 

     * @param file

     *            文件目录，不可以是文件

     * @param subDir

     * @throws Exception

     */

    public WatchDir(File file, boolean subDir, FileActionCallback callback) throws Exception {

        if (!file.isDirectory())

            throw new Exception(file.getAbsolutePath() + "is not a directory!")

 

        this.watcher = FileSystems.getDefault().newWatchService()

        this.keys = new HashMap<WatchKey, Path>()

        this.subDir = subDir

 

        Path dir = Paths.get(file.getAbsolutePath())

 

        if (subDir) {

            registerAll(dir)

        } else {

            register(dir)

        }

        processEvents(callback)

    }

 

    @SuppressWarnings("unchecked")

    static <T> WatchEvent<T> cast(WatchEvent<?> event) {

        return (WatchEvent<T>) event

    }

 

    /**

     * 观察指定的目录

     * 

     * @param dir

     * @throws IOException

     */

    private void register(Path dir) throws IOException {

        WatchKey key = dir.register(watcher, StandardWatchEventKinds.ENTRY_CREATE, StandardWatchEventKinds.ENTRY_DELETE, StandardWatchEventKinds.ENTRY_MODIFY)

        keys.put(key, dir)

    }

 

    /**

     * 观察指定的目录，并且包括子目录

     */

    private void registerAll(final Path start) throws IOException {

        Files.walkFileTree(start, new SimpleFileVisitor<Path>() {

            @Override

            public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {

                register(dir)

                return FileVisitResult.CONTINUE

            }

        })

    }

 

    /**

     * 发生文件变化的回调函数

     */

    @SuppressWarnings("rawtypes")

    void processEvents(FileActionCallback callback) {

        for () {

            WatchKey key

            try {

                key = watcher.take()

            } catch (InterruptedException x) {

                return

            }

            Path dir = keys.get(key)

            if (dir == null) {

                System.err.println(" *** 作未识别")

                continue

            }

 

            for (WatchEvent<?> event : key.pollEvents()) {

                Kind kind = event.kind()

 

                // 事件可能丢失或遗弃

                if (kind == StandardWatchEventKinds.OVERFLOW) {

                    continue

                }

 

                // 目录内的变化可能是文件或者目录

                WatchEvent<Path> ev = cast(event)

                Path name = ev.context()

                Path child = dir.resolve(name)

                File file = child.toFile()

                if (kind.name().equals(FileAction.DELETE.getValue())) {

                    callback.delete(file)

                } else if (kind.name().equals(FileAction.CREATE.getValue())) {

                    callback.create(file)

                } else if (kind.name().equals(FileAction.MODIFY.getValue())) {

                    callback.modify(file)

                } else {

                    continue

                }

 

                // if directory is created, and watching recursively, then

                // register it and its sub-directories

                if (subDir && (kind == StandardWatchEventKinds.ENTRY_CREATE)) {

                    try {

                        if (Files.isDirectory(child, NOFOLLOW_LINKS)) {

                            registerAll(child)

                        }

                    } catch (IOException x) {

                        // ignore to keep sample readbale

                    }

                }

            }

 

            boolean valid = key.reset()

            if (!valid) {

                // 移除不可访问的目录

                // 因为有可能目录被移除，就会无法访问

                keys.remove(key)

                // 如果待监控的目录都不存在了，就中断执行

                if (keys.isEmpty()) {

                    break

                }

            }

        }

    }

 

}

jdk7 新增了WatchService，就是监控文件夹变化的。

可以监控 新增、改变、删除等.

如果不能用 jdk7，就需要自己判断了，得到目录文件，每隔几秒，再次检测，是否有增加、删除、改变

JDK 7 的nio2 WatchService可以监听文件系统。

Oracle官方教程链接 http://docs.oracle.com/javase/tutorial/essential/io/notification.html

样例代码：

import static java.nio.file.StandardWatchEventKinds.*

Path path = Paths.get("/home")

WatchService watchService = FileSystems.getDefault().newWatchService()

WatchKey watchKey = path.register(watchService,ENTRY_CREATE,ENTRY_DELETE,ENTRY_MODIFY)

/*

private boolean notDone = true

while(notDone){

    try{

         WatchKey watchKey = watchService.poll(60,TimeUnit.SECONDS)

         List<WatchEvent.Kind<?>> events = watchKey.pollEvents()

         for(WatchEvent event : events){

            //WatchKey watchable returns the calling Path object of Path.register

             Path watchedPath = (Path) watchKey.watchable()

             //returns the event type

             StandardWatchEventKinds eventKind = event.kind()

             //returns the context of the event

             Path target = (Path)event.context()

         }

         if(!watchKey.reset()){

            ...handle situation no longer valid

         }

     }catch(InterruptedException e){

            Thread.currentThread().interrupt()

     }

}

*/

---