Zookeeper基本知识点及使用java操作zk 且实现循环监听节点

最新推荐文章于 2024-05-10 16:03:40 发布

巴中第一皇子

最新推荐文章于 2024-05-10 16:03:40 发布

阅读量1.5k

点赞数

分类专栏：分布式框架文章标签： zookeeper

本文链接：https://blog.csdn.net/weixin_38312502/article/details/106341173

版权

分布式框架专栏收录该内容

22 篇文章 0 订阅

订阅专栏

1. 概述

Zookeeper是一个开源的分布式的，为分布式应用提供协调服务的Apache项目。

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

所以可以大概理解成：Zookeeper=文件系统+通知机制。

官网下载：https://zookeeper.apache.org/

2. 特点

Zookeeper：一个领导者（Leader），多个跟随者（Follower）组成的集群
集群中只要有半数以上节点存活，Zookeeper集群就能正常服务。
全局数据一致：每个Server保存一份相同的数据副本，Client无论连接到哪个Server，数据都是一致的。
更新请求顺序进行，来自同一个Client的更新请求按其发送顺序依次执行。
数据更新原子性，一次数据更新要么成功，要么失败。
实时性，在一定时间范围内，Client能读到最新数据。

3. 数据结构

ZooKeeper数据模型的结构与Unix文件系统很类似，整体上可以看作是一棵树，每个节点称做一个ZNode。每一个ZNode默认能够存储1MB的数据，每个ZNode都可以通过其路径唯一标识。且节点的名称都是唯一的，不允许重复。

4. 应用场景

统一命名服务、统一配置管理、统一集群管理、服务器节点动态上下线、软负载均衡，分布式锁等。

统一命名：在分布式系统中，经常需要对应用/服务进行统一命名，便于识别，和ip和域名类似，而zk的树形结构有个特点就是节点名称不允许重复，所以可以使用这个特性来实现命名服务。
配置管理：集群环境下，一般将应用的统一配置集中管理，即写到zookeeper中的Znode上，然后客户端通过监听该节点数据，配置一变更，Zookeeper就立即通知监听该节点的各个服务器
统一集群管理：集群中的各个应用都将自身信息注册到Zookeeper上，然后通过监听节点获取他们的实时状态变化
服务器节点动态上下线：集群中，将服务器自身注册为Zookeeper上的一个节点，当服务器宕机，节点自动删除，此时，客户端就能即使响应，当下次请求时就能避免访问宕机的服务器
软负载均衡：服务器作为节点注册到Zookeeper上，然后Zookeeper记录每台服务器被访问的次数，让访问数最少的服务器区处理最新的客户端请求
分布式锁：可实现分布式锁。

5.Zookeeper内部原理

5.1 选举机制（重要）

半数机制：集群中半数以上机器存活，集群可用。所以Zookeeper适合安装奇数台服务器。
Zookeeper虽然在配置文件中并没有指定Master和Slave。但是，Zookeeper工作时，是有一个节点为Leader，其他则为Follower，Leader是通过内部的选举机制临时产生的。

举例说明：

假设有五台服务器组成的Zookeeper集群，它们的id从1-5（通过myid文件设置id），同时它们都是最新启动的，也就是没有历史数据，在存放数据量这一点上，都是一样的。假设这些服务器依序启动，来看看会发生什么？

注意：一开始都是会选举自己的，但是如果选举自己后没当上Leader的话，下次其他服务器启动，就会投票给其他的zk server

（1）服务器1启动，此时只有它一台服务器启动了，它发出去的报文没有任何响应，所以它的选举状态一直是LOOKING状态。

（2）服务器2启动，它与最开始启动的服务器1进行通信，互相交换自己的选举结果，由于两者都没有历史数据，所以id值较大的服务器2胜出，但是由于没有达到超过半数以上的服务器都同意选举它(这个例子中的半数以上是3)，所以服务器1、2还是继续保持LOOKING状态。

（3）服务器3启动，根据前面的理论分析，服务器3成为服务器1、2、3中的老大，而与上面不同的是，此时有三台服务器选举了它，所以它成为了这次选举的Leader。

（4）服务器4启动，根据前面的分析，理论上服务器4的id应该是服务器1、2、3、4中最大的，但是由于前面已经有半数以上的服务器选举了服务器3，所以它只能当Follow。

（5）服务器5启动，同4一样当小弟。

5.2 节点类型

持久型目录节点：客户端与Zookeeper断开连接后，该节点依旧存在
持久性顺序编号目录节点：和持久型目录节点不同的是，Zookeeper会给该节点名称进行顺序编号。
临时目录节点：客户端与Zookeeper断开连接后，该节点被删除
临时顺序编号目录节点：和临时目录节点不同的是，Zookeeper会给该节点名称进行顺序编号。

