ZooKeeper3.6.3

-有一个叫做 Paxos的小岛（Island）上面住了一批居民（Islander）；
-岛上面所有的事情由一些特殊的人决定，他们叫做议员（Senator）；
-议员的总数（Senator Count）是确定的，不能更改；
-岛上每次环境事务的变更都需要通过一个提议（Proposal），每个提议都有一个编号（PID），这个编号是一直增长的，不能倒退；
-每个提议都需要超过半数（（Senator Count）/2＋1）的议员同意才能生效（少数服从多数）；
-每个议员只会同意大于当前编号的提议，包括已生效的和未生效的；
-如果议员收到小于等于当前编号的提议，他会拒绝，并告知对方：你的提议已经有人提过了。这里的当前编号是每个议员在自己记事本上记录的编号，他会不断更新这个编号；
-整个议会不能保证所有议员记事本上的编号总是相同的；
-现在议会有一个目标：保证所有的议员对于提议都能达成一致的看法。

现在议会开始运作，所有议员一开始记事本上面记录的编号都是0。有一个议员发了一个提议：将电费设定为1元／度。他首先看了一下记事本，嗯，当前提议编号是0，那么我的这个提议的编号就是1，于是他给所有议员发消息：1号提议，设定电费1元／度。其他议员收到消息以后查了一下记事本，哦，当前提议编号是0，这个提议可接受，于是他记录下这个提议并回复：我接受你的1号提议，同时他在记事本上记录：当前提议编号为1。发起提议的议员收到了超过半数的回复，立即给所有人发通知：1号提议生效！收到的议员会修改他的记事本，将1好提议由记录改成正式的法令，当有人问他电费为多少时，他会查看法令并告诉对方：1元／度。

再看冲突的解决：假设总共有三个议员S1-S3，S1和S2同时发起了一个提议：1号提议，设定电费。S1想设为1元／度，S2想设为2元／度。结果S3先收到了S1的提议，于是他做了和前面同样的操作。紧接着他又收到了S2的提议，结果他一查记事本，咦，这个提议的编号小于等于我的当前编号1，于是他拒绝了这个提议：对不起，这个提议先前提过了。于是S2的提议被拒绝，S1正式发布了提议：1号提议生效。S2向S1或者S3打听并更新了1号法令的内容，然后他可以选择继续发起2号提议。

如果Paxos岛上的议员人人平等，在某种情况下会由于提议的冲突而产生一个“活锁”（所谓活锁我的理解是大家都没有死，都在动，但是一直解决不了冲突问题）。Paxos的作者在所有议员中设立一个总统，只有总统有权发出提议，如果议员有自己的提议，必须发给总统并由总统来提出。

情况一：屁民甲（Client）到某个议员（ZK Server）那里询问（Get）某条法令的情况（ZNode的数据），议员毫不犹豫的拿出他的记事本（local storage），查阅法令并告诉他结果，同时声明：我的数据不一定是最新的。你想要最新的数据？没问题，等着，等我找总统Sync一下再告诉你。

情况二：屁民乙（Client）到某个议员（ZK Server）那里要求政府归还欠他的一万元钱，议员让他在办公室等着，自己将问题反映给了总统，总统询问所有议员的意见，多数议员表示欠屁民的钱一定要还，于是总统发表声明，从国库中拿出一万元还债，国库总资产由100万变成99万。屁民乙拿到钱回去了（Client函数返回）。

情况三：总统突然挂了，议员接二连三的发现联系不上总统，于是各自发表声明，推选新的总统，总统大选期间政府停业，拒绝屁民的请求。

[root@node01 ~]# tar -zxvf apache-zookeeper-3.6.3-bin.tar.gz -C /opt/yjx/
[root@node01 ~]# rm apache-zookeeper-3.6.3-bin.tar.gz -rf

[root@node01 ~]# mkdir -p /var/yjx/zookeeper/data
[root@node01 ~]# mkdir -p /opt/yjx/apache-zookeeper-3.6.3-bin/logs

[root@node01 ~]# cd /opt/yjx/apache-zookeeper-3.6.3-bin/
[root@node01 apache-zookeeper-3.6.3-bin]# cp conf/zoo_sample.cfg conf/zoo.cfg
[root@node01 apache-zookeeper-3.6.3-bin]# vim conf/zoo.cfg

12 dataDir=/var/yjx/zookeeper/data
13 dataLogDir=/opt/yjx/apache-zookeeper-3.6.3-bin/logs
15 clientPort=2181
37 server.1=node01:2888:3888
38 server.2=node02:2888:3888
39 server.3=node03:2888:3888

