Zookeeper学习笔记

作者: dev_winner | 来源:发表于2020-11-18 10:28 被阅读0次

Zookeeper是一个开源的，为分布式应用提供协调服务的 Apache 项目。从设计模式的角度来理解：Zookeeper是一个基于观察者模式设计的分布式服务管理框架，它负责存储和管理大家都关心的数据，然后接受观察者的注册，一旦这些数据的状态发生变化，Zookeeper就将负责通知已经在Zookeeper上注册的那些观察者做出相应的反应。

Zookeeper基本原理

Zookeeper集群

Zookeeper：一个领导者（Leader），多个跟随者（Follower）组成的集群。
集群中只要有半数以上节点存活，Zookeeper集群就能正常服务。
全局数据一致：每个Server保存一份相同的数据副本，Client无论连接到哪个Server，数据都是一致的。
更新请求顺序进行：来自同一个Client的更新请求按其发送顺序依次执行。
数据更新原子性：一次数据更新要么成功，要么失败。
实时性：在一定时间范围内，Client能读到最新数据。
ZooKeeper数据模型的结构与Unix文件系统很类似，整体上可以看作是一棵树，每个节点称做一个ZNode。每一个ZNode默认能够存储1MB的数据，每个ZNode都可以通过其路径唯一标识。

Zookeeper数据结构

Zookeeper提供的服务包括：
- 统一命名服务：在分布式环境下，经常需要对应用/服务进行统一命名，便于识别。例如：IP不容易记住，而域名容易记住。
- 统一配置管理：一般要求在一个集群中，所有节点的配置信息都是一致的，并且对配置文件修改后，希望能够快速同步到各个节点上。配置管理可交由ZooKeeper实现：①可将配置信息写入ZooKeeper上的一个Znode；②各个客户端服务器监听这个Znode；③一旦Znode中的数据被修改， ZooKeeper将通知各个客户端服务器。
- 统一集群管理：分布式环境中，实时掌握每个节点的状态是必要的，可根据节点实时状态做出一些调整。ZooKeeper可以实现实时监控节点状态变化：①可将节点信息写入ZooKeeper上的一个ZNode；②监听这个ZNode可获取它的实时状态变化。
- 服务器动态上下线：客户端能实时洞察到服务器上下线的变化。
- 软负载均衡：在Zookeeper中记录每台服务器的访问数，让访问数最少的服务器去处理最新的客户端请求。

统一命名服务

统一配置管理

统一集群管理

服务器动态上下线

软负载均衡

安装步骤：①下载zookeeper-3.4.11.tar.gz压缩包；②解压到/opt/目录下：tar -zxvf zookeeper-3.4.11.tar.gz -C /opt/；③将/opt/zookeeper-3.4.11/conf/目录下的zoo_sample.cfg文件名修改为zoo.cfg：mv zoo_sample.cfg zoo.cfg；④在/opt/zookeeper-3.4.11/目录下创建文件夹zkData；⑤修改zoo.cfg文件内容：dataDir=/opt/zookeeper-3.4.11/zkData；⑥启动服务：./bin/zkServer.sh start；⑦启动客户端：./bin/zkCli.sh；⑧退出客户端：quit；⑨注销服务：./bin/zkServer.sh stop。

[root@localhost zookeeper-3.4.11]# ./bin/zkServer.sh start
ZooKeeper JMX enabled by default
Using config: /opt/zookeeper-3.4.11/bin/../conf/zoo.cfg
Starting zookeeper ... STARTED
[root@localhost zookeeper-3.4.11]# jps
4008 QuorumPeerMain
4025 Jps
[root@localhost zookeeper-3.4.11]# ./bin/zkServer.sh status
ZooKeeper JMX enabled by default
Using config: /opt/zookeeper-3.4.11/bin/../conf/zoo.cfg
Mode: standalone
[root@localhost zookeeper-3.4.11]# ./bin/zkCli.sh 
Connecting to localhost:2181
2020-11-18 09:41:43,054 [myid:] - INFO  [main:Environment@100] - Client environment:zookeeper.version=3.4.11-37e277162d567b55a07d1755f0b31c32e93c01a0, built on 11/01/2017 18:06 GMT
......
WatchedEvent state:SyncConnected type:None path:null
[zk: localhost:2181(CONNECTED) 0] ls /
[zookeeper]
[zk: localhost:2181(CONNECTED) 1] quit
Quitting...
2020-11-18 09:43:06,692 [myid:] - INFO  [main:ZooKeeper@687] - Session: 0x1000033c8b00000 closed
2020-11-18 09:43:06,697 [myid:] - INFO  [main-EventThread:ClientCnxn$EventThread@520] - EventThread shut down for session: 0x1000033c8b00000
[root@localhost zookeeper-3.4.11]# ./bin/zkServer.sh stop
ZooKeeper JMX enabled by default
Using config: /opt/zookeeper-3.4.11/bin/../conf/zoo.cfg
Stopping zookeeper ... STOPPED

