知春秋

邂逅”拉勾教育Java高薪训练营“的美好与学习笔记分享

文章内容输出来源：拉勾教育Java高薪训练营

一、初识拉勾教育

最开始并不知道拉勾有教育模块的业务，一直都以为只有招聘。直到今年5月份的时候拉勾的小姐姐打电话给我说他们有一个训练营问我是否有兴趣，那个时候刚好处于技术的瓶颈期，对于技术感觉怎么都上不去。于是就听了拉勾小姐姐的介绍（拉勾教育Java工程师高薪训练营课程），主要介绍从以下几个方面讲解：

拉勾为什么做教育培训

拉勾主营业务是招聘，在长期的招聘过程中积累了大量的企业对人才的需求和人才的自身能力数据信息。同时也根据企业对人才的需求推荐合适的候选人。但是符合企业要求的高端人才比较稀缺，而拉勾又掌握了企业的需求。所以拉勾本着为企业培养候选人的愿景开启教育培训业务，主要目的是通过系统培训为企业输送符合的高质量人才。

高薪训练营课程大纲介绍
- Java高薪训练营是拉勾教育历经十几个月时间精心打磨才确定推出的课程。
- 课程设计是对标阿里P7技术要求，针对专项提升技术能力。
- 课程知识体系覆盖全面，详细规划层层递进提升技术能力，涵盖了99%的企业对技术的要求。
- 课程内容分阶段，从12个阶段全面提升架构能力。内容涵盖主流源码剖析、微服务、分布式中间件（缓存、MQ等）、海量数据存储、容器虚拟化技术、底层调优与算法等。
- 讲师团队都是由一线多年经验的资深技术专家讲解，更加贴近实际开发应用。
课程学习模式介绍
- 线上学习直播+录播，课程阶段学习闯关式。只有前面的阶段学完提交作业老师批改及格才解锁下一个模块。
- 学习成果测验，每个模块的知识学完都有测验可以检验自己的学习成果。大的模块学完有专门设计的作业进行实操。
- 导师在线实时解答疑惑，进行作业思路指导与批改。
- 班主任在线监督学习情况。

二、反复斟酌后的选择

听完了训练营的课程介绍后，还是比较激动因为课程内容很符合自己目前的情况，但是依然很淡定因为我要反复对比课程内容选择最好的才可以。后面的2-3天对比了其他平台课程发现内容都没有拉勾教育的系统和全面，最终在课程报名截止的前几天缴费参与了课程。

做出这个决定比较难，因为学费不便宜（大家一定这样觉得）。但是这个费用和以后的职业提升发展做对比，我还是觉得可以承受的。毕竟未来还很长，而且学习一周不满意可以全额退款。如果觉得学的不够好还可以免费读一次，那么就可以学习一年。

三、学习过程亲身感受

目前截止已经认真学习了六周的拉勾教育Java高薪训练营课程，课程的质量我是非常认可的。我看过很多平台的机构直播课程，但是感觉讲解的知识并没有那么容易吸收。但是拉勾教育的子幕和应颠老师讲解从浅到深，前面学习的内容是为了给后面的内容做铺垫。层层递进的教学方式让我能够很好的吸收知识。并且对于每个模块的知识点都能够讲的很透彻。而且对于源码剖析过程源代码都有非常详细的注释，老师会给有注释的源代码，这样自己学习起来也没有那么吃力。

以前都是自己学习，整体学下来回感觉到很痛苦。比较技术的道路不太好走，没有人带领也不知道应该如何做，整体的知识体系会比较乱、还会松懈。在加入了拉勾的训练营后，每天都要学习2-3个小时，跟着老师的脚步慢慢学。松懈的时候看到与别人的进度有差距，这个时候不服输的心理就诞生了，促使这我继续坚持学习下去。

导师和班主任认真负责

班主任和导师很热情认真负责，信息回复很及时。班主任和导师分别负责服务类和技术类的问题。在班群中班主任会不时的给大家打气，在学习中缓解了我们的紧张气氛，还营造了很好的学习氛围。如果对于课程有什么不理解的咨询班主任也会第一时间的到答复。说到最主要的技术问题，班群的讨论氛围也是热烈的。如果有问题可以在班群提出，那么有空的同学会给予答复，当然大家都解决不了的时候导师会给你解答。很多同学都是晚上提交作业，导师也会第一时间批改给你开下一个模块让你可以学习，不耽误你的学习时间。导师和班主任非常非常负责