[root@node02 ~]# scp -r root@node01:/opt/yjx/apache-zookeeper-3.6.3-bin /opt/yjx/
[root@node03 ~]# scp -r root@node01:/opt/yjx/apache-zookeeper-3.6.3-bin /opt/yjx/
# 或者使用分发脚本
[root@node01 ~]# yjxrsync /opt/yjx/apache-zookeeper-3.6.3-bin

[root@node01 ~]# echo 1 > /var/yjx/zookeeper/data/myid

[root@node02 ~]# mkdir -p /var/yjx/zookeeper/data
[root@node02 ~]# echo 2 > /var/yjx/zookeeper/data/myid

[root@node03 ~]# mkdir -p /var/yjx/zookeeper/data
[root@node03 ~]# echo 3 > /var/yjx/zookeeper/data/myid

export ZOOKEEPER_HOME=/opt/yjx/apache-zookeeper-3.6.3-bin
export PATH=$ZOOKEEPER_HOME/bin:$PATH

[root@node01 ~]# zkServer.sh start
[root@node02 ~]# zkServer.sh start
[root@node03 ~]# zkServer.sh start

[root@node01 ~]# zkServer.sh status
ZooKeeper JMX enabled by default
Using config: /opt/yjx/apache-zookeeper-3.6.3-bin/bin/../conf/zoo.cfg
Client port found: 2181. Client address: localhost. Client SSL: false.
Mode: follower
[root@node02 ~]# zkServer.sh status
ZooKeeper JMX enabled by default
Using config: /opt/yjx/apache-zookeeper-3.6.3-bin/bin/../conf/zoo.cfg
Client port found: 2181. Client address: localhost. Client SSL: false.
Mode: follower
[root@node03 ~]# zkServer.sh status
ZooKeeper JMX enabled by default
Using config: /opt/yjx/apache-zookeeper-3.6.3-bin/bin/../conf/zoo.cfg
Client port found: 2181. Client address: localhost. Client SSL: false.
Mode: leader

[root@node01 ~]# zkServer.sh stop
[root@node02 ~]# zkServer.sh stop
[root@node03 ~]# zkServer.sh stop

[root@node01 ~]# vim /usr/local/bin/zookeeper

#!/bin/bash

user=$(whoami)
case $1 in
    "start")
        for i in node01 node02 node03
        do
            echo -e "\e[1;34m==================== $i ZooKeeper 启动 ====================\e[0m"
            ssh $user@$i "/opt/yjx/apache-zookeeper-3.6.3-bin/bin/zkServer.sh start"
        done
        ;;
    "stop")
        for i in node01 node02 node03
        do
            echo -e "\e[1;34m==================== $i ZooKeeper 停止 ====================\e[0m"
            ssh $user@$i "/opt/yjx/apache-zookeeper-3.6.3-bin/bin/zkServer.sh stop"
        done
        ;;
    "status")
        for i in node01 node02 node03
        do
            echo -e "\e[1;34m==================== $i ZooKeeper 状态 ====================\e[0m"
            ssh $user@$i "/opt/yjx/apache-zookeeper-3.6.3-bin/bin/zkServer.sh status"
        done
        ;;
    "restart")
        for i in node01 node02 node03
        do
            echo -e "\e[1;34m==================== $i ZooKeeper 重启 ====================\e[0m"
            ssh $user@$i "/opt/yjx/apache-zookeeper-3.6.3-bin/bin/zkServer.sh restart"
        done
        ;;
esac

[root@node01 ~]# chmod 750 /usr/local/bin/zookeeper

一、zk服务命令
1. 启动ZK服务: bin/zkServer.sh start
2. 查看ZK服务状态: bin/zkServer.sh status
3. 停止ZK服务: bin/zkServer.sh stop
4. 重启ZK服务: bin/zkServer.sh restart
5. 连接服务器: zkCli.sh -server 127.0.0.1:2181

二、zk客户端命令
1.ls -- 查看某个目录包含的所有文件，例如：
[zk: 127.0.0.1:2181(CONNECTED) 1] ls /
ls /path

2.create -- 创建znode，并设置初始内容，例如：
[zk: 127.0.0.1:2181(CONNECTED) 1] create /test "test"
Created /test
创建一个新的 znode节点“ test ”以及与它关联的字符串
create /path data 默认创建持久节点
create -s /path data 创建顺序节点
create -e /path data 创建临时节点
create /parent/sub/path /data