配置文件zoo.cfg中的参数含义解读如下：
- tickTime=2000：服务器之间或客户端与服务器之间维持心跳的时间间隔，即每隔tickTime时间就会发送一个心跳。单位：毫秒(ms)。它用于心跳机制，并且设置最小的session超时时间为两倍心跳时间。（session的最小超时时间是 $2 \times tickTime$ ）
- initLimit=10：集群中的Follower节点与Leader节点之间初始连接时能容忍的最多心跳数（tickTime的数量），用它来限定集群中的Zookeeper服务器连接到Leader的时限。
- syncLimit=5：集群中Leader节点与Follower节点之间的最大响应时间单位（tickTime的数量）。若响应时间超过 $syncLimit \times tickTime$ ，Leader节点认为Follwer节点已死掉，则从服务器列表中删除Follwer节点。
- dataDir：用于保存 Zookeeper 中数据的路径。
- clientPort=2181：客户端连接的端口号。
Zookeeper的选举机制：半数机制，即集群中半数以上机器存活，集群可用。因此，Zookeeper 适合安装奇数台节点。例如，5台服务器有3台存活，集群可用，而只有2台存活，集群不可用。

Zookeeper选举过程

Zookeeper虽然在配置文件中并没有指定 Master节点和 Slave节点，但Zookeeper在工作时，是有一个节点为 Leader，其他节点为 Follower。Leader节点是通过内部的选举机制临时产生的，过程如下：
- 节点1启动后发起一次选举，节点1投自己一票。此时节点1的票数为1票，不够半数以上（3 票），选举无法完成，节点1的状态保持为LOOKING；
- 节点2启动后再发起一次选举，节点1和2分别投自己一票并交换选票信息：节点1发现节点2的ID比自己目前投票推举的（节点1）大，更改选票为推举节点2。此时节点1 的票数为0票，节点2的票数为2票，没有半数以上结果，选举无法完成。节点1和2的状态保持LOOKING；
- 节点3启动后发起一次选举，此时节点1和2都会更改选票为节点3。此次投票结果：节点1为0票，节点2为0票，节点3为3票。此时节点3的票数已经超过半数，节点3当选为Leader。节点1和2更改状态为FOLLOWING，节点3更改状态为LEADING；
- 节点4启动后发起一次选举，此时节点1， 2， 3已不是LOOKING状态，不会更改选票信息。交换选票信息结果：节点3为3票，节点4 为1票。此时节点4服从多数，更改选票信息为节点3，并更改状态为FOLLOWING；
- 节点5启动，同节点4一样当小弟。
Zookeeper节点类型：①持久（Persistent）：客户端和服务器端断开连接后，创建的节点不删除；②短暂（Ephemeral）：客户端和服务器端断开连接后，创建的节点自己删除。
- 持久化目录节点：客户端与Zookeeper断开连接后，该节点依旧存在。
- 持久化顺序编号目录节点：客户端与Zookeeper断开连接后，该节点依旧存在，只是Zookeeper给该节点名称进行顺序编号。
- 临时目录节点：客户端与Zookeeper断开连接后，该节点被删除。
- 临时顺序编号目录节点：客户端与Zookeeper断开连接后，该节点被删除，只是Zookeeper给该节点名称进行顺序编号。
- 说明：创建Znode时设置顺序标识，Znode名称后会附加一个值，顺序号是一个单调递增的计数器，由父节点维护。
- 注意：在分布式系统中，顺序号可以被用于为所有的事件进行全局排序，这样客户端可以通过顺序号推断事件的顺序。

节点类型

在单个server节点上模拟搭建3个zk server的集群

下载并解压到3个目录：/opt/zookeeper-1、/opt/zookeeper-2、/opt/zookeeper-3。
创建每个解压目录下的conf/zoo.cfg配置文件：