四、学习笔记分享`部分`（Zookeeper）

4.1 Zookeeper简介

Zookeeper是Apache开源的致力于开发和维护实现高可用、高可靠的分布式协调服务器。Zookeeper提供了一种集中式服务，用于维护配置信息、服务命名、提供分布式同步以及提供组服务。这一类的服务如果没有统一的管理，那么就在分布式应用运行过程中，会导致不可避免的错误和竞争条件。

4.2 Zookeeper安装

Zookeeper的安装有单机、集群和伪集群三种类型。在开发中只需要搭建单机就可以，但是在生产环境一般为了避免单点故障都会部署集群或者伪集群模式。

由于Zookeeper采用过半投票机制策略，所以集群至少需要保证有3个以上的服务器。那么集群和伪集群有什么区别呢。

集群：在多个独立的物理服务器上各自部署Zookeeper，这样的好处是单台物理服务器故障不会导致整体受影响。但是也增加了网络通信的问题。

伪集群：伪集群和集群其实差不多，只是在同一台物理服务器上部署多个Zookeeper，这样的确定就是如果物理服务器故障，将导致整体不可用。

以下演示的安装是以 Linux环境、CentOS 7系统为基础，那么在使用之前我们需要做一下配置，如果有环境并且已经处理了可以忽略

JDK安装问题，Zookeeper是Java语言编写的，所以安装之前需要确保Linux已经安装了JDK并且可以正常使用

使用java -version检查是否有默认安装的JDK,如果有需要卸载
将linux的JDK安装包tar.gz上传到服务器
tar -zxvf jdk-11.0.7_linux-x64_bin.tar.gz解压

配置JDK环境变量

vi /etc/profile打开环境配置文件

#java environment
export JAVA_HOME=/usr/local/java/jdk1.8.0_201
export CLASSPATH=.:$JAVA_HOME/jre/lib/rt.jar:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
export PATH=$PATH:$JAVA_HOME/bin

source /etc/profile让配置文件生效
java -version如果显示jdk版本信息就是安装成功

防火墙问题，CentOS 7防火墙默认是开启的，那么如果不关闭端口就不可以访问，在代码中调用的时候就无法使用默认的2181和其他端口

# CentOS 6处理方法
//临时关闭
service iptables stop
//禁止开机启动
chkconfig iptables off

# CentOS 7处理方法，由于CentOS 7以后的防火墙默认使用firewalld，因此处理方法和CentOS 6有差异
//临时关闭
systemctl stop firewalld
//禁止开机启动
systemctl disable firewalld
Removed symlink /etc/systemd/system/multi-user.target.wants/firewalld.service.
Removed symlink /etc/systemd/system/dbus-org.fedoraproject.FirewallD1.sersvice.

# 额外提供的命令
# 防火墙相关命令
1、查看防火墙状态 ： systemctl status firewalld.service
注：active是绿的running表示防火墙开启
2、关闭防火墙 ：systemctl stop firewalld.service
3、开机禁用防火墙自启命令 ：systemctl disable firewalld.service
4、启动防火墙 ：systemctl start firewalld.service
5、防火墙随系统开启启动 ： systemctl enable firewalld.service
6、重启防火墙 ： firewall-cmd --reload

# 端口开放命令
1、查询已经开放的端口 ：firewall-cmd --list-port
2、查询某个端口是否开放 ：firewall-cmd --query-port=80/tcp
3、开启端口 ：firewall-cmd --zone=public --add-port=80/tcp --permanent
注：可以是一个端口范围，如1000-2000/tcp
4、移除端口 ：firewall-cmd --zone=public --remove-port=80/tcp --permanent
5、命令含义：
	--zone #作用域
	--add-port=80/tcp #添加端口，格式为：端口/通讯协议
	--remove-port=80/tcp #移除端口，格式为：端口/通讯协议
	--permanent #永久生效，没有此参数重启后失效

4.2.1 单机版

下载Zookeeper http://zookeeper.apache.org/releases.html 打开这个网址就可以看到不同的版本直接下载即可
在/usr/local/目录下创建zookeeper文件夹，用于存放zookeeper。mkdir zookeeper
将下载的zookeeper.tar.gz压缩包上传到Linux的/usr/local/zookeeper目录下

