zookeeper01

1 zookeeper简介

1.1 什么是zookeeper？

• zookeeper的官网。

• zookeeper由雅虎研究院开发，是Google Chubby的开源实现，后来托管到Apache，于2010年11月正式成为Apache的顶级项目。

• 大数据生态系统里的很多组件的命名都是某种动物或者昆虫，比如Hadoop就是🐘，Hive就是🐝。zookeeper即动物园管理者，顾名思义就是管理大数据生态系统各组件的管理员，如下图所示。

1.2 zookeeper应用场景

• zookeeper是一个经典的分布式数据一致性解决方案，致力于为分布式应用提供一个高性能、高可用，且具有严格顺序访问控制能力的分布式协调存储服务。
• zookeeper的应用场景如下：
  • 1️⃣维护配置信息。
  • 2️⃣分布式锁服务。
  • 3️⃣集群管理。
  • 4️⃣生成分布式唯一ID。

1.2.1 维护配置信息

• Java编程经常会遇到配置项，比如数据库的url、schema、user和password等。通常这些配置项我们会放置在配置文件中，再将配置文件放置在服务器上，当需要更改配置项的时候，需要去服务器上修改对应的配置文件。但是随着分布式系统的兴起，由于许多服务都需要用到该配置文件，因此必须保证该配置服务的高可用性以及各台服务器上配置数据的一致性。通常会将配置文件部署在一个集群上，然而一个集群动辄上千台服务器，此时如果再需要一台一台服务器逐个修改配置文件，那将是非常繁琐且危险的操作，因此就需要一种服务，能够高效快速且可靠的完成配置项的更改等操作，并能够保证各配置项在每台服务器上的数据的一致性。
• zookeeper就可以提供这样的一种服务，zookeeper使用了ZAB这种一致性协议来保证一致性。现在有很多开源项目都使用zookeeper来维护配置，比如在HBase中，客户端就是连接一个zookeeper，获取必要的HBase集群的配置信息，然后才可以进行下一步操作。还有在开源的消息队列Kafka中，也可以使用zookeeper来维护Broker的信息。在Alibaba的开源SOA框架Dubbo中也广泛的使用zookeeper管理一些配置来实现服务治理。

1.2.2 分布式锁服务

• 一个集群是一个分布式系统，由多台服务器组成。为了提高并发度和可靠性，多台服务器上运行着同一种服务。当多个服务在运行的时候就需要协调各服务的进度，有时候需要保证当某个服务在进行某个操作的时候，其他的服务都不能进行该操作，即对该操作进行加锁，如果当前机器挂掉后，释放锁并fail over到其他的机器上继续执行该服务。

1.2.3 集群管理

• 一个集群有时会因为各种软硬件故障或者网络故障，出现某些服务器挂掉而被移除集群，而某些服务器加入到集群中的情况，zookeeper会将这些服务器加入/移除的情况通知到集群中的其他正常工作的服务器，以便及时调整存储和计算等任务的分配和执行等。此外zookeeper还会对故障的服务器做出诊断并尝试修复。

1.2.4 生成分布式唯一ID

• 在过去的单库单表型系统中，通常可以使用数据库字段自带的auto_increment属性来自动为每条记录生成一个唯一的ID。但是分库分表以后，就无法再依靠数据库的auto_increment属性来唯一标识一条记录了。此时我们可以使用zookeeper在分布式环境下生成全局唯一ID。
• 做法如下：每次要生成一个新ID的时候，创建一个持久顺序节点，创建操作返回的节点序号，即为新的ID，然后把比自己节点小的删除即可。

1.3 zookeeper的设计目标

• zookeeper致力于为分布式应用提供一个高性能、高可用，且具有严格顺序访问控制能力的分布式协调服务。

1.3.1 高性能

• zookeeper将全量数据存储在内存中，并直接服务于客户端的所有非事务请求，尤其适用于以读为主的应用场景。

1.3.2 高可用

• zookeeper一般以集群的方式对外提供服务，一般3~5台机器就可以组成一个可用的zookeeper集群了，每台机器都会在内存中维护当前的服务器状态，并且每台机器之间都相互保持着通信。只要集群中超过一半的机器都能够正常工作，那么整个集群就能够正常对外服务。

1.3.3 严格顺序访问

• 对于来自客户端的每个更新请求，zookeeper都会分配一个全局唯一的递增编号，这个编号反映了所有事务操作的先后顺序。

2 zookeeper的数据模型

2.1 zookeeper的数据模型

• zookeeper的数据节点可以视为树状结构（或者目录），树中的各个节点被称为znode（即zookeeper node），一个znode可以有多个子节点。zookeeper节点在结构上表现为树状。使用路径path来定位某个znode，比如/ns-1/com/sunxiaping/mysql/schema/table1，此处的ns-1、com、sunxiaping、mysql、schema、table1分别表示根节点、2级节点、3级节点、4级节点、5级节点以及6级节点。其中ns-1是com的父节点，com是sunxiaping的父节点，sunxiaping是mysql的父节点，mysql是schema的父节点，依次类推。
• znode，兼具文件和目录两种特点。既像文件一样维护着数据、元信息、ACL、时间戳等数据结构，又像目录一样可以作为路径标识的一部分。