/opt/zookeeper-1/conf/zoo.cfg  内容如下：
--------------------------------------------
tickTime=2000
initLimit=10
syncLimit=5
dataDir=/opt/zookeeper-1/zkData
clientPort=2181
server.1=localhost:2287:3387
server.2=localhost:2288:3388
server.3=localhost:2289:3389
--------------------------------------------
/opt/zookeeper-2/conf/zoo.cfg  内容如下：
--------------------------------------------
tickTime=2000
initLimit=10
syncLimit=5
dataDir=/opt/zookeeper-2/zkData
clientPort=2182
server.1=localhost:2287:3387
server.2=localhost:2288:3388
server.3=localhost:2289:3389
--------------------------------------------
/opt/zookeeper-3/conf/zoo.cfg  内容如下：
--------------------------------------------
tickTime=2000
initLimit=10
syncLimit=5
dataDir=/opt/zookeeper-3/zkData
clientPort=2183
server.1=localhost:2287:3387
server.2=localhost:2288:3388
server.3=localhost:2289:3389

注：因为是在同一台机器上模拟集群，所以端口不能重复，这里用 $2181 \sim 2183$ ， $2287 \sim 2289$ ，以及 $3387 \sim 3389$ 相互错开。另外每个zk的instance，都需要设置独立的数据存储目录、日志存储目录，所以dataDir目录需要手动先创建好。另外，还有一个非常关键的设置，在每个zk server配置文件的dataDir所对应的目录下，必须创建一个名为myid的文件，其中的内容必须与zoo.cfg中server.x 中的x相同，即：

/opt/zookeeper-1/zkData/myid 中的内容为1，对应server.1中的1
/opt/zookeeper-2/zkData/myid 中的内容为2，对应server.2中的2
/opt/zookeeper-3/zkData/myid 中的内容为3，对应server.3中的3

生产环境中，分布式集群部署的步骤与上面基本相同，只不过因为各zk server分布在不同的机器，上述配置文件中的localhost换成各服务器的真实Ip即可。分布在不同的机器后，不存在端口冲突问题，可以让每个服务器的zk均采用相同的端口，这样管理起来比较方便。
配置参数解读：server.A=B:C:D
- A是一个数字，表示这个是第几号服务器；集群模式下配置一个文件 myid，这个文件在 dataDir 目录下，这个文件里面有一个数据就是 A 的值， Zookeeper 启动时读取此文件，拿到里面的数据与zoo.cfg里面的配置信息进行比较从而判断到底是哪个 server。
- B是这个服务器的IP地址；
- C是这个Follower节点与集群中的 Leader 节点交换信息的端口号；
- D是万一集群中的 Leader 节点挂了，需要一个端口来重新进行选举，选出一个新的Leader，而这个端口就是用来执行选举时节点间相互通信的端口号。
启动验证：

[root@localhost opt]# /opt/zookeeper-1/bin/zkServer.sh start
ZooKeeper JMX enabled by default
Using config: /opt/zookeeper-1/bin/../conf/zoo.cfg
Starting zookeeper ... STARTED
[root@localhost opt]# /opt/zookeeper-2/bin/zkServer.sh start
ZooKeeper JMX enabled by default
Using config: /opt/zookeeper-2/bin/../conf/zoo.cfg
Starting zookeeper ... STARTED
[root@localhost opt]# /opt/zookeeper-3/bin/zkServer.sh start
ZooKeeper JMX enabled by default
Using config: /opt/zookeeper-3/bin/../conf/zoo.cfg
Starting zookeeper ... STARTED
[root@localhost opt]# jps （三个QuorumPeerMain就是刚刚启动的三个Server）
9501 QuorumPeerMain
9582 QuorumPeerMain
9535 QuorumPeerMain
9631 Jps
[root@localhost opt]# /opt/zookeeper-1/bin/zkServer.sh status
ZooKeeper JMX enabled by default
Using config: /opt/zookeeper-1/bin/../conf/zoo.cfg
Mode: follower
[root@localhost opt]# /opt/zookeeper-2/bin/zkServer.sh status
ZooKeeper JMX enabled by default
Using config: /opt/zookeeper-2/bin/../conf/zoo.cfg
Mode: leader
[root@localhost opt]# /opt/zookeeper-3/bin/zkServer.sh status
ZooKeeper JMX enabled by default
Using config: /opt/zookeeper-3/bin/../conf/zoo.cfg
Mode: follower

Zookeeper客户端操作命令如下：

