java监控目录文件的两种实现方法

这里我们采用的是两种常用的方法，一中是基于jdk7之后，java自带的文件监控工具（Watch Service），一种是使用Commons-io的monitor下的相关类可以处理对文件进行监控。

1. 基于WatchService实现文件监控

Java 7的新IO - NIO.2提供了一组新的类和方法，主要存在于java.nio包内。它完全取代了java.io.File与文件系统的交互，并提供了新的异步处理类，无需手动配置线程池和其他底层并发控制，便可在后台线程中执行文件和网络IO操作。

Watch Service API可用于将指定目录注册到监视服务上。注册时须指定事件类型，如文件创建，修改，删除等。相关类图如下：

image

WatchService是监视服务接口，在不同系统上有不同的实现类。实现了Watchable接口的对象方可注册监视服务，java.nio.file.Path实现了此接口。WatchKey表示Watchable对象和WatchService的关联关系，在注册时被创建。注册完成后，WatchKey将被置为'ready'状态，直到下列三种情况之一发生：

WatchKey.cancel()被调用
被监控的目录不存在或不可访问
WatchService对象被关闭

当文件改动发生时，WatchKey的状态将会被置为"signaled"然后被放入待处理队列中。WatchService提供了三种从队列中获取WatchKeys的方式：

poll - 返回队列中的一个key。如果没有可用的key，将立即返回null。
poll(long, TimeUnit) - 如果队列中存在可用的key则将之返回，否则在参数预置的时间内等待可用的key。TimeUnit用来指定前一个参数表示的时间是纳秒、毫秒或是其他的时间单位。
例子：final WatchKey watchKey = watchService.poll(1, TimeUnit.MINUTES);将会等待1分钟
take - 方法将会等待直到可用的key被返回。
示例如下：

public class FileWatchTask implements Runnable {

public String fileDirectory;
public static final Logger logger = LoggerFactory.getLogger(FileWatchTask.class);

public FileWatchTask(String fileDirectory) {
    this.fileDirectory = fileDirectory;
}

ExecutorService cachedThreadPool = Executors.newFixedThreadPool(5);

public void run() {
    WatchService service = null;
    try {
        //获取当前文件系统的监控对象
        service = FileSystems.getDefault().newWatchService();
    } catch (Exception e) {
        e.printStackTrace();
    }
    try {
        //获取文件目录下的Path对象注册到 watchService中。
        //监听的事件类型，有创建，删除，以及修改
        Paths.get(fileDirectory)
                .register(service, StandardWatchEventKinds.ENTRY_CREATE, StandardWatchEventKinds.ENTRY_DELETE,
                        StandardWatchEventKinds.ENTRY_MODIFY);
    } catch (IOException e) {
        e.printStackTrace();
    }
    while (true) {
        WatchKey key = null;
        try {
            //获取可用key.没有可用的就wait
            key = service.take();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (WatchEvent<?> event : key.pollEvents()) {
            //todo
            logger.info(event.context() + "文件:" + event.kind() + "次数: " + event.count());
        }
        //重置，这一步很重要，否则当前的key就不再会获取将来发生的事件
        boolean valid = key.reset();
        //失效状态，退出监听
        if (!valid) {
            break;
        }
    }

  }
}

然后创建一个线程开始进行监听：

public class MyWatchService {

public static void main(String[] args) throws Exception {
    String propFileName = "c:/Users/zcl/Desktop"; //要监控的文件目录
    //因为是线程安全的所以可以放入ThreadPool中使用
    ExecutorService cachedThreadPool = Executors.newFixedThreadPool(1);
    cachedThreadPool.execute(new FileWatchTask(propFileName));
    }
}

2. 利用common-io包进行监控

使用Commons-io的monitor下的相关类可以处理对文件进行监控，它采用的是观察者模式来实现的

可以监控文件夹的创建、删除和修改
可以监控文件的创建、删除和修改
采用的是观察者模式来实现的
采用线程去定时去刷新检测文件的变化情况

2.1 导入依赖

<dependency>
  <groupId>commons-io</groupId>
  <artifactId>commons-io</artifactId>
  <version>2.6</version>
</dependency>

2.2 编写FileListener类

/**
 * 文件变化监听器
 *
 * 在Apache的Commons-IO中有关于文件的监控功能的代码. 文件监控的原理如下：
 * 由文件监控类FileAlterationMonitor中的线程不停的扫描文件观察器FileAlterationObserver，
 * 如果有文件的变化，则根据相关的文件比较器，判断文件时新增，还是删除，还是更改。（默认为1000毫秒执行一次扫描）
 *
 *
 */
public class FileListener extends FileAlterationListenerAdaptor {
    private Logger log = Logger.getLogger(FileListener.class);
    /**
     * 文件创建执行
     */
    public void onFileCreate(File file) {
        log.info("[新建]:" + file.getAbsolutePath());
    }

    /**
     * 文件创建修改
     */
    public void onFileChange(File file) {
        log.info("[修改]:" + file.getAbsolutePath());
    }

    /**
     * 文件删除
     */
    public void onFileDelete(File file) {
        log.info("[删除]:" + file.getAbsolutePath());
    }

    /**
     * 目录创建
     */
    public void onDirectoryCreate(File directory) {
        log.info("[新建]:" + directory.getAbsolutePath());
    }

    /**
     * 目录修改
     */
    public void onDirectoryChange(File directory) {
        log.info("[修改]:" + directory.getAbsolutePath());
    }

    /**
     * 目录删除
     */
    public void onDirectoryDelete(File directory) {
        log.info("[删除]:" + directory.getAbsolutePath());
    }

    public void onStart(FileAlterationObserver observer) {
        // TODO Auto-generated method stub
        super.onStart(observer);
    }

    public void onStop(FileAlterationObserver observer) {
        // TODO Auto-generated method stub
        super.onStop(observer);
    }

}

2.3 编写测试方法

public static void main(String[] args) throws Exception{
        // 监控目录
        String rootDir = "D:\\apache-tomcat-7.0.78";
        // 轮询间隔 5 秒
        long interval = TimeUnit.SECONDS.toMillis(1);
        // 创建过滤器
        IOFileFilter directories = FileFilterUtils.and(
                FileFilterUtils.directoryFileFilter(),
                HiddenFileFilter.VISIBLE);
        IOFileFilter files       = FileFilterUtils.and(
                FileFilterUtils.fileFileFilter(),
                FileFilterUtils.suffixFileFilter(".txt"));
        IOFileFilter filter = FileFilterUtils.or(directories, files);
        // 使用过滤器
        FileAlterationObserver observer = new FileAlterationObserver(new File(rootDir), filter);
        //不使用过滤器
        //FileAlterationObserver observer = new FileAlterationObserver(new File(rootDir));
        observer.addListener(new FileListener());
        //创建文件变化监听器
        FileAlterationMonitor monitor = new FileAlterationMonitor(interval, observer);
        // 开始监控
        monitor.start();
    }

3. 两者的区别

相比于jdk自带的文件监控，common-io有以下优点

可以对其子文件夹进行监控，只能提示目录被修改。
可以对文件类型进行过滤。
另外：当使用WatchService时，文件修改时，会被调用两次，输出两个相同的修改。