• 一个znode大体上分为3个部分：
• 1️⃣节点的数据：即znode data（节点path ,节点data）的关系就像是Java中Map中的key和value的关系。
• 2️⃣节点的子节点children。
• 3️⃣节点的状态stat：用来描述当前节点的创建、修改记录，包括cZxid、ctime等。

2.2 节点状态的stat属性

• 在zookeeper中的shell中使用get命令查看指定路径节点的data、stat信息：

[zk: localhost:2181(CONNECTED) 7] get /ns-1/tenant                 

cZxid = 0x6a0000000a
ctime = Wed Mar 27 09:56:44 CST 2019
mZxid = 0x6a0000000a
mtime = Wed Mar 27 09:56:44 CST 2019
pZxid = 0x6a0000000e
cversion = 2
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 0
numChildren = 2

• 属性说明：
  • cZxid：数据节点创建时的事务ID。
  • ctime：数据节点创建时的时间。
  • mZxid：数据节点最后一次更新的事务ID。
  • mtime：数据节点最后一次更新的时间。
  • pZxid：数据节点的子节点最后一次修改的事务ID。
  • cversion：子节点的更改次数。
  • dataVersion：节点数据的更改次数。
  • aclVersion：节点的ACL的更改次数。
  • ephemeralOwner：如果节点是临时节点，则表示创建该节点的会话的SessionID；如果节点是持久节点，则该属性值为0。
  • dataLength：数据内容的长度。
  • numChildren：数据节点当前的子节点个数。

2.3 节点类型

• zookeeper中的节点有两种类型：临时节点和持久节点。节点的类型在创建的时候就被确定，并且不能修改。
• 1️⃣临时节点：该节点的生命周期依赖于创建它们的会话。一旦会话（Session）结束，临时节点则被自动删除，当然也可以手动删除。虽然每个临时的znode都会绑定到一个客户端会话，但是它们对所有的客户端都是课件的。另外，zookeeper的临时节点不允许拥有子节点。
• 2️⃣持久节点：该节点的生命周期不依赖于会话，并且只有在客户端显示执行删除操作的时候，它们才会被删除。

3 zookeeper单机安装

2.1 系统环境

• 操作系统版本：CentOS 7。
• JDK版本：jdk-8u131-linux-x64.tar.gz。
• zookeeper的版本：zookeeper-3.4.10.tar.gz。

2.2 在Centos 7中使用root用户创建zookeeper用户和密码

# 用户名和密码均为zookeeper
useradd zookeeper
passwd zookeeper

2.2 安装JDK

• zookeeper底层依赖于JDK，zookeeper用户登录后，根目录下先进行JDK的安装，JDK使用的是jdk-8u131-linux-x64.tar.gz，上传并解压JDK。

# 解压JDK
tar -zxvf jdk-8u131-linux-x64.tar.gz

2.3 设置JDK环境变量

# 使用vim 打开.bash_profile
vim .bash_profile

#文件中增加如下的内容
JAVA_HOME=/home/zookeeper/jdk1.8.0_131

export JAVA_HOME

PATH=$JAVA_HOME:$PATH

export PATH

# 使得环境变量生效
. .bash_profile

2.4 检查JDK是否安装成功

# 输入如下的命令，系统如下图所示，则说明安装成功
java -version

2.5 解压zookeeper-3.4.10.tar.gz

tar -zxvf zookeeper-3.4.10.tar.gz

2.6 为zookeeper准备配置文件

# 进入conf目录
cd /home/zookeeper/zookeeper-3.4.10/conf
# 复制配置文件
cp zoo_sample.cfg zoo.cfg
# 退出当前目录，返回上一级目录
cd ..
# 为zookeeper的根目录创建data目录
mkdir -pv data
# 使用vim修改zoo.cfg配置文件中的dataDir
# dataDir是用于存储zookeeper中数据的内存快照、事务以及日志
dataDir=/home/zookeeper/zookeeper-3.4.10/data

2.7 启动zookeeper

# 进入zookeeper的bin目录
cd /home/zookeeper/zookeeper-3.4.10/bin
# 启动zookeeper
./zkServer.sh start

#命令
# 启动zookeeper
./zkServer.sh start
# 停止zookeeper
./zkServer.sh stop
# z查看状态
./zkServer.sh status

4 zookeeper常用shell命令

4.1 新增节点

# -s：有序节点 -e：临时节点
create [-s] [-e] path data acl

• 示例：创建持久化节点并写入数据：

create /hadoop "123456"

• 示例：创建持久化有序节点，此时创建的节点名为指定节点名+自增序号：

create -s /a "aa"

create -s /b "bb"

create /s /c "cc"

• 示例：创建临时节点，临时节点会在会话过期后自动被删除：

create -e /tmp "tmp"

• 示例：创建临时有序节点，临时节点会在会话过期后自动被删除：

create -s -e /aa 'aaa'

4.2 更新节点

set path data [version]

• 示例：

set /hadoop "345"

• 示例：也可以基于版本号进行更改，此时类似于乐观锁机制，当你传入的数据版本号(dataVersion)和当前节点的数据版本号不符合的时候，zookeeper会拒绝本次修改。

set /hadoop "123" 1

4.3 删除节点

delete path [version]

要想删除某个节点及其所有后代节点，可以使用递归删除，命令为：rmr path

• 示例：和更新节点一样，删除节点也可以传入版本号，当你传入的数据版本号(dataVersion)和当前节点的数据版本号不一致的时候，zookeeper不会执行删除操作。