# 解压
tar -zxvf zookeeper-3.4.14.tar.gz

# 进入conf目录,zookeeper启动是读取zoo.cfg配置文件，所以重命名或者拷贝一份都可以
cp zoo_sample.cfg zoo.cfg

# 在zookeeper目录下创建data文件夹，用于存储文件，不使用默认的路径文件夹
mkdir data
# 修改conf/zoo.cfg配置文件的dataDir路径,这个是数据存放的文件路径
dataDir=/usr/local/zookeeper/data

# 命令
./bin/zkServer.sh start  # 启动
./bin/zkServer.sh stop   # 暂停
./bin/zkServer.sh status # 查看状态

# 启动命令执行的效果
[root@localhost zookeeper-3.4.14-2181]# ./bin/zkServer.sh start
ZooKeeper JMX enabled by default
Using config: /usr/local/zookeeper/zookeeper-3.4.14-2181/bin/../conf/zoo.cfg
Starting zookeeper ... STARTED

# 查看状态命令执行的效果
[root@localhost zookeeper-3.4.14-2181]# ./bin/zkServer.sh status
ZooKeeper JMX enabled by default
Using config: /usr/local/zookeeper/zookeeper-3.4.14-2181/bin/../conf/zoo.cfg
Mode: standalone  # standalone表示单机版本

# 暂停命令执行的效果
[root@localhost zookeeper-3.4.14-2181]# ./bin/zkServer.sh stop
ZooKeeper JMX enabled by default
Using config: /usr/local/zookeeper/zookeeper-3.4.14-2181/bin/../conf/zoo.cfg
Stopping zookeeper ... STOPPED

4.2.2 集群版

下载http://zookeeper.apache.org/releases.html 打开这个网址就可以看到不同的版本直接下载
上传zookeeper.tar.gz压缩包到/usr/local/zookeeper目录下

# 在/usr/local/目录下创建文件夹
mkdir zkcluster

# 解压zookeeper到zkcluster文件夹，-C的作用是指定解压到那个文件夹下
tar -zxvf zookeeper-3.4.14.tar.gz -C /zkcluster

# 修改文件名称，并复制
mv zookeeper-3.4.14 zookeeper01
# 复制2份，集群数量为3
cp -r zookeeper01/ zookeeper02
cp -r zookeeper01/ zookeeper03

# 在每个zookeeper目录下创建data文件夹,并在data目录下创建log文件夹
mkdir data
cd data
mkdir log

# 修改/conf/zoo_sample.cfg配置文件名 zookeeper01  zookeeper02  zookeeper03都要执行
cp zoo_sample.cfg zoo.cfg

# 修改zoo.cfg配置文件的端口的数据存储就以及日志路径，端口分别是：2181 2182 2183
# 端口
clientPort=2181
# 存储路径
dataDir=/usr/local/zookeeper/zkcluster/zookeeper01/data
# 日志路径
dataLogDir=/usr/local/zookeeper/zkcluster/zookeeper01/data/log

clientPort=2182
dataDir=/usr/local/zookeeper/zkcluster/zookeeper02/data
dataLogDir=/usr/local/zookeeper/zkcluster/zookeeper02/data/log

clientPort=2183
dataDir=/usr/local/zookeeper/zkcluster/zookeeper03/data
dataLogDir=/usr/local/zookeeper/zkcluster/zookeeper03/data/log

# 配置集群，分别在data目录下创建myid，内容分别是1 2 3用于记录每个服务器的ID，也是集群中zookeeper的唯一标记，不可以重复
touch ./zookeeper01/data/myid
touch ./zookeeper02/data/myid
touch ./zookeeper03/data/myid

#在每个zookeeper的zoo.cfg文件中配置客户端访问端口（clientPort）和集群服务器IP列表
#server.服务器ID=服务器IP地址：服务器之间通信端口：服务器之间投票选举端口
server.1=192.168.247.100:2881:3881
server.2=192.168.247.100:2882:3882
server.3=192.168.247.100:2883:3883

# 依次启动3个zookeeper，相关命令如下
./bin/zkServer.sh start
./bin/zkServer.sh stop
./bin/zkServer.sh status

