详解Zookeeper基础知识详解Zookeeper基础知识

1. 简介
2. 数据模型

2.1 模型结构
2.2 模型的特点
2.3 节点分类

2.3.1 Persistent
2.3.2 Persistent Sequential
2.3.3 Ephemeral
2.3.4 Ephemeral Sequential

3. 安装

3.1 官方

3.2 docker

3.3 docker-compose

3.4 配置信息

4. 基础命令

4.1 创建会话

4.2 ls

4.3 create

4.4 get

4.5 stat

4.6 set

4.7 delete

4.8 quit

5. 节点的监听机制

6. quick start

6.1 项目结构

6.2 引入依赖

6.3 application.

6.4 CuratorClientProperties

6.5 CuratorClientConfig

6.6 CuratorClient

6.7 AppController

7. ZAB 协议介绍

1. 简介 zookeeper是一个开源的分布式协调服务, 提供分布式数据一致性解决方案,分布式应用程序可以实现数据统一配置管理、统一命名服务、分布式锁、集群管理等功能.
ZooKeeper主要服务于分布式系统，使用分布式系统就无法避免对节点管理的问题(需要实时感知节点的状态、对节点进行统一管理等等)，而由于这些问题处理起来可能相对麻烦和提高了系统的复杂性，ZooKeeper作为一个能够通用解决这些问题的中间件就应运而生了。

2. 数据模型
2.1 模型结构
ZooKeeper 提供的命名空间很像标准文件系统的命名空间。名称是由斜杠 (/) 分隔的一系列路径元素。ZooKeeper 命名空间中的每个节点都由路径标识。
与典型的为存储而设计的文件系统不同，ZooKeeper 数据保存在内存中，这意味着 ZooKeeper 可以实现高吞吐量和低延迟。

文章图片

2.2 模型的特点

每个子目录如/app1都被称作一个znode（节点）。这个znode是被它所在的路径唯一标识。
znode可以有子节点目录，并且每个znode可以存储数据。
znode是有版本的，每个znode中存储的数据可以有多个版本，也就是一个访问路径中可以存储多份数据。每次 znode 的数据更改时，版本号都会增加。例如，每当客户端检索数据时，它也会收到数据的版本。
每个znode都有一个访问控制列表 (ACL)，它限制了谁可以做什么。
znode可以被监控，包括这个目录中存储的数据的修改，子节点目录变化等，一旦变化可以通知设置监控的客户端。

??注意：当使用zkCli.sh 创建会话时，节点的监听事件只能被触发一次。

2.3 节点分类

2.3.1 Persistent 持久节点：节点被创建后，就一直存在，除非客户端主动删除这个节点。

2.3.2 Persistent Sequential 持久顺序节点：有序的持久节点。在zk中，每个父节点会为它的第一级子节点维护一份时序，会记录每个子节点创建的先后顺序。例如：

$ create -s /app1 # 创建 /app1 节点Created /app10000000000 # 创建成功后的节点名称为 /app10000000000

2.3.3 Ephemeral 临时节点：和持久节点不同的是，临时节点的生命周期和客户端会话绑定且临时节点下面不能创建子节点。如果客户端会话失效，那么这个节点就会自动被清除掉。

【详解Zookeeper基础知识】注意：客户端失效临时节点会被清除，但如果是断开链接，临时节点并不会立马被清除。
“立马”：在会话超时持续时间内未从客户端收到任何心跳信号之后，zk服务器将删除该会话的临时节点。但如果正常关闭会话，临时节点会立马被清除。

# 1. 创建会话$ ./zkCli.sh# 2. 创建临时节点 /app3$ create -e /app3Created /app3# 3. ctrl + c 关闭会话# 4. 紧接着再次创建会话 $ ./zkCli.sh# 5. 查看节点内容发现临时节点依旧存在$ ls /[app10000000000, app3, zookeeper]# 6. 等待几秒，再次查看发现临时节点消失$ ls /[app10000000000, zookeeper]# 7. 再次创建临时节点 /app3$ create -e /app3Created /app3# 8. 正常关闭会话$ quit# 9. 再次创建会话临时节点消失$ ./zkCli.sh$ ls /[app10000000000, zookeeper]

2.3.4 Ephemeral Sequential 临时顺序节点：有序的临时节点。创建es节点时，zk会维护一份时序，会记录每个节点的顺序。例如：