delete /hadoop 2

4.4 查看节点

get path [watch]

• 节点的各个属性如下表所示。其中一个重要的概念是Zxid（Zookeeper Transaction id），zookeeper节点的每一次更改都具有唯一的Zxid，如果Zxid1小于Zxid2，则Zxid1的更改发生在Zxid2之前。

状态属性	说明
cZxid	数据节点创建时的事务ID
ctime	数据节点创建时的时间
mZxid	数据节点最后一次更新时的事务ID
mtime	数据节点最后一次更新时的时间
pZxid	数据节点的子节点最后一次被修改时的事务ID
cversion	子节点的更改次数
dataVersion	节点数据的更改次数
aclVersion	节点的ACL的更改次数
ephemeralOwner	如果节点是临时节点，则表示创建该节点的会话的SessionID；如果节点是持久节点，则该属性为0
dataLength	数据内容的长度
numChildren	数据节点当前的子节点个数

• 示例：

get /hadoop

4.5 查看节点状态

# stat命令可以查看节点状态，它的返回值和get命令类似，但是不会返回节点数据
stat path [watch]

• 示例：

stat /hadoop

4.6 返回节点列表

ls path [watch]
# ls2是ls的增强，不仅可以查看指定路径下的所有节点，还可以查看当前节点的信息
ls2 path [watch]

• 示例：查看/下的节点列表

ls /

• 示例：查看/下的节点列表，并同时返回/的节点信息

ls2 /

4.6 监听器get path [watch]

# 使用get path [watch]注册的监听器能够在节点内容发生改变的时候，向客户端发出通知。需要注意的是，zookeeper的触发器是一次性的，即触发一次后就会立即失效。
get path [watch]

• 示例：

get /hadoop watch

set /hadoop "123"

4.7 监听器 stat path [watch]

# 使用stat path [watch]注册的监听器能够在节点状态改变的时候，向客户端发出通知
stat path [watch]

• 示例：

stat /hadoop watch

set /hadoop "123"

4.8 监听器ls/ls2 path watch

# 使用ls/ls2 path watch注册的监听器能够监听该节点下的所有子节点的增加和删除操作
ls/ls2 path watch

• 示例：

ls /hadoop watch

create /hadoop/node1 "node1"

5 zookeeper的ACL（Access Control List）权限控制

5.1 概念

• zookeeper类似于文件系统，client可以创建节点、更新节点、删除节点，那么如何做到节点的权限的控制？zookeeper的Access Control List（访问控制列表）可以做到这一点。

• zookeeper的权限控制，使用schema: id: permission来标识，主要涵盖了3个方面：

  • 1️⃣权限模式（schema）：授权的策略。
  • 2️⃣授权对象（id）：授权的对象。
  • 3️⃣权限（permission）：授权的权限。

• zookeeper的权限控制的特性：

  • 1️⃣zookeeper的权限控制是基于每个znode的节点，需要对每个节点设置权限。
  • 2️⃣每个znode支持多种权限控制方案和权限。
  • 3️⃣子节点不会继承父节点的权限，客户端无权访问某个节点，但是可能访问它的子节点。

• 示例：

# 对节点权限设置为ip:192.168.64.101的客户端可以对节点进行增、删、改、差、管理权限
setAcl /hadoop ip:192.168.64.101:crwda

5.2 权限模式

• 采用何种方式授权：

方案	模式
world	只有一个用户：anyone，代表登录zookeeper的所有人（默认）
ip	对客户端添加ip地址认证
auth	使用已添加认证的用户认证
digest	使用“用户名密码”方式认证

5.3 授权对象

• 给谁授予权限。
• 授权对象ID是指，权限赋予的实体，比如：IP地址或用户。

5.4 权限

• 授予什么权限。
• create、delete、read、write、admin也就是增、删、改、查、管理权限，这五种权限简写为cdrwa，注意：这五种权限中，delete是指对子节点的删除权限，其它四种权限是指对自身节点的操作权限。

权限	ACL简介	描述
create	c	可以创建子节点
delete	d	可以删除子节点（仅下一级节点）
read	r	可以读取节点数据以及显示子节点列表
write	w	可以设置节点数据
admin	a	可以设置节点访问控制列表权限

5.5 授权的相关命令

命令	使用方式	描述
getAcl	getAcl path	读取ACL权限
setAcl	setAcl path acl	设置ACL权限
addauth	addauth scheme auth	添加认证用户

5.6 应用案例

• 示例：world授权模式

setAcl path world:anyone:acl

• 示例：ip授权模式

setAcl path ip:ip地址:acl

如果需要连接远程的zookeeper，需要使用./zkCli.sh -server 远程主机的ip，测试阶段可以关闭防火墙。

• 示例：auth授权模式

# 添加认证用户
addauth digest <user>:<password>

setAcl path auth:<user>:<acl>

• 示例：digest授权模式

setAcl path digest:<user>:<password>:<acl>

这里的<password>是经过SHA1和BASE64处理的密文，可以使用如下的命令计算。

echo -n <user>:<password> | openssl dgst -binary -sha1 | openssl base64

• 示例：多种模式授权

setAcl /node ip:192.168.60.100:cdra,auth:xuweiwei:cdrwa,digest:xuweiwei:qlzQzCLKhBROghkooLvb+Mlwv4A=:cdrwa

5.7 acl超级管理员

