diamond源码阅读-目录监控

PathNode(Path)
StandardWatchEventKind(WatchEvent)
Watchable(WatchKey WatchService WatchEvent)
WatchKey(PathNode WatchEvent WatchService)
WatchService(WatchKey Path)
WatchEvent
FileSystem(WatchService)
Path>Watchable

WatchEvent
StandardWatchEventKind(ENTRY_CREATE； ENTRY_DELETE； ENTRY_MODIFY； OVERFLOW)

WatchService  WatchKey

WatchService
1 register 注册监视目录 ，生成watchedKey（遍历子目录，每个文件都注册一个事件），添加到watchedKeys

  1.1

    public WatchKey register(Path root, boolean fireCreatedEventOnIndex, WatchEvent.Kind<?>... events) {
        if (events == null || events.length == 0)
            throw new UnsupportedOperationException("null events");
        if (this.service.isShutdown())
            throw new IllegalStateException("服务已经关闭");
        if (!root.exists())
            throw new IllegalArgumentException("监视的目录不存在");
        WatchKey key = new WatchKey(root, this, fireCreatedEventOnIndex, events);
        resetKey(key);
        return key;
    }

 1.1.1 WatchKey

   public WatchKey(final Path path, final WatchService watcher, boolean fireCreatedEventOnIndex,
            WatchEvent.Kind<?>... events) {
        valid = true;
        this.watcher = watcher;
        // 建立内存索引
        this.root = new PathNode(path, true);
        if (events != null) {
            for (WatchEvent.Kind<?> event : events) {
                filterSet.add(event);
            }
        }
        LinkedList<WatchEvent<?>> changedEvents = new LinkedList<WatchEvent<?>>();
        index(this.root, fireCreatedEventOnIndex, changedEvents);
        this.changedEvents = changedEvents;
    }

  1.1.1.1 WatchKey  为每个目录下子文件建立一个ENTRY_CREATE 监听事件

  private void index(PathNode node, boolean fireCreatedEventOnIndex, LinkedList<WatchEvent<?>> changedEvents) {
        File file = node.getPath().getFile();
        if (!file.isDirectory()) {
            return;
        }
        File[] subFiles = file.listFiles();
        if (subFiles != null) {
            for (File subFile : subFiles) {
                PathNode subNode = new PathNode(new Path(subFile), false);
                if (fireCreatedEventOnIndex) {
                    changedEvents.add(new WatchEvent<Path>(StandardWatchEventKind.ENTRY_CREATE, 1, subNode.getPath()));
                }
                node.addChild(subNode);
                if (subNode.getPath().isDirectory()) {
                    index(subNode, fireCreatedEventOnIndex, changedEvents);
                }
            }
        }
    }

2  启动的一个线程，定时扫描watchedKeys,调用watchedKey.check(),
　　如果有变化，watchedKeys 删掉watchedKey ，changedKeys add watchedKey

　　

    public WatchService(long checkInterval) {
        service = Executors.newSingleThreadScheduledExecutor();
        service.scheduleAtFixedRate(new CheckThread(), checkInterval, checkInterval, TimeUnit.MILLISECONDS);
    }

    private final class CheckThread implements Runnable {
        public void run() {
            check();
        }
    }

  /**
     * 主动check
     */
    public void check() {
        synchronized (this) {
            Iterator<WatchKey> it = watchedKeys.iterator();
            while (it.hasNext()) {
                WatchKey key = it.next();
                try {
                    if (key.check()) {
                        changedKeys.add(key);
                        it.remove();
                    }
                }
                catch (Throwable t) {
                    log.error("检测WatchKey异常,key=" + key, t);
                }
            }
        }
    }

 2.1 key.check()

　　

    boolean check() {
        if (this.changedEvents != null && this.changedEvents.size() > 0)
            return true;
        if (!this.valid)
            return false;
        List<WatchEvent<?>> list = new LinkedList<WatchEvent<?>>();
        if (check(root, list)) {
            this.changedEvents = list;
            return true;
        }
        else {
            return false;
        }
    }

2.1.1

　　

    private boolean check(PathNode node, List<WatchEvent<?>> changedEvents) {
        Path nodePath = node.getPath();
        File nodeNewFile = new File(nodePath.getAbsolutePath());
        if (nodePath != null) {
            if (node.isRoot()) {
                if (!nodeNewFile.exists())
                    return fireOnRootDeleted(changedEvents, nodeNewFile);//触发删除事件，添加到当前watchedKey的changedEvents
                else {
                    return checkNodeChildren(node, changedEvents, nodeNewFile);
                }
            }
            else {
                return checkNodeChildren(node, changedEvents, nodeNewFile);
            }
        }
        else
            throw new IllegalStateException("PathNode没有path");
    }

