Zookeeper Watcher 机制详解
1、Watcher 机制：
Zookeeper 允许客户端向服务端的某个 Znode 注册一个 Watcher 监听，当服务端的一些指定事件触发了这个 Watcher，服务端会向指定客户端发送一个事件通知来实现分布式的通知功能，然后客户端根据 Watcher 通知状态和事件类型做出业务上的改变。
工作机制：（1）客户端注册 watcher（2）服务端处理 watcher（3）客户端回调 watcher
Watcher 特性：当数据发生变化的时候， zookeeper 会产生一个 watcher 事件，并且会发送到客户端。但是客户端只会收到一次通知。如果后续这个节点再次发生变化，那么之前设置 watcher 的客户端不会再次收到消息。（Watcher 是一次性的操作）。 当然，可以通过循环监听去达到永久监听效果。
2、Watcher 特性：
（1）一次性无论是服务端还是客户端，一旦一个 Watcher 被 触 发 ，Zookeeper 都会将其从相应的存储中移除。这样的设计有效的减轻了服务端的压力，不然对于更新非常频繁的节点，服务端会不断的向客户端发送事件通知，无论对于网络还是服务端的压力都非常大。
（2）客户端串行执行客户端 Watcher 回调的过程是一个串行同步的过程。
（3）轻量
3.1、Watcher 通知非常简单，只会告诉客户端发生了事件，而不会说明事件的具体内容。
3.2、客户端向服务端注册 Watcher 的时候，并不会把客户端真实的 Watcher 对象实体传递到服务端，仅仅是在客户端请求中使用 boolean 类型属性进行了标记。
（4）watcher event 异步发送 watcher 的通知事件从 server 发送到 client 是异步的，这就存在一个问题，不同的客户端和服务器之间通过 socket 进行通信，由于网络延迟或其他因素导致客户端在不通的时刻监听到事件，由于 Zookeeper 本身提供了 ordering guarantee，即客户端监听事件后，才会感知它所监视 znode发生了变化。所以我们使用 Zookeeper 不能期望能够监控到节点每次的变化。Zookeeper 只能保证最终的一致性，而无法保证强一致性。
（5）注册 watcher getData、exists、getChildren
（6）触发 watcher create、delete、setData
（7）当一个客户端连接到一个新的服务器上时，watch 将会被以任意会话事件触发。当与一个服务器失去连接的时候，是无法接收到 watch 的。而当 client 重新连接时，如果需要的话，所有先前注册过的 watch，都会被重新注册。通常这是完全透明的。只有在一个特殊情况下，watch 可能会丢失：对于一个未创建的 znode的 exist watch，如果在客户端断开连接期间被创建了，并且随后在客户端连接上之前又删除了，这种情况下，这个 watch 事件可能会被丢失。
3、客户端注册 Watcher 实现
（1）调用 getData()/getChildren()/exist()三个 API，传入 Watcher 对象
（2）标记请求 request，封装 Watcher 到 WatchRegistration
（3）封装成 Packet 对象，发服务端发送 request
（4）收到服务端响应后，将 Watcher 注册到 ZKWatcherManager 中进行管理
（5）请求返回，完成注册。
而可能监测的事件类型有: None,NodeCreated, NodeDataChanged, NodeDeleted, NodeChildrenChanged.
None // 客户端连接状态发生变化的时候 会收到None事件 NodeCreated // 节点创建事件 NodeDeleted // 节点删除事件 NodeDataChanged // 节点数据变化 NodeChildrenChanged // 子节点被创建 删除触发该事件
ZK 可以做到，只要数据一发生变化，就会通知相应地注册了监听的客户端。那么，它是怎么做到的呢？
其实原理应该是很简单的，四个步骤：
1. 客户端注册Watcher到服务端;
2. 服务端发生数据变更;
3. 服务端通知客户端数据变更;
4. 客户端回调Watcher处理变更应对逻辑;
（1）Zookeeper命令实现
#起两个客户端，都监听同一个节点 [root@ydt1 zookeeper-3.4.6]# ./bin/zkCli.sh [zk: localhost:2181(CONNECTED) 6] create /watchtest "abc" Created /watchtest [zk: localhost:2181(CONNECTED) 0] get /watchtest watch #监听节点变化 "111" cZxid = 0xf0000000a ctime = Wed Jul 29 17:00:30 CST 2020 mZxid = 0xf0000000b mtime = Wed Jul 29 17:01:03 CST 2020 pZxid = 0xf0000000a cversion = 0 dataVersion = 1 aclVersion = 0 ephemeralOwner = 0x0 dataLength = 5 numChildren = 0 #再起一个客户端，用来修改上一个客户端的节点数据 [root@ydt2 zookeeper-3.4.6]# ./bin/zkCli.sh [zk: localhost:2181(CONNECTED) 0] set /watchtest "111" cZxid = 0xf0000000a ctime = Wed Jul 29 17:00:30 CST 2020 mZxid = 0xf0000000b mtime = Wed Jul 29 17:01:03 CST 2020 pZxid = 0xf0000000a cversion = 0 dataVersion = 1 aclVersion = 0 ephemeralOwner = 0x0 dataLength = 5 numChildren = 0 #回过头再看两个监听节点，都可以看大节点数据变化的信息 [zk: localhost:2181(CONNECTED) 1] WATCHER:: WatchedEvent state:SyncConnected type:NodeDataChanged path:/watchtest #客户端再次修改该节点数据，监听客户端不会有响应，说明监听是一次性的
（2）Java API实现
package com.ydt.zookeeper.watcher; import org.apache.zookeeper.*; import org.apache.zookeeper.data.Stat; import org.junit.Before; import org.junit.Test; import java.io.IOException; public class WatcherTest { ZooKeeper zk; @Before public void init() throws IOException, KeeperException, InterruptedException { zk= new ZooKeeper("ydt1:2181,ydt2:2181,ydt3:2181" , Integer.MAX_VALUE,new Watcher() { //全局监听 public void process(WatchedEvent watchedEvent) { //客户端回调Watcher System.out.println("-----------------------------------------"); System.out.println("connect state:" + watchedEvent.getState()); System.out.println("event type:" + watchedEvent.getType()); System.out.println("znode path:" + watchedEvent.getPath()); System.out.println("-----------------------------------------"); } } ); } /** * exists监听事件： * NodeCreated：节点创建 * NodeDeleted：节点删除 * NodeDataChanged：节点内容 * @throws IOException * @throws KeeperException * @throws InterruptedException */ @Test public void test1() throws KeeperException, InterruptedException { //exists注册监听 zk.exists("/watcher-exists", new Watcher() { public void process(WatchedEvent watchedEvent) { System.out.println("-----------------------------------------"); System.out.println("connect state:" + watchedEvent.getState()); System.out.println("event type:" + watchedEvent.getType()); System.out.println("znode path:" + watchedEvent.getPath()); System.out.println("-----------------------------------------"); try { zk.exists("/watcher-exists",this); } catch (KeeperException e) { e.printStackTrace(); } catch (InterruptedException e) { e.printStackTrace(); } } }); //不开启ACL，以持久化自动生成序列方式创建 zk.create("/watcher-exists", "watcher-exists".getBytes() , ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); //通过修改的事务类型操作来触发监听事件 zk.setData("/watcher-exists", "watcher-exists2".getBytes(), -1); //删除节点看看能否触发监听事件 zk.delete("/watcher-exists", -1); } /** * getData监听事件： * NodeDeleted：节点删除 * NodeDataChange：节点内容发生变化 * @throws IOException * @throws KeeperException * @throws InterruptedException */ @Test public void test2() throws IOException, KeeperException, InterruptedException { //不开启ACL，以持久化自动生成序列方式创建 zk.create("/watcher-getData", "watcher-getData".getBytes() , ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); //getData注册监听 zk.getData("/watcher-getData", new Watcher() { public void process(WatchedEvent watchedEvent) { System.out.println("-----------------------------------------"); System.out.println("connect state:" + watchedEvent.getState()); System.out.println("event type:" + watchedEvent.getType()); System.out.println("znode path:" + watchedEvent.getPath()); System.out.println("-----------------------------------------"); try { zk.getData("/watcher-getData",this,null); } catch (KeeperException e) { e.printStackTrace(); } catch (InterruptedException e) { e.printStackTrace(); } } },null); //通过修改的事务类型操作来触发监听事件 zk.setData("/watcher-getData", "watcher-getData2".getBytes(), -1); //删除节点看看能否触发监听事件 zk.delete("/watcher-getData", -1); } /** * getChildren监听事件： * NodeChildrenChanged：子节点发生变化 * NodeDeleted：节点删除 * @throws IOException * @throws KeeperException * @throws InterruptedException */ @Test public void test3() throws IOException, KeeperException, InterruptedException { zk.create("/watcher-getChildren",null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); zk.create("/watcher-getChildren/watcher-getChildren01","watcher-getChildren01".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); //getChildren注册监听 zk.getChildren("/watcher-getChildren", new Watcher() { public void process(WatchedEvent watchedEvent) { System.out.println("-----------------------------------------"); System.out.println("connect state:" + watchedEvent.getState()); System.out.println("event type:" + watchedEvent.getType()); System.out.println("znode path:" + watchedEvent.getPath()); System.out.println("-----------------------------------------"); try { zk.getChildren("/watcher-getChildren",this); } catch (KeeperException e) { e.printStackTrace(); } catch (InterruptedException e) { e.printStackTrace(); } } }); zk.setData("/watcher-getChildren/watcher-getChildren01","watcher-getChildren02".getBytes(), -1);//修改子节点 zk.delete("/watcher-getChildren/watcher-getChildren01", -1);//删除子节点 zk.delete("/watcher-getChildren", -1);//删除根节点 } }
4. 服务端处理 Watcher 实现
（1）服务端接收 Watcher 并存储接收到客户端请求，处理请求判断是否需要注册 Watcher，需要的话将数据节点的节点路径和 ServerCnxn（ServerCnxn 代表一个客户端和服务端的连接，实现了 Watcher 的 process 接口，此时可以看成一个 Watcher 对象）存储在WatcherManager 的 WatchTable 和 watch2Paths 中去。
（2）Watcher 触发以服务端接收到 setData() 事务请求触发 NodeDataChanged 事件为例：
2.1 封装 WatchedEvent将通知状态（SyncConnected）、事件类型（NodeDataChanged）以及节点路径封装成一个 WatchedEvent 对象
2.2 查询 Watcher从 WatchTable 中根据节点路径查找 Watcher
2.3 没找到；说明没有客户端在该数据节点上注册过 Watcher2.4 找到；提取并从 WatchTable 和 Watch2Paths 中删除对应 Watcher（从这里可以看出 Watcher 在服务端是一次性的，触发一次就失效了）
（3）调用 process 方法来触发 Watcher这里 process 主要就是通过 ServerCnxn 对应的 TCP 连接发送 Watcher 事件通知。
5. 客户端回调 Watcher
客户端 SendThread 线程接收事件通知，交由 EventThread 线程回调 Watcher。客户端的 Watcher 机制同样是一次性的，一旦被触发后，该 Watcher 就失效了。
https://blog.csdn.net/huxiang19851114/article/details/114079324
