前言：
分布式系统定义及⾯临的问题
ZooKeeper最为主要的使⽤场景，是作为分布式系统的分布式协同服务。
我们将分布式系统定义为：分布式系统是同时跨越多个物理主机，独⽴运⾏的多个软件所组成系统。类⽐⼀下，分布式系统就是⼀群⼈⼀起⼲活。⼈多⼒量⼤，每个服务器的算⼒是有限的，但是通过分布式系统，由n个服务器组成起来的集群，算⼒是可以⽆限扩张的。
优点显⽽易⻅，⼈多⼲活快，并且互为备份。但是缺点也很明显。我们可以想象⼀下，以⼀个⼩研发团队开发软件为例，假设我们有⼀个5⼈的项⽬组，要开始⼀个系统的开发，项⽬组将⾯临如下问题：
图中列举的就是项⽬组将要⾯临到的问题，这些问题在我们⽇常⼯作中也是天天发⽣，并没感觉有多么复杂，但是这是因为我们⼈类的⼤脑是个超级计算机，能够灵活应对这些问题，⽽且现实中信息的交换不依赖⽹络，不会因⽹络延迟或者中断，出现信息不对等，⽽且现实中对以上问题的处理其实并不严谨，从⽽也引发了很多问题。想⼀想，项⽬中是不是出现过沟通不畅造成任务分配有歧义？是否由于⼈员离职造成任务进⾏不下去，甚⾄要联系离职⼈员协助？是不是出现过任务分配不合理？类似这样的各种问题，肯定会发⽣于你的项⽬组中。在现实世界，我们可以⼈为去协调，即使出错了，⼈⼯去补错，加加班搞定就好。但在计算机的世界，这样做是⾏不通的，⼀切都要保证严谨，以上问题要做到尽可能不要发⽣。因此，分布式系统必须采⽤合理的⽅式解决掉以上的问题。
实际上要想解决这些问题并没有那么复杂，我们仅需要做⼀件事就可以万事⽆忧---让信息在项⽬组成员中同步。如果能做到信息同步，那么每个⼈在⼲什么，⼤家都是清楚的，⼲到什么程度也是清晰的，⽆论谁离职也不会产⽣问题。分配的⼯作，能够及时清晰的同步给每个组员，确保每个组员收到的任务分配没有冲突。
分布式系统的协调⼯作就是通过某种⽅式，让每个节点的信息能够同步和共享。这依赖于服务进程之间的通信。通信⽅式有两种：
*通过⽹络进⾏信息共享
这就像现实中，开发leader在会上把任务传达下去，组员通过听leader命令或者看leader的邮件知道⾃⼰要⼲什么。当任务分配有变化时，leader会单ᇿ告诉组员，或者再次召开会议。信息通过⼈与⼈之间的直接沟通，完成传递。
*通过共享存储
这就好⽐开发leader按照约定的时间和路径，把任务分配表放到了svn上，组员每天去svn上拉取最新的任务分配表，然后⼲活。其中svn就是共享存储。更好⼀点的做法是，当svn⽂件版本更新时，触发邮件通知，每个组员再去拉取最新的任务分配表。这样做更好，因为每次更新，组员都能第⼀时间得到消息，从⽽让⾃⼰⼿中的任务分配表永远是最新的。此种⽅式依赖于中央存储。整个过程如下图所示：
ZooKeeper如何解决分布式系统⾯临的问题
ZooKeeper对分布式系统的协调，使⽤的是第⼆种⽅式，共享存储。其实共享存储，分布式应⽤也需要和存储进⾏⽹络通信。
实际上，通过ZooKeeper实现分布式协同的原理，和项⽬组通过SVN同步⼯作任务的例⼦是⼀样的。ZooKeeper就像是svn，存储了任务的分配、完成情况等共享信息。每个分布式应⽤的节点就是组员，订阅这些共享信息。当主节点（组leader），对某个从节点的分⼯信息作出改变时，相关订阅的从节点得到zookeeper的通知，取得⾃⼰最新的任务分配。完成⼯作后，把完成情况存储到zookeeper。主节点订阅了该任务的完成情况信息，所以将得到zookeeper的完⼯的通知。参考下图，是不是和前⾯项⽬组通过svn分配⼯作的例⼦⼀模⼀样？仅仅是把svn和邮件系统合⼆为⼀，以ZooKeeper代替
注:Slave节点要想获取zk的更新通知，需事先在关⼼的数据节点上设置观察点。\
⼤多数分布式系统中出现的问题，都源于信息的共享出了问题。如果各个节点间信息不能及时共享和同步，那么就会在协作过程中产⽣各种问题。ZooKeeper解决协同问题的关键，就是在于保证分布式系统信息的⼀致性。
zookeeper的基本概念
Zookeeper是⼀个开源的分布式协调服务，其设计⽬标是将那些复杂的且容易出错的分布式⼀致性服务封装起来，构成⼀个⾼效可靠的原语集，并以⼀些简单的接⼝提供给⽤户使⽤。zookeeper是⼀个典型的分布式数据⼀致性的解决⽅案，分布式应⽤程序可以基于它实现诸如数据订阅/发布、负载均衡、命名服务、集群管理、分布式锁和分布式队列等功能。
一.zk中的集群角色介绍
1.集群角色:
通常在分布式系统中，构成⼀个集群的每⼀台机器都有⾃⼰的⻆⾊，最典型的集群就是Master/Slave模
式（主备模式），此情况下把所有能够处理写操作的机器称为Master机器，把所有通过异步复制⽅式获
取最新数据，并提供读服务的机器为Slave机器。
⽽在Zookeeper中，这些概念被颠覆了。它没有沿⽤传递的Master/Slave概念，⽽是引⼊了Leader、
Follower、Observer三种⻆⾊。Zookeeper集群中的所有机器通过Leader选举来选定⼀台被称为
Leader的机器，Leader服务器为客户端提供读和写服务，除Leader外，其他机器包括Follower和
Observer,Follower和Observer都能提供读服务，唯⼀的区别在于Observer不参与Leader选举过程(投票)，
不参与写操作的过半写成功策略，因此Observer可以在不影响写性能的情况下提升集群的性能。
2.会话(session):
Session指客户端会话，⼀个客户端连接是指客户端和服务端之间的⼀个TCP⻓连接，Zookeeper对外的服务默认端口为2181，客户端启动的时候，⾸先会与服务器建⽴⼀个TCP连接，从第⼀次连接建⽴开始，客户端会话的⽣命周期也开始了，通过这个连接，客户端能够⼼跳检测与服务器保持有效的会话，也能够向Zookeeper服务器发送请求并接受响应，同时还能够通过该连接接受来⾃服务器的Watch事件通知。
3.数据节点(Znode):
在谈到分布式的时候，我们通常说的“节点”是指组成集群的每⼀台机器。然⽽，在ZooKeeper中，“节点”分为两类，第⼀类同样是指构成集群的机器，我们称之为机器节点；第⼆类则是指数据模型中的数据单元，我们称之为数据节点——ZNode。ZooKeeper将所有数据存储在内存中，数据模型是⼀棵树（ZNode Tree），由斜杠（/）进⾏分割的路径，就是⼀个Znode，例如/app/path1。每个ZNode上都会保存⾃⼰的数据内容，同时还会保存⼀系列属性信息。
4.版本: 刚刚我们提到，Zookeeper的每个Znode上都会存储数据，对于每个ZNode，Zookeeper都会为其维护 ⼀个叫作Stat的数据结构，Stat记录了这个ZNode的三个数据版本，分别是version（当前ZNode的版 本）、cversion（当前ZNode⼦节点的版本）、aversion（当前ZNode的ACL版本）。
5.Watcher(事件监听器): Wathcer（事件监听器），是Zookeeper中⼀个很重要的特性，Zookeeper允许⽤户在指定节点上注册⼀些Watcher，并且在⼀些特定事件触发的时候，Zookeeper服务端会将事件通知到感兴趣的客户端，该机制是Zookeeper实现分布式协调服务的重要特性
6.ACL:
Zookeeper采⽤ACL（Access Control Lists）策略来进⾏权限控制，其定义了如下五种权限：
· CREATE：创建⼦节点的权限。
· READ：获取节点数据和⼦节点列表的权限。
· WRITE：更新节点数据的权限。
· DELETE：删除⼦节点的权限。
· ADMIN：设置节点ACL的权限。
其中需要注意的是，CREATE和DELETE这两种权限都是针对⼦节点的权限控制
二.Zookeeper环境搭建
2.1 Zookeeper的搭建⽅式:
Zookeeper安装⽅式有三种，单机模式和集群模式以及伪集群模式。
■ 单机模式：Zookeeper只运⾏在⼀台服务器上，适合测试环境；
■ 集群模式：Zookeeper运⾏于⼀个集群上，适合⽣产环境，这个计算机集群被称为⼀个“集合体”
■ 伪集群模式：就是在⼀台服务器上运⾏多个Zookeeper 实例；
单机模式：
关闭服务输⼊命令
./zkServer.sh stop
查看状态
./zkServer.sh status
2.2伪集群模式：
Zookeeper不但可以在单机上运⾏单机模式Zookeeper，⽽且可以在单机模拟集群模式 Zookeeper的运⾏，也就是将不同实例运⾏在同⼀台机器，⽤端⼝进⾏区分，伪集群模式为我们体验Zookeeper和做⼀些尝试性的实验提供了很⼤的便利。⽐如，我们在测试的时候，可以先使⽤少量数据在伪集群模式下进⾏测试。当测试可⾏的时候，再将数据移植到集群模式进⾏真实的数据实验。这样不但保证了它的可⾏性，同时⼤⼤提⾼了实验的效率。这种搭建⽅式，⽐较简便，成本⽐较低，适合测试和学习。
注意事项：
⼀台机器上部署了3个server，也就是说单台机器及上运⾏多个Zookeeper实例。这种情况下，必须保证每个配置⽂档的各个端⼝号不能冲突，除clientPort不同之外，dataDir也不同。另外，还要在dataDir所对应的⽬录中创建myid⽂件来指定对应的Zookeeper服务器实例。
■ clientPort端⼝：
如果在1台机器上部署多个server，那么每台机器都要不同的 clientPort，⽐如 server1是2181,server2是2182，server3是2183
■ dataDir和dataLogDir：
dataDir和dataLogDir也需要区分下，将数据⽂件和⽇志⽂件分开存放，同时每个server的这两变量所对应的路径都是不同的
■ server.X和myid：
server.X 这个数字就是对应，data/myid中的数字。在3个server的myid⽂件中分别写⼊了1，2，3，那么每个server中的zoo.cfg都配 server.1 server.2,server.3就⾏了。因为在同⼀台机器上，后⾯连着的2个端⼝，3个server都不要⼀样，否则端⼝冲。
开始安装：
使用单台服务器搭建zk伪集群
clientPort=2181
dataDir=/zkcluster/zookeeper01/data
dataLogDir=/zkcluster/zookeeper01/data/logs
server.1=10.211.55.4:2881:3881
server.2=10.211.55.4:2882:3882
server.3=10.211.55.4:2883:3883
#server.服务器ID=服务器IP地址：服务器之间通信端⼝：服务器之间投票选举端⼝(注意:如果使用云服务记得在每个zk实例的zoo.cfg里面添加该配置quorumListenOnAllIPs=true
启动集群
依次启动三个zk实例,可以使用该命令(./zkServer.sh status)在任意节点的bin目录下查看集群状态，可以得出一个Leader两个Flower
3.Zookeeper基本使⽤
ZooKeeper数据模型Znode
在ZooKeeper中，数据信息被保存在⼀个个数据节点上，这些节点被称为znode。ZNode 是
Zookeeper 中最⼩数据单位，在 ZNode 下⾯⼜可以再挂 ZNode，这样⼀层层下去就形成了⼀个层次化命名空间 ZNode 树，我们称为 ZNode Tree，它采⽤了类似⽂件系统的层级树状结构进⾏管理。⻅下图
示例：
在 Zookeeper 中，每⼀个数据节点都是⼀个 ZNode，上图根⽬录下有两个节点，分别是：app1 和app2，其中 app1 下⾯⼜有三个⼦节点,所有ZNode按层次化进⾏组织，形成这么⼀颗树，ZNode的节点路径标识⽅式和Unix⽂件系统路径⾮常相似，都是由⼀系列使⽤斜杠（/）进⾏分割的路径表示，开发⼈员可以向这个节点写⼊数据，也可以在这个节点下⾯创建⼦节点。
ZNode 的类型
刚刚已经了解到，Zookeeper的znode tree是由⼀系列数据节点组成的，那接下来，我们就对数据节点
做详细讲解
Zookeeper 节点类型可以分为三⼤类：
持久性节点（Persistent）
临时性节点（Ephemeral）
顺序性节点（Sequential）
在开发中在创建节点的时候通过组合可以⽣成以下四种节点类型：持久节点、持久顺序节点、临时节点、临时顺序节点。不同类型的节点则会有不同的⽣命周期
持久节点：是Zookeeper中最常⻅的⼀种节点类型，所谓持久节点，就是指节点被创建后会⼀直存在服务器，直到删除操作主动清除
持久顺序节点：就是有顺序的持久节点，节点特性和持久节点是⼀样的，只是额外特性表现在顺序上。顺序特性实质是在创建节点的时候，会在节点名后⾯加上⼀个数字后缀，来表示其顺序。
临时节点：就是会被⾃动清理掉的节点，它的⽣命周期和客户端会话绑在⼀起，客户端会话结束，节点会被删除掉。与持久性节点不同的是，临时节点不能创建⼦节点。
临时顺序节点：就是有顺序的临时节点，和持久顺序节点相同，在其创建的时候会在名字后⾯加上数字后缀。
事务ID:⾸先，先了解，事务是对物理和抽象的应⽤状态上的操作集合。往往在现在的概念中，ሀ义上的事务通常指的是数据库事务，⼀般包含了⼀系列对数据库有序的读写操作，这些数据库事务具有所谓的ACID特性，即原⼦性（Atomic）、⼀致性（Consistency）、隔离性（Isolation）和持久性（Durability）。 ⽽在ZooKeeper中，事务是指能够改变ZooKeeper服务器状态的操作，我们也称之为事务操作或更新操作，⼀般包括数据节点创建与删除、数据节点内容更新等操作。对于每⼀个事务请求，ZooKeeper都会为其分配⼀个全局唯⼀的事务ID，⽤ ZXID 来表示，通常是⼀个 64 位的数字。每⼀个 ZXID 对应⼀次更新操作，从这些ZXID中可以间接地识别出ZooKeeper处理这些更新操作请求的全局顺序。
ZNode 的状态信息：
整个 ZNode 节点内容包括两部分：节点数据内容和节点状态信息。图中quota 是数据内容，其他的属于状态信息。那么这些状态信息都有什么含义呢？
Watcher--数据变更通知:
Zookeeper使⽤Watcher机制实现分布式数据的发布/订阅功能
⼀个典型的发布/订阅模型系统定义了⼀种 ⼀对多的订阅关系，能够让多个订阅者同时监听某⼀个主题对象，当这个主题对象⾃身状态变化时，会通知所有订阅者，使它们能够做出相应的处理。在 ZooKeeper 中，引⼊了 Watcher 机制来实现这种分布式的通知功能。ZooKeeper 允许客户端向服务端注册⼀个 Watcher 监听，当服务端的⼀些指定事件触发了这个 Watcher，那么就会向指定客户端发送⼀个事件通知来实现分布式的通知功能。
整个Watcher注册与通知过程如图所示。
Zookeeper的Watcher机制主要包括客户端线程、客户端WatcherManager、Zookeeper服务器三部分。
具体⼯作流程为：客户端向Zookeeper服务器注册的同时，会将Watcher对象存储在客户端的WatcherManager当中。当zk服务器触发Watcher事件后，会向客户端发送通知，客户端线程从WatcherManager中取出对应的Watcher对象来执⾏回调逻辑。
ACL--保障数据的安全: Zookeeper作为⼀个分布式协调框架，其内部存储了分布式系统运⾏时状态的元数据，这些元数据会直接影响基于Zookeeper进⾏构造的分布式系统的运⾏状态，因此，如何保障系统中数据的安全，从⽽避免因误操作所带来的数据随意变更⽽导致的数据库异常⼗分重要，在Zookeeper中，提供了⼀套完善的ACL（Access Control List）权限控制机制来保障数据的安全。
我们可以从三⽅⾯来理解ACL机制：权限模式（Scheme）、授权对象（ID）、权限 （Permission），通常使⽤"scheme: id : permission"来标识⼀个有效的ACL信息。
权限模式：Scheme
权限模式⽤来确定权限验证过程中使⽤的检验策略，有如下四种模式：
-
IP IP模式就是通过IP地址粒度来进⾏权限控制，如"ip:192.168.0.110"表示权限控制针对该IP地址，同时IP模式可以⽀持按照⽹段⽅式进⾏配置，如"ip:192.168.0.1/24"表示针对192.168.0.*这个⽹段进⾏权限控制。
-
Digest Digest是最常⽤的权限控制模式，要更符合我们对权限控制的认识，其使 ⽤"username:password"形式的权限标识来进⾏权限配置，便于区分不同应⽤来进⾏权限控制。当我们通过“username:password”形式配置了权限标识后，Zookeeper会先后对其进⾏SHA-1加密和BASE64编码。
-
World World是⼀种最开放的权限控制模式，这种权限控制⽅式⼏乎没有任何作⽤，数据节点的访问权限对所有⽤户开放，即所有⽤户都可以在不进⾏任何权限校验的情况下操作ZooKeeper上的数据。另外，World模式也可以看作是⼀种特殊的Digest模式，它只有⼀个权限标识，即“world：anyone”。\
-
Super Super模式，顾名思义就是超级⽤户的意思，也是⼀种特殊的Digest模式。在Super模式下，超级⽤户可以对任意ZooKeeper上的数据节点进⾏任何操作。
授权对象：ID
授权对象指的是权限赋予的⽤户或⼀个指定实体，例如 IP 地址或是机器等。在不同的权限模式下，授权对象是不同的，表中列出了各个权限模式和授权对象之间的对应关系。
权限
权限就是指那些通过权限检查后可以被允许执⾏的操作。在ZooKeeper中，所有对数据的操作权限分为以下五⼤类：
CREATE（C）：数据节点的创建权限，允许授权对象在该数据节点下创建⼦节点。 DELETE（D）：⼦节点的删除权限，允许授权对象删除该数据节点的⼦节点。READ（R）：数据节点的读取权限，允许授权对象访问该数据节点并读取其数据内容或⼦节点列表等。 WRITE（W）：数据节点的更新权限，允许授权对象对该数据节点进⾏更新操作。ADMIN（A）：数据节点的管理权限，允许授权对象对该数据节点进⾏ ACL 相关的设置操作。
三.ZooKeeper命令⾏操作
现在已经搭建起了⼀个能够正常运⾏的zookeeper服务了，所以接下来，就是来借助客户端来对zookeeper的数据节点进⾏操作⾸先，进⼊到zookeeper的bin⽬录之后通过zkClient进⼊zookeeper客户端命令。
./zkcli.sh 连接本地的zookeeper服务器
./zkCli.sh -server ip:port 连接指定的服务器\
连接成功之后，系统会输出Zookeeper的相关环境及配置信息等信息。输⼊help之后，屏幕会输出可⽤的Zookeeper命令，如下图所示
创建节点
使⽤create命令，可以创建⼀个Zookeeper节点， 如
① 创建顺序节点
使⽤ create -s /zk-test 123 命令创建zk-test顺序节点
执⾏完后，就在根节点下创建了⼀个叫做/zk-test的节点，该节点内容就是123，同时可以看到创建的zk-test节点后⾯添加了⼀串数字以示区别
② 创建临时节点
使⽤ create -e /zk-temp 123 命令创建zk-temp临时节
临时节点在客户端会话结束后，就会⾃动删除，下⾯使⽤quit命令退出客户端
③ 创建永久节点
使⽤ create /zk-permanent 123 命令创建zk-permanent永久节点
可以看到永久节点不同于顺序节点，不会⾃动在后⾯添加⼀串数字
更新节点
使⽤set命令，可以更新指定节点的数据内容，⽤法如下
其中，data就是要更新的新内容，version表示数据版本，在zookeeper中，节点的数据是有版本概念的，这个参数⽤于指定本次更新操作是基于Znode的哪⼀个数据版本进⾏的，如将/zk-permanent节点的数据更新为456，可以使⽤如下命令：set /zk-permanent 456
现在dataVersion已经变为1了，表示进⾏了更新
删除节点
使⽤delete命令可以删除Zookeeper上的指定节点，⽤法如下
其中version也是表示数据版本，使⽤delete /zk-permanent 命令即可删除/zk-permanent节点
可以看到，已经成功删除/zk-permanent节点。值得注意的是，若删除节点存在⼦节点，那么⽆法删除该节点，必须先删除⼦节点，再删除⽗节点
四.Zookeeper的api使⽤
Zookeeper作为⼀个分布式框架，主要⽤来解决分布式⼀致性问题，它提供了简单的分布式原语，并且对多种编程语⾔提供了API，所以接下来重点来看下Zookeeper的java客户端API使⽤⽅式
Zookeeper API共包含五个包，分别为：
（1）org.apache.zookeeper
（2）org.apache.zookeeper.data
（3）org.apache.zookeeper.server
（4）org.apache.zookeeper.server.quorum
（5）org.apache.zookeeper.server.upgrade
其中org.apache.zookeeper，包含Zookeeper类，他是我们编程时最常⽤的类⽂件。这个类是
Zookeeper客户端的主要类⽂件。如果要使⽤Zookeeper服务，应⽤程序⾸先必须创建⼀个Zookeeper实例，这时就需要使⽤此类。⼀旦客户端和Zookeeper服务端建⽴起了连接，Zookeeper系统将会给本次连接会话分配⼀个ID值，并且客户端将会周期性的向服务器端发送⼼跳来维持会话连接。只要连接有效，客户端就可以使⽤Zookeeper API来做相应处理了。
准备⼯作：导⼊依赖
建⽴会话
注意，ZooKeeper 客户端和服务端会话的建⽴是⼀个异步的过程，也就是说在程序中，构造⽅法会在处理完客户端初始化⼯作后⽴即返回，在⼤多数情况下，此时并没有真正建⽴好⼀个可⽤的会话，在会话的⽣命周期中处于“CONNECTING”的状态。 当该会话真正创建完毕后ZooKeeper服务端会向会话对应的客户端发送⼀个事件通知，以告知客户端，客户端只有在获取这个通知之后，才算真正建⽴了会话。
创建节点\
public class CreateNote implements Watcher {
private static CountDownLatch countDownLatch = new CountDownLatch(1);
private static ZooKeeper zooKeeper;
public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
/*
客户端可以通过创建一个zk实例来连接zk服务器
new Zookeeper(connectString,sesssionTimeOut,Wather)
connectString: 连接地址：IP：端口
sesssionTimeOut：会话超时时间：单位毫秒
Wather：监听器(当特定事件触发监听时，zk会通过watcher通知到客户端)
*/
zooKeeper = new ZooKeeper("集群节点ip:2181", 5000, new CreateNote());
System.out.println(zooKeeper.getState());
// 计数工具类：CountDownLatch:不让main方法结束，让线程处于等待阻塞
//countDownLatch.await();\
Thread.sleep(Integer.MAX_VALUE);
}
/*
回调方法：处理来自服务器端的watcher通知
*/
public void process(WatchedEvent watchedEvent) {
// SyncConnected
if (watchedEvent.getState() == Event.KeeperState.SyncConnected) {
//解除主程序在CountDownLatch上的等待阻塞
System.out.println("process方法执行了...");
// 创建节点
try {
createNoteSync();
} catch (KeeperException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
/*
创建节点的方法
*/
private static void createNoteSync() throws KeeperException, InterruptedException {
/**
* path ：节点创建的路径
* data[] ：节点创建要保存的数据，是个byte类型的
* acl ：节点创建的权限信息(4种类型)
* ANYONE_ID_UNSAFE : 表示任何人
* AUTH_IDS ：此ID仅可用于设置ACL。它将被客户机验证的ID替换。
* OPEN_ACL_UNSAFE ：这是一个完全开放的ACL(常用)--> world:anyone
* CREATOR_ALL_ACL ：此ACL授予创建者身份验证ID的所有权限
* createMode ：创建节点的类型(4种类型)
* PERSISTENT：持久节点
* PERSISTENT_SEQUENTIAL：持久顺序节点
* EPHEMERAL：临时节点
* EPHEMERAL_SEQUENTIAL：临时顺序节点
String node = zookeeper.create(path,data,acl,createMode);
*/
// 持久节点
String note_persistent = zooKeeper.create("/lg-persistent", "持久节点内容".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
// 临时节点
String note_ephemeral = zooKeeper.create("/lg-ephemeral", "临时节点内容".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
// 持久顺序节点
String note_persistent_sequential = zooKeeper.create("/lg-persistent_sequential", "持久顺序节点内容".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT_SEQUENTIAL);
System.out.println("创建的持久节点" + note_persistent);
System.out.println("创建的临时节点" + note_ephemeral);
System.out.println("创建的持久顺序节点" + note_persistent_sequential);
}
}
获取节点数据\
public class GetNoteData implements Watcher {
private static ZooKeeper zooKeeper;
/*
建立会话
*/
public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
/*
客户端可以通过创建一个zk实例来连接zk服务器
new Zookeeper(connectString,sesssionTimeOut,Wather)
connectString: 连接地址：IP：端口
sesssionTimeOut：会话超时时间：单位毫秒
Wather：监听器(当特定事件触发监听时，zk会通过watcher通知到客户端)
*/
zooKeeper = new ZooKeeper("集群节点ip:2182", 5000, new GetNoteData());
System.out.println(zooKeeper.getState());
Thread.sleep(Integer.MAX_VALUE);
}
/*
回调方法：处理来自服务器端的watcher通知
*/
public void process(WatchedEvent watchedEvent) {
/*
子节点列表发生改变时，服务器端会发生noteChildrenChanged事件通知
要重新获取子节点列表，同时注意：通知是一次性的，需要反复注册监听
*/
if(watchedEvent.getType() == Event.EventType.NodeChildrenChanged){
List<String> children = null;
try {
children = zooKeeper.getChildren("/lg-persistent", true);
} catch (KeeperException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("-----"+children);
}
// SyncConnected
if(watchedEvent.getState() == Event.KeeperState.SyncConnected){
System.out.println("process方法执行了...");
// 获取节点数据的方法
try {
//获取某个节点的内容
getNoteData();
// 获取节点的子节点列表方法
getChildrens();
} catch (KeeperException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
/*
获取某个节点的内容
*/
private void getNoteData() throws KeeperException, InterruptedException {
/**
* path : 获取数据的路径
* watch : 是否开启监听
* stat : 节点状态信息
* null: 表示获取最新版本的数据
* zk.getData(path, watch, stat);
*/
byte[] data = zooKeeper.getData("/lg-persistent", false, null);
System.out.println("lg-persistent节点的内容是："+new String(data));
}
/*
获取某个节点的子节点列表方法
*/
public static void getChildrens() throws KeeperException, InterruptedException {
/*
path:路径
watch:是否要启动监听，当子节点列表发生变化，会触发监听
zooKeeper.getChildren(path, watch);
*/
List<String> children = zooKeeper.getChildren("/lg-persistent", true);
System.out.println("lg-persistent节点的子节点: "+children);
}
}
修改节点数据\
public class UpdateNoteData implements Watcher {
private static ZooKeeper zooKeeper;
/*
建立会话
*/
public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
/*
客户端可以通过创建一个zk实例来连接zk服务器
new Zookeeper(connectString,sesssionTimeOut,Wather)
connectString: 连接地址：IP：端口
sesssionTimeOut：会话超时时间：单位毫秒
Wather：监听器(当特定事件触发监听时，zk会通过watcher通知到客户端)
*/
zooKeeper = new ZooKeeper("集群节点ip:2181", 5000, new UpdateNoteData());
System.out.println(zooKeeper.getState());
Thread.sleep(Integer.MAX_VALUE);
}
/*
回调方法：处理来自服务器端的watcher通知
*/
public void process(WatchedEvent watchedEvent) {
// SyncConnected
if(watchedEvent.getState() == Event.KeeperState.SyncConnected){
//解除主程序在CountDownLatch上的等待阻塞
System.out.println("process方法执行了...");
// 更新数据节点内容的方法
try {
updateNoteSync();
} catch (KeeperException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
/*
更新数据节点内容的方法
*/
private void updateNoteSync() throws KeeperException, InterruptedException {
/*
path:路径
data:要修改的内容 byte[]
version:为-1，表示对最新版本的数据进行修改
zooKeeper.setData(path, data,version);
*/
byte[] data = zooKeeper.getData("/lg-persistent", false, null);
System.out.println("修改前的值：" + new String(data));
//修改/lg-persistent 的数据 stat: 状态信息对象
Stat stat = zooKeeper.setData("/lg-persistent", "客户端修改了节点数据".getBytes(), -1);
byte[] data2 = zooKeeper.getData("/lg-persistent", false, null);
System.out.println("修改后的值：" + new String(data2));
}
}
删除节点
这里我先创建了一个节点yefeng000000006,,且该节点下还有一个子节点abc，测试删除子节点abc
public class DeleteNote implements Watcher {
private static ZooKeeper zooKeeper;
/*
建立会话
*/
public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
/*
客户端可以通过创建一个zk实例来连接zk服务器
new Zookeeper(connectString,sesssionTimeOut,Wather)
connectString: 连接地址：IP：端口
sesssionTimeOut：会话超时时间：单位毫秒
Wather：监听器(当特定事件触发监听时，zk会通过watcher通知到客户端)
*/
zooKeeper = new ZooKeeper("集群节点ip:2181", 5000, new DeleteNote());
System.out.println(zooKeeper.getState());
Thread.sleep(Integer.MAX_VALUE);
}
/*
回调方法：处理来自服务器端的watcher通知
*/
public void process(WatchedEvent watchedEvent) {
// SyncConnected
if(watchedEvent.getState() == Event.KeeperState.SyncConnected){
//解除主程序在CountDownLatch上的等待阻塞
System.out.println("process方法执行了...");
// 删除节点
try {
deleteNoteSync();
} catch (KeeperException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
/*
删除节点的方法
*/
private void deleteNoteSync() throws KeeperException, InterruptedException {
/*
zooKeeper.exists(path,watch) :判断节点是否存在
zookeeper.delete(path,version) : 删除节点
*/
Stat stat = zooKeeper.exists("/yefeng0000000006/abc", false);
System.out.println(stat == null ? "该节点不存在":"该节点存在");
if(stat != null){
zooKeeper.delete("/yefeng0000000006/abc",-1);
}
Stat stat2 = zooKeeper.exists("/lg-persistent/c1", false);
System.out.println(stat2 == null ? "该节点不存在":"该节点存在");
}
}
可以看到abc节点不存在了
以上只是简单介绍了zk的作用，我们需要了解分布式场景下一致性问题，重点关注zk的主要作用，集群角色，不同节点的特点，Watcher机制等概念。
