最近公司的项目要采集客户服务器的文件，但按照常规的对接方法无法实现。遂开始了解监控文件的实现方式。

一、利用common-io包进行监控

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

有以下特点

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

1、导入依赖

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

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);
    }

}

3、 编写测试方法

public static void main(String[] args) throws Exception{
        // 监控目录
        String rootDir = "D:\\aaa";
        // 轮询间隔 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();
    }

二、基于WatchService实现文件监控

Java 7的新IO - NIO.2提供了一组新的类和方法，主要存在于java.nio包内。它完全取代了java.io.File与文件系统的交互，并提供了新的异步处理类，无需手动配置线程池和其他底层并发控制，便可在后台线程中执行文件和网络IO操作。
Watch Service API可用于将指定目录注册到监视服务上。注册时须指定事件类型，如文件创建，修改，删除等。相关类图如下：

Java中监视器连接数据库 java监视文件_Java中监视器连接数据库

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被返回。

实现流程如下

1.为文件系统创建一个WatchService 实例 watcher

2.为你想监听的目录注册 watcher。注册时，要注明监听那些事件。

3.在无限循环里面等待事件的触发。当一个事件发生时，key发出信号，并且加入到watcher的queue

4.从watcher的queue查找到key，你可以从中获取到文件名等相关信息

5.遍历key的各种事件

6.重置 key，重新等待事件

7.关闭服务

1、创建监听类

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;
        }
    }

  }
}

2、创建一个线程开始进行监听

public class MyWatchService {

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

3、看效果

接下来，见证奇迹的时刻

1.随便新建一个文件夹 例如 c:\test
2.运行程序 java TestWatcherService c:\test
3.在该文件夹下新建一个文件本件 “新建文本文档.txt”
4.将上述文件改名为 “abc.txt”
5.打开文件，输入点什么吧，再保存。
6.Over！看看命令行输出的信息吧

Event ENTRY_CREATE has happened,which fileName is 新建文本文档.txt
Event ENTRY_DELETE has happened,which fileName is 新建文本文档.txt
Event ENTRY_CREATE has happened,which fileName is abc.txt
Event ENTRY_MODIFY has happened,which fileName is abc.txt
Event ENTRY_MODIFY has happened,which fileName is abc.txt