2.1.1.1 监听新增事件 修改事件，若有讲事件添加到当前watchedKey的changedEvents

  private boolean checkNodeChildren(PathNode node, List<WatchEvent<?>> changedEvents, File nodeNewFile) {
        boolean changed = false;
        Iterator<PathNode> it = node.getChildren().iterator();
        // 用于判断是否有新增文件或者目录的现有名称集合
        Set<String> childNameSet = new HashSet<String>();
        while (it.hasNext()) {
            PathNode child = it.next();
            Path childPath = child.getPath();
            childNameSet.add(childPath.getName());
            File childNewFile = new File(childPath.getAbsolutePath());
            // 1、判断文件是否还存在
            if (!childNewFile.exists() && filterSet.contains(StandardWatchEventKind.ENTRY_DELETE)) {
                changed = true;
                changedEvents.add(new WatchEvent<Path>(StandardWatchEventKind.ENTRY_DELETE, 1, childPath));
                it.remove();// 移除节点
            }
            // 2、如果是文件，判断是否被修改
            if (childPath.isFile()) {
                if (checkFile(changedEvents, child, childNewFile) && !changed) {
                    changed = true;
                }

            }
            // 3、递归检测目录
            if (childPath.isDirectory()) {
                if (check(child, changedEvents) && !changed) {
                    changed = true;
                }
            }
        }

        // 查看是否有新增文件
        File[] newChildFiles = nodeNewFile.listFiles();
        if(newChildFiles!=null)
        for (File newChildFile : newChildFiles) {
            if (!childNameSet.contains(newChildFile.getName())
                    && filterSet.contains(StandardWatchEventKind.ENTRY_CREATE)) {
                changed = true;
                Path newChildPath = new Path(newChildFile);
                changedEvents.add(new WatchEvent<Path>(StandardWatchEventKind.ENTRY_CREATE, 1, newChildPath));
                PathNode newSubNode = new PathNode(newChildPath, false);
                node.addChild(newSubNode);// 新增子节点
                // 如果是目录，递归调用
                if (newChildFile.isDirectory()) {
                    checkNodeChildren(newSubNode, changedEvents, newChildFile);
                }
            }
        }
        return changed;
    }

 

3 如何使用

 private void startCheckLocalDir(final String filePath) {
        final WatchService watcher = FileSystem.getDefault().newWatchService();

        Path path = new Path(new File(filePath));
        // 注册事件
        watcher.register(path, true, StandardWatchEventKind.ENTRY_CREATE, StandardWatchEventKind.ENTRY_DELETE,
            StandardWatchEventKind.ENTRY_MODIFY);
        // 第一次运行，主动check
        checkAtFirst(watcher);
        singleExecutor.execute(new Runnable() {
            public void run() {
                log.debug(">>>>>>已经开始监控目录<<<<<<");
                // 无限循环等待事件
                while (isRun) {
                    // 凭证
                    WatchKey key;
                    try {
                        key = watcher.take();
                    }
                    catch (InterruptedException x) {
                        continue;
                    }
                    // reset，如果无效，跳出循环,无效可能是监听的目录被删除
                    if (!processEvents(key)) {
                        log.error("reset unvalid,监控服务失效");
                        break;
                    }
                }
                log.debug(">>>>>>退出监控目录<<<<<<");
                watcher.close();

            }

        });
    }

3.1 处理触发的事件，并继续监听

 /**
     * 处理触发的事件
     * 
     * @param key
     * @return
     */
    @SuppressWarnings({ "unchecked" })
    private boolean processEvents(WatchKey key) {
        /**
         * 获取事件集合
         */
        for (WatchEvent<?> event : key.pollEvents()) {
            // 事件的类型
            // WatchEvent.Kind<?> kind = event.kind();

            // 通过context方法得到发生事件的path
            WatchEvent<Path> ev = (WatchEvent<Path>) event;
            Path eventPath = ev.context();

            String realPath = eventPath.getAbsolutePath();
            if (ev.kind() == StandardWatchEventKind.ENTRY_CREATE || ev.kind() == StandardWatchEventKind.ENTRY_MODIFY) {

                String grandpaDir = null;
                try {
                    grandpaDir = FileUtils.getGrandpaDir(realPath);
                }
                catch (Exception e1) {

                }
                if (!Constants.BASE_DIR.equals(grandpaDir)) {
                    log.error("无效的文件进入监控目录: " + realPath);
                    continue;
                }
                existFiles.put(realPath, System.currentTimeMillis());
                if (log.isInfoEnabled()) {
                    log.info(realPath + "文件被添加或更新");
                }
            }
            else if (ev.kind() == StandardWatchEventKind.ENTRY_DELETE) {
                String grandpaDir = null;
                try {
                    grandpaDir = FileUtils.getGrandpaDir(realPath);
                }
                catch (Exception e1) {

                }
                if (Constants.BASE_DIR.equals(grandpaDir)) {
                    // 删除的是文件
                    existFiles.remove(realPath);
                    if (log.isInfoEnabled()) {
                        log.info(realPath + "文件被被删除");
                    }
                }
                else {
                    // 删除的是目录
                    Set<String> keySet = new HashSet<String>(existFiles.keySet());
                    for (String filePath : keySet) {
                        if (filePath.startsWith(realPath)) {
                            existFiles.remove(filePath);
                            if (log.isInfoEnabled()) {
                                log.info(filePath + "文件被删除");
                            }
                        }
                    }

                }
            }
        }
        return key.reset();//WatchService 继续监听
    }