• zookeeper的权限管理模式有一种叫super，该模式提供一个超级管理员可以方便的访问任何权限的节点。
• 假设这个超级管理员是：super:admin，需要先为超级管理员生成密码的密文：

echo -n super:admin | openssl dgst -binary -sha1 | openssl base64
# 得到的密文是  xQJmxLMiHGwaqBvst5y6rkB6HQs=

• 打开zookeeper目录下的/bin/zkServer.sh服务器脚本文件，找到如下的一行：

nohup "$JAVA" "-Dzookeeper.log.dir=${ZOO_LOG_DIR}" "-Dzookeeper.root.logger=${ZOO_LOG4J_PROP}" \

• 上面是脚本中启动zookeeper的命令，默认只有上面的两项配置，我们只需要加一个超级管理员的配置：

"-Dzookeeper.DigestAuthenticationProvider.superDigest=super:xQJmxLMiHGwaqBvst5y6rkB6HQs="

• 修改之后，这条命令就变成了如下的样子：

nohup "$JAVA" "-Dzookeeper.log.dir=${ZOO_LOG_DIR}" "-Dzookeeper.root.logger=${ZOO_LOG4J_PROP}" "-Dzookeeper.DigestAuthenticationProvider.superDigest=super:xQJmxLMiHGwaqBvst5y6rkB6HQs=" \

• 之后启动zookeeper，输入如下的命令添加权限：

# 添加认证用户
addauth digest super:admin

6 zookeeper的Java API

6.1 概述

• znode是zookeeper的核心组件，zookeeper API提供了一组方法来操作znode的所有细节。
• 客户端应该遵循以下步骤和zookeeper服务器进行交互。
  • 1️⃣连接到zookeeper服务。zookeeper服务器为客户端分配会话ID。
  • 2️⃣定期向服务器发送心跳。否则，zookeeper服务器将过期会话ID，客户端需要重新连接。
  • 3️⃣只要会话ID处于活动连接，就可以获取/设置znode。
  • 4️⃣所有任务完成后，断开和zookeeper服务器的连接。如果客户端长时间不活动，则zookeeper服务器将自动断开客户端。

6.2 准备工作

• 导入zookeeper的Maven坐标：

<dependency>
    <groupId>org.apache.zookeeper</groupId>
    <artifactId>zookeeper</artifactId>
    <version>3.4.10</version>
</dependency>

6.3 连接到zookeeper

    /**
     * @param 服务器的ip地址和端口
     *            comma separated host:port pairs, each corresponding to a zk
     *            server. e.g. "127.0.0.1:3000,127.0.0.1:3001,127.0.0.1:3002" If
     *            the optional chroot suffix is used the example would look
     *            like: "127.0.0.1:3000,127.0.0.1:3001,127.0.0.1:3002/app/a"
     *            where the client would be rooted at "/app/a" and all paths
     *            would be relative to this root - ie getting/setting/etc...
     *            "/foo/bar" would result in operations being run on
     *            "/app/a/foo/bar" (from the server perspective).
     * @param 客户端和服务器之间的会话超时时间（以毫秒为单位）
     *            session timeout in milliseconds
     * @param 监视器对象
     *            a watcher object which will be notified of state changes, may
     *            also be notified for node events

     */
    public ZooKeeper(String connectString, int sessionTimeout, Watcher watcher)
        throws IOException
    {
        this(connectString, sessionTimeout, watcher, false);
    }

• 示例：

package com.sunxiaping.zookeeper;

import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;

import java.io.IOException;
import java.util.concurrent.CountDownLatch;

public class ZookeeperApplicationTests {

    ZooKeeper zooKeeper;

    @AfterEach
    public void after() throws InterruptedException {
        if (zooKeeper != null) {
            zooKeeper.close();
        }
    }


    /**
     * 连接zookeeper
     *
     * @throws IOException
     * @throws InterruptedException
     */
    @Test
    public void testZookeeperConnection() throws IOException, InterruptedException {
        //计数器对象
        CountDownLatch countDownLatch = new CountDownLatch(1);
        //服务器的ip地址和端口
        String connectString = "192.168.64.100:2181";
        //客户端和服务器之间的会话超时时间（以毫秒为单位）
        int sessionTimeout = 5000;
        //监视器对象
        Watcher watcher = new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                //客户端和服务器连接创建成功
                if (event.getState() == Event.KeeperState.SyncConnected) {
                    System.out.println("event = " + event);
                    System.out.println("连接创建成功");
                    countDownLatch.countDown();
                }
            }
        };
        zooKeeper = new ZooKeeper(connectString, sessionTimeout, watcher);

        //主线程阻塞等待连接对象的创建成功
        countDownLatch.await();

        System.out.println("zooKeeper = " + zooKeeper.getSessionId());
    }
}

6.4 新增节点

• 同步方式：

//path：znode的路径。例如/hadoop/node1
//data：要存储在执行znode路径中的数据
//acl：要创建的节点的访问控制列表。zookeeper的API提供了一个静态接口zooDefs.Ids来获取一些基本的acl列表。
//CreateMode:节点的类型 比如持久化节点 临时节点 持久有序节点 临时有序节点
public String create(final String path, byte data[], List<ACL> acl,CreateMode createMode){}

• 异步方式：

