zookeeper学习

已于 2022-05-22 20:42:18 修改
阅读量240 收藏
点赞数
分类专栏： java 文章标签： java
于 2022-05-19 23:15:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/proxbj/article/details/124873182
版权

一、安装

  • docker安装
docker pull zookeeper

docker run -d -p 2181:2181 --restart=always --name zk zookeeper:latest

docker exec -it 69f0622fdd4e /bin/bash

二、服务端命令

  • 本文章讲解docker安装zk，因此运行容器后自动启动了zk，不需要重新启动服务端，启动一个客户端连接服务端就行了
  • 如果需要启动服务端，则命令如下：
root@69f0622fdd4e:/apache-zookeeper-3.8.0-bin/bin# ./zkServer.sh status

root@69f0622fdd4e:/apache-zookeeper-3.8.0-bin/bin# ./zkServer.sh stop

root@69f0622fdd4e:/apache-zookeeper-3.8.0-bin/bin# ./zkServer.sh start

三、客户端命令

  1. 持久节点
 # 创建根节点zoo，并存储数据’hello‘
create /zoo 'hello'

 # 在zoo下面创建child1 存储'hello'
create /zoo/child3 'msg'

 # 在zoo下面创建child2
create /zoo/child1

create /zoo/child1/gran1 'grand'

 # 获取创建的节点
[zk: localhost:2181(CONNECTED) 11] get /zoo/child3
msg3

 # 查看zoo下面的所有子节点（不包括子节点以下的）
 ls /zoo
 
 # 删除和递归删除
 [zk: localhost:2181(CONNECTED) 16] delete /zoo/child2
[zk: localhost:2181(CONNECTED) 17] ls /zoo
[child1, child3]
[zk: localhost:2181(CONNECTED) 18] delete /zoo/child3
[zk: localhost:2181(CONNECTED) 19] ls /zoo
[child1]
[zk: localhost:2181(CONNECTED) 20] delete /zoo/child1
Node not empty: /zoo/child1

 # 新版本用deleteall替代rmr
[zk: localhost:2181(CONNECTED) 29] deleteall /zoo
[zk: localhost:2181(CONNECTED) 30] ls /zoo
Node does not exist: /zoo
  1. 临时节点
  • 临时节点不能创建子节点
 # 创建临时节点
[zk: localhost:2181(CONNECTED) 42] create -e /znode 'msg'
Created /znode

[zk: localhost:2181(CONNECTED) 43] get /znode
msg

 # 不能创建子节点
[zk: localhost:2181(CONNECTED) 44] create /znode/child
Ephemerals cannot have children: /znode/child
[zk: localhost:2181(CONNECTED) 45] create -e /znode/child
Ephemerals cannot have children: /znode/child
  • 临时节点在客户端会话结束或者发生故障的时候被 ZooKeeper 系统自动清除。创建第二个客户端连接，查看节点信息
 # 退出客户端1会监听到WatchedEvent state:SyncConnected type:NodeDeleted path:/znode
[zk: localhost:2181(CONNECTED) 1] 
WATCHER::

WatchedEvent state:SyncConnected type:NodeDeleted path:/znode

 # 查看节点信息（也可以用ls -s [节点路径]）
[zk: localhost:2181(CONNECTED) 0] stat /znode true
'stat path [watch]' has been deprecated. Please use 'stat [-w] path' instead.
cZxid = 0x1a
ctime = Fri May 20 08:14:18 UTC 2022
mZxid = 0x1a
mtime = Fri May 20 08:14:18 UTC 2022
pZxid = 0x1a
cversion = 0
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x1004aba99840002
dataLength = 3
numChildren = 0
  1. 顺序节点
 # 持久顺序节点
[zk: localhost:2181(CONNECTED) 15] create /test
Created /test
[zk: localhost:2181(CONNECTED) 16] create -s /test/seq1 'seq1'
Created /test/seq10000000000
[zk: localhost:2181(CONNECTED) 17] create -s /test/seq1 'seq2'
Created /test/seq10000000001
[zk: localhost:2181(CONNECTED) 18] create -s /test/seq1 'seq3'
Created /test/seq10000000002
[zk: localhost:2181(CONNECTED) 19] create -s /test/seq1 'seq4'
Created /test/seq10000000003
[zk: localhost:2181(CONNECTED) 20] ls /test
[seq10000000000, seq10000000001, seq10000000002, seq10000000003]

 # 删除的时候要删除顺序号的节点
 delete /test/seq10000000000

 # 临时顺序节点