$ create -s -e /app2 # 创建临时有序节点 /app2Created /app20000000001 # 创建成功后的节点名称为 app20000000001

3. 安装
3.1 官方
官方地址：https://zookeeper.apache.org/releases.html

3.2 docker

$ docker run --name zookeeper --restart always -d zookeeper

3.3 docker-compose
??注意：执行脚本前，需先将配置文件挂载到宿主机上。

version: '3.1'services:zk:image: zookeeperrestart: alwayscontainer_name: zookeeperports:- 2181:2181volumes:- ./data:/data- ./logs:/datalog- ./conf/zoo.cfg:/conf/zoo.cfg

3.4 配置信息

# 数据存储目录dataDir=/data# 日志存储目录dataLogDir=/datalog# 集群模式下节点之间的心跳时间2s（每2s进行一次心跳检测）tickTime=2000# 集群初始化时节点之间同步次数。（5 * 2s = 10s 10s内未初始化成功则初始化失败）initLimit=5# 集群模式下同步数据次数。（2 * 2s = 4s 4s内未同步则超时失败）syncLimit=2# 数据快照保留个数autopurge.snapRetainCount=3# 数据快照清除时间间隔（单位为小时） 0：不清除，1：1小时 autopurge.purgeInterval=0# 最大的客户端链接数maxClientCnxns=60

4. 基础命令不同版本之前的命令会有所差异，本章是基于zk:3.7版本。官方地址

4.1 创建会话
首先执行命令，创建新的会话，进入终端。

# 进入到zk的安装目录的bin目录下执行$ ./zkCli.sh# 如果zk不是在本机则可以使用server参数指定链接地址$ ./zkCli.sh -server 127.0.0.1:2181

4.2 ls
ls [-s] [-w] [-R] path：ls 命令用于查看某个路径下目录列表。

-s：查看此znode状态信息。
-w：监听此znode目录变化。
-R：递归查看

$ ls / # 查看根目录[app, app10000000000, zookeeper]$ ls /app[]$ ls -s /app[app01, app02]cZxid = 0x1bctime = Sun Aug 29 13:07:24 UTC 2021mZxid = 0x1bmtime = Sun Aug 29 13:07:24 UTC 2021pZxid = 0x2ecversion = 2dataVersion = 0aclVersion = 0ephemeralOwner = 0x0dataLength = 0numChildren = 2

监听znode目录变化：

文章图片

4.3 create
create [-s] [-e] [-c] [-t ttl] path [data] [acl]：create 用于创建znode。

-s：创建顺序节点。
-e：创建临时节点。
-c：创建一个容器节点，当容器中的最后一个子节点被删除时，容器也随之消失。
-t：设置节点存活时间（毫秒）。

??注意：如果要设置超时时间需在配置文件中激活配置：zookeeper.extendedTypesEnabled=true

data：设置的数据。
acl：访问控制配置。

$ ls /[app, app10000000000, zookeeper]# 创建持久节点 /app3$ create /app3 zhangtieniuCreated /app3# 创建有序的持久节点 /app4$ create -s /app4 zhangsanCreated /app40000000011# 创建临时节点 /app5$ create -e /app5 linshiCreated /app5# 创建临时有序节点 /app6$ create -s -e /app6 linshiyouxuCreated /app60000000013$ ls /[app, app10000000000, app3, app40000000011, app5, app60000000013, zookeeper]

4.4 get
get [-s] [-w] path：命令用于获取节点数据和状态信息。

-s：查看此znode状态信息。
-w：监听此znode值变化。

$ get /app3 # 查看/app3 znode内容zhangtieniu

监听znod值变化：

文章图片

4.5 stat
stat [-w] path：命令用于查看节点状态信息。
-w：监听节点状态变化。

$ stat /app3cZxid = 0x34 # 创建节点时的事务idctime = Sun Aug 29 14:31:52 UTC 2021 # 创建时间mZxid = 0x34 # 创建的版本号mtime = Sun Aug 29 14:31:52 UTC 2021 # 修改时间pZxid = 0x34 # 子节点列表最后一次被修改的事务idcversion = 0 # 节点版本号dataVersion = 0 # 数据版本号aclVersion = 0 # 权限版本号 ephemeralOwner = 0x0 # 临时拥有者dataLength = 11 # 节点值数据长度numChildren = 0 # 子节点数量

4.6 set
set [-s] [-v version] path data：命令用于修改节点存储的数据。
-s：查看设置成功后的状态信息。
-v：指定设置值的版本号，该值只能为该节点的最新版本。可以使用其实现乐观锁。