//path：znode的路径。例如/hadoop/node1
//data：要存储在执行znode路径中的数据
//acl：要创建的节点的访问控制列表。zookeeper的API提供了一个静态接口zooDefs.Ids来获取一些基本的acl列表。
//CreateMode:节点的类型 比如持久化节点 临时节点 持久有序节点 临时有序节点
//callBack：异步回调接口
//ctx：传递上下文参数
public void create(final String path, byte data[], List<ACL> acl,CreateMode createMode,  StringCallback cb, Object ctx){}

• 示例：

package com.sunxiaping.zookeeper;

import org.apache.zookeeper.*;
import org.apache.zookeeper.data.ACL;
import org.apache.zookeeper.data.Id;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import java.io.IOException;
import java.util.ArrayList;
import java.util.concurrent.CountDownLatch;

public class ZookeeperApplicationTests {

    ZooKeeper zooKeeper;

    @AfterEach
    public void after() throws InterruptedException {
        if (zooKeeper != null) {
            zooKeeper.close();
        }
    }


    /**
     * 连接zookeeper
     *
     * @throws IOException
     * @throws InterruptedException
     */
    @BeforeEach
    public void testZookeeperConnection() throws IOException, InterruptedException {
        //计数器对象
        CountDownLatch countDownLatch = new CountDownLatch(1);
        //服务器的ip地址和端口
        String connectString = "192.168.64.100:2181";
        //客户端和服务器之间的会话超时时间（以毫秒为单位）
        int sessionTimeout = 5000;
        //监视器对象
        Watcher watcher = new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                //客户端和服务器连接创建成功
                if (event.getState() == Event.KeeperState.SyncConnected) {
                    System.out.println("event = " + event);
                    System.out.println("连接创建成功");
                    countDownLatch.countDown();
                }
            }
        };
        zooKeeper = new ZooKeeper(connectString, sessionTimeout, watcher);

        //主线程阻塞等待连接对象的创建成功
        countDownLatch.await();

        System.out.println("zooKeeper = " + zooKeeper.getSessionId());
    }

    /**
     * 同步新增节点
     */
    @Test
    public void testCreateZnode() throws KeeperException, InterruptedException {
        //znode的路径
        String path = "/hadoop";
        //znode的数据
        byte[] data = "hadoop".getBytes();
        //acl 访问控制列表 world:anyone:cdrwa
        ArrayList<ACL> acl = ZooDefs.Ids.OPEN_ACL_UNSAFE;
        //节点的类型 PERSISTENT：持久化节点
        CreateMode createMode = CreateMode.PERSISTENT;
        String actualPath = zooKeeper.create(path, data, acl, createMode);
        System.out.println("actualPath = " + actualPath);
    }

    @Test
    public void testCreateZnode2() throws KeeperException, InterruptedException {
        //znode的路径
        String path = "/hadoop/node2";
        //znode的数据
        byte[] data = "node2".getBytes();
        //acl 访问控制列表 world:anyone:r
        ArrayList<ACL> acl = ZooDefs.Ids.READ_ACL_UNSAFE;
        //节点的类型 PERSISTENT：持久化节点
        CreateMode createMode = CreateMode.PERSISTENT;
        String actualPath = zooKeeper.create(path, data, acl, createMode);
        System.out.println("actualPath = " + actualPath);
    }

    @Test
    public void testCreateZnode3() throws KeeperException, InterruptedException {
        //znode的路径
        String path = "/hadoop/node3";
        //znode的数据
        byte[] data = "node3".getBytes();
        //acl 访问控制列表 world:anyone:rw
        ArrayList<ACL> acl = new ArrayList<>();
        org.apache.zookeeper.data.Id id = new Id("world", "anyone");
        ACL read = new ACL(ZooDefs.Perms.READ, id);
        ACL write = new ACL(ZooDefs.Perms.WRITE, id);
        acl.add(write);
        acl.add(read);
        //节点的类型 PERSISTENT：持久化节点
        CreateMode createMode = CreateMode.PERSISTENT;
        String actualPath = zooKeeper.create(path, data, acl, createMode);
        System.out.println("actualPath = " + actualPath);
    }

    /**
     * ip授权模式
     *
     * @throws KeeperException
     * @throws InterruptedException
     */
    @Test
    public void testCreateZnode4() throws KeeperException, InterruptedException {
        //znode的路径
        String path = "/hadoop/node4";
        //znode的数据
        byte[] data = "node4".getBytes();
        //acl 访问控制列表 world:anyone:rw
        ArrayList<ACL> acl = new ArrayList<>();
        org.apache.zookeeper.data.Id id = new Id("ip", "192.168.64.100");
        acl.add(new ACL(ZooDefs.Perms.ALL, id));
        //节点的类型 PERSISTENT：持久化节点
        CreateMode createMode = CreateMode.PERSISTENT;
        String actualPath = zooKeeper.create(path, data, acl, createMode);
        System.out.println("actualPath = " + actualPath);
    }

    /**
     * auth授权模式：添加授权用户
     *
     * @throws KeeperException
     * @throws InterruptedException
     */
    @Test
    public void testCreateZnode5() throws KeeperException, InterruptedException {
        zooKeeper.addAuthInfo("digest", "xuweiwei:123456".getBytes());
        //znode的路径
        String path = "/hadoop/node5";
        //znode的数据
        byte[] data = "node5".getBytes();
        //acl 访问控制列表 world:anyone:rw
        ArrayList<ACL> acl = ZooDefs.Ids.CREATOR_ALL_ACL;
        //节点的类型 PERSISTENT：持久化节点
        CreateMode createMode = CreateMode.PERSISTENT;
        String actualPath = zooKeeper.create(path, data, acl, createMode);
        System.out.println("actualPath = " + actualPath);
    }

    /**
     * digest授权模式
     *
     * @throws KeeperException
     * @throws InterruptedException
     */
    @Test
    public void testCreateZnode6() throws KeeperException, InterruptedException {
        //znode的路径
        String path = "/hadoop/node6";
        //znode的数据
        byte[] data = "node6".getBytes();
        //acl 访问控制列表 world:anyone:rw
        ArrayList<ACL> acl = new ArrayList<>();
        Id id = new Id("digest", "xuweiwei:qlzQzCLKhBROghkooLvb+Mlwv4A=");
        acl.add(new ACL(ZooDefs.Perms.ALL, id));
        //节点的类型 PERSISTENT：持久化节点
        CreateMode createMode = CreateMode.PERSISTENT;
        String actualPath = zooKeeper.create(path, data, acl, createMode);
        System.out.println("actualPath = " + actualPath);
    }


    /**
     * 异步新增节点
     */
    @Test
    public void testAsyncCreateNode() throws InterruptedException {
        //znode的路径
        String path = "/hadoop/node1";
        //znode的数据
        byte[] data = "node1".getBytes();
        //acl 访问控制列表 world:anyone:cdrwa
        ArrayList<ACL> acl = ZooDefs.Ids.OPEN_ACL_UNSAFE;
        //节点的类型 PERSISTENT：持久化节点
        CreateMode createMode = CreateMode.PERSISTENT;
        //
        AsyncCallback.StringCallback cb = new AsyncCallback.StringCallback() {
            @Override
            public void processResult(int rc, String path, Object ctx, String name) {
                //0 代表创建成功
                System.out.println("rc = " + rc);
                //节点的路径
                System.out.println("path = " + path);
                //上下文参数
                System.out.println("ctx = " + ctx);
                //节点的路径
                System.out.println("name = " + name);
            }
        };

        zooKeeper.create(path, data, acl, createMode, cb, "我是上下文参数");
        //睡眠
        Thread.sleep(1000);
        //结束
        System.out.println("结束");

    }
}