[zk: localhost:2181(CONNECTED) 42] create /test
Created /test
[zk: localhost:2181(CONNECTED) 43] create -s -e /test/linshi1 'linshi1'
Created /test/linshi10000000000
[zk: localhost:2181(CONNECTED) 44] create -e -s /test/linshi2 'linshi2'
Created /test/linshi20000000001

四、JavaAPI操作

  • 添加pom依赖
<!-- https://mvnrepository.com/artifact/org.apache.curator/curator-framework -->
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
            <version>4.2.0</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.apache.curator/curator-recipes -->
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-recipes</artifactId>
            <version>4.2.0</version>
        </dependency>
  • 学到新的test注解，此时启动会报错，需要在测试类加上@TestInstance(TestInstance.Lifecycle.PER_CLASS)
private CuratorFramework client;

    // 在每个单元测试启动的时候就会创建一个连接
    @BeforeAll
    void testConnect(){
        /**
         *String connectString, 连接字符串。zkServer 地址和段含
         * int sessionTimeoutMs,会话超时时间。单位ms
         * int connectionTimeoutMs,连接超时时间。单位ms
         * RetryPolicy retryPolicy,重试策略
         */
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(3000,10);
        client = CuratorFrameworkFactory.newClient(
                "120.79.157.16:2181", 60 * 1000, 15 * 1000, retryPolicy);
        // 开启连接
        client.start();
    }

	//在每个单元测试运行结束释放资源
	@AfterAll
    void close(){
        if (client != null){
            client.close();
        }
    }
  1. 创建连接
// 第一种创建方式
    @Test
    void testConnect(){
        /**
         *String connectString, 连接字符串。zkServer 地址和段含
         * int sessionTimeoutMs,会话超时时间。单位ms
         * int connectionTimeoutMs,连接超时时间。单位ms
         * RetryPolicy retryPolicy,重试策略
         */
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(3000,10);
        CuratorFramework client = CuratorFrameworkFactory.newClient(
                "120.79.157.16:2181", 60 * 1000, 15 * 1000, retryPolicy);
        // 开启连接
        client.start();
    }

    // 第二种创建方式
    @Test
    void testConn(){
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(3000,10);
        CuratorFramework build = CuratorFrameworkFactory.builder().connectString("120.79.157.16:2181")
                .sessionTimeoutMs(60 * 1000)
                .connectionTimeoutMs(15 * 1000)
                .retryPolicy(retryPolicy).build();
        build.start();
    }
  1. 创建节点