基本语法	功能描述
help	显示所有操作命令
ls path [watch]	使用 ls 命令来查看（并监控）当前 znode 中所包含的内容
ls2 path [watch]	查看当前节点数据并能看到更新次数等数据
create	普通创建 -s：创建节点时包含序号 -e：临时（重启或者超时消失）
get path [watch]	获得（并监控）节点的值
set	设置节点的具体值
stat	查看节点的状态
delete	删除节点
rmr	递归删除节点及其子节点

[zk: localhost:2181(CONNECTED) 0] ls /
[zookeeper]
[zk: localhost:2181(CONNECTED) 1] help
ZooKeeper -server host:port cmd args
    stat path [watch]
    set path data [version]
    ls path [watch]
    delquota [-n|-b] path
    ls2 path [watch]
    setAcl path acl
    setquota -n|-b val path
    history 
    redo cmdno
    printwatches on|off
    delete path [version]
    sync path
    listquota path
    rmr path
    get path [watch]
    create [-s] [-e] path data acl
    addauth scheme auth
    quit 
    getAcl path
    close 
    connect host:port
[zk: localhost:2181(CONNECTED) 2] ls2 /
[zookeeper]
cZxid = 0x0
ctime = Thu Jan 01 08:00:00 CST 1970
mZxid = 0x0
mtime = Thu Jan 01 08:00:00 CST 1970
pZxid = 0x0
cversion = -1
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 0
numChildren = 1
[zk: localhost:2181(CONNECTED) 3] create /sanguo "jinlian" 
Created /sanguo
[zk: localhost:2181(CONNECTED) 4] ls /
[zookeeper, sanguo]
[zk: localhost:2181(CONNECTED) 5] create /sanguo/shuguo "liubei" 
Created /sanguo/shuguo
[zk: localhost:2181(CONNECTED) 6] ls /sanguo
[shuguo]
[zk: localhost:2181(CONNECTED) 7] get /sanguo/shuguo
liubei
cZxid = 0x100000003
ctime = Wed Nov 18 14:57:47 CST 2020
mZxid = 0x100000003
mtime = Wed Nov 18 14:57:47 CST 2020
pZxid = 0x100000003
cversion = 0
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 6
numChildren = 0
[zk: localhost:2181(CONNECTED) 8] create -e /sanguo/wuguo "zhouyu" #（创建临时节点）
Created /sanguo/wuguo
[zk: localhost:2181(CONNECTED) 9] ls /sanguo
[wuguo, shuguo]
[zk: localhost:2181(CONNECTED) 10] quit
Quitting...
[zk: localhost:2181(CONNECTED) 0] ls /sanguo   
[shuguo]
[zk: localhost:2181(CONNECTED) 1] create -s /sanguo/weiguo "caocao" # 若原来没有序号节点，序号则从0开始递增。若原节点下已有2个节点，则在排序时从2开始，以此类推。
Created /sanguo/weiguo0000000002
[zk: localhost:2181(CONNECTED) 2] create -s /sanguo/weiguo "caocao"
Created /sanguo/weiguo0000000002
[zk: localhost:2181(CONNECTED) 3] set /sanguo/shuguo "diaochan"
cZxid = 0x100000003
ctime = Wed Nov 18 14:57:47 CST 2020
mZxid = 0x10000000a
mtime = Wed Nov 18 15:09:54 CST 2020
pZxid = 0x100000003
cversion = 0
dataVersion = 1
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 8
numChildren = 0
[zk: localhost:2181(CONNECTED) 5] get /sanguo/shuguo           
diaochan
cZxid = 0x100000003
ctime = Wed Nov 18 14:57:47 CST 2020
mZxid = 0x10000000a
mtime = Wed Nov 18 15:09:54 CST 2020
pZxid = 0x100000003
cversion = 0
dataVersion = 1
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 8
numChildren = 0
[zk: localhost:2181(CONNECTED) 6] get /sanguo watch # 监视某个节点的一次变化，注意：仅有一次
jinlian
cZxid = 0x100000002
ctime = Wed Nov 18 14:57:02 CST 2020
mZxid = 0x100000002
mtime = Wed Nov 18 14:57:02 CST 2020
pZxid = 0x100000009
cversion = 6
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 7
numChildren = 4
[zk: localhost:2181(CONNECTED) 7] set /sanguo "jingjing"
cZxid = 0x100000002
ctime = Wed Nov 18 14:57:02 CST 2020
mZxid = 0x100000011
mtime = Wed Nov 18 17:22:19 CST 2020
pZxid = 0x100000009
cversion = 6
dataVersion = 1
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 8