6.5 更新节点

• 同步方式：

public Stat setData(final String path, byte data[], int version) throws KeeperException, InterruptedException{}

• 异步方式：

public void setData(final String path, byte data[], int version,StatCallback cb, Object ctx){}

• 示例：

package com.sunxiaping.zookeeper;

import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;
import java.util.concurrent.CountDownLatch;

public class ZookeeperApplicationTests2 {

    ZooKeeper zooKeeper;

    @AfterEach
    public void after() throws InterruptedException {
        if (zooKeeper != null) {
            zooKeeper.close();
        }
    }

    /**
     * 连接zookeeper
     *
     * @throws IOException
     * @throws InterruptedException
     */
    @BeforeEach
    public void testZookeeperConnection() throws IOException, InterruptedException {
        //计数器对象
        CountDownLatch countDownLatch = new CountDownLatch(1);
        //服务器的ip地址和端口
        String connectString = "192.168.179.100:2181";
        //客户端和服务器之间的会话超时时间（以毫秒为单位）
        int sessionTimeout = 5000;
        //监视器对象
        Watcher watcher = new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                //客户端和服务器连接创建成功
                if (event.getState() == Event.KeeperState.SyncConnected) {
                    System.out.println("event = " + event);
                    System.out.println("连接创建成功");
                    countDownLatch.countDown();
                }
            }
        };
        zooKeeper = new ZooKeeper(connectString, sessionTimeout, watcher);

        //主线程阻塞等待连接对象的创建成功
        countDownLatch.await();

        System.out.println("zooKeeper = " + zooKeeper.getSessionId());
    }

    /**
     * 同步方式：更新节点
     */
    @Test
    public void testUpdateZnode() throws KeeperException, InterruptedException {
        String path = "/hadoop";
        String data = "hadoop set data";
        //version：-1，表示版本号不参与更新
        int version = -1;
        Stat stat = zooKeeper.setData(path, data.getBytes(), version);
        System.out.println("stat = " + stat);
    }

    /**
     * 异步方式：更新节点
     *
     * @throws KeeperException
     * @throws InterruptedException
     */
    @Test
    public void testUpdateZnode2() throws KeeperException, InterruptedException {
        String path = "/hadoop";
        String data = "hadoop set async data";
        //version：-1，表示版本号不参与更新
        int version = -1;
        zooKeeper.setData(path, data.getBytes(), version, new AsyncCallback.StatCallback() {
            @Override
            public void processResult(int rc, String path, Object ctx, Stat stat) {
                //0 代表创建成功
                System.out.println("rc = " + rc);
                //节点的路径
                System.out.println("path = " + path);
                //上下文参数
                System.out.println("ctx = " + ctx);
                //节点的状态信息
                System.out.println("stat = " + stat);
            }
        }, "我是上下文参数");
    }
}

6.6 删除节点

• 同步方式：

public void delete(final String path, int version) throws InterruptedException, KeeperException {}

• 异步方式：

public void delete(final String path, int version, VoidCallback cb,Object ctx){}

• 示例：

package com.sunxiaping.zookeeper;