$ set /app wangmazi$ set -s /app lisicZxid = 0x1bctime = Sun Aug 29 13:07:24 UTC 2021mZxid = 0x43mtime = Sun Aug 29 14:50:52 UTC 2021pZxid = 0x3fcversion = 4dataVersion = 6aclVersion = 0ephemeralOwner = 0x0dataLength = 4numChildren = 4

4.7 delete
delete [-v version] path：删除指定节点。

??注意：当删除的节点有子节点时，不能使用该命令。需使用deleteall命令删除。

-v：删除指定版本。与set同理

$ delete /app3

4.8 quit
关闭会话。

5. 节点的监听机制 zk的监听机制，可以使客户端可以监听znode节点的变化，znode节点的变化出发相应的事件，然后清除对该节点的检测。

??注意：在这里再强调一次，当使用zkCli.sh 创建会话时，对znode的监听只能触发一次。但在使用java客户端链接时，可以一直触发。

$ ls -w /path # 监听节点目录的变化$ get -w /path # 监听节点数据的变化

6. quick start
6.1 项目结构

文章图片

.├── pom.xml└── src└── main├── java│└── com│└── ldx│└── zookeeper│├── ZookeeperApplication.java # 启动类│├── config││├── CuratorClientConfig.java # zk配置类││└── CuratorClientProperties.java # zk 配置属性文件│├── controller││└── AppController.java # zk 测试文件│└── util│└── CuratorClient.java # zk工具类└── resources└── application.yaml # 服务配置文件

6.2 引入依赖

Curator 是 Netflix 公司开源的一套 zookeeper 客户端框架，解决了很多 Zookeeper 客户端非常底层的细节开发工作，包括连接重连、反复注册 Watcher 和 NodeExistsException 异常等。
curator-recipes：封装了一些高级特性，如：Cache 事件监听、选举、分布式锁、分布式计数器、分布式 Barrier 等。

4.0.0org.springframework.bootspring-boot-starter-parent2.5.4 com.ldxzookeeper0.0.1-SNAPSHOTzookeeperDemo project for Spring Boot1.8org.springframework.bootspring-boot-starter-weborg.apache.curatorcurator-recipes5.2.0org.springframework.bootspring-boot-configuration-processororg.projectlomboklomboktrueorg.springframework.bootspring-boot-starter-testtestorg.springframework.bootspring-boot-maven-pluginorg.projectlomboklombok

6.3 application.

server:port: 8080# curator配置curator-client:# 连接字符串connection-string: localhost:2181# 根节点namespace: ldx# 节点数据编码charset: utf8# session超时时间session-timeout-ms: 60000# 连接超时时间connection-timeout-ms: 15000# 关闭连接超时时间max-close-wait-ms: 1000# 默认数据default-data: ""# 当半数以上zookeeper服务出现故障仍然提供读服务can-be-read-only: false# 自动创建父节点use-container-parents-if-available: true# 重试策略，默认使用BoundedExponentialBackoffRetryretry:max-sleep-time-ms: 10000base-sleep-time-ms: 1000max-retries: 3# 认证信息#auth:#scheme: digest# auth: username:password

6.4 CuratorClientProperties

