关于zookeeper:Spring整合ZooKeeper基础使用介绍

【中间件】Spring 整合 ZooKeeper 根底应用介绍

ZooKeeper 是一个分布式的，开放源码的分布式应用程序协调服务，广泛应用于分布式系统中，比方有用它做配置核心，注册核心，也有应用它来实现分布式锁的，作为高并发技术栈中不可或缺的一个根底组件，接下来咱们将看一下，zk 应该怎么玩，能够怎么玩

本文作为第一篇，将次要介绍基于 zk-client 的根本应用姿态，顺次来理解下 zk 的基本概念

<!– more –>

用于学习试点目标的体验 zk 性能，装置比较简单，能够参考博文: 210310-ZooKeeper 装置及初体验

wget https://mirrors.bfsu.edu.cn/apache/zookeeper/zookeeper-3.6.2/apache-zookeeper-3.6.2-bin.tar.gz
tar -zxvf apache-zookeeper-3.6.2-bin.tar.gz
cd apache-zookeeper-3.6.2-bin

# 前台启动
bin/zkServer.sh start-foreground

本文演示的是间接应用 apache 的 zookeeper 包来操作 zk，与是否是 SpringBoot 环境无关

外围依赖

<!-- https://mvnrepository.com/artifact/org.apache.zookeeper/zookeeper -->
<dependency>
    <groupId>org.apache.zookeeper</groupId>
    <artifactId>zookeeper</artifactId>
    <version>3.7.0</version>
    <exclusions>
        <exclusion>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
        </exclusion>
    </exclusions>
</dependency>

版本阐明:

zk: 3.6.2
SpringBoot: 2.2.1.RELEASE

首先介绍下 zk 的几个次要的知识点，如 zk 的数据模型，四种常说的节点

zk 的数据模型和咱们常见的目录树很像，从 / 开始，每一个层级就是一个节点

每个节点，蕴含数据 + 子节点

留神：EPHEMERAL 节点，不能有子节点（能够了解为这个目录下不能再挂目录）

zk 中常说的监听器，就是基于节点的，一般来讲监听节点的创立、删除、数据变更

长久节点 persistent node
长久程序节点 persistent sequental
长期节点 ephemeral node
长期程序节点 ephemeral sequental

留神：

节点类型一经指定，不容许批改
长期节点，当会话完结，会主动删除，且不能有子节点

接下来咱们看一下 zk 的应用姿态，首先是创立节点，当然创立前提是得先拿到 zkClient

初始化连贯

private ZooKeeper zooKeeper;

@PostConstruct
public void initZk() throws IOException {
    // 500s 的会话超时工夫
    zooKeeper = new ZooKeeper("127.0.0.1:2181", 500_000, this);
}

节点创立办法，上面别离给出两种不同的 case