[zk: localhost:2181(CONNECTED) 8] 
WATCHER::

WatchedEvent state:SyncConnected type:NodeDataChanged path:/sanguo
[zk: localhost:2181(CONNECTED) 9] ls /sanguo watch
[weiguo0000000003, weiguo0000000004, shuguo, weiguo]
[zk: localhost:2181(CONNECTED) 10] create /sanguo/banzhang "banzhang"
Created /sanguo/banzhang
[zk: localhost:2181(CONNECTED) 11] 
WATCHER::

WatchedEvent state:SyncConnected type:NodeChildrenChanged path:/sanguo
[zk: localhost:2181(CONNECTED) 0] delete /sanguo/banzhang
[zk: localhost:2181(CONNECTED) 1] ls /sanguo
[weiguo0000000003, weiguo0000000004, shuguo, weiguo]
[zk: localhost:2181(CONNECTED) 2] rmr /sanguo
[zk: localhost:2181(CONNECTED) 3] ls /
[zookeeper]
[zk: localhost:2181(CONNECTED) 4] stat /
cZxid = 0x0
ctime = Thu Jan 01 08:00:00 CST 1970
mZxid = 0x0
mtime = Thu Jan 01 08:00:00 CST 1970
pZxid = 0x10000001d
cversion = 1
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 0
numChildren = 1

Stat结构体详细解释如下：
- cZxid：创建节点的事务Zxid。每次修改zk节点都会收到一个 Zxid 形式的时间戳，也就是 ZooKeeper 的事务 ID。事务 ID 是 ZooKeeper 中所有修改总的次序。每个修改都有唯一的 Zxid，如果 Zxid1 小于 Zxid2，那么 Zxid1 在 Zxid2 之前发生。
- ctime：节点被创建的毫秒数（从 1970 年开始）。
- mZxid：节点最后更新的事务 Zxid。
- mtime：节点最后修改的毫秒数（从 1970 年开始）。
- pZxid：节点最后更新的子节点事务 Zxid。
- cversion：节点修改次数。
- dataVersion：节点的数据变化号。
- aclVersion：节点访问控制列表的变化号。
- ephemeralOwner：若是临时节点，则其值为节点拥有者的 session id，否则为 0。
- dataLength：节点的数据长度。
- numChildren：儿子节点的数量。
监听器原理详解如下：
- 首先要有一个main()线程；
- 在main()线程中创建Zookeeper客户端，这时就会创建两个线程，一个负责网络连接通信（connet），一个负责监听（listener）；
- 通过connect线程将注册的监听事件发送给Zookeeper；
- 在Zookeeper的注册监听器列表中将注册的监听事件添加到列表中；
- Zookeeper监听到有数据或路径变化，就会将这个消息发送给listener线程；
- listener线程内部调用了process()方法。
常见的监听：①监听节点数据的变化：get path [watch]；②监听子节点增减的变化：ls path [watch]。

监听器原理

写数据流程

Java与zk的连接示例

创建一个maven项目，在其pom.xml文件中添加以下依赖：

<dependencies>
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-core</artifactId>
        <version>2.8.2</version>
    </dependency>
    <dependency>
        <groupId>org.apache.zookeeper</groupId>
        <artifactId>zookeeper</artifactId>
        <version>3.4.10</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>compile</scope>
    </dependency>
</dependencies>

在项目的 src/main/resources 目录下，新建一个文件（log4j.properties），在文件中填入如下内容：

log4j.rootLogger=INFO, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n
log4j.appender.logfile=org.apache.log4j.FileAppender
log4j.appender.logfile.File=target/spring.log
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - %m%n

创建zk客户端并进行相应的API测试：