说明：创建znode时设置顺序标识，znode名称后会附加一个值，顺序号是一个单调递增的计数器，由父节点维护。如设置的节点名为user,那么添加顺序标识后，生成的就编程user,user001，user002

5.3 Stat结构体

属性有很多，需要记住的就是：

dataLength- znode的数据长度

numChildren - znode子节点数量

5.4 监听器使用（重要）

常见的监听器：

监听节点数据的变化：get path [watch]
监听子节点增减的变化：ls path [watch]

监听注意点：

监听只能监听一次节点变化，如果想再次监听，那就必须再次发送监听请求，即再次调用get path watch命令。

在代码中实现循环监听有两种方式：

对某个路径在本次监听完后主动用简单（exist()方法）的调用再次注册监听
使用addWatch方法设定AddWatchMode属性

实现监听：

首先要有一个main()线程
在main线程中创建Zookeeper客户端，这时就会创建两个线程，一个负责网络连接通信（connet），一个负责监听（listener）。
通过connect线程将注册的监听事件发送给Zookeeper。
在Zookeeper的注册监听器列表中将注册的监听事件添加到列表中。
Zookeeper监听到有数据或路径变化，就会将这个消息发送给listener线程。
listener线程内部调用了process()方法。

5.5 写数据流程

6. 单节点集群安装

6.1 安装前准备

（1）安装Jdk

（2）拷贝Zookeeper安装包到Linux系统下

（3）解压到指定目录

tar -zxvf zookeeper-3.4.10.tar.gz -C /opt/module/

6.2 修改配置

（1）将/opt/module/zookeeper-3.4.10/conf这个路径下的zoo_sample.cfg修改为zoo.cfg；

mv zoo_sample.cfg zoo.cfg

（2）打开zoo.cfg文件，修改dataDir路径（保存数据到本地系统，便于数据管理）：

vim zoo.cfg
dataDir=/opt/module/zookeeper-3.4.10/zkData

（3）在/opt/module/zookeeper-3.4.10/这个目录上创建zkData文件夹

mkdir zkData

6.3 操作Zookeeper

（1）启动Zookeeper服务器端

bin/zkServer.sh start

（2）查看进程是否启动

jps

（3）查看状态：

bin/zkServer.sh status

（4）启动客户端：

bin/zkCli.sh

（5）退出客户端：

quit

（6）停止Zookeeper

bin/zkServer.sh stop

6.4 配置文件参数解读

Zookeeper中的配置文件zoo.cfg中参数含义解读如下：

1．tickTime =2000：服务器之间或客户端与服务器之间维持心跳的时间间隔，也就是每个tickTime时间就会发送一个心跳，时间单位为毫秒。

它用于心跳机制，并且设置最小的session超时时间为两倍心跳时间。(session的最小超时时间是2*tickTime)

2．initLimit =10：Follower和Leader初始通信时限

集群中的Follower跟随者服务器与Leader领导者服务器之间初始连接时能容忍的最多心跳数（tickTime的数量）。像这样设置的话，启动Zookeeper时Leader和Follow最大的连接时间为2000*10=20s

3．syncLimit =5：Leader和Follower初始连接成功后，集群中Leader与Follower之间的最大响应时间单位。假如响应超过syncLimit * tickTime，Leader认为Follwer死掉，从服务器列表中删除Follwer。这里的话就是10秒

4．dataDir：数据文件目录+数据持久化路径，主要用于保存Zookeeper中的数据。

5．clientPort =2181：客户端连接服务器端时的端口

7. 分布式安装部署

部署在3台机器上

7.1 解压安装

解压zookeeper的安装包到3台机器上

7.2 配置服务器编号

（1）在/opt/module/zookeeper-3.4.10/这个目录下创建zkData

（2）在/opt/module/zookeeper-3.4.10/zkData目录下创建一个myid的文件，并添加id

touch myid
vi myid
#在 myid文件中添加与server对应的编号2
2

添加myid文件，注意一定要在linux里面创建，在notepad++里面很可能乱码

（3）在其他两台机器上都添加myid文件，并修改文件内容为3、4

7.3 配置zoo.cfg文件

(1) 重命名/opt/module/zookeeper-3.4.10/conf这个目录下的zoo_sample.cfg为zoo.cfg

(2) 打开zoo.cfg文件，修改数据存储地址

dataDir=/opt/module/zookeeper-3.4.10/zkData

再添加如下配置

增加如下配置
#######################cluster##########################
server.2=192.168.24.200:2888:3888
server.3=192.168.24.201:2888:3888
server.4=192.168.24.202:2888:3888

（3）配置参数解读