4.3 基本使用命令

启动后打开客户端

./bin/zkCli.sh如果要连接的是远程的zookeeper，那么使用./bin/zkCli.sh -server ip:port连接指定的服务器

4.3.1 创建节点

create命令用于创建一个zookeeper节点

create [-s][-e] path data
其中，-s或-e分别指定节点特性，顺序或临时节点，若不指定，则创建持久节点；

在执行创建节点之前，可以使用ls /命令，那么就会显示[zookeeper]这个是自动生成的持久节点。

节点需要一级一级的创建，不可以一下子创建多级

创建持久节点

[zk: localhost:2181(CONNECTED) 5] create /zk-seq 123
Created /zk-seq
[zk: localhost:2181(CONNECTED) 6] ls / 
# zk-seq已经创建好
[zk-seq, zookeeper]

创建持久顺序节点

注意：

顺序节点创建后zookeeper默认会在节点名称后面拼接序列，这个数字序列用于标记节点的顺序。
顺序节点的特点就是节点后面会拼接一串数字表示和非顺序节点的区别。

[zk: localhost:2181(CONNECTED) 3] create -s /zk-test 123
Created /zk-test0000000000
[zk: localhost:2181(CONNECTED) 4] ls /
# zk-test已经创建好
[zk-test0000000000, zookeeper]

创建临时节点

注意：

临时节点的特点是如果会话断开连接，那么节点就会自动被zookeeper删除。

[zk: localhost:2181(CONNECTED) 7] create -e /zk-temp 123
Created /zk-temp
[zk: localhost:2181(CONNECTED) 8] ls /
# zk-temp已经创建好
[zookeeper, zk-temp]
# 退出关闭会话，然后重新登录看临时节点是否还存在
[zk: localhost:2181(CONNECTED) 9] quit
Quitting...
2020-08-08 15:29:51,404 [myid:] - INFO  [main:ZooKeeper@693] - Session: 0x1000009d3a80000 closed
2020-08-08 15:29:51,407 [myid:] - INFO  [main-EventThread:ClientCnxn$EventThread@522] - EventThread shut down for session: 0x1000009d3a80000
# 重新登录后执行ls命令，可以看到临时节点/zk-temp已经被删除
[zk: localhost:2181(CONNECTED) 0] ls /

创建临时顺序节点

[zk: localhost:2181(CONNECTED) 1] create -s -e /zk-temp 123456
Created /zk-temp0000000003
[zk: localhost:2181(CONNECTED) 2] ls /
[zk-temp0000000003, zookeeper]

4.3.2 读取节点

读取节点命令主要有ls path和get path。ls 命令可以列出zookeeper指定节点的所有子节点，但是只可以查看子一级目录。get命令可以获取zookeeper指定节点的数据和属性信息。

[zk: localhost:2181(CONNECTED) 4] get /zk-temp0000000003 # 获取临时顺序节点的信息
123456 # 节点数据内容
cZxid = 0x7 # 创建时候的事务ID
ctime = Sat Aug 08 15:32:00 CST 2020 # 创建时间
mZxid = 0x7 # 修改时候的事务ID
mtime = Sat Aug 08 15:32:00 CST 2020 # 修改时间
pZxid = 0x7 # 最新修改的zxid
cversion = 0 # 子节点被修改版本
dataVersion = 0 # 数据版本
aclVersion = 0 # acl权限控制版本
ephemeralOwner = 0x1000009d3a80001
dataLength = 6 # 数据长度
numChildren = 0 # 子节点数

4.3.3 更新节点

更新节点使用set path data [version]命令。一般不需要指定version版本。

# 以下命令非核心打印的信息省略了
[zk: localhost:2181(CONNECTED) 6] get /zk-seq # 获取节点数据
123 # 数据为123
[zk: localhost:2181(CONNECTED) 7] set /zk-seq 456 # 更新节点数据为456
[zk: localhost:2181(CONNECTED) 8] get /zk-seq # 获取节点数据
456 # 数据已经被更新为456

4.3.4 删除节点

删除节点使用delete path [version]命令。

[zk: localhost:2181(CONNECTED) 0] ls / # 查看节点
[zk-seq, zk-test0000000000, zookeeper]

