Zookeeper

 

Zookeeper

1.Zookeeper概述

  1. Zookeeper是一个开源的分布式的，为分布式应用提供协调服务。
  2. Zookeeper从设计模式角度来理解，是一个基于观察者模式设计的分布式服务管理框架，它负责存储和管理大家都关心的数据，然后接受观察者的注册，一旦这些数据的状态发生了变化，Zookeeper就负责通知已经在Zookeeper上注册的那些观察者做出相应的反应。
  3. ZooKeeper数据模型的结构与Unix文件系统很类似，整体上可以看作是一棵树，每个节点称做一个ZNode。每一个ZNode默认能够存储1MB的数据，每个ZNode都可以通过其路径唯一标识。
  4. Zookeeper引用场景。
    1. 统一命名服务。在分布式环境下，经常需要对应用/服务进行统一命名，便于识别。
    2. 统一配置管理。分布式环境下，一般要求一个集群中，所有节点的配置信息是一致的，比如 Kafka 集群。所以可将配置信息写入ZooKeeper上的一个Znode，各个客户端服务器监听这个Znode，一旦Znode中的数据被修改，ZooKeeper将通知各个客户端服务器。
    3. 统一集群管理。分布式环境中，实时掌握每个节点的状态是必要的，可以根据节点实时状态做出一些调整。ZooKeeper可以实现，将节点信息写入ZooKeeper上的一个ZNode中，监听这个ZNode以获取它的实时状态变化。
    4. 服务器节点动态上下线。
    5. 软负载均衡。Zookeeper可以记录每台服务器的访问数，让访问数最少的服务器去处理最新的客户端请求。
  5. Zookeeper官网地址，https://zookeeper.apache.org/。

2.Zookeeper特点

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

3.Zookeeper本地安装

  1. 解压，tar -zxvf apache-zookeeper-3.5.7-bin.tar.gz -C /opt/module/。
  2. 修改文件名，mv apache-zookeeper-3.5.7-bin/ zookeeper-3.5.7。
  3. 修改配置文件，zoo.cfg为zookeeper的启动识别的配置文件。
cp zoo_sample.cfg zoo.cfg
mkdir /opt/module/zookeeper-3.5.7/zkData

# 修改zookeeper的数据存放地址
dataDir=/opt/module/zookeeper-3.5.7/zkData
  1. 启动zookeeper服务端。
# 启动服务
/opt/module/zookeeper-3.5.7/bin/zkServer.sh start
jps # 查看Zookeeper进程名。进程号为，1395；进程名，QuorumPeerMain
		
/opt/module/zookeeper-3.5.7/bin/zkServer.sh status # 查看服务状态
/opt/module/zookeeper-3.5.7/bin/zkServer.sh stop # 停止服务
  1. 启动zookeeper客户端。
# -server 127.0.0.1:2181 服务端ip和端口
/opt/module/zookeeper-3.5.7/bin/zkCli.sh -server 127.0.0.1:2181

4.Zookeeper配置文件

  1. tickTime=2000，通信心跳数，Zookeeper服务器与客户端心跳时间，单位毫秒。Zookeeper使用的基本时间，服务器之间或客户端与服务器之间维持心跳的时间间隔，也就是每个tickTime时间就会发送一个心跳，时间单位为毫秒。它用于心跳机制，并且设置最小的session超时时间为两倍心跳时间，session的最小超时时间是2*tickTime。
  2. initLimit =10，LF(Leader和Follower)初始通信时限。集群中的Follower跟随者服务器与Leader领导者服务器之间初始连接时能容忍的最多心跳数（tickTime的数量），用它来限定集群中的Zookeeper服务器连接到Leader的时限。启动集群时的初始化时间，启动集群初始化时间=initLimit*tickTime的时间内，在这个时间内，如果集群中超过一般的节点都和主节点建立连接，则集群启动成功；否则集群启动失败。
  3. syncLimit =5，LF同步通信时限。集群中Leader与Follower之间的最大响应时间单位，假如响应超过syncLimit * tickTime，Leader认为Follwer死掉，从服务器列表中删除Follwer。
  4. dataDir，数据文件目录+数据持久化路径，主要用于保存Zookeeper中的数据。
  5. clientPort=2181，客户端连接端口，监听客户端连接的端口。

5.Zookeeper集群启动

  1. 如果不是第一次搭建集群，那么就把zk安装目录下的zkData目录删除，并且把logs目录也删除，rm -rf logs/ zkData/。
  2. 在ZK的安装目录下创建zkData，mkdir zkData。
  3. 修改zoo.cfg 配置文件。
