缓存文件变化 && WatchService监控文件变化分析

这样一个需求：
编写一个缓存池，把groovy文件每次加载到缓存池中，如果发生了变化，就把新的文件加到缓存池中，如果没变，就使用缓存池中的缓存文件。
我最开始使用静态的map作为缓存池来处理的，一方面是因为map便于查找，另一方面做成单例模式一切就ok。但是在判断文件是否变化的时候，老大觉得有点low，而且耽误时间。代码如下：

import restful.CacheElement;import transfer.ReloadHandler;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import java.io.File;import java.util.*;import java.util.concurrent.ConcurrentHashMap;public class CacheUtil {    private final static Logger logger = LoggerFactory.getLogger(CacheUtil.class);    private static Map<String, CacheElement> cacheElementMap = new ConcurrentHashMap<>();    private Set<String> fileSet = new LinkedHashSet<>();    private static final CacheUtil cacheUtil = new CacheUtil();    public static CacheUtil getCacheUtil() {        return cacheUtil;    }    /**     * 获取缓存对象，如果缓存对象被修改重新加载最新配置     *     * @param fileName     * @param handler     * @return     * @throws Exception     */    public Object getCache(String fileName, ReloadHandler handler) throws Exception {        fileName = fileName.trim();        if (isModified(fileName)) {            synchronized (this){                reload(fileName, handler);            }        }        return cacheElementMap.get(fileName).getCache();    }    private boolean isModified(String fileName) {        CacheElement cacheElement = cacheElementMap.get(fileName);        //没有被加载过        if (cacheElement == null) {            return true;        }        //被修改过        if (cacheElement.getFile().lastModified() != cacheElement.getLastEditTime()) {            return true;        }        //没变过        return false;    }    private void reload(String fileName, ReloadHandler handler) throws Exception {        CacheElement cacheElement = cacheElementMap.get(fileName);        if (cacheElement == null || cacheElement.getFile().lastModified() != cacheElement.getLastEditTime()) {            cacheElement = new CacheElement();            cacheElement.setFile(new File(fileName));            cacheElementMap.put(fileName, cacheElement);            if (!fileSet.contains(fileName)) {                fileSet.add(fileName);            }        }        cacheElement.setCache(handler.processNewCache());        cacheElement.setLastEditTime(cacheElement.getFile().lastModified());    }}

判断文件是否修改过的时候，使用了cacheElement.getFile().lastModified()，这个方法是大多数人都会使用的方法，但是弊端就是尽管不需要读写文件，但是还要读出文件的配置，获取最后修改时间，这样的方法还是有IO，对于要求较高的系统来说，不是很好的方法。
所以在老大的建议下，我使用了一下的方法。WatcherService，有点类似于观察者模式。下面介绍一下。

WatcherService

这个类的对象就是操作系统原生的文件系统监控器。每个系统都有自己的文件监控器，而这种监控器的实现是不需要比较和遍历的，基于的是信号收发的监控，效率一定最高。这个对于代码是很有帮助的。

Q:我要对文件进行一个监控，如果文件发生了变化就将新文件替换缓存中的文件。
A:这个问题可能第一时间的解决办法就是利用lastModified这个方法进行操作，比较和缓存中文件的时间是否一致。但是，这个方法有一个弊端，虽然不用读文件，但是获取文件配置也是要进行IO的，并不能缩短时间提高效率。这个时候就用上我们的WatchService了。

获取当前操作系统下的文件系统监控器：

watchService = FileSystems.getDefault().newWatchService();

OS上可以开启多个监控器，当然这里也可以开启多个监控器。不同的线程，所以互不影响。

获取了监控器以后，就要将你所要监控的文件夹，注册到监控器上，得让监控器知道监控哪个地方。

Path.register(watchService, StandardWatchEventKinds.ENTRY_CREATE,                StandardWatchEventKinds.ENTRY_DELETE, StandardWatchEventKinds.ENTRY_MODIFY);

Path就是获取的文件夹的路径，这里可以通过

Path path = Paths.get(String path)//path为文件夹路径

后面的看上去为常量的，是文件的状态，如果在本地跑的话，监控一个文件夹，这几个状态都会出现，是因为打开本地文件(word)本身就会创建出一个副本来，修改副本，并且最后将符文内容与主文件合并，删除副本，所以这几个状态在这里都会出现。

下面就是开始准备监控的过程了。

WatchKey

• 即监控键，说的明确一点就是该文件节点所绑定的监控器的监控信息池，即文件节点的监控池，简称监控池；
• 所有监控到的信息都会放到监控池中；
• register方法返回的就是节点的监控池；

监控池是静态的，它获取的是某一个时间节点下的文件变化信息（上面所说的常量），不能动态的保存。当register发生以后，返回的是一个空的监控池，即使后面发生了文件修改，如果不加以操作，这个监控池还是空的。只有当我们主动的去获取监控池的信息的时候，更新的操作才会放进监控池。

获取下一个信息，就是获取新的监控池

WatchKey watchKey = watchService.take();

这个语句，就是在尝试获取下一个信息，也就是获取新的监控池，如果没有变化的话，就会一直等待，这里可能解决了一些朋友分明写的是while循环，但是一直过不去这条一句的困惑。

WatchKey WatchService.poll(); // 尝试获取下一个变化信息的监控池，如果没有变化则返回null

这个与take的方法，异曲同工，只是用的地方不同。

获取监控池的具体信息

WatchEvent<?> watchEvent : watchKey.pollEvents()

当获取监控池的信息，发现有更新以后，就要获取其中信息到底是什么。这里对应的即为StandardWatchEventKinds对应的几个时间。这里为了严谨，一般采取遍历模式，遍历出此次操作变化的所有事件（例如改变word的例子）

下面就要说一下当发现有了这个事件的变化，我要如何处理了。这里主要提供了两个方法：

WatchEvent.Kind<?> kind = watchEvent.kind();Path fileName = watchEvent.context();

kind返回了目前在监控池中产生了什么事件，就是最开始定义的几种那样。
context返回了产生这个事件的文件名称

reset

最后需要重置监视器，使用poll或take时监控器线程就被阻塞了，因为你处理文件变化的操作可能需要挺长时间的，为了防止在这段时间内又要处理其他类似的事件，因此需要阻塞监控器线程，而调用reset表示重启该线程；

最后上一下代码：

import transfer.ReloadHandler;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import java.io.IOException;import java.nio.file.*;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;public class WatcherServiceUtil extends Thread{    private static final Logger logger = LoggerFactory.getLogger(WatcherServiceUtil.class);    private static WatchService watchService;    public WatcherServiceUtil(Path path) throws IOException {        watchService = FileSystems.getDefault().newWatchService();        path.register(watchService, StandardWatchEventKinds.ENTRY_CREATE,                StandardWatchEventKinds.ENTRY_DELETE, StandardWatchEventKinds.ENTRY_MODIFY);    }    public void run() {        logger.info("deal with the Events");        try {            while (true){                logger.info("while while while while");                WatchKey watchKey = watchService.take();                logger.info("watchKey watchKey watchKey");                for (WatchEvent<?> watchEvent : watchKey.pollEvents()) {                    logger.info("enter into the watchEvent");                    WatchEvent.Kind<?> kind = watchEvent.kind();                    if (kind == StandardWatchEventKinds.OVERFLOW) {                        continue;                    }                    Path fileName = (Path) watchEvent.context();                    logger.info("fileName: " + fileName.toString());                    if (kind.name().equals("ENTRY_MODIFY")) {                        synchronized (this){                            CachePoolUtil.getCachePoolUtil().reload(fileName.toString(), new ReloadHandler() {                                @Override                                public Object processNewCache() throws Exception {                                    return GroovyUtil.getInstance().newInstance("groovy/" + fileName.toString());                                }                            });                        }                        logger.info("Ready to return");                    }                }                if (!watchKey.reset()){                    break;                }            }        }catch (Exception e){            logger.info("error: " + e.getMessage());        }    }    public static void addListener(String path) throws Exception {        new WatcherServiceUtil(Paths.get(path)).run();    }}

这里继承了Thread类，主要是因为一般采用了take的连续监控，而不是poll的返回值方式，都是需要一个新的线程持续的监控，所以在主函数里面new一个线程，就可以解决问题了。