3.get -- 获取znode的数据，如下：
[zk: 127.0.0.1:2181(CONNECTED) 1] get /test
get /path
get /path0000000018 访问顺序节点必须输入完整路径

4.set -- 修改znode内容，例如：
[zk: 127.0.0.1:2181(CONNECTED) 1] set /test "ricky"
set /path /data

5.delete -- 删除znode，例如：
[zk: 127.0.0.1:2181(CONNECTED) 1] delete /test
delete /path 删除没有子节点的节点
rmr /path 移除节点并且递归移除所有子节点

6.quit -- 退出客户端

7.help -- 帮助命令

[zk: localhost:2181(CONNECTED) 10] stat /yjx
666 当前节点的值
cZxid = 0xf00000013
创建这个节点的事务id，ZXID是一个长度64位的数字，
低32位是按照数字递增，即每次客户端发起一个proposal,低32位的数字简单加1。
高32位是leader周期的epoch编号
ctime = Mon Dec 09 17:33:06 CST 2019 创建时间
mZxid = 0xf00000013 最后一次修改节点数据的事务ID
mtime = Mon Dec 09 17:33:06 CST 2019 修改时间
pZxid = 0xf00000014 子节点的最新事务ID
cversion = 1 对此znode的子节点进行的更改次数
dataVersion = 对此znode的数据所作的修改次数
aclVersion = 对此znode的acl更改次数
ephemeralOwner = 0x0 （持久化节点）0x16ee9fc0feb0001（临时节点）
dataLength = 3 数据的长度
numChildren = 1 子节点的数目

# 创建节点
[zk: localhost:2181(CONNECTED) 0] create /bigdata 100
Created /bigdata

# 监听节点，使用 PERSISTENT 模式
[zk: localhost:2181(CONNECTED) 1] addWatch -m PERSISTENT /bigdata

# 修改当前节点会触发监听事件
[zk: localhost:2181(CONNECTED) 2] set /bigdata 200

WATCHER:: # 触发监听事件 NodeDataChanged
WatchedEvent state:SyncConnected type:NodeDataChanged path:/bigdata

# 创建子节点会触发监听事件
[zk: localhost:2181(CONNECTED) 3] create /bigdata/zk 300

WATCHER:: # 触发监听事件 NodeChildrenChanged
WatchedEvent state:SyncConnected type:NodeChildrenChanged path:/bigdata
Created /bigdata/zk

# 修改子节点不会触发监听事件
[zk: localhost:2181(CONNECTED) 4] set /bigdata/zk 301

# 删除子节点触发监听事件
[zk: localhost:2181(CONNECTED) 5] delete /bigdata/zk

WATCHER:: # 触发监听事件 NodeChildrenChanged
WatchedEvent state:SyncConnected type:NodeChildrenChanged 
path:/bigdata

# 删除当前节点会触发监听事件
[zk: localhost:2181(CONNECTED) 6] delete /bigdata

WATCHER:: # 触发监听事件 NodeDeleted
WatchedEvent state:SyncConnected type:NodeDeleted path:/bigdata

# 创建节点
[zk: localhost:2181(CONNECTED) 0] create /bigdata 100
Created /bigdata

# 监听节点，不指定模式默认采用 PERSISTENT_RECURSIVE 模式
[zk: localhost:2181(CONNECTED) 1] addWatch /bigdata

# 修改当前节点会触发监听事件
[zk: localhost:2181(CONNECTED) 2] set /bigdata 200

WATCHER:: # 触发监听事件 NodeDataChanged
WatchedEvent state:SyncConnected type:NodeDataChanged path:/bigdata

# 创建子节点会触发监听事件
[zk: localhost:2181(CONNECTED) 3] create /bigdata/zk 30

WATCHER:: # 触发监听事件 NodeCreated
WatchedEvent state:SyncConnected type:NodeCreated path:/bigdata/zk
Created /bigdata/zk

# 创建子节点的子节点会触发监听事件
[zk: localhost:2181(CONNECTED) 4] create /bigdata/zk/test 400

WATCHER:: # 触发监听事件 NodeCreated
WatchedEvent state:SyncConnected type:NodeCreated 
path:/bigdata/zk/test
Created /bigdata/zk/test

# 修改子节点会触发监听事件
[zk: localhost:2181(CONNECTED) 5] set /bigdata/zk 301

WATCHER:: # 触发监听事件 NodeDataChanged
WatchedEvent state:SyncConnected type:NodeDataChanged path:/bigdata/zk