package com.ldx.zookeeper.config; import lombok.Data; import org.springframework.boot.context.properties.ConfigurationProperties; /** * zk 属性配置类 * * @author ludangxin * @date 2021/8/31 */@Data@ConfigurationProperties(prefix = "curator-client")public class CuratorClientProperties {/*** 连接地址*/private String connectionString; /*** 命名空间*/private String namespace; /*** 字符集*/private String charset = "utf8"; /*** 会话超时时间毫秒*/private int sessionTimeoutMs = 60000; /*** 连接超时时间毫秒*/private int connectionTimeoutMs = 15000; /*** 最大关闭等待时间毫秒*/private int maxCloseWaitMs = 1000; /*** 默认数据*/private String defaultDatahttps://www.it610.com/article/= ""; /*** 当半数以上zookeeper服务出现故障仍然提供读服务*/private boolean canBeReadOnly = false; /*** 自动创建父节点*/private boolean useContainerParentsIfAvailable = true; /*** 线程池名称*/private String threadFactoryClassName; private Retry retry = new Retry(); private Auth auth = new Auth(); @Datapublic static class Retry {private int maxSleepTimeMs = 10000; private int baseSleepTimeMs = 1000; private int maxRetries = 3; }@Datapublic static class Auth {private String scheme = "digest"; private String auth; }}

6.5 CuratorClientConfig

package com.ldx.zookeeper.config; import com.ldx.zookeeper.util.CuratorClient; import lombok.SneakyThrows; import lombok.extern.slf4j.Slf4j; import org.apache.commons.lang.StringUtils; import org.apache.curator.RetryPolicy; import org.apache.curator.ensemble.EnsembleProvider; import org.apache.curator.ensemble.fixed.FixedEnsembleProvider; import org.apache.curator.framework.CuratorFrameworkFactory; import org.apache.curator.framework.api.ACLProvider; import org.apache.curator.framework.api.CompressionProvider; import org.apache.curator.framework.imps.GzipCompressionProvider; import org.apache.curator.retry.BoundedExponentialBackoffRetry; import org.apache.curator.utils.DefaultZookeeperFactory; import org.apache.curator.utils.ZookeeperFactory; import org.apache.zookeeper.ZooDefs; import org.apache.zookeeper.data.ACL; import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import java.nio.charset.Charset; import java.util.List; import java.util.concurrent.ThreadFactory; /** * zk 配置类 * * @author ludangxin * @date 2021/8/31 */@Slf4j@Configuration@EnableConfigurationProperties(CuratorClientProperties.class)public class CuratorClientConfig {@Beanpublic EnsembleProvider ensembleProvider(CuratorClientProperties curatorClientProperties) {return new FixedEnsembleProvider(curatorClientProperties.getConnectionString()); }@Beanpublic RetryPolicy retryPolicy(CuratorClientProperties curatorClientProperties) {CuratorClientProperties.Retry retry = curatorClientProperties.getRetry(); return new BoundedExponentialBackoffRetry(retry.getBaseSleepTimeMs(), retry.getMaxSleepTimeMs(), retry.getMaxRetries()); }@Beanpublic CompressionProvider compressionProvider() {return new GzipCompressionProvider(); }@Beanpublic ZookeeperFactory zookeeperFactory() {return new DefaultZookeeperFactory(); }@Beanpublic ACLProvider aclProvider() {return new ACLProvider() {@Overridepublic List getDefaultAcl() {return ZooDefs.Ids.CREATOR_ALL_ACL; }@Overridepublic List getAclForPath(String path) {return ZooDefs.Ids.CREATOR_ALL_ACL; }}; }@Bean@SneakyThrowspublic CuratorFrameworkFactory.Builder builder(EnsembleProvider ensembleProvider,RetryPolicy retryPolicy,CompressionProvider compressionProvider,ZookeeperFactory zookeeperFactory,ACLProvider aclProvider,CuratorClientProperties curatorClientProperties) {String charset = curatorClientProperties.getCharset(); CuratorFrameworkFactory.Builder builder = CuratorFrameworkFactory.builder().ensembleProvider(ensembleProvider).retryPolicy(retryPolicy).compressionProvider(compressionProvider).zookeeperFactory(zookeeperFactory).namespace(curatorClientProperties.getNamespace()).sessionTimeoutMs(curatorClientProperties.getSessionTimeoutMs()).connectionTimeoutMs(curatorClientProperties.getConnectionTimeoutMs()).maxCloseWaitMs(curatorClientProperties.getMaxCloseWaitMs()).defaultData(curatorClientProperties.getDefaultData().getBytes(Charset.forName(charset))).canBeReadOnly(curatorClientProperties.isCanBeReadOnly()); if (!curatorClientProperties.isUseContainerParentsIfAvailable()) {builder.dontUseContainerParents(); }CuratorClientProperties.Auth auth = curatorClientProperties.getAuth(); if (StringUtils.isNotBlank(auth.getAuth())) {builder.authorization(auth.getScheme(), auth.getAuth().getBytes(Charset.forName(charset))); builder.aclProvider(aclProvider); }String threadFactoryClassName = curatorClientProperties.getThreadFactoryClassName(); if (StringUtils.isNotBlank(threadFactoryClassName)) {try {Class cls = Class.forName(threadFactoryClassName); ThreadFactory threadFactory = (ThreadFactory) cls.newInstance(); builder.threadFactory(threadFactory); } catch (Exception e) {log.error("init CuratorClient error", e); }}return builder; }@Bean(initMethod = "init", destroyMethod = "stop")public CuratorClient curatorClient(CuratorFrameworkFactory.Builder builder) {return new CuratorClient(builder); }}

6.6 CuratorClient

package com.ldx.zookeeper.util; import lombok.SneakyThrows; import lombok.extern.slf4j.Slf4j; import org.apache.curator.framework.CuratorFramework; import org.apache.curator.framework.CuratorFrameworkFactory; import org.apache.curator.framework.recipes.cache.CuratorCache; import org.apache.curator.framework.recipes.cache.CuratorCacheListener; import org.apache.curator.framework.recipes.locks.*; import org.apache.curator.framework.state.ConnectionState; import org.apache.zookeeper.CreateMode; import java.nio.charset.Charset; import java.util.List; import java.util.Objects; import java.util.concurrent.Executor; import java.util.concurrent.TimeUnit; /** * zookeeper工具类 * * @author ludangxin * @date 2021/8/30 */@Slf4jpublic class CuratorClient {/*** 默认的字符编码集*/private static final String DEFAULT_CHARSET = "utf8"; /*** 客户端*/private final CuratorFramework client; /*** 字符集*/private String charset = DEFAULT_CHARSET; @SneakyThrowspublic CuratorClient(CuratorFrameworkFactory.Builder builder) {client = builder.build(); }@SneakyThrowspublic CuratorClient(CuratorFrameworkFactory.Builder builder, String charset) {client = builder.build(); this.charset = charset; }public void init() {client.start(); client.getConnectionStateListenable().addListener((client, state) -> {if (state==ConnectionState.LOST) {// 连接丢失log.info("lost session with zookeeper"); } else if (state==ConnectionState.CONNECTED) {// 连接新建log.info("connected with zookeeper"); } else if (state==ConnectionState.RECONNECTED) {// 重新连接log.info("reconnected with zookeeper"); }}); }/*** 关闭会话*/public void stop() {log.info("zookeeper session close"); client.close(); }/*** 创建节点** @param mode节点类型*1、PERSISTENT 持久化目录节点，存储的数据不会丢失。*2、PERSISTENT_SEQUENTIAL顺序自动编号的持久化目录节点，存储的数据不会丢失*3、EPHEMERAL临时目录节点，一旦创建这个节点的客户端与服务器端口也就是session 超时，这种节点会被自动删除*4、EPHEMERAL_SEQUENTIAL临时自动编号节点，一旦创建这个节点的客户端与服务器端口也就是session 超时，这种节点会被自动删除，并且根据当前已经存在的节点数自动加 1，然后返回给客户端已经成功创建的目录节点名。* @param path节点名称* @param nodeData 节点数据*/@SneakyThrowspublic void createNode(CreateMode mode, String path, String nodeData) {// 使用creatingParentContainersIfNeeded()之后Curator能够自动递归创建所有所需的父节点client.create().creatingParentsIfNeeded().withMode(mode).forPath(path, nodeData.getBytes(Charset.forName(charset))); }/*** 创建节点** @param mode 节点类型*1、PERSISTENT 持久化目录节点，存储的数据不会丢失。*2、PERSISTENT_SEQUENTIAL顺序自动编号的持久化目录节点，存储的数据不会丢失*3、EPHEMERAL临时目录节点，一旦创建这个节点的客户端与服务器端口也就是session 超时，这种节点会被自动删除*4、EPHEMERAL_SEQUENTIAL临时自动编号节点，一旦创建这个节点的客户端与服务器端口也就是session 超时，这种节点会被自动删除，并且根据当前已经存在的节点数自动加 1，然后返回给客户端已经成功创建的目录节点名。* @param path 节点名称*/@SneakyThrowspublic void createNode(CreateMode mode, String path) {// 使用creatingParentContainersIfNeeded()之后Curator能够自动递归创建所有所需的父节点client.create().creatingParentsIfNeeded().withMode(mode).forPath(path); }/*** 删除节点数据** @param path 节点名称*/@SneakyThrowspublic void deleteNode(final String path) {deleteNode(path, true); }/*** 删除节点数据** @param path 节点名称* @param deleteChildre 是否删除子节点*/@SneakyThrowspublic void deleteNode(final String path, Boolean deleteChildre) {if (deleteChildre) {// guaranteed()删除一个节点，强制保证删除,// 只要客户端会话有效，那么Curator会在后台持续进行删除操作，直到删除节点成功client.delete().guaranteed().deletingChildrenIfNeeded().forPath(path); } else {client.delete().guaranteed().forPath(path); }}/*** 设置指定节点的数据** @param path 节点名称* @param data 节点数据*/@SneakyThrowspublic void setNodeData(String path, String data) {client.setData().forPath(path, data.getBytes(Charset.forName(charset))); }/*** 获取指定节点的数据** @param path 节点名称* @return 节点数据*/@SneakyThrowspublic String getNodeData(String path) {return new String(client.getData().forPath(path), Charset.forName(charset)); }/*** 获取数据时先同步** @param path 节点名称* @return 节点数据*/public String synNodeData(String path) {client.sync(); return getNodeData(path); }/*** 判断节点是否存在** @param path 节点名称* @return true 节点存在，false 节点不存在*/@SneakyThrowspublic boolean isExistNode(final String path) {client.sync(); return Objects.nonNull(client.checkExists().forPath(path)); }/*** 获取节点的子节点** @param path 节点名称* @return 子节点集合*/@SneakyThrowspublic List getChildren(String path) {return client.getChildren().forPath(path); }/*** 创建排他锁** @param path 节点名称* @return 排他锁*/public InterProcessSemaphoreMutex getSemaphoreMutexLock(String path) {return new InterProcessSemaphoreMutex(client, path); }/*** 创建可重入排他锁** @param path 节点名称* @return 可重入排他锁*/public InterProcessMutex getMutexLock(String path) {return new InterProcessMutex(client, path); }/*** 创建一组可重入排他锁** @param paths 节点名称集合* @return 锁容器*/public InterProcessMultiLock getMultiMutexLock(List paths) {return new InterProcessMultiLock(client, paths); }/*** 创建一组任意类型的锁** @param locks 锁集合* @return 锁容器*/public InterProcessMultiLock getMultiLock(List locks) {return new InterProcessMultiLock(locks); }/*** 加锁** @param lock 分布式锁对象*/@SneakyThrowspublic void acquire(InterProcessLock lock) {lock.acquire(); }/*** 加锁** @param lock 分布式锁对象* @param time 等待时间* @param unit 时间单位*/@SneakyThrowspublic void acquire(InterProcessLock lock, long time, TimeUnit unit) {lock.acquire(time, unit); }/*** 释放锁** @param lock 分布式锁对象*/@SneakyThrowspublic void release(InterProcessLock lock) {lock.release(); }/*** 检查是否当前jvm的线程获取了锁** @param lock 分布式锁对象* @return true/false*/public boolean isAcquiredInThisProcess(InterProcessLock lock) {return lock.isAcquiredInThisProcess(); }/*** 获取读写锁** @param path 节点名称* @return 读写锁*/public InterProcessReadWriteLock getReadWriteLock(String path) {return new InterProcessReadWriteLock(client, path); }/*** 监听数据节点的变化情况** @param path 节点名称* @param listener 监听器* @return 监听节点的TreeCache实例*/@SneakyThrowspublic CuratorCache watch(String path, CuratorCacheListener listener) {CuratorCache curatorCache = CuratorCache.builder(client, path).build(); curatorCache.listenable().addListener(listener); curatorCache.start(); return curatorCache; }/*** 监听数据节点的变化情况** @param path 节点名称* @param listener 监听器* @return 监听节点的TreeCache实例*/public CuratorCache watch(String path, CuratorCacheListener listener, Executor executor) {CuratorCache curatorCache = CuratorCache.builder(client, path).build(); curatorCache.listenable().addListener(listener, executor); curatorCache.start(); return curatorCache; }/*** 取消监听节点** @param path 节点名称* @param listener 监听器*/public void unwatch(String path, CuratorCacheListener listener) {CuratorCache curatorCache = CuratorCache.builder(client, path).build(); curatorCache.listenable().removeListener(listener); }}

6.7 AppController

package com.ldx.zookeeper.controller; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; import com.ldx.zookeeper.util.CuratorClient; import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; import org.apache.curator.framework.recipes.cache.CuratorCacheListener; import org.apache.zookeeper.CreateMode; import org.apache.zookeeper.data.Stat; import org.springframework.web.bind.annotation.*; /** * demo * * @author ludangxin * @date 2021/8/30 */@Slf4j@RestController@RequestMapping("app")@RequiredArgsConstructorpublic class AppController {private final CuratorClient curatorClient; @GetMapping("{appName}")public String getData(@PathVariable String appName) {return curatorClient.getNodeData(setPrefix(appName)); }@PostMapping("{appName}")public String addApp(@PathVariable String appName, @RequestParam String data) {curatorClient.createNode(CreateMode.PERSISTENT, setPrefix(appName), data); return "ok"; }@PostMapping("{appName}/{childName}")public String addAppChild(@PathVariable String appName, @PathVariable String childName, @RequestParam String data) {curatorClient.createNode(CreateMode.PERSISTENT, setPrefix(appName).concat(setPrefix(childName)), data); return "ok"; }@PutMapping("{appName}")public String setData(@PathVariable String appName, String data) {curatorClient.setNodeData(setPrefix(appName), data); return "ok"; }@PutMapping("{appName}/{childName}")public String setData(@PathVariable String appName, @PathVariable String childName, String data) {curatorClient.setNodeData(setPrefix(appName).concat(setPrefix(childName)), data); return "ok"; }@DeleteMapping("{appName}")public String delApp(@PathVariable String appName) {curatorClient.deleteNode(setPrefix(appName)); return "ok"; }@PostMapping("{appName}/watch/dir")public String watchAppDir(@PathVariable String appName) {CuratorCacheListener listener = CuratorCacheListener.builder().forDeletes(obj -> {String path = obj.getPath(); String data = https://www.it610.com/article/new String(obj.getData()); Stat stat = obj.getStat(); log.info("节点：{} 被删除，节点数据：{}，节点状态：\\{version：{}，createTime:{}\\}", path, data,stat.getVersion(), stat.getCtime()); }).build(); curatorClient.watch(setPrefix(appName), listener); return "ok"; }@PostMapping("{appName}/watch/data")public String watchAppData(@PathVariable String appName) {ObjectMapper mapper = new ObjectMapper(); CuratorCacheListener listener = CuratorCacheListener.builder().forChanges((oldNode, newNode) -> {try {String path = oldNode.getPath(); log.info("节点：{} 被修改，修改前：{} ", path, mapper.writeValueAsString(oldNode)); log.info("节点：{} 被修改，修改后：{} ", path, mapper.writeValueAsString(newNode)); } catch(JsonProcessingException e) {e.printStackTrace(); }}).build(); curatorClient.watch(setPrefix(appName), listener); return "ok"; }private String setPrefix(String appName) {String prefix = "/"; if(!appName.startsWith(prefix)) {appName = prefix.concat(appName); }return appName; }}

7. ZAB 协议介绍 ZAB（ZooKeeper Atomic Broadcast 原子广播）协议是为分布式协调服务 ZooKeeper 专门设计的一种支持崩溃恢复的原子广播协议。在 ZooKeeper 中，主要依赖 ZAB 协议来实现分布式数据一致性，基于该协议，ZooKeeper 实现了一种主备模式的系统架构来保持集群中各个副本之间的数据一致性。
ZAB 协议两种基本的模式：崩溃恢复和消息广播
ZAB协议包括两种基本的模式，分别是崩溃恢复和消息广播。当整个服务框架在启动过程中，或是当 Leader 服务器出现网络中断、崩溃退出与重启等异常情况时，ZAB 协议就会进人恢复模式并选举产生新的Leader服务器。当选举产生了新的 Leader 服务器，同时集群中已经有过半的机器与该Leader服务器完成了状态同步之后，ZAB协议就会退出恢复模式。其中，所谓的状态同步是指数据同步，用来保证集群中存在过半的机器能够和Leader服务器的数据状态保持一致。
当集群中已经有过半的Follower服务器完成了和Leader服务器的状态同步，那么整个服务框架就可以进人消息广播模式了。当一台同样遵守ZAB协议的服务器启动后加人到集群中时，如果此时集群中已经存在一个Leader服务器在负责进行消息广播，那么新加人的服务器就会自觉地进人数据恢复模式：找到Leader所在的服务器，并与其进行数据同步，然后一起参与到消息广播流程中去。正如上文介绍中所说的，ZooKeeper设计成只允许唯一的一个Leader服务器来进行事务请求的处理。Leader服务器在接收到客户端的事务请求后，会生成对应的事务提案并发起一轮广播协议；而如果集群中的其他机器接收到客户端的事务请求，那么这些非Leader服务器会首先将这个事务请求转发给Leader服务器。
以上就是详解Zookeeper基础知识的详细内容，更多关于Zookeeper基础的资料请关注脚本之家其它相关文章！