[zk: localhost:2181(CONNECTED) 1] delete /zk-seq # 删除/zk-seq节点

[zk: localhost:2181(CONNECTED) 2] ls / # 查看节点/zk-seq节点已经不存在
[zk-test0000000000, zookeeper]

4.4 基本API操作Zookeeper

Zookeeper作为一个分布式框架，主要用于解决分布式一致性问题。所以提供了基于各种版本的原生API，那么下面我们就学习一下Zookeeper的Java API如何操作Zookeeper。

引入Jar


<dependency>
    <groupId>org.apache.zookeepergroupId>
    <artifactId>zookeeperartifactId>
    <version>3.4.14version>
dependesncy>

4.4.1 创建会话

在进行Zookeeper的节点操作之前，我们需要和Zookeeper创建一个会话连接的过程。但是Zookeeper的原生API进行会话连接是异步操作的，如果你和Zookeeper创建连接，那么Zookeeper会立刻返回给你。但是最终连接成功后会异步的通知。

// 类实现Watcher接口，Zookeeper基于这个异步通知
public class CreateSession implements Watcher {

    // 使用同步操作阻塞等待Zookeeper异步的通知
    private static CountDownLatch countDownLatch = new CountDownLatch(1);

    public static void main(String[] args) throws IOException, InterruptedException {
        // 参数一：Zookeeper的ip:port
       	// 参数二：连接超时时间
        // 参数三：异步通知
        ZooKeeper zooKeeper = new ZooKeeper("192.168.247.100:2181", 5000, new CreateSession());
        System.out.println(zooKeeper.getState());
        countDownLatch.await();
        System.out.println("zookeeper会话创建成功......");
    }

    // 实现异步通知回调的方法
    @Override
    public void process(WatchedEvent watchedEvent) {
        // 异步通知的事件类型有很多，只有是创建会话成功的才放行，其他的不处理
        if (watchedEvent.getState() == Event.KeeperState.SyncConnected) {
            countDownLatch.countDown();
        }
    }
}

4.4.2 创建节点

public class CreateNode implements Watcher {

    private static CountDownLatch countDownLatch = new CountDownLatch(1);
    private static ZooKeeper zooKeeper;

    public static void main(String[] args) throws Exception {
        zooKeeper = new ZooKeeper("192.168.247.100:2181", 5000, new CreateNode());
        System.out.println(zooKeeper.getState());
        countDownLatch.await();
        System.out.println("zookeeper会话创建成功......");
        // 创建节点
        createNodeSync();
        Thread.sleep(Integer.MAX_VALUE);
    }

    /**
     * 创建节点
     * 节点的类型：
     * 	CreateMode.PERSISTENT 持久节点
     * 	CreateMode.PERSISTENT_SEQUENTIAL 持久顺序节点
     * 	CreateMode.EPHEMERAL 临时节点
     * 	CreateMode.EPHEMERAL_SEQUENTIAL 临时顺序节点
     */
    private static void createNodeSync() throws Exception {
        // 参数一：要创建的节点，一次只可以创建一个子节点，不可以创建多级
        // 参数二：节点的内容，是一个字节数组
        // 参数三：节点的权限类型
        // 参数四：节点的类型，这是持久节点
        String s = zooKeeper.create("/lg_persistent", "持久节点内容".getBytes("UTF-8"), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);

        String s1 = zooKeeper.create("/lg_persistent_sequential", "持久顺序节点内容".getBytes("UTF-8"), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT_SEQUENTIAL);

        String s2 = zooKeeper.create("/lg_ephemeral", "临时节点内容".getBytes("UTF-8"), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);

        String s3 = zooKeeper.create("/lg_ephemeral_sequential", "临时顺序节点内容".getBytes("UTF-8"), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
        System.out.println("创建的持久节点是：" + s);
        System.out.println("创建的持久顺序节点是：" + s1);
        System.out.println("创建的临时节点是：" + s2);
        System.out.println("创建的临时顺序节点是：" + s3);
    }

    @Override
    public void process(WatchedEvent watchedEvent) {
        if (watchedEvent.getState() == Event.KeeperState.SyncConnected) {
            countDownLatch.countDown();
        }
    }
}

4.4.3 获取节点数据

public class GetNodeData implements Watcher {