server.A=B:C:D

A是一个数字，表示这个是第几号服务器，即设置在myid中的值

集群模式下配置一个文件myid，这个文件在dataDir目录下，这个文件里面有一个数据就是A的值，Zookeeper启动时读取此文件，拿到里面的数据与zoo.cfg里面的配置信息比较从而判断到底是哪个server。

B是这个服务器的ip地址；

C是这个服务器与集群中的Leader服务器交换数据的端口；

D是万一集群中的Leader服务器挂了，需要一个端口来重新进行选举，选出一个新的Leader，而这个端口就是用来执行选举时服务器相互通信的端口。

7.4 启动服务器

分别启动3台机器的zk server

bin/zkServer.sh start

8. 客户端命令行操作

ls path [watch]：使用 ls 命令来查看当前znode中所包含的内容
ls2 path [watch]：看当前节点数据并能看到更新次数等数据
create：普通创建（-s 含有序列，-e 临时节点）
get path [watch]：获得节点的值
set：设置节点的具体值
stat：查看节点状态
delete：删除节点
rmr：递归删除节点

1.启动客户端

bin/zkCli.sh

2.创建2个普通节点

create /sanguo "jinlian"
create /sanguo/shuguo "liubei"

3.创建短暂节点

create -e /sanguo/wuguo "zhouyu"

4.创建带序号的节点

create -s /sanguo/weiguo/xiaoqiao "jinlian"
create -s /sanguo/weiguo/daqiao "jinlian"
create -s /sanguo/weiguo/daqiao "jinlian"

结果：

Created /sanguo/weiguo/xiaoqiao0000000000

Created /sanguo/weiguo/daqiao0000000001

Created /sanguo/weiguo/diaocan0000000002

如果原来没有序号节点，序号从0开始依次递增。如果原节点下已有2个节点，则再排序时从2开始，以此类推。

5.获得节点的值

get /sanguo

6.节点的值变化监听，在命令行可添加watch（上面的命令列表查看）的条件下，给命令最后添加watch，可以实现监听节点值的变化

get /sanguo watch

7. 监听某节点的子节点路径变化

ls /sanguo watch

9. JAVA 操作zookeeper

9.1 引入依赖包

<dependency>
	<groupId>org.apache.zookeeper</groupId>
	<artifactId>zookeeper</artifactId>
	<version>3.6.1</version>
</dependency>

9.2 代码展示

public class MyZkClient {
    // 集群连接地址，多个以逗号分隔
    private static final String CONNECT_ADDRES = "127.0.0.1:2181,127.0.0.1:2182";
    // 会话超时时间
    private static final int SESSIONTIME = 2000;
    // 信号量,让zk在连接之前等待,连接成功后才能往下走.
    private static final CountDownLatch countDownLatch = new CountDownLatch(1);
    private static String LOG_MAIN = "【main】 ";
    private static ZooKeeper zk;