# 修改子节点的子节点会触发监听事件
[zk: localhost:2181(CONNECTED) 6] set /bigdata/zk/test 401

WATCHER:: # 触发监听事件 NodeDataChanged
WatchedEvent state:SyncConnected type:NodeDataChanged path:/bigdata/zk/test

# 删除子节点的子节点触发监听事件
[zk: localhost:2181(CONNECTED) 7] delete /bigdata/zk/test

WATCHER:: # 触发监听事件 NodeDeleted
WatchedEvent state:SyncConnected type:NodeDeleted 
path:/bigdata/zk/test

# 删除子节点和当前节点都会触发监听事件
[zk: localhost:2181(CONNECTED) 8] deleteall /bigdata

WATCHER:: # 触发监听事件 NodeDeleted
WatchedEvent state:SyncConnected type:NodeDeleted path:/bigdata/zk

WATCHER:: # 触发监听事件 NodeDeleted
WatchedEvent state:SyncConnected type:NodeDeleted path:/bigdata

ACL权限控制

ZK的节点有5种操作权限：CREATE、READ、WRITE、DELETE、ADMIN 也就是 增、删、改、查、管理权限，这5种权限简写为crwda，这5种权限中，delete是指对子节点的删除权限，其它4种权限指对自身节点的操作权限

身份的认证有4种方式：
- world：默认方式，相当于全世界都能访问
- auth：代表已经认证通过的用户(cli中可以通过addauth digest user:pwd 来添加当前上下文中的授权用户)
- digest：即用户名:密码这种方式认证，这也是业务系统中最常用的
- ip：使用Ip地址认证

schema
    world:只有一个用户anyone,代表所有人（默认）
    ip：使用IP地址认证
    auth：使用已添加认证的用户认证
    digest：使用用户名：密码 方式认证
id
    world:只有一个id，anyone
    ip：通常是一个ip地址或者地址段
    auth:用户名
    digest：自定义
    
权限
    create 简写为c,可以创建子节点
    delete 简写为d 可以删除子节点
    read 简写为r 可以读取节点数据及显示子节点列表
    write 简写为w 可以设置节点数据
    admin 简写为a 可以设置管理权限
    
查看ACL
	getAcl /parent
设置ACL
	setAcl /parent world:anyone:r
添加用户
    addauth digest zhangsan:123456
    addauth digest lisi:123456
设置权限
    setAcl /parent auth:zhangsan:123456:r
    setAcl /parent auth:lisi:123456:rcwd
退出当前用户
	quit
后续访问 /parent路径，需要先添加用户
	addauth digest zhangsan:123456

<!-- ZooKeeper 核心依赖 -->
<dependency>
<groupId>org.apache.zookeeper</groupId>
<artifactId>zookeeper</artifactId>
<version>3.6.3</version>
</dependency>
<!-- JUnit 单元测试依赖 -->
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<version>5.9.2</version>
<scope>test</scope>
</dependency>

package com.yjxxt;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import java.io.IOException;
import java.util.concurrent.CountDownLatch;
/*
@DisplayName：测试类在测试报告中的名称，可以加在类上，也可以加在方法上。
@BeforeAll和@AfterAll：它们定义了整个测试类在开始前以及结束时的操作，只能修饰静态方法，主要用于在测试过程中所需要的全局数据和外部资源的初始化和清理。
@BeforeEach和@AfterEach：它们所标注的方法会在每个测试用例方法开始前和结束时执行，主要是负责该测试用例所需要的运行环境的准备和销毁。
*/
@DisplayName("ZooKeeper 测试类")
public class ZooKeeperTest {
    /**
    * 客户端对象
    */
    private ZooKeeper zooKeeper;
    
    @BeforeEach
    public void init() {
        try {
        /*
        初始次数为 1，后面要在内部类中使用。
        三种写法：
        1、写成外部类成员变量，不用加 final；
        2、作为函数局部变量，放在 try 外面，写成 final；
        3、写在 try 中，不加 final。
        */
        CountDownLatch countDownLatch = new CountDownLatch(1);
        // zkServer 的 ip、port，如果是集群逗号分隔
        String connectString = "192.168.100.101:2181,192.168.100.102:2181,192.168.100.103:2181";
        // 超时时间
        int sessionTimeout = 5000;
        zooKeeper = new ZooKeeper(connectString, sessionTimeout,
        	// 连接成功后监听
        	watchedEvent -> {
        		// 如果状态变成已连接则次数 -1
        		if (Watcher.Event.KeeperState.SyncConnected.equals(watchedEvent.getState())) {
        			System.out.println("连接成功");
        			// 次数 -1
        			countDownLatch.countDown();
        		}
        	});
        // 等待，次数为 0 时才会继续往下执行（等待监听器监听到连接成功，才能操作 zk）
        	countDownLatch.await();
        } catch (IOException | InterruptedException e) {
        	e.printStackTrace();
        }
    }
    
