服务注册与分布式协调 / 系统课时

Java Watcher 实现

Java Watcher 实现

ZooKeeper Watcher 的难点不在实现 process 方法,而在于区分连接状态事件和节点事件,并记住普通 Watch 是一次性的。本篇实现一个数据监听器:收到变更后把重新注册工作移出回调线程,从而持续观察后续更新。

学习目标

  • 区分 EventType.None 的连接事件与带路径的节点事件。
  • 实现轻量的 Watcher.process,避免在事件线程中执行耗时操作。
  • 在节点事件触发后重新注册 Watch,并理解会话过期时的处理边界。

先区分连接事件和节点事件

创建 ZooKeeper 客户端时传入的 Watcher 既会收到连接状态变化,也可能作为默认 Watcher 被后续 API 使用。连接事件的 type 是 EventType.None,重点看 KeeperState;节点事件则看 NodeCreated、NodeDeleted、NodeDataChanged、NodeChildrenChanged 等类型,并通常带有节点路径。

普通 getData(path, watcher, stat)、exists(path, watcher) 和 getChildren(path, watcher) 注册的是一次性 Watch:事件触发后,这次注册就消费掉了。要继续监听后续变化,应用必须再次调用相应读取 API。

Java Watcher 一次触发与重新注册流程

这个“一次触发,再注册”的循环是理解原生 Watcher 的关键。Disconnected 通常表示临时失联,不等同于会话已经失效;而 Expired 表示旧会话已经结束,不能只在旧客户端上再次注册。

实现轻量回调并重新注册

下面示例监听一个临时创建的持久节点。process 只做事件分类和任务投递,真正的 getData 放到单线程执行器中完成,因此不会长时间占用 ZooKeeper 的事件派发线程。

java
import java.nio.charset.StandardCharsets;
import java.util.UUID;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;

public class DataWatchDemo implements Watcher {
    private final CountDownLatch connected = new CountDownLatch(1);
    private final ExecutorService worker = Executors.newSingleThreadExecutor();
    private ZooKeeper zk;
    private String path;

    public static void main(String[] args) throws Exception {
        String connectString = args.length > 0 ? args[0] : "127.0.0.1:2181";
        new DataWatchDemo().run(connectString);
    }

    private void run(String connectString) throws Exception {
        zk = new ZooKeeper(connectString, 5000, this);
        if (!connected.await(5, TimeUnit.SECONDS)) {
            throw new IllegalStateException("ZooKeeper connection timed out");
        }

        path = "/watch-demo-" + UUID.randomUUID();
        zk.create(path, "v0".getBytes(StandardCharsets.UTF_8),
                ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);

        registerDataWatch();
        zk.setData(path, "v1".getBytes(StandardCharsets.UTF_8), -1);
        Thread.sleep(500);
        zk.setData(path, "v2".getBytes(StandardCharsets.UTF_8), -1);
        Thread.sleep(500);

        zk.delete(path, -1);
        Thread.sleep(200);
        zk.close();
        worker.shutdownNow();
    }

    @Override
    public void process(WatchedEvent event) {
        if (event.getType() == Event.EventType.None) {
            System.out.println("connection=" + event.getState());
            if (event.getState() == Event.KeeperState.SyncConnected) {
                connected.countDown();
            } else if (event.getState() == Event.KeeperState.Expired) {
                System.out.println("session expired: create a new ZooKeeper client");
            }
            return;
        }

        System.out.println("node event=" + event.getType() + " path=" + event.getPath());

        // 普通 Watch 一次触发后即失效,把重新注册工作交给业务线程。
        if (event.getType() == Event.EventType.NodeDataChanged
                || event.getType() == Event.EventType.NodeCreated
                || event.getType() == Event.EventType.NodeDeleted) {
            worker.execute(this::registerDataWatch);
        }
    }

    private void registerDataWatch() {
        try {
            Stat stat = new Stat();
            byte[] data = zk.getData(path, this, stat);
            System.out.println("watch armed version=" + stat.getVersion()
                    + " data=" + new String(data, StandardCharsets.UTF_8));
        } catch (KeeperException.NoNodeException e) {
            try {
                // 节点不存在时改用 exists,等待它重新创建。
                zk.exists(path, this);
                System.out.println("node missing: existence watch armed");
            } catch (Exception inner) {
                System.err.println("failed to arm existence watch: " + inner.getMessage());
            }
        } catch (Exception e) {
            System.err.println("failed to arm data watch: " + e.getMessage());
        }
    }
}

预期输出

text
connection=SyncConnected
watch armed version=0 data=v0
node event=NodeDataChanged path=<PATH>
watch armed version=1 data=v1
node event=NodeDataChanged path=<PATH>
watch armed version=2 data=v2
node event=NodeDeleted path=<PATH>
node missing: existence watch armed

<PATH> 代表本次运行随机生成的节点路径;线程调度可能让日志时间略有差异,但每次数据变更之后都应看到新的 watch armed。关闭客户端时还可能出现额外的连接状态日志,不影响判断。

重新注册时要防两个误区

第一,不要在 process 中做慢查询、网络调用或长时间阻塞。ZooKeeper 客户端按顺序派发 Watch 事件,回调过慢会拖延同一客户端后续事件处理。把回调当成“快速分类器”,再交给业务线程处理更稳妥。

第二,重新注册并不等于事件队列。Watch 只告诉你“状态发生过变化”,应用应该在触发后重新读取当前状态,而不能假设每一次中间变化都会逐条送达。如果业务需要严格消费每个变更,应使用能够表达事件日志的其他机制,而不是把 Watch 当消息队列。

连接恢复和会话过期的边界

短暂 Disconnected 后,只要原会话仍有效,客户端恢复连接后可以继续工作;不要因为一次断连就盲目创建多个客户端。收到 Expired 时则不同:旧会话及其临时节点、Watch 语义都已经结束,应新建 ZooKeeper 实例,等待 SyncConnected,再按应用当前需要重新建立监听。

把“连接状态处理”和“节点监听逻辑”分开后,Watcher 会更容易维护:连接事件决定客户端是否还能使用,节点事件只负责提示重新读取并注册下一次 Watch。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

Java Watcher 实现

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通