    private static CountDownLatch countDownLatch = new CountDownLatch(1);
    private static ZooKeeper zooKeeper;

    public static void main(String[] args) throws Exception {
        zooKeeper = new ZooKeeper("192.168.247.100:2181", 5000, new GetNodeData());
        System.out.println(zooKeeper.getState());
        countDownLatch.await();
        System.out.println("zookeeper会话创建成功......");
        // 获取节点内容
        getNodeData();
        // 获取所有的节点
        getChildrens();
        Thread.sleep(Integer.MAX_VALUE);
    }

    private static void getChildrens() throws Exception {
        /*
            参数一：path节点路径
            参数二：是否要监听，如果子节点变化会触发监听
         */
        List<String> children = zooKeeper.getChildren("/lg_persistent", true);
        System.out.println("/lg_persistent子节点为：" + children);
    }

    private static void getNodeData() throws Exception {
        /**
         * 参数一：要获取内容的节点path
         * 参数二：是否监听
         * 参数三：版本，不填默认最新版本
         */
        byte[] data = zooKeeper.getData("/lg_persistent", true, null);
        System.out.println("获取到的节点内容为：" + new String(data));
    }

    @Override
    public void process(WatchedEvent watchedEvent) {
        if (watchedEvent.getState() == Event.KeeperState.SyncConnected) {
            countDownLatch.countDown();
        }
        // 当字节点变化的时候，触发
        if (watchedEvent.getType() == Event.EventType.NodeChildrenChanged) {
            List<String> children = null;
            try {
                // true参数继续注册监听
                children = zooKeeper.getChildren(watchedEvent.getPath(), true);
            } catch (KeeperException e) {
                e.printStackTrace();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(children);
        }
    }
}

4.4.4 修改节点数据

public class UpdateNodeData implements Watcher {

    private static CountDownLatch countDownLatch = new CountDownLatch(1);
    static ZooKeeper zooKeeper;

    public static void main(String[] args) throws Exception {
        zooKeeper = new ZooKeeper("192.168.247.100:2181", 5000, new UpdateNodeData());
        System.out.println(zooKeeper.getState());
        countDownLatch.await();
        System.out.println("zookeeper会话创建成功......");
        // 修改节点内容
        updateNodeData();
        Thread.sleep(Integer.MAX_VALUE);
    }

    private static void updateNodeData() throws Exception {
        // 修改前的节点数据
        byte[] data = zooKeeper.getData("/lg_persistent/c1", true, null);
        System.out.println("修改前的数据为：" + new String(data));
        // 节点数据修改, 版本为-1表示更新最新版本数据
        zooKeeper.setData("/lg_persistent/c1", "节点修改后的数据".getBytes("UTF-8"), -1);
        // 修改后的节点数据
        byte[] data1 = zooKeeper.getData("/lg_persistent/c1", true, null);
        System.out.println("修改后的数据为：" + new String(data1));
    }

    @Override
    public void process(WatchedEvent watchedEvent) {
        if (watchedEvent.getState() == Event.KeeperState.SyncConnected) {
            countDownLatch.countDown();
        }
    }
}

4.4.5 删除节点

public class DeleteNode implements Watcher {

    static ZooKeeper zooKeeper;

    public static void main(String[] args) throws IOException, InterruptedException {
        zooKeeper = new ZooKeeper("192.168.247.100:2181", 5000, new DeleteNode());
        System.out.println(zooKeeper.getState());
        System.out.println("zookeeper会话创建成功......");
        Thread.sleep(Integer.MAX_VALUE);
    }

    @Override
    public void process(WatchedEvent watchedEvent) {
        // 连接成功后删除节点
        try {
            Stat exists = zooKeeper.exists("/lg_persistent/c1", false);
            System.out.println("节点是否存在：" + exists);
            // 删除节点
            zooKeeper.delete("/lg_persistent/c1", -1);

            Stat exists1 = zooKeeper.exists("/lg_persistent/c1", false);
            System.out.println("节点是否存在：" + exists1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (KeeperException e) {
            e.printStackTrace();
        }
    }
}

4.5 开源客户端操作Zookeeper

Zookeeper的开源客户端有很多，这里只列举ZkClient进行演示。开源客户端对Zookeeper的原生API进行了大量的封装，使得我们使用起来非常的方便。