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