    @AfterEach
    public void close() {
        // 关闭连接
        try {
            if (zooKeeper != null) {
            	zooKeeper.close();
            }
        } catch (InterruptedException e) {
        	e.printStackTrace();
        }
    }
}

连接成功

/**
* 操作后，服务端会返回处理结果，返回 void、null也算处理结果。
* 同步指的是当前线程阻塞，等待服务端返回数据，收到返回的数据才继续往下执行；
* 异步回调指的是，把对结果（返回的数据）的处理写在回调函数中，当前线程不等待返回的数据，继续往下执行，收到返回的数据时自动调用回调函数来处
理。
*/
@DisplayName("检测节点是否存在")
@Test
public void testDataIsExists() {
	// 同步方式
    System.out.println("同步方式");
    Stat exists = null;
    String znode = "/bigdata";
    try {
    // 如果存在，返回节点状态 stat；如果不存在，返回 null。
    // 第二个参数是 watch，是否监听。
    exists = zooKeeper.exists(znode, false);
   	} catch (KeeperException | InterruptedException e) {
		e.printStackTrace();
    }
    if (exists == null) {
    	System.out.println(znode + "节点不存在");
    } else {
    	System.out.println(znode + "节点存在");
    }
    System.out.println("========== 华丽的分割线 ==========");
    // 异步回调
    System.out.println("异步回调");
    zooKeeper.exists(znode, false,
    	// 第二个是 path znode 路径，第三个是 ctx 后面传入实参，第四个是 znode 的状态
    (i, s, o, stat) -> {
        // 如果节点不存在，返回的 stat 是 null
        if (stat == null) {
        	System.out.println(znode + "节点不存在");
        } else {
        	System.out.println(znode + "节点存在");
        }
        // ctx：Object 类型
    }, "传给回调的参数");
}     

连接成功
同步方式
/bigdata节点不存在
========== 华丽的分割线 ==========
异步回调
/bigdata节点不存在

