Java實現監聽檔案變化的三種方案詳解

public class FileWatchDemo {
​
 /**
  * 上次更新時間
  */
 public static long LAST_TIME = 0L;
​
 public static void main(String[] args) throws IOException {
​
  String fileName = "/Users/zzs/temp/1.txt";
  // 建立檔案，僅為範例，實踐中由其他程式觸發檔案的變更
  createFile(fileName);
​
  // 執行2次
  for (int i = 0; i < 2; i++) {
   long timestamp = readLastModified(fileName);
   if (timestamp != LAST_TIME) {
    System.out.println("檔案已被更新：" + timestamp);
    LAST_TIME = timestamp;
    // 重新載入，檔案內容
   } else {
    System.out.println("檔案未更新");
   }
  }
 }
​
 public static void createFile(String fileName) throws IOException {
  File file = new File(fileName);
  if (!file.exists()) {
   boolean result = file.createNewFile();
   System.out.println("建立檔案：" + result);
  }
 }
​
 public static long readLastModified(String fileName) {
  File file = new File(fileName);
  return file.lastModified();
 }
}

public class WatchServiceDemo {
  public static void main(String[] args) throws IOException {
    // 這裡的監聽必須是目錄
    Path path = Paths.get("/Users/zzs/temp/");
    // 建立WatchService，它是對作業系統的檔案監視器的封裝，相對之前，不需要遍歷檔案目錄，效率要高很多
    WatchService watcher = FileSystems.getDefault().newWatchService();
    // 註冊指定目錄使用的監聽器，監視目錄下檔案的變化；
    // PS：Path必須是目錄，不能是檔案；
    // StandardWatchEventKinds.ENTRY_MODIFY，表示監視檔案的修改事件
    path.register(watcher, StandardWatchEventKinds.ENTRY_MODIFY);
​
    // 建立一個執行緒，等待目錄下的檔案發生變化
    try {
      while (true) {
        // 獲取目錄的變化:
        // take()是一個阻塞方法，會等待監視器發出的訊號才返回。
        // 還可以使用watcher.poll()方法，非阻塞方法，會立即返回當時監視器中是否有訊號。
        // 返回結果WatchKey，是一個單例物件，與前面的register方法返回的範例是同一個；
        WatchKey key = watcher.take();
        // 處理檔案變化事件：
        // key.pollEvents()用於獲取檔案變化事件，只能獲取一次，不能重複獲取，類似佇列的形式。
        for (WatchEvent<?> event : key.pollEvents()) {
          // event.kind()：事件型別
          if (event.kind() == StandardWatchEventKinds.OVERFLOW) {
            //事件可能lost or discarded
            continue;
          }
          // 返回觸發事件的檔案或目錄的路徑（相對路徑）
          Path fileName = (Path) event.context();
          System.out.println("檔案更新: " + fileName);
        }
        // 每次呼叫WatchService的take()或poll()方法時需要通過本方法重置
        if (!key.reset()) {
          break;
        }
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}
複製程式碼

PollingWatchService() {
        // TBD: Make the number of threads configurable
        scheduledExecutor = Executors
            .newSingleThreadScheduledExecutor(new ThreadFactory() {
                 @Override
                 public Thread newThread(Runnable r) {
                     Thread t = new Thread(null, r, "FileSystemWatcher", 0, false);
                     t.setDaemon(true);
                     return t;
                 }});
    }

void enable(Set<? extends Kind<?>> var1, long var2) {
            synchronized(this) {
                this.events = var1;
                Runnable var5 = new Runnable() {
                    public void run() {
                        PollingWatchKey.this.poll();
                    }
                };
                this.poller = PollingWatchService.this.scheduledExecutor.scheduleAtFixedRate(var5, var2, var2, TimeUnit.SECONDS);
            }
        }

public enum SensitivityWatchEventModifier implements Modifier {
    HIGH(2),
    MEDIUM(10),
    LOW(30);
    // ...
}

path.register(watcher, new WatchEvent.Kind[]{StandardWatchEventKinds.ENTRY_MODIFY},
        SensitivityWatchEventModifier.HIGH);

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

public class FileListener extends FileAlterationListenerAdaptor {
​
  @Override
  public void onStart(FileAlterationObserver observer) {
    super.onStart(observer);
    System.out.println("onStart");
  }
​
  @Override
  public void onDirectoryCreate(File directory) {
    System.out.println("新建：" + directory.getAbsolutePath());
  }
​
  @Override
  public void onDirectoryChange(File directory) {
    System.out.println("修改：" + directory.getAbsolutePath());
  }
​
  @Override
  public void onDirectoryDelete(File directory) {
    System.out.println("刪除：" + directory.getAbsolutePath());
  }
​
  @Override
  public void onFileCreate(File file) {
    String compressedPath = file.getAbsolutePath();
    System.out.println("新建：" + compressedPath);
    if (file.canRead()) {
      // TODO 讀取或重新載入檔案內容
      System.out.println("檔案變更，進行處理");
    }
  }
​
  @Override
  public void onFileChange(File file) {
    String compressedPath = file.getAbsolutePath();
    System.out.println("修改：" + compressedPath);
  }
​
  @Override
  public void onFileDelete(File file) {
    System.out.println("刪除：" + file.getAbsolutePath());
  }
​
  @Override
  public void onStop(FileAlterationObserver observer) {
    super.onStop(observer);
    System.out.println("onStop");
  }
}

public class FileMonitor {
  private FileAlterationMonitor monitor;
​
  public FileMonitor(long interval) {
    monitor = new FileAlterationMonitor(interval);
  }
  /**
   * 給檔案新增監聽
   *
   * @param path     檔案路徑
   * @param listener 檔案監聽器
   */
  public void monitor(String path, FileAlterationListener listener) {
    FileAlterationObserver observer = new FileAlterationObserver(new File(path));
    monitor.addObserver(observer);
    observer.addListener(listener);
  }
​
  public void stop() throws Exception {
    monitor.stop();
  }
​
  public void start() throws Exception {
    monitor.start();
​
  }
}

public class FileRunner {
​
  public static void main(String[] args) throws Exception {
    FileMonitor fileMonitor = new FileMonitor(1000);
    fileMonitor.monitor("/Users/zzs/temp/", new FileListener());
    fileMonitor.start();
  }
}

public FileAlterationObserver(String directoryName, FileFilter fileFilter, IOCase caseSensitivity) {
    this(new File(directoryName), fileFilter, caseSensitivity);
}