JAVA實時監控目錄下檔案的變化

一、commons-io方法

1、使用Commons-io的monitor下的相關類可以處理對檔案進行監控，它采用的是觀察者模式來實作的

（1）可以監控檔案夾的建立、删除和修改
（2）可以監控檔案的建立、删除和修改
（3）采用的是觀察者模式來實作的
（4）采用線程去定時去重新整理檢測檔案的變化情況
           

2、引入commons-io包，需要2.0以上。

<!-- https://mvnrepository.com/artifact/commons-io/commons-io -->
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.6</version>
</dependency>
           

3、編寫繼承FileAlterationListenerAdaptor的類FileListener。

import java.io.File;

import org.apache.commons.io.monitor.FileAlterationListenerAdaptor;
import org.apache.commons.io.monitor.FileAlterationObserver;
import org.apache.log4j.Logger;

/**
 * 檔案變化監聽器
 *
 * 在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);
    }

}
           

4、實作main方法

public static void main(String[] args) throws Exception{
        // 監控目錄
        String rootDir = "D:\\apache-tomcat-7.0.78";
        // 輪詢間隔 5 秒
        long interval = TimeUnit.SECONDS.toMillis();
        // 建立過濾器
        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();
    }
           

二、使用JDK7提供的WatchService

public static void main(String[] a) {

        final Path path = Paths.get("D:\\apache-tomcat-7.0.78");

        try (WatchService watchService = FileSystems.getDefault().newWatchService()) {
            //給path路徑加上檔案觀察服務
            path.register(watchService, StandardWatchEventKinds.ENTRY_CREATE,
                    StandardWatchEventKinds.ENTRY_MODIFY,
                    StandardWatchEventKinds.ENTRY_DELETE);
            while (true) {
                final WatchKey key = watchService.take();

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

                    final WatchEvent.Kind<?> kind = watchEvent.kind();

                    if (kind == StandardWatchEventKinds.OVERFLOW) {
                        continue;
                    }
                    //建立事件
                    if (kind == StandardWatchEventKinds.ENTRY_CREATE) {
                        System.out.println("[建立]");
                    }
                    //修改事件
                    if (kind == StandardWatchEventKinds.ENTRY_MODIFY) {
                        System.out.println("修改]");
                    }
                    //删除事件
                    if (kind == StandardWatchEventKinds.ENTRY_DELETE) {
                        System.out.println("[删除]");
                    }
                    // get the filename for the event
                    final WatchEvent<Path> watchEventPath = (WatchEvent<Path>) watchEvent;
                    final Path filename = watchEventPath.context();
                    // print it out
                    System.out.println(kind + " -> " + filename);

                }
                boolean valid = key.reset();
                if (!valid) {
                    break;
                }
            }

        } catch (IOException | InterruptedException ex) {
            System.err.println(ex);
        }

    }
           

三、以上方法都可以實作對相應檔案夾得檔案監控，但是在使用jdk7提供的API時，會出現些許問題。

（1）當檔案修改時，會被調用兩次，即輸出兩個相同的修改。
（2）不能對其子檔案夾進行監控，隻能提示目錄被修改。
（3）無法對檔案類型進行過濾。