dataDir=/opt/module/zookeeper-3.5.7/zkData

# .2为机器id。2888端口进行集群内部服务器的通信；
# 3888端口进行集群启动时leader选举或者集群运行中leader宕机时的投票选举。
server.2=192.168.253.134:2888:3888
server.3=192.168.253.135:2888:3888
server.4=192.168.253.136:2888:3888
  1. 在ZK的安装目录下的zkData目录中创建一个myid的文件，用于标记当前服务器的编号。
vim /opt/module/zookeeper-3.5.7/zkData/myid # 写入数据2
192.168.253.134 --> 2
192.168.253.135 --> 3
192.168.253.136 --> 4
  1. 将192.168.253.134整个ZK的安装目录分发到其他机器，/home/admin/bin/mycopy.sh /opt/module/zookeeper-3.5.7/。
  2. 在不同机器上修改myid文件中的值，vim /opt/module/zookeeper-3.5.7/zkData/myid。
  3. 启动集群，/opt/module/zookeeper-3.5.7/bin/zkServer.sh start。

6.自定义Zookeeper启动脚本

#!/bin/bash

if [ $# -lt 1 ]
then
	echo "参数错误"
exit
fi

for host in 192.168.253.134 192.168.253.135 192.168.253.136
do
    case $1 in
    "start")
        echo "$host == $1"
        ssh $host /opt/module/zookeeper-3.5.7/bin/zkServer.sh $1
    ;;
    "status")
        echo "$host == $1"
        ssh $host /opt/module/zookeeper-3.5.7/bin/zkServer.sh $1
    ;;
    "stop")
        echo "$host == $1"
        ssh $host /opt/module/zookeeper-3.5.7/bin/zkServer.sh $1
    ;;
    *)
        echo "参数错误 $1"
        exit
    ;;
    esac
done


/home/admin/bin/zookeeper-all.sh start # 脚本启动集群
/home/admin/bin/zookeeper-all.sh status # 查看集群状态
/home/admin/bin/zookeeper-all.sh stop # 停止集群

7.Zookeeper客户端命令

  1. 客户端连接到服务端，/opt/module/zookeeper-3.5.7/bin/zkCli.sh -server 192.168.253.134:2181。
  2. ls。
ls / # 查看根节点下的节点。
ls -s / # 查看根节点的附加信息。
ls -w / # 监听根据节点下所有节点的变化。
  1. create，创建节点。
create /tom01 # 创建不带序号的持久节点。
create -s /tom02 # 创建带序号的持久节点。

# 临时节点在客户端重新启动后，会不存在。
create -e /tom03 # 创建不带序号的临时节点。
create -e -s /tom04 # 创建带序号的临时节点。
  1. get和set，获取和设置节点的内容。
get /tom01
get -s /tom01 # 监听节点值的变化。
set /tom01 "username" # 给阶段设置值
  1. stat，查看节点的状态。
stat / # 查看根节点的内容。
  1. delete，删除节点。
delete /tom01 # 删除空节点
deleteall /tom02 # 递归删除

8.Java API操作Zookeeper

  1. 导入依赖。
<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>RELEASE</version>
    </dependency>
    <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.5.7</version>
    </dependency>
</dependencies>
  1. 配置文件，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
  1. 代码操作API。
public class ZookeeperClientText {

    private ZooKeeper zk;

    @Test
    public void deleteAll() throws KeeperException, InterruptedException {
        deleteAll("/bob");
    }

    public void deleteAll(String path) throws KeeperException, InterruptedException {
        Stat stat = zk.exists(path, false);
        if (stat == null) {
            System.out.println("节点不存在");
            return;
        }

        // delete /bob
        List<String> children = zk.getChildren(path, false);
        if (children.isEmpty()) {
            // 当前节点没有子节点，可以直接删除
            zk.delete(path, stat.getVersion());
        } else {
            for (String child : children) {
                deleteAll(path + "/" + child);
            }

            // 删除传入的节点
            zk.delete(path, stat.getVersion());
        }
    }



    /**
     * 删除节点
     * @throws KeeperException
     * @throws InterruptedException
     */
    @Test
    public void delete() throws KeeperException, InterruptedException {
        String path = "/bob";
        Stat stat = zk.exists(path, false);
        if (stat == null) {
            System.out.println("节点不存在");
        }else {
            // delete /bob
            zk.delete(path, stat.getVersion());
        }
    }