/**
     * 创建节点  持久、临时、顺序、是否携带数据
     */
    @Test
    void testCreate() throws Exception {
        // 如果创建节点没有指定数据，则默认存储当前客户端的ip
        String s = client.create().forPath("/api");
        System.out.println(s);
    }
    @Test
    void testCreate1() throws Exception {
        // 创建节点带有数据
        String data = client.create().forPath("/data", "hehe".getBytes());
        System.out.println(data);
    }
    @Test
    void testCreate2() throws Exception {
        // 创建临时节点
        String data = client.create().withMode(CreateMode.EPHEMERAL).forPath("/EPHEMERAL", "EPHEMERAL".getBytes());
        System.out.println(data);
    }
    @Test
    void testCreate3() throws Exception {
        // 创建持久顺序节点
        String data = client.create().withMode(CreateMode.PERSISTENT_SEQUENTIAL).forPath("/PERSISTENT_SEQUENTIAL", "PERSISTENT_SEQUENTIAL".getBytes());
        System.out.println(data);
    }
    @Test
    void testCreate4() throws Exception {
        // 创建临时顺序节点
        String data = client.create().withMode(CreateMode.EPHEMERAL_SEQUENTIAL).forPath("/EPHEMERAL_SEQUENTIAL", "EPHEMERAL_SEQUENTIAL".getBytes());
        System.out.println(data);
    }
    @Test
    void testCreate5() throws Exception {
        // 创建多级节点，如果父节点不存在则创建
        String data = client.create().creatingParentsIfNeeded().forPath("/parent/child");
        System.out.println(data);
    }
  1. 查询节点
	/**
     * 查询数据
     * @throws Exception
     */
    @Test
    void get1() throws Exception {
        byte[] data = client.getData().forPath("/data");
        System.out.println(new String(data));
    }

    /**
     * 查询子节点
     * @throws Exception
     */
    @Test
    void get2() throws Exception {
        List<String> strings = client.getChildren().forPath("/");
        System.out.println(strings);
    }

    /**
     * 查询节点信息
     * @throws Exception
     */
    @Test
    void get3() throws Exception {
        Stat stat = new Stat();
        System.out.println(stat);
        System.out.println("------------------");
        client.getData().storingStatIn(stat).forPath("/data");
        System.out.println(stat);
    }
  1. 修改节点
	/**
     * 修改数据
     * @throws Exception
     */
    @Test
    void update1() throws Exception {
        Stat stat = client.setData().forPath("/data", "update2".getBytes());
        System.out.println(stat);
    }

    /**
     * 根据版本号修改数据
     * @throws Exception
     */
    @Test
    void update2() throws Exception {
        Stat stat = new Stat();
        client.getData().storingStatIn(stat).forPath("/data");
        int version = stat.getVersion();
        System.out.println("数据版本："+version);
        client.setData().withVersion(version).forPath("/data", "update3".getBytes());
        System.out.println(stat);
    }
  1. 删除节点
	/**
     * 删除单个节点
     */
    @Test
    void del1() throws Exception{
        client.delete().forPath("/test0000000009");
    }

    /**
     * 删除有子节点的节点
     * @throws Exception
     */
    @Test
    void del2() throws Exception{
        client.delete().deletingChildrenIfNeeded().forPath("/parent");
    }

    /**
     * 必须要删除的节点
     * @throws Exception
     */
    @Test
    void del3() throws Exception{
        client.delete().guaranteed().forPath("/api");
    }

    /**
     * 具有回调函数的删除
     * @throws Exception
     */
    @Test
    void del4() throws Exception{
        client.delete().guaranteed().inBackground(new BackgroundCallback() {
            @Override
            public void processResult(CuratorFramework curatorFramework, CuratorEvent curatorEvent) throws Exception {
                System.out.println("我被删除了！");
                System.out.println(curatorEvent);
            }
        }).forPath("/del");
    }
  1. Watch事件监听
zookeeper提供了三种watcher：
  • NodeCache:只是监听某一个特定的节点
  • PathChildCache：监控一个ZNode的子节点
  • TreeCache：可以监控整个树上的所有节点，就是将前面两种整合
curator引入cache来实现对zookeeper服务端事件的监听
  • NodeCache:
	/**
     * 给指定的一个节点注册监听器
     */
    @Test
    void nodeCache() throws Exception {
        // 创建NodeCache
        NodeCache nodeCache = new NodeCache(client,"/data/nodecache");
        // 注册监听
        nodeCache.getListenable().addListener(new NodeCacheListener() {
            @Override
            public void nodeChanged() throws Exception {
                System.out.println("节点变化了");
                // 获取修改节点的数据
                byte[] data = nodeCache.getCurrentData().getData();
                System.out.println(new String(data));
            }
        });
        // 开启监听,设置为true则开启监听时加载缓存数据
        nodeCache.start(true);

        while (true){

        }
    }
  • PathChildrenCache:
	/**
     * 给节点添加监听器，监听某个节点的子节点的变化
     * @throws Exception
     */
    @Test
    void childCache() throws Exception {
        PathChildrenCache pathChildrenCache = new PathChildrenCache(client,"/parent",true);
        pathChildrenCache.getListenable().addListener(new PathChildrenCacheListener() {
            @Override
            public void childEvent(CuratorFramework curatorFramework, PathChildrenCacheEvent pathChildrenCacheEvent) throws Exception {
                System.out.println("儿子们变化了");
                System.out.println(pathChildrenCacheEvent);
                // 监听子节点的数据变更，拿到变更的类型
                PathChildrenCacheEvent.Type type = pathChildrenCacheEvent.getType();
                if (type.equals(PathChildrenCacheEvent.Type.CHILD_UPDATED)){
                    // 输出跟新后的数据
                    byte[] data = pathChildrenCacheEvent.getData().getData();
                    System.out.println(new String(data));
                }
            }
        });
        pathChildrenCache.start();

        while (true){

        }
    }
  • TreeCache:
	/**
     * 给节点添加监听器，监听某个节点的子节点的变化
     * @throws Exception
     */
    @Test
    void treeCache() throws Exception {
        TreeCache treeCache = new TreeCache(client,"/parent");
        treeCache.getListenable().addListener(new TreeCacheListener() {
            @Override
            public void childEvent(CuratorFramework curatorFramework, TreeCacheEvent treeCacheEvent) throws Exception {
                System.out.println("发生变化");
            }
        });
        treeCache.start();

        while (true){

        }
    }