    public void createConnection(String connectAddres, int sessionTimeOut) {
        try {
            zk = new ZooKeeper(connectAddres, sessionTimeOut, new Watcher() {
                public void process(WatchedEvent watchedEvent) {
                    System.out.println("事件来了");
                    // 获取事件状态
                    Watcher.Event.KeeperState keeperState = watchedEvent.getState();
                    // 获取事件类型
                    Watcher.Event.EventType eventType = watchedEvent.getType();
                    // zk 路径
                    String path = watchedEvent.getPath();
                    System.out.println("进入到 process() keeperState:" + keeperState + ", eventType:" + eventType + ", path:" + path);
                    // 判断是否建立连接
                    if (Watcher.Event.KeeperState.SyncConnected == keeperState) {
                        if (Watcher.Event.EventType.None == eventType) {
                            // 如果建立建立成功,让后程序往下走
                            System.out.println(LOG_MAIN + "zk 建立连接成功!");
                            countDownLatch.countDown();
                        } else if (Watcher.Event.EventType.NodeCreated == eventType) {
                            System.out.println(LOG_MAIN + "事件通知,新增node节点" + path);
                        } else if (Watcher.Event.EventType.NodeDataChanged == eventType) {
                            System.out.println(LOG_MAIN + "事件通知,当前node节点" + path + "被修改....");
                        }
                        else if (Watcher.Event.EventType.NodeDeleted == eventType) {
                            System.out.println(LOG_MAIN + "事件通知,当前node节点" + path + "被删除....");
                        }

                    }
                    System.out.println("--------------------------------------------------------");
                }
            });
            System.out.println(LOG_MAIN + "zk 开始启动连接服务器....");
            countDownLatch.await();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public boolean createPath(String path, String data) {
        try {
            this.exists(path, true);
            this.zk.create(path, data.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
            System.out.println(LOG_MAIN + "节点创建成功, Path:" + path + ",data:" + data);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 判断指定节点是否存在
     *
     * @param path
     *            节点路径
     */
    public Stat exists(String path, boolean needWatch) {
        try {
            return this.zk.exists(path, needWatch);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public boolean updateNode(String path,String data) throws KeeperException, InterruptedException {
        exists(path, true);
        this.zk.setData(path, data.getBytes(), -1);
        return false;
    }


    public static void main(String[] args) throws KeeperException, InterruptedException {
        MyZkClient zkClientWatcher = new MyZkClient();
        zkClientWatcher.createConnection(CONNECT_ADDRES, SESSIONTIME);
        boolean createResult = zkClientWatcher.createPath("/p15", "pa-644064");
        zkClientWatcher.updateNode("/p15","7894561");
        
        // 一次性监听器
        zk.getData("/p15", new Watcher() {
            public void process(WatchedEvent watchedEvent) {
                System.out.println("haha");
            }
        }, null);

        //添加自定义监听器
        //AddWatchMode.PERSISTENT表示循环监听指定节点，能监听到子节点的新增和删除，监听不了子节点的更新。监听不了孙节点的任何操作
        //AddWatchMode.PERSISTENT_RECURSIVE 表示循环监听指定节点及其子孙节点的增删改操作
        zk.addWatch("/p15", new Watcher() {
            public void process(WatchedEvent watchedEvent) {
                System.out.println("xixi");
            }
        }, AddWatchMode.PERSISTENT);
        Thread.sleep(Long.MAX_VALUE);
    }
}

代码说明：

1. 使用CountDownLatch的作用是让zk client连接服务器后再去做新增，修改那些操作，因为可以看到，我们在createConnection后立即就调了createPath创建节点了，如果zk client都还没连上zk server，就去做新增，修改，那肯定是会出问题的

2.在createConnection方法中可看到我们在new ZooKeeper时传入了一个Watcher的一个匿名内部类，重写了process方法，这里其实就是添加了一个默认的事件监听器。该默认的事件监听器默认只会监听一次，且监听的触发是在zk client连接上zk server。

3.创建节点时调用ZooKeeper类的create方法，且通过CreateMode参数来改变节点的类型（暂时性和持久性）

4.在updateNode()和createPath()方法中可以看到调用了this.exists(path, true)方法，true就表示给path节点再次添加事件监听。通过次方法来实现简单的循环监听。

因为上面说过了，在zk client连接上zk server后，事件就已经监听过一次了，而zk 的事件监听也只能是一次，如果想再次监听，必须再次发送监听请求。而this.exists(path, true)方法不仅判断了节点是否存在，还会为节点再次添加事件监听，当监听到事件后，会调用new ZooKeeper()中实现的Watch监听器。

5.如果不想使用new ZooKeeper()中实现的Watch监听器，就自己再写个监听器，然后调用exists的重载方法 exists(String path, Watcher watcher)，这样监听到后就会执行新的监听器代码

6.可以看到我的main方法中有端代码：zk.getData。。。，这个事件就是自己重新定义了一个监听器，没有再使用那个默认的监听器。

9.3 自定义注册事件及循环监听

（1）自定义监听器：实现Watcher接口，实现process方法

（2）注册事件：zk.addWatch(),其中有个参数AddWatchMode。它有两个值：

AddWatchMode.PERSISTENT：循环监听指定节点，能监听到子节点的新增和删除，监听不了子节点的更新。监听不了孙节点的任何操作

AddWatchMode.PERSISTENT_RECURSIVE：循环监听指定节点及其子孙节点的增删改操作

使用addWatch()监听的节点即使被删除，也会持续监听。将节点删除后再次添加，会发现依然是可以监听到节点的新增的

9.4 WatchedEvent

WatchedEvent表示监听器中process方法中的回调参数：WatchedEvent watchedEvent

该参数定义了事件通知相关的逻辑，包含KeeperState和EventType两个枚举类，分别代表了通知状态和事件类型

巴中第一皇子

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
打赏
0
评论
Zookeeper基本知识点及使用java操作zk 且实现循环监听节点

1. 概述Zookeeper是一个开源的分布式的，为分布式应用提供协调服务的Apache项目。Zookeeper从设计模式角度来理解：是一个基于观察者模式设计的分布式服务管理框架，它负责存储和管理大家都关心的数据，然后接受观察者的注册，一旦这些数据的状态发生变化，Zookeeper就将负责通知已经在Zookeeper上注册的那些观察者做出相应的反应。所以可以大概理解成：Zookeeper=文件系统+通知机制。官网下载：https://zookeeper.apache.org/2. 特..
复制链接

扫一扫