@DisplayName("创建节点")
    @Test
    public void testCreateNode() {
        // 同步方式
        System.out.println("同步方式");
        String znode1 = "/bigdata";
        try {
            // 数据要写成 byte[]，不携带数据写成 null；
            // 默认 acl 权限使用 ZooDefs.Ids.OPEN_ACL_UNSAFE；
            // 最后一个是节点类型，P 是永久，E 是临时，S 是有序
            zooKeeper.create(znode1, "abc".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
            System.out.println(znode1 + "节点创建成功");
            // 如果节点已存在，会抛出异常
        } catch (KeeperException | InterruptedException e) {
            System.out.println("创建节点" + znode1 + "失败，请检查节点是否已存在");
            e.printStackTrace();
        }
        System.out.println("========== 华丽的分割线 ==========");
        // 异步回调
        System.out.println("异步回调");
        String znode2 = "/java";
        zooKeeper.create(znode2, "abc".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT,
                // 第二个 path，第三个 ctx，第四个节点状态
                (i, s, o, s1, stat) -> {
                    // 回调方式不抛出异常，返回的 stat 是创建节点的状态，如果节点已存在，返回的 stat 是 null
                    if (stat == null) {
                        System.out.println("创建节点" + znode2 + "失败，请检查节点是否已存在");
                    } else {
                        System.out.println(znode2 + "节点创建成功");
                    }
                }, null);
    }

连接成功
同步方式
/bigdata节点创建成功
========== 华丽的分割线 ==========
异步回调
/java节点创建成功

 @DisplayName("获取节点数据")
    @Test
    public void testGetNodeData() {
        // 获取节点数据，返回 byte[]
        // 同步方式
        System.out.println("同步方式");
        String znode1 = "/bigdata";
        byte[] data = null;
        try {
            // 第二个参数是 watch，第三个是 stat
            data = zooKeeper.getData(znode1, false, null);
        } catch (KeeperException | InterruptedException e) {
            e.printStackTrace();
        }
        // 调用 new String() 时要判断 data 是否为 null，如果是 null 会抛 NPE
        if (data == null) {
            System.out.println(znode1 + "节点没有数据");
        } else {
            System.out.println(znode1 + "节点数据：" + new String(data));
        }
        System.out.println("========== 华丽的分割线 ==========");
        // 异步回调
        System.out.println("异步回调");
        String znode2 = "/java";
        zooKeeper.getData(znode2, false,
                // 第二个起依次是：path、ctx、返回的节点数据、节点状态
                (i, s, o, bytes, stat) -> {
                    // 不必判断 bytes 是否是 null，如果节点没有数据，不会调用回调函数；
                    // 执行到此，说明 bytes 不是 null
                    System.out.println(znode2 + "节点数据：" + new String(bytes));
                }, null);
    }

连接成功
同步方式
/bigdata节点数据：abc
========== 华丽的分割线 ==========
异步回调
/java节点数据：abc

 @DisplayName("更新节点数据")
    @Test
    public void testUpdateNodeData() {
        // 同步方式
        System.out.println("同步方式");
        String znode1 = "/bigdata";
        try {
            // 最后一个参数是版本号，-1 表示可以是任何版本
            zooKeeper.setData(znode1, "123".getBytes(), -1);
            System.out.println(znode1 + "节点数据更新成功");
        } catch (KeeperException | InterruptedException e) {
            System.out.println(znode1 + "节点数据更新失败");
            e.printStackTrace();
        }
        System.out.println("========== 华丽的分割线 ==========");
        // 异步回调
        System.out.println("异步回调");
        String znode2 = "/java";
        zooKeeper.setData("/java", "123".getBytes(), -1,
                // 第二个是 path，第三个是 ctx
                (i, s, o, stat) -> {
                    System.out.println(znode2 + "节点数据更新成功");
                }, null);
    }

连接成功
同步方式
/bigdata节点数据更新成功
========== 华丽的分割线 ==========
异步回调
/java节点数据更新成功

 /**
     * 只获取子节点，不获取孙节点。
     * watch：可以写 boolean，要添加监听就写 true，不监听写 false；
     * 可以写 Watcher 对象，new 一个 Watcher 对象表示要监听，null 表示不监听。
     */
    @DisplayName("获取子节点列表")
    @Test
    public void testGetNodeList() {
        // 获取子节点列表，List<String>，比如/bigdata/zk,/bigdata/java，返回的是["zk"、"java"]
        // 同步方式
        System.out.println("同步方式");
        String znode1 = "/";
        List<String> children = null;
        try {
            // 第二个参数是 watch
            children = zooKeeper.getChildren(znode1, false);
        } catch (KeeperException | InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(znode1 + "子节点列表：" + children);
        System.out.println("========== 华丽的分割线 ==========");
        // 异步回调
        System.out.println("异步回调");
        String znode2 = "/zookeeper";
        zooKeeper.getChildren(znode2, false,
                // 第二个起依次是：path、ctx、返回的子节点列表
                (i, s, o, list) -> System.out.println(znode2 + "子节点列表：" + list), null);
    }

连接成功
同步方式
/子节点列表：[bigdata, java, zookeeper]
========== 华丽的分割线 ==========
异步回调
/zookeeper子节点列表：[config, quota]

/**
     * delete() 只能删除没有子节点的 znode，如果该 znode 有子节点会抛出异常。
     * 没有提供递归删除子节点的方法，如果要删除带有子节点的 znode，需要自己实现递归删除。
     * 可以先 getChildren() 获取子节点列表，遍历列表依次删除子节点，再删除父节点。
     */
    @DisplayName("删除节点")
    @Test
    public void testDeleteNode() {
        // 同步方式
        System.out.println("同步方式");
        String znode1 = "/bigdata";
        try {
            // 第二个参数是版本号，-1 表示可以是任何版本
            zooKeeper.delete(znode1, -1);
            System.out.println(znode1 + "节点删除成功");
        } catch (InterruptedException | KeeperException e) {
            System.out.println(znode1 + "节点删除失败");
            e.printStackTrace();
        }
        System.out.println("========== 华丽的分割线 ==========");
        // 异步回调
        System.out.println("异步回调");
        String znode2 = "/java";
        zooKeeper.delete(znode2, -1,
                // 第二个是 path，第三个是 ctx
                (i, s, o) -> System.out.println(znode2 + "节点删除成功"), null);
    }

连接成功
同步方式
/bigdata节点删除成功
========== 华丽的分割线 ==========
异步回调
/java节点删除成功