@Service
public class NodeExample implements Watcher {
    /**
     * 创立节点
     *
     * @param path
     */
    private void nodeCreate(String path) {
        // 第三个参数 ACL 示意访问控制权限
        // 第四个参数，管制创立的是长久节点，长久程序节点，还是长期节点；长期程序节点
        // 返回 the actual path of the created node
        // 单节点存在时，抛异样 KeeperException.NodeExists
        try {String node = zooKeeper.create(path + "/yes", "保留的数据".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
            System.out.println("create node:" + node);
        } catch (KeeperException.NodeExistsException e) {
            // 节点存在
            System.out.println("节点已存在:" + e.getMessage());
        } catch (Exception e) {e.printStackTrace();
        }

        // 带生命周期的节点
        try {Stat stat = new Stat();
            // 当这个节点上没有 child，且 1s 内没有变动，则删除节点
            // 实测抛了异样，未知起因
            String node = zooKeeper.create(path + "/ttl", ("now:" + LocalDateTime.now()).getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT_WITH_TTL, stat, 1000);
            System.out.println("ttl nod:" + node + "|" + stat);
            // 创立已给监听器来验证
            zooKeeper.exists(path + "/ttl", (e) -> {System.out.println("ttl 节点变更:" + e);
            });
        } catch (KeeperException.NodeExistsException e) {System.out.println("节点已存在:" + e.getMessage());
        } catch (Exception e) {e.printStackTrace();
        }
    }
}

节点创立，外围在于 zooKeeper.create(path + "/yes", "保留的数据".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);

当节点已存在时，再创立会抛异样 KeeperException.NodeExistsException
最初一个参数，来决定咱们创立的节点类型
todo: 下面实例中在指定 ttl 时，没有胜利，暂未找到起因，待解决

判断节点是否存在，比拟常见了（比方咱们在创立之前，可能会先判断一下是否存在）

/**
 * 判断节点是否存在
 */
private void checkPathExist(String path) {
    try {
        // 节点存在，则返回 stat 对象；不存在时，返回 null
        // watch: true 示意给这个节点增加监听器，当节点呈现创立 / 删除 或者 新增数据时，触发 watcher 回调
        Stat stat = zooKeeper.exists(path + "/no", false);
        System.out.println("NoStat:" + stat);
    } catch (Exception e) {e.printStackTrace();
    }

    try {
        // 判断节点是否存在，并监听 节点的创立 + 删除 + 数据变更
        // 留神这个事件监听，只会触发一次，即单这个节点数据变更屡次，只有第一次能拿到，之后的变动，须要从新再注册监听
        Stat stat = zooKeeper.exists(path + "/yes", this);
        System.out.println("YesStat:" + stat);
    } catch (Exception e) {e.printStackTrace();
    }
}

留神

外围用法：zooKeeper.exists(path + "/yes", this);

当节点存在时，返回 Stat 对象，蕴含一些根本信息；如果不存在，则返回 null
第二个参数，传入的是事件回调对象，咱们的测试类NodeExmaple 实现了接口 Watcher，所以间接传的是this
注册事件监听时，须要留神这个回调只会执行一次，即触发之后就没了；前面再次批改、删除、创立节点都不会再被接管到

获取某个节点的所有子节点，这里返回的是以后节点的一级子节点

/**
 * 获取节点的所有子节点, 只能获取一级节点
 *
 * @param path
 */
private void nodeChildren(String path) {
    try {
        // 如果获取胜利，会监听 以后节点的删除，子节点的创立和删除，触发回调事件, 这个回调也只会触发一次
        List<String> children = zooKeeper.getChildren(path, this, new Stat());
        System.out.println("path:" + path + "'s children:" + children);
    } catch (KeeperException e) {System.out.println(e.getMessage());
    } catch (Exception e) {e.printStackTrace();
    }
}

节点上是能够存储数据的，在创立的时候，能够加上数据；前期能够读取，也能够批改

/**
 * 设置数据，获取数据
 *
 * @param path
 */
public void dataChange(String path) {
    try {Stat stat = new Stat();
        byte[] data = zooKeeper.getData(path, false, stat);
        System.out.println("path:" + path + "data:" + new String(data) + ":" + stat);

        // 依据版本准确匹配; version = -1 就不须要进行版本匹配了
        Stat newStat = zooKeeper.setData(path, ("new data" + LocalDateTime.now()).getBytes(), stat.getVersion());
        System.out.println("newStat:" + stat.getVersion() + "/" + newStat.getVersion() + "data:" + new String(zooKeeper.getData(path, false, stat)));
    } catch (Exception e) {e.printStackTrace();
    }
}

在设置数据时，能够指定版本，当 version > 0 时，示意依据版本准确匹配；如果为 - 1 时，则只有节点门路对上就成

监听次要是针对节点而言，后面在判断节点是否存在、批改数据时都能够设置监听器，然而他们是一次性的，如果咱们心愿短暂无效，则能够应用上面的addWatch

public void watchEvent(String path) {
    try {
        // 留神这个节点存在
        // 增加监听, 与 exist 判断节点是否存在时增加的监听器 不同的在于，触发之后，仍然无效还会被触发，只有手动调用 remove 才会勾销
        // 感知：节点创立，删除，数据变更；创立子节点，删除子节点
        // 无奈感知：子节点的子节点创立 / 删除，子节点的数据变更
        zooKeeper.addWatch(path + "/yes", new Watcher() {
            @Override
            public void process(WatchedEvent event) {System.out.println("事件触发 on" + path + "event:" + event);
            }
        }, AddWatchMode.PERSISTENT);
    } catch (Exception e) {e.printStackTrace();
    }

    try {
        // 留神这个节点不存在
        // 增加监听, 与 exist 不同的在于，触发之后，仍然无效还会被触发，只有手动调用 remove 才会勾销
        // 与后面的区别在于，它的子节点的变动也会被监听到
        zooKeeper.addWatch(path + "/no", new Watcher() {
            @Override
            public void process(WatchedEvent event) {System.out.println("事件触发 on" + path + "event:" + event);
            }
        }, AddWatchMode.PERSISTENT_RECURSIVE);
    } catch (Exception e) {e.printStackTrace();
    }

    // 移除所有的监听
    //zooKeeper.removeAllWatches(path, WatcherType.Any, true);
}

下面给出了两种 case，

AddWatchMode.PERSISTENT：示意只关怀以后节点的删除、数据变更，创立，一级子节点的创立、删除；无奈感知子节点的子节点创立、删除，无奈感知子节点的数据变更
AddWatchMode.PERSISTENT_RECURSIVE: 相当于递归监听，改节点及其子节点的所有变更都监听

最初再介绍一个基本功能，节点删除，只有子节点都不存在时，能力删除以后节点（和 linux 的 rmdir 相似）

/**
 * 删除节点
 */
public void deleteNode(String path) {
    try {
        // 依据版本限定删除，-1 示意不须要管版本，path 匹配就能够执行；否则须要版本匹配，不然就会抛异样
        zooKeeper.delete(path, -1);
    } catch (Exception e) {e.printStackTrace();
    }
}

本文次要介绍的是 java 侧对 zookeeper 的基本操作姿态，能够算是 zk 的入门，理解下节点的增删改，事件监听；

当然个别更加举荐的是应用 Curator 来操作 zk，相比拟于 apache 的 jar 包，应用姿态更加顺滑，前面也会做比照介绍

工程：https://github.com/liuyueyi/spring-boot-demo
我的项目源码: https://github.com/liuyueyi/spring-boot-demo/tree/master/spring-boot/410-zookeeper-basic

尽信书则不如，以上内容，纯属一家之言，因集体能力无限，不免有疏漏和谬误之处，如发现 bug 或者有更好的倡议，欢送批评指正，不吝感谢

上面一灰灰的集体博客，记录所有学习和工作中的博文，欢送大家前去逛逛

一灰灰 Blog 集体博客 https://blog.hhui.top
一灰灰 Blog-Spring 专题博客 http://spring.hhui.top

关于zookeeper:Spring整合ZooKeeper基础使用介绍

I. 筹备

1. zk 环境装置

2. 我的项目环境

II. ZK 应用姿态

1. zk 根本知识点

1.1 数据模型

1.2 节点

2. 节点创立

3. 节点存在判断

4. 子节点获取

5. 数据获取与批改

6. 事件监听

7. 节点删除

8. 小结

II. 其余

0. 我的项目

1. 一灰灰 Blog