遇到了监听配置文件是否被修改的需求，因功能规模小，没有加入 Apollo、config 等组件，所以得自己实现
1. 自行实现
第一想法是用定时任务去实现，下面是笔者的实现思路：FileModifyManager 来监听管理全部文件，要实现监听接口 FileListener 并传入给 FileModifyManager ，每当文件发生变化就调用监听接口的方法 doListener
1.1 FileListener
@FunctionalInterface
public interface FileListener {
void doListener();
}
看了 Hutool 文档才知道这种设计叫钩子函数，那笔者和 Hutool 作者思路也有相似之处
1.2 FileModifyManager
/**
* @author Howl
* @date 2022/01/15
*/
public class FileModifyManager {
// 存放监听的文件及 FileNodeRunnable 节点
private static ConcurrentHashMap<File, FileNodeRunnable> data = new ConcurrentHashMap<>(16);
// 线程池执行定时监听任务
private static ScheduledExecutorService service = Executors.newScheduledThreadPool(20);
// 单例模式--双重校验锁
private volatile static FileModifyManager instance = null;
private FileModifyManager() {
}
public static FileModifyManager getInstance() {
if (instance == null) {
synchronized (FileModifyManager.class) {
if (instance == null) {
instance = new FileModifyManager();
}
}
}
return instance;
}
// 开始监听，默认 10 秒监听一次
public FileModifyManager startWatch(File file, FileListener fileListener) throws Exception {
return startWatch(file, fileListener, 0, 1000 * 10, TimeUnit.MILLISECONDS);
}
public FileModifyManager startWatch(File file, FileListener fileListener, long delay, long period, TimeUnit timeUnit) throws Exception {
FileNodeRunnable fileNodeRunnable = addFile(file, fileListener);
ScheduledFuture<?> scheduledFuture = service.scheduleAtFixedRate(fileNodeRunnable, delay, period, timeUnit);
fileNodeRunnable.setFuture(scheduledFuture);
return instance;
}
// 停止监听
public FileModifyManager stopWatch(File file) {
return stopWatch(file, true);
}
public FileModifyManager stopWatch(File file, boolean mayInterruptIfRunning) {
FileNodeRunnable fileNodeRunnable = data.get(file);
fileNodeRunnable.getFuture().cancel(mayInterruptIfRunning);
removeFile(file);
return instance;
}
// 是否监听
public boolean isWatching(File file) {
return containsFile(file);
}
// 监听列表
public Set listWatching() {
return getFileList();
}
// 管理文件
private FileNodeRunnable addFile(File file, FileListener fileListener) throws Exception {
isFileExists(file);
FileNodeRunnable fileNodeRunnable = new FileNodeRunnable(file, fileListener, file.lastModified());
data.put(file, fileNodeRunnable);
return fileNodeRunnable;
}
private void removeFile(File file) {
data.remove(file);
}
private boolean containsFile(File file) {
return data.containsKey(file);
}
private Set getFileList() {
return data.keySet();
}
// 判断文件存在与否
private void isFileExists(File file) throws Exception {
if (!file.exists()) {
throw new Exception("文件或路径不存在");
}
}
// 文件节点及其定时任务
private class FileNodeRunnable implements Runnable {
private File file;
private long lastModifyTime;
private FileListener listener;
private ScheduledFuture future;
FileNodeRunnable(File file, FileListener listener, long lastModifyTime) {
this.file = file;
this.listener = listener;
this.lastModifyTime = lastModifyTime;
}
@Override
public void run() {
if (this.lastModifyTime != file.lastModified()) {
System.out.println(file.toString() + " lastModifyTime is " + this.lastModifyTime);
this.lastModifyTime = file.lastModified();
listener.doListener();
}
}
public ScheduledFuture getFuture() {
return future;
}
public void setFuture(ScheduledFuture future) {
this.future = future;
}
}
}
对外只暴露 startWatch、stopWatch、listWatching 三个方法，入参为 File 和 FileListener
Hutool 也是用了 HashMap 来存放对应的关系表，那笔者思路还是挺清晰的
1.3 使用案例
public class FileTest {
public static void main(String[] args) throws Exception {
File file1 = new File("C:\\Users\\Howl\\Desktop\\123.txt");
File file2 = new File("C:\\Users\\Howl\\Desktop\\1234.txt");
FileModifyManager manager = FileModifyManager.getInstance();
manager.startWatch(file1,() -> System.out.println("123.txt 文件改变了"))
.startWatch(file2,() -> System.out.println("1234.txr 文件改变了"));
}
}
2. WatchService
WatchService 是利用本机操作系统的文件系统来实现监控文件目录（监控目录），于 JDK1.7 引入的位于 NIO 包下的新机制，所以使用方式和 NIO 也很相似
JDK 自带的 watchService 的缺点是修改文件会触发两次事件，因操作系统有不同情况：
- 修改了文件的 meta 信息和日期
- 写时复制效果，即旧文件改名，并将内容复制到新建的文件里
watchService 只能监控本目录的内容，不能检测子目录里的内容，如需监控则遍历添加子目录
public class WatchServiceTest {
public static void main(String[] args) throws IOException, InterruptedException {
// 目录路径，不能输入文件否则报错
Path path = Paths.get("C:\\Users\\Howl\\Desktop");
// 获取监听服务
WatchService watchService = FileSystems.getDefault().newWatchService();
// 只注册修改事件（还有创建和删除）
path.register(watchService, StandardWatchEventKinds.ENTRY_MODIFY);
// 监听
while (true) {
// 获取监听到的事件 key
WatchKey watchKey = watchService.poll(3 * 1000, TimeUnit.MILLISECONDS);
// poll 的返回有可能为 null
if (watchKey == null) {
continue;
}
// 遍历这些事件
for (WatchEvent<?> watchEvent : watchKey.pollEvents()) {
if (watchEvent.kind() == StandardWatchEventKinds.ENTRY_MODIFY) {
Path watchPath = (Path) watchEvent.context();
File watchFile = watchPath.toFile();
System.out.println(watchFile.toString() + "文件修改了");
}
}
// watchKey 复原，用于下次监听
watchKey.reset();
}
}
}
3. Hutool（推荐）
Hutool 是国人维护的工具集，使用别人的轮子，总比自己重复造轮子高效（但也要了解轮子的设计思路），hutool 底层还是使用 WatchService ，其解决了修改文件会触发两次事件，思路是在某个毫秒数范围内的修改视为同一个修改。还可以监控子目录，思路是递归遍历
3.1 添加依赖
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.7.19</version>
</dependency>
参考文档 Hutool
3.2 示例
public class HutoolTest {
public static void main(String[] args) throws Exception {
File file = new File("C:\\Users\\Howl\\Desktop\\123.txt");
// 监听文件修改
WatchMonitor watchMonitor = WatchMonitor.create(file, WatchMonitor.ENTRY_MODIFY);
// 设置钩子函数
watchMonitor.setWatcher(new SimpleWatcher() {
@Override
public void onModify(WatchEvent<?> event, Path currentPath) {
System.out.println(((Path) event.context()).toFile().toString() + "修改了");
}
});
// 设置监听目录的最大深入，目录层级大于制定层级的变更将不被监听，默认只监听当前层级目录
watchMonitor.setMaxDepth(1);
// 启动监听
watchMonitor.start();
}
}
思路是继承 Thread 类，然后 run 方法一直循环监听 watchService 事件
4. commons-io
commons-io 是 Apache 提供的实现 I/O 操作的工具集
4.1 添加依赖
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.11.0</version>
</dependency>
4.2 示例
稍微看了一下使用的是观察者模式
public class CommonsTest {
public static void main(String[] args) throws Exception {
// 也是只能写目录
String filePath = "C:\\Users\\Howl\\Desktop";
// 文件观察者
FileAlterationObserver observer = new FileAlterationObserver(filePath);
// 添加监听
observer.addListener(new FileAlterationListenerAdaptor() {
@Override
public void onFileChange(File file) {
System.out.println(file.toString() + "文件修改了");
}
});
// 监视器
FileAlterationMonitor monitor = new FileAlterationMonitor(10);
// 添加观察者
monitor.addObserver(observer);
// 启动线程
monitor.start();
}
}