    /**
     * 修改节点的值
     * @throws KeeperException
     * @throws InterruptedException
     */
    @Test
    public void set() throws KeeperException, InterruptedException {
        String path = "/bob";
        Stat stat = zk.exists(path, false);
        if (stat == null) {
            System.out.println("节点不存在");
        }else {
            // set /bob "username bob"
            String setData = "username bob";
            // 修改节点值时需要传入版本号，版本号可以通过stat.getVersion()获取。
            // 如果传入的是-1，则不会对版本号进行校验。
            // zookeeper一个节点可以存储1M的数据量。
            zk.setData(path, setData.getBytes(), stat.getVersion());
        }
    }

    /**
     * 获取节点的内容
     */
    @Test
    public void getData() throws KeeperException, InterruptedException {
        String path = "/bob";
        Stat stat = zk.exists(path, false);
        if (stat == null) {
            System.out.println("节点不存在");
        }else {
            // get /bob
            byte[] data = zk.getData(path, false, stat);
            System.out.println("==" + new String(data));

            // get -w /bob，获取节点内容并监控
            byte[] zkData = zk.getData(path, new Watcher() {
                public void process(WatchedEvent watchedEvent) {

                }
            }, stat);
        }
    }

    /**
     * 节点是否存在
     */
    @Test
    public void exists() throws KeeperException, InterruptedException {
        Stat stat = zk.exists("/bob10", false);
        if (stat == null) {
            System.out.println("节点不存在");
        }
    }

    /**
     * 查看目录，并且监控
     * @throws KeeperException
     * @throws InterruptedException
     */
    @Test
    public void getAndWatch() throws KeeperException, InterruptedException {
        // ls -w /
        List<String> children = zk.getChildren("/", new Watcher() {
            public void process(WatchedEvent watchedEvent) {
                System.out.println("节点发生了变化==============" + watchedEvent);
            }
        });
        for (String child : children) {
            System.out.println(child);
        }

        TimeUnit.SECONDS.sleep(Long.MAX_VALUE);
    }

    /**
     * 查看目录
     * @throws KeeperException
     * @throws InterruptedException
     */
    @Test
    public void get() throws KeeperException, InterruptedException {
        // 获取节点不监控 ls /
        List<String> children = zk.getChildren("/", false);
        for (String child : children) {
            System.out.println(child);
        }
    }

    /**
     * 创建节点
     * @throws KeeperException
     * @throws InterruptedException
     */
    @Test
    public void create() throws KeeperException, InterruptedException {
        // 创建的节点路径 create /bob "username is bob"
        String path = "/bob";
        // 节点的内容
        String data = "username is bob";
        // 节点的权限
        ArrayList<ACL> acl = ZooDefs.Ids.OPEN_ACL_UNSAFE;
        // 创建的节点的模式，临时、持久、是否带序号
        CreateMode createMode = CreateMode.PERSISTENT;
        String result = zk.create(path, data.getBytes(), acl, createMode);

        System.out.println("===" + result);
    }

    @Before
    public void before() throws IOException {
        // 连接服务端的ip和端口
        String connectString = "192.168.253.134:2181,192.168.253.135:2181,192.168.253.136:2181";
        // 设置超时时间
        int sessionTimeout = 10000;
        // 监听器对象
        Watcher watcher = new Watcher() {
            public void process(WatchedEvent watchedEvent) {
                System.out.println("-----监听-----");
            }
        };
        zk = new ZooKeeper(connectString, sessionTimeout, watcher);

        System.out.println("=====" + zk);
    }

    @After
    public void after() throws InterruptedException {
        zk.close();
    }
}

9.Zookeeper内部原理-节点种类

  1. 持久节点和临时节点的区别。持久（Persistent）节点，在客户端和服务器端断开连接后，创建的节点不删除；短暂（Ephemeral）节点，客户端和服务器端断开连接后，创建的节点会删除。
  2. 带序号的节点。创建节点时设置顺序标识，节点名称后会附加一个值，顺序号是一个单调递增的计数器，由父节点维护。在分布式系统中，顺序号可以被用于为所有的事件进行全局排序，这样客户端可以通过顺序号推断事件的顺序。
  3. Zookeeper四种节点类型。持久节点不带需要；持久节点带序号；临时节点不带序号；临时节点带序号。