五、分布式锁

  1. 概念：跨机器的进程之间的数据同步问题
  2. zk实现：客户端获取锁时创建节点，使用完后删除该节点。
  • 在lock（随便取的）下创建临时顺序节点，临时保证宕机自动删除，顺序保证
  • 获取lock下面的所有子节点，客户端获取到所有的子节点之后，如果发现自己创建的子节点序号最小，那么就认为改客户端获取到了锁，使用完成后，将该节点删除。
  • 如果发现自己创建的节点并非lock下所有子结点中最小的，说明自己还没获取到锁，此时客户端需要找到比自己小的那个节点（注意是靠近当前节点的前面那一个节点），同时对其注册事件监听器，监听删除事件。
  • 如果发现比自己小的那个节点被删除，此时再次判断自己创建的节点是否是lock子节点中序号最小的，如果是则获取到锁，如果不是则重复以上步骤继续获取到比自己小的一个节点并注册监听。

六、Curator实现分布式锁API

  • 支持五种锁方案，需要详细了解可以换个博客看看
  • 分布式锁案例：
package com.test.ticket;

import org.apache.curator.RetryPolicy;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.locks.InterProcessLock;
import org.apache.curator.framework.recipes.locks.InterProcessMutex;
import org.apache.curator.retry.ExponentialBackoffRetry;

import java.util.concurrent.TimeUnit;

/**
 * author:towards
 * date:2022/5/22 20:24
 * discribe:never encounter bug!
 */
public class SellTicket implements Runnable{

    private CuratorFramework client;

    private Integer tickets = 10;

    private InterProcessLock lock;

    public SellTicket(){
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(3000,10);
        client = CuratorFrameworkFactory.newClient(
                "120.79.157.16:2181", 60 * 1000, 15 * 1000, retryPolicy);
        // 开启连接
        client.start();
        // 給lock初始化
        lock = new InterProcessMutex(client,"/lock");
    }