import org.apache.zookeeper.*;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;
import java.util.concurrent.CountDownLatch;

public class ZookeeperApplicationTests3 {

    ZooKeeper zooKeeper;

    @AfterEach
    public void after() throws InterruptedException {
        if (zooKeeper != null) {
            zooKeeper.close();
        }
    }

    /**
     * 连接zookeeper
     *
     * @throws IOException
     * @throws InterruptedException
     */
    @BeforeEach
    public void testZookeeperConnection() throws IOException, InterruptedException {
        //计数器对象
        CountDownLatch countDownLatch = new CountDownLatch(1);
        //服务器的ip地址和端口
        String connectString = "192.168.179.100:2181";
        //客户端和服务器之间的会话超时时间（以毫秒为单位）
        int sessionTimeout = 5000;
        //监视器对象
        Watcher watcher = new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                //客户端和服务器连接创建成功
                if (event.getState() == Event.KeeperState.SyncConnected) {
                    System.out.println("event = " + event);
                    System.out.println("连接创建成功");
                    countDownLatch.countDown();
                }
            }
        };
        zooKeeper = new ZooKeeper(connectString, sessionTimeout, watcher);

        //主线程阻塞等待连接对象的创建成功
        countDownLatch.await();

        System.out.println("zooKeeper = " + zooKeeper.getSessionId());
    }

    /**
     * 同步方式：删除节点
     */
    @Test
    public void testDeleteZnode() throws KeeperException, InterruptedException {
        String path = "/hadoop";
        int version = -1;
        zooKeeper.delete(path, version);
    }

    /**
     * 异步方式：删除节点
     *
     * @throws KeeperException
     * @throws InterruptedException
     */
    @Test
    public void testDeleteZnode2() throws KeeperException, InterruptedException {
        String path = "/hadoop";
        int version = -1;
        zooKeeper.delete(path, version, new AsyncCallback.VoidCallback() {
            @Override
            public void processResult(int rc, String path, Object ctx) {
                //0 代表创建成功
                System.out.println("rc = " + rc);
                //节点的路径
                System.out.println("path = " + path);
                //上下文参数
                System.out.println("ctx = " + ctx);
            }
        }, "我是上下文参数");
    }
}

6.7 读取节点数据

• 同步方式：

public byte[] getData(final String path, Watcher watcher, Stat stat)
    throws KeeperException, InterruptedException{}

• 异步方式：

public void getData(String path, boolean watch, DataCallback cb, Object ctx) {}

• 示例：

package com.sunxiaping.zookeeper;

import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;
import java.util.concurrent.CountDownLatch;

public class ZookeeperApplicationTests4 {

    ZooKeeper zooKeeper;

    @AfterEach
    public void after() throws InterruptedException {
        if (zooKeeper != null) {
            zooKeeper.close();
        }
    }

    /**
     * 连接zookeeper
     *
     * @throws IOException
     * @throws InterruptedException
     */
    @BeforeEach
    public void testZookeeperConnection() throws IOException, InterruptedException {
        //计数器对象
        CountDownLatch countDownLatch = new CountDownLatch(1);
        //服务器的ip地址和端口
        String connectString = "192.168.179.100:2181";
        //客户端和服务器之间的会话超时时间（以毫秒为单位）
        int sessionTimeout = 5000;
        //监视器对象
        Watcher watcher = new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                //客户端和服务器连接创建成功
                if (event.getState() == Event.KeeperState.SyncConnected) {
                    System.out.println("event = " + event);
                    System.out.println("连接创建成功");
                    countDownLatch.countDown();
                }
            }
        };
        zooKeeper = new ZooKeeper(connectString, sessionTimeout, watcher);

        //主线程阻塞等待连接对象的创建成功
        countDownLatch.await();

        System.out.println("zooKeeper = " + zooKeeper.getSessionId());
    }

    /**
     * 同步方式：读取节点数据
     *
     * @throws KeeperException
     * @throws InterruptedException
     */
    @Test
    public void testGetZnode() throws KeeperException, InterruptedException {
        //节点的路径
        String path = "/hadoop";
        boolean watch = false;
        //读取节点属性的对象
        Stat stat = new Stat();
        //返回节点的数据
        byte[] data = zooKeeper.getData(path, watch, stat);
        System.out.println("data = " + new String(data));
        System.out.println("stat = " + stat);
        System.out.println("版本信息 = " + stat.getVersion());
    }

    /**
     * 异步方式：读取节点数据
     *
     * @throws KeeperException
     * @throws InterruptedException
     */
    @Test
    public void testGetZnode2() throws KeeperException, InterruptedException {
        //节点的路径
        String path = "/hadoop";
        boolean watch = false;
        AsyncCallback.DataCallback dataCallback = new AsyncCallback.DataCallback() {
            @Override
            public void processResult(int rc, String path, Object ctx, byte[] data, Stat stat) {
                //读取节点属性的对象
                System.out.println("stat = " + stat);
                //0 代表创建成功
                System.out.println("rc = " + rc);
                //节点的路径
                System.out.println("path = " + path);
                //上下文参数
                System.out.println("ctx = " + ctx);
            }
        };
        //返回节点的数据
        zooKeeper.getData(path, watch, dataCallback, "我是上下文参数");
    }
}

6.8 获取子节点数据

• 同步方式：

public List<String> getChildren(String path, boolean watch)
    throws KeeperException, InterruptedException {}