import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;
import org.junit.Before;
import org.junit.Test;
import java.util.List;
public class ZookeeperTest {
    private static String connectString = "192.168.211.146:2181,192.168.211.146:2182,192.168.211.146:2183";
    private static int sessionTimeout = 2000;
    private ZooKeeper zkClient = null;
    // @Test
    @Before
    public void init() throws Exception {
        zkClient = new ZooKeeper(connectString, sessionTimeout, new Watcher() {
            @Override
            // 收到事件通知后的回调函数（用户的业务逻辑）
            public void process(WatchedEvent event) {
                /*System.out.println("------------------start---------------------");
                System.out.println("-------" + event.getType() + "-------" + event.getPath());
                // 再次启动监听
                try {
                    List<String> children = zkClient.getChildren("/", true);
                    for (String child : children) {
                        System.out.println(child);
                    }
                    System.out.println("------------------end-------------------");
                } catch (Exception e) {
                    e.printStackTrace();
                }*/
            }
        });
    }
    // 1、创建子节点
    @Test
    public void create() throws Exception {
        // 参数 1：要创建的节点的路径； 参数 2：节点数据（字节数组）； 参数 3：节点权限 ；参数 4：节点的类型
        String nodeCreated = zkClient.create("/zzw", "zhangsan".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        System.out.println(nodeCreated);
    }
    // 2、获取子节点
    @Test
    public void getChildren() throws Exception {
        List<String> children = zkClient.getChildren("/", true);
        for (String child : children) {
            System.out.println(child);
        }
        // 延时阻塞使得上面的回调函数被执行
        Thread.sleep(Long.MAX_VALUE);
    }
    // 3、判断 zNode 是否存在
    @Test
    public void exist() throws Exception {
        Stat stat = zkClient.exists("/zhangsan", false);
        System.out.println(stat == null ? "not exist" : "exist");
    }
}

服务器节点动态上下线案例

需求：某分布式系统中，主节点可以有多台，可以动态上下线，任意一台客户端都能实时感知到主节点服务器的上下线。

需求分析

先在集群上创建/servers节点：create /servers "servers"；
服务器端向 Zookeeper 注册信息：

import org.apache.zookeeper.*;
import java.io.IOException;
public class DistributeServer {
    private static String connectString = "192.168.211.146:2181,192.168.211.146:2182,192.168.211.146:2183";
    private static int sessionTimeout = 2000;
    private ZooKeeper zkClient = null;
    private String parentNode = "/servers";
    // 创建到 zk 的客户端连接
    public void getConnect() throws IOException {
        zkClient = new ZooKeeper(connectString, sessionTimeout, new Watcher() {
            @Override
            public void process(WatchedEvent event) {
            }
        });
    }
    // 注册服务器
    public void registerServer(String hostname) throws Exception {
        String create = zkClient.create(parentNode + "/server", hostname.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE,
                CreateMode.EPHEMERAL_SEQUENTIAL);
        System.out.println(hostname + " is online " + create);
    }
    // 业务功能
    public void business(String hostname) throws Exception {
        System.out.println(hostname + " is working ...");
        Thread.sleep(Long.MAX_VALUE);
    }
    public static void main(String[] args) throws Exception {
        // 1、获取 zk 连接
        DistributeServer server = new DistributeServer();
        server.getConnect();
        // 2、利用 zk 连接注册服务器信息
        server.registerServer(args[0]);
        // 3、启动业务功能
        server.business(args[0]);
    }
}

客户端监听服务端节点动态上下线：

import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
public class DistributeClient {
    private static String connectString = "192.168.211.146:2181,192.168.211.146:2182,192.168.211.146:2183";
    private static int sessionTimeout = 2000;
    private ZooKeeper zkClient = null;
    private String parentNode = "/servers";
    // 创建到 zkClient 的客户端连接
    public void getConnect() throws IOException {
        zkClient = new ZooKeeper(connectString, sessionTimeout, new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                // 再次启动监听
                try {
                    getServerList();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }
    // 获取服务器列表信息
    public void getServerList() throws Exception {
        // 1、获取服务器子节点信息，并且对父节点进行监听
        List<String> children = zkClient.getChildren(parentNode, true);
        // 2、存储服务器信息列表
        List<String> servers = new ArrayList<>();
        // 3、遍历所有节点，获取节点中的主机名称信息
        for (String child : children) {
            byte[] data = zkClient.getData(parentNode + "/" + child, false, null);
            servers.add(new String(data));
        }
        // 4、打印服务器列表信息
        System.out.println(servers);
    }
    // 业务功能
    public void business() throws Exception {
        System.out.println("client is working ...");
        Thread.sleep(Long.MAX_VALUE);
    }
    public static void main(String[] args) throws Exception {
        // 1、获取 zk 连接
        DistributeClient client = new DistributeClient();
        client.getConnect();
        // 2、获取 servers 的子节点信息，从中获取服务器信息列表
        client.getServerList();
        // 3、业务进程启动
        client.business();
    }
}

Zookeeper学习笔记

在单个server节点上模拟搭建3个zk server的集群

Java与zk的连接示例

服务器节点动态上下线案例

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读