10.Zookeeper节点的数据结构

  1. ls -s /，查看节点的数据。
  2. czxid，创建节点的事务的zxid。每次修改ZooKeeper都会生成一个zxid形式的时间戳，也就是ZooKeeper事务ID，而且如果zxid1小于zxid2，那么zxid1在zxid2之前发生。
  3. ctime，znode被创建的毫秒数。
  4. mzxid，znode最后更新的事务zxid。
  5. mtime，znode最后修改的毫秒数。
  6. pZxid，znode最后更新的子节点的zxid。
  7. cversion，znode子节点变化号，znode子节点修改次数。
  8. dataversion，znode数据变化号。
  9. aclVersion，znode访问控制列表的变化号。
  10. ephemeralOwner，如果是临时节点，这个是znode拥有者的session id。如果不是临时节点则是0。
  11. dataLength，znode的数据长度。
  12. numChildren，znode子节点数量。

11.Zookeeper监听原理

  1. 在客户端的main线程中创建Zookeeper客户端连接。这时就会在main线程中创建两个线程：Connet线程，负责网络连接通信；Listener线程，负责监听。
  2. 然后Connect线程将注册的监听事件发送给Zookeeper，然后Zookeeper的将注册的监听事件添加到监听器列表中。
  3. 当Zookeeper监听到有数据或路径变化，就会将这个消息发送给Listener线程。
  4. Listener线程内部调用了process()方法。

12.Zookeeper选举机制

  1. Zookeeper集群需要半数以上的机器存活集群才可用，所以Zookeeper集群适合奇数台服务器。
  2. Zookeeper配置文件中并不会指定Master和Slave。但是在Zookeeper工作时，一个节点为Leader，其他为Follower，Leader是通过内部的选举机制临时产生的。
  3. Zookeeper选举的过程，以5台服务器为例。
    1. 服务器1启动，发起一次选举，1投自己一票，此时服务器1票数一票，不够半数以上（3票），选举无法完成，服务器1状态保持为LOOKING。
    2. 服务器2启动，再发起一次选举。服务器1和2分别投自己一票并交换选票信息，此时服务器1发现服务器2的ID比自己目前投票推举的（服务器1）大，更改选票为推举服务器2。此时服务器1票数0票，服务器2票数2票，没有半数以上结果，选举无法完成，服务器1，2状态保持LOOKING。
    3. 服务器3启动，发起一次选举。此时服务器1和2都会更改选票为服务器3。此次投票结果：服务器1为0票，服务器2为0票，服务器3为3票。此时服务器3的票数已经超过半数，服务器3当选Leader。服务器1，2更改状态为FOLLOWING，服务器3更改状态为LEADING。
    4. 服务器4启动，发起一次选举。此时服务器1，2，3已经不是LOOKING状态，不会更改选票信息。交换选票信息结果：服务器3为3票，服务器4为1票。此时服务器4服从多数，更改选票信息为服务器3，并更改状态为FOLLOWING。
    5. 服务器5启动，和服务器4执行相同的操作。
  4. Zookeeper选举过程，服务运行中，Leader宕机。
    1. 当集群中的Leader挂掉，集群会重新选出一个Leader，此时首先会比较每一台机器的czxid，czxid最大的被选为Leader。czxid是最有一次事务zxid，越大拥有的数据越多。
    2. 如果czxid都相等的情况，那么就会直接比较myid，myid在zookeeper配置文件/opt/module/zookeeper-3.5.7/zkData/myid中定义。

13.Zookeeper写数据流程

  1. Client客户端向ZooKeeper的Server1上写数据，发送写数据请求。
  2. 如果Server1不是Leader，那么Server1 会把接受到的请求进一步转发给Leader，因为每个ZooKeeper的Server里面都有一个是Leader。
  3. Leader会将写请求广播给各个Server，比如Server1和Server2，各个Server会将该写请求加入待写队列，并向Leader发送成功信息。
  4. 当Leader收到半数以上Server的成功信息，说明该写操作可以执行。Leader会向各个Server发送提交信息，各个Server收到信息后会落实队列里的写请求，此时写成功。
  5. Server1会进一步通知Client数据写成功了，这时就认为整个写操作成功。
posted @   行稳致远方  阅读(43)  评论(0)  编辑  收藏  举报
（评论功能已被禁用）
相关博文：
·  Kafka01-集群和基础原理
·  12.观察者模式
·  看完这篇文章你就可以告诉领导你精通Zookeeper了
·  Zookeeper基础
·  ZooKeeper笔记
阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· Manus的开源复刻OpenManus初探
· AI 智能体引爆开源社区「GitHub 热点速览」
· 从HTTP原因短语缺失研究HTTP/2和HTTP/3的设计差异
· 三行代码完成国际化适配，妙~啊~
点击右上角即可分享
微信分享提示
SQL AI 助手