• 异步方式：

public void getChildren(String path, boolean watch, ChildrenCallback cb,Object ctx){}

• 示例：

package com.sunxiaping.zookeeper;

import org.apache.zookeeper.*;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CountDownLatch;


public class ZookeeperApplicationTests5 {

    ZooKeeper zooKeeper;

    @AfterEach
    public void after() throws InterruptedException {
        if (zooKeeper != null) {
            zooKeeper.close();
        }
    }

    /**
     * 连接zookeeper
     *
     * @throws IOException
     * @throws InterruptedException
     */
    @BeforeEach
    public void testZookeeperConnection() throws IOException, InterruptedException {
        //计数器对象
        CountDownLatch countDownLatch = new CountDownLatch(1);
        //服务器的ip地址和端口
        String connectString = "192.168.179.100:2181";
        //客户端和服务器之间的会话超时时间（以毫秒为单位）
        int sessionTimeout = 5000;
        //监视器对象
        Watcher watcher = new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                //客户端和服务器连接创建成功
                if (event.getState() == Event.KeeperState.SyncConnected) {
                    System.out.println("event = " + event);
                    System.out.println("连接创建成功");
                    countDownLatch.countDown();
                }
            }
        };
        zooKeeper = new ZooKeeper(connectString, sessionTimeout, watcher);

        //主线程阻塞等待连接对象的创建成功
        countDownLatch.await();

        System.out.println("zooKeeper = " + zooKeeper.getSessionId());
    }

    /**
     * 同步方式：读取子节点数据
     */
    @Test
    public void testGetChildData() throws KeeperException, InterruptedException {
        String path = "/hadoop";
        //是否使用连接对象中注册的监视器
        boolean watch = false;
        List<String> children = zooKeeper.getChildren(path, watch);
        System.out.println("读取子节点数据: = " + Arrays.asList(children));
    }

    /**
     * 异步方式：读取子节点数据
     *
     * @throws KeeperException
     * @throws InterruptedException
     */
    @Test
    public void testGetChildData2() throws KeeperException, InterruptedException {
        String path = "/hadoop";
        //是否使用连接对象中注册的监视器
        boolean watch = false;
        zooKeeper.getChildren(path, watch, new AsyncCallback.ChildrenCallback() {
            @Override
            public void processResult(int rc, String path, Object ctx, List<String> children) {
                System.out.println("读取子节点数据: = " + Arrays.asList(children));
                //0 代表创建成功
                System.out.println("rc = " + rc);
                //节点的路径
                System.out.println("path = " + path);
                //上下文参数
                System.out.println("ctx = " + ctx);
            }
        },"我是上下文参数");

    }
}

6.9 判断节点是否存在

• 同步方式：

public Stat exists(String path, boolean watch) throws KeeperException,InterruptedException{}

• 异步方式：

public void getChildren(String path, boolean watch, ChildrenCallback cb,Object ctx){}

• 示例：

package com.sunxiaping.zookeeper;

import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import java.io.IOException;
import java.util.concurrent.CountDownLatch;


public class ZookeeperApplicationTests6 {

    ZooKeeper zooKeeper;

    @AfterEach
    public void after() throws InterruptedException {
        if (zooKeeper != null) {
            zooKeeper.close();
        }
    }

    /**
     * 连接zookeeper
     *
     * @throws IOException
     * @throws InterruptedException
     */
    @BeforeEach
    public void testZookeeperConnection() throws IOException, InterruptedException {
        //计数器对象
        CountDownLatch countDownLatch = new CountDownLatch(1);
        //服务器的ip地址和端口
        String connectString = "192.168.179.100:2181";
        //客户端和服务器之间的会话超时时间（以毫秒为单位）
        int sessionTimeout = 5000;
        //监视器对象
        Watcher watcher = new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                //客户端和服务器连接创建成功
                if (event.getState() == Event.KeeperState.SyncConnected) {
                    System.out.println("event = " + event);
                    System.out.println("连接创建成功");
                    countDownLatch.countDown();
                }
            }
        };
        zooKeeper = new ZooKeeper(connectString, sessionTimeout, watcher);

        //主线程阻塞等待连接对象的创建成功
        countDownLatch.await();

        System.out.println("zooKeeper = " + zooKeeper.getSessionId());
    }

    /**
     * 同步方式：判断节点是否存在
     *
     * @throws KeeperException
     * @throws InterruptedException
     */
    @Test
    public void testExistsZnode() throws KeeperException, InterruptedException {
        String path = "/hadoop";
        boolean watch = false;
        Stat stat = zooKeeper.exists(path, watch);
        System.out.println("stat = " + stat);
    }

    /**
     * 异步方式：判断节点是否存在
     *
     * @throws KeeperException
     * @throws InterruptedException
     */
    @Test
    public void testExistsZnode2() throws KeeperException, InterruptedException {
        String path = "/hadoop";
        boolean watch = false;
       zooKeeper.exists(path, watch, new AsyncCallback.StatCallback() {
            @Override
            public void processResult(int rc, String path, Object ctx, Stat stat) {
                System.out.println("stat = " + stat);
                //0 代表创建成功
                System.out.println("rc = " + rc);
                //节点的路径
                System.out.println("path = " + path);
                //上下文参数
                System.out.println("ctx = " + ctx);
            }
        },"我是上下文参数");
    }
}