    @Override
    public void run() {
        try {
            while (true){
                // 获取锁
                lock.acquire();
                if (tickets > 0){
                    System.out.println(Thread.currentThread().getName()+":"+tickets);
                    tickets--;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                // 释放锁
                lock.release();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}
Proxbj
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
zookeeper使用详解（命令、客户端、源码）
weixin_33739627的博客
03-27 417
1. zookeeper使用详解（命令、客户端、源码） 1.1. 前言   zookeeper我们常用来做分布式协调中间件，很多时候我们都接触不到它的原理和用法，我对他的了解也仅限于知道它可以做分布式协调、配置管理、分布式锁，并且有个watch节点监听常常能听到。接下来我要系统的学下zookeeper的功能和原理，一起走进zookeeper的世界 1.2. 概述   zookeeper主要目的就是...
Zookeeper分布式锁
weixin_33758863的博客
06-05 101
2019独角兽企业重金招聘Python工程师标准>>> ...
临时节点不能有child 子节点
weixin_30242907的博客
07-20 116
[zk: 127.0.0.1:2181(CONNECTED) 67] create '/zk01/0001/aaaa' dada Ephemerals cannot have children: /zk01/0001/aaaa 转载于:https://www.cnblogs.com/zhaoyangjian724/p/6199549.html
zookeeper错误码以及常见问题
热门推荐
MyObject-C的专栏
08-13 1万+
Zookeeper C API 错误码介绍 ZOO_ERRORS ZOK  正常返回 ZSYSTEMERROR  系统或服务器端错误(System and server-side errors)，服务器不会抛出该错误，该错误也只是用来标识错误范围的，即大于该错误值，且小于 ZAPIERROR 都是系统错误。 ZRUNTIMEINCONSISTE...
Zookeeper 学习1
08-08
【Zookeeper 学习1】 Zookeeper 是一个分布式协调服务，广泛应用于分布式系统中的命名服务、配置管理、集群管理等领域。它提供了高可用、高性能的数据一致性保障，是Apache Hadoop项目的一部分。 1、Zookeeper ...
Zookeeper学习笔记
03-07
今晚上在上传学习笔记的时候，看了之前发布的文章，突然发现对于我上传的学习笔记是没有展示出来的，所以在这里对笔记进行重新的上传。不知道能不能上传成功！
zookeeper 学习资料 中篇
02-21
《Zookeeper学习资料 中篇》 Zookeeper，作为Apache Hadoop的一个子项目，是一个分布式的，开放源码的分布式应用程序协调服务，它是集群的管理者，监视着集群中各个节点的状态根据节点提交的反馈进行下一步合理操作...
tempdb：Redis支持的临时键值存储节点
02-05
临时数据库 TempDB是Redis支持的Node临时键值存储。 这对于存储临时数据（例如登录代码，身份验证令牌和临时密码）很有用。 安装 npm install tempdb 运行Redis服务器 查看以为您的平台安装，或使用众多云提供商之一。 根据您的Redis提供程序，您可能需要启用密钥空间事件才能使临时密钥正常工作。 为macOS默认的Homebrew Redis安装提供了一个方便脚本： npm run redis 用法 需要TempDB： const TempDB = require ( 'tempdb' ) ; 初始化TempDB，连接到： const tempDB =
Zookeeper学习手册
03-08
基于 Zookeeper部署微服务，实现前后端分离，提高开发效率。
zookeeper学习Demo
08-02
Zookeeper学习Demo是一个用于深入理解并实践Apache Zookeeper功能的示例集合。Apache Zookeeper是一个分布式协调服务，广泛应用于分布式系统中的配置管理、命名服务、分布式锁、集群管理等多个场景。这个Demo涵盖了...
zookeeper错误：KeeperErrorCode = NoChildrenForEphemerals的原因
teddybear01的专栏
02-12 9549
zookeeper错误：zookeeper.KeeperException$NoChildrenForEphemera： KeeperErrorCode = NoChildrenForEphemerals 我在构建父节点的时候zookeeper.create(ZK_PATH, ZK_PATH.getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHE
zookeeper创建子节点报NoChildrenForEphemeralsException问题
Qi.zheng
06-21 7056
用ZOOKEEPER客户端向zookeeper的某一个节点添加子节点时出现以下错误： org.apache.zookeeper.KeeperException$NoChildrenForEphemeralsException: KeeperErrorCode = NoChildrenForEphemerals for /xxxxx/xxxx/ at org.apache.zookeeper.K
运行出现不允许有子节点的问题
Moqin
06-19 1379
运行vs时总是提示说是不允许有子节点……什么的，当然这个项目并不是我们写的，我们写的话就可以运行的，跟同学做一个项目，同学的vs可以运行那个项目，但是我的却是提示说是  不允许有子节点问题，那个郁闷啊！重装了vs，还是不行，最后搞得连系统都重装了（想起来煞是悲剧），最后网上找一下一才知道安装时缺少包了（但是以前没有出现过），最后下载安装了就可以了！下面的是下载地址！ http://do
zookeeper 原理 应用场景
weixin_34415923的博客
08-08 1075
2019独角兽企业重金招聘Python工程师标准>>> ...
java版的上门家政系统和PHP版的上门家政有什么区别？
最新发布
baina666的博客
07-12 602
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值