0
点赞
收藏
分享

微信扫一扫

Zookeeper学习笔记

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

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

  • 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.cfgmv 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的最小超时时间是)
    • initLimit=10:集群中的Follower节点与Leader节点之间初始连接时能容忍的最多心跳数(tickTime的数量),用它来限定集群中的Zookeeper服务器连接到Leader的时限。
    • syncLimit=5:集群中Leader节点与Follower节点之间的最大响应时间单位(tickTime的数量)。若响应时间超过 ,Leader节点认为Follwer节点已死掉,则从服务器列表中删除Follwer节点。
    • dataDir:用于保存 Zookeeper 中数据的路径。
    • clientPort=2181:客户端连接的端口号。
  • Zookeeper的选举机制:半数机制,即集群中半数以上机器存活,集群可用。因此,Zookeeper 适合安装奇数台节点。例如,5台服务器有3台存活,集群可用,而只有2台存活,集群不可用。

  • 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
  • 注:因为是在同一台机器上模拟集群,所以端口不能重复,这里用,,以及相互错开。另外每个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客户端, 这时就会创建两个线程,一个负责网络连接通信(connect), 一个负责监听(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();
}
}
举报

相关推荐

0 条评论