zookeeper——客户端Curator 的简单操作

最新推荐文章于 2023-09-03 22:31:10 发布
最新推荐文章于 2023-09-03 22:31:10 发布
阅读量260 收藏 1
点赞数 2
分类专栏： zookeeper 文章标签： 分布式 zookeeper
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cj_eryue/article/details/113536682
版权

目录

 

curator简介

1.curator连接zookeeper

2.创建节点

2.1简单创建

2.2 自定义权限

2.3递归创建

2.4异步创建

3.修改节点

3.1 同步修改

3.2 异步修改

4.删除节点

4.1同步删除

4.2异步删除

5.查看节点数据

5.1同步方式

5.2异步方式

6.查看子节点

6.1同步方式

6.2 异步方式

7.是否存在

7.1同步方式

7.2异步方式

8.监视器

8.1监视当前节点

8.2 监听子节点

9.事务

10.分布式锁

 

curator简介

curator是Netfilx公司开源的一个zookeeper客户端，后捐献给apache，curator框架在zookeeper原生API接口上进行了包装，解决了很多zookeeper客户端非常底层的细节开发。提供zookeeper各种应用场景（比如：分布式锁服务、集群领导选举、共享计数器、缓存机制、分布式队列等）的抽象封装，实现了Fluent风格的API接口，是最好用，最流行的zookeeper的客户端。

 

导入依赖：

<!-- 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>
        <!-- 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>

1.curator连接zookeeper

package com.cjian.curator;

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.retry.RetryOneTime;


public class CuratorConnection {
    public static void main(String[] args) {
        /**
         * 重连策略
         * new RetryOneTime(3000)  三秒后重连一次，只重连一次
         * new RetryNTimes(3, 3000); 每三秒重连一次，重连三次
         * new RetryUntilElapsed(10000, 3000); 每三秒重连一次，总等待时间超过10秒后停止重连
         * new ExponentialBackoffRetry(1000, 3);随着重连次数的增加，重连的时间增加  baseSleepTimeMs*Math.max(1,random.nextInt(1<<retryCount+1))
         *
         */
        CuratorFramework client = CuratorFrameworkFactory.builder()
            //IP端口号
            .connectString("127.0.0.1:2181,127.0.0.1:2182,127.0.0.1:2183")
            //会话超时时间
            .sessionTimeoutMs(5000)
            //重连机制  策略
            .retryPolicy(new RetryOneTime(3000))
            //命名空间  父节点
            .namespace("create")
            //构建连接对象
            .build();
        //打开连接
        client.start();
        System.out.println(client.isStarted());
        //关闭连接
        client.close();
    }

}

2.创建节点

2.1简单创建

 @Test
    public void create1() throws Exception {
        client.create()
            .withMode(CreateMode.PERSISTENT)
            .withACL(ZooDefs.Ids.OPEN_ACL_UNSAFE)
            .forPath("/node1", "node1".getBytes());
        System.out.println("创建结束");
    }
[zk: 127.0.0.1:2182(CONNECTED) 3] ls /
[zookeeper]
[zk: 127.0.0.1:2182(CONNECTED) 4] ls /
[create, zookeeper]
[zk: 127.0.0.1:2182(CONNECTED) 5] get /create/node1
node1
cZxid = 0x300000025
ctime = Tue Feb 02 09:21:13 CST 2021
mZxid = 0x300000025
mtime = Tue Feb 02 09:21:13 CST 2021
pZxid = 0x300000025
cversion = 0
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 5
numChildren = 0

2.2 自定义权限

@Test
    public void create2() throws Exception {
        //自定义权限列表
        ArrayList<ACL> acls = new ArrayList<>();
        Id id = new Id("ip", "127.0.0.1");
        acls.add(new ACL(ZooDefs.Perms.ALL, id));
        client.create()
            .withMode(CreateMode.PERSISTENT)
            .withACL(acls)
            .forPath("/node2", "node2".getBytes());
        System.out.println("创建结束");
    }
[zk: 127.0.0.1:2182(CONNECTED) 7] getAcl /create/node2
'ip,'127.0.0.1
: cdrwa

2.3递归创建

 @Test
    public void create3() throws Exception {
        //递归创建节点树
        client.create()
            .creatingParentsIfNeeded()//支持递归创建节点
            .withMode(CreateMode.PERSISTENT)
            .withACL(ZooDefs.Ids.OPEN_ACL_UNSAFE)
            .forPath("/node3/node31", "node31".getBytes());
    }

2.4异步创建

@Test
    public void create4() throws Exception {
        //异步方式创建节点
        client.create()
            .creatingParentsIfNeeded()//支持递归创建节点
            .withMode(CreateMode.PERSISTENT)
            .withACL(ZooDefs.Ids.OPEN_ACL_UNSAFE)
            .inBackground(new BackgroundCallback() {
                @Override
                public void processResult(CuratorFramework curatorFramework, CuratorEvent curatorEvent)
                    throws Exception {
                    //节点路径
                    System.out.println(curatorEvent.getPath());
                    //事件类型
                    System.out.println(curatorEvent.getType());
                }
            })
            .forPath("/node4", "node4".getBytes());
        Thread.sleep(5000);
        System.out.println("创建结束");
    }
/node4
CREATE
创建结束

3.修改节点

3.1 同步修改

@Test
    public void set1() throws Exception {
        client.setData()
            .forPath("/node1", "node11".getBytes());
    }
    @Test
    public void set2() throws Exception {
        client.setData()
            //指定版本号
            .withVersion(-1)
            .forPath("/node1", "node22".getBytes());
    }

3.2 异步修改

 @Test
    public void set3() throws Exception {
        //异步方式
        client.setData()
            //指定版本号
            .withVersion(-1)
            .inBackground(new BackgroundCallback() {
                @Override
                public void processResult(CuratorFramework curatorFramework, CuratorEvent curatorEvent)
                    throws Exception {
                    //节点路径
                    System.out.println(curatorEvent.getPath());
                    //事件类型
                    System.out.println(curatorEvent.getType());
                }
            })
            .forPath("/node1", "node33".getBytes());
        Thread.sleep(5000);
        System.out.println("修改结束");
    }
/node1
SET_DATA
修改结束

4.删除节点

4.1同步删除

  @Test
    public void delete1() throws Exception {
        client.delete().forPath("/node1");
    }
    @Test
    public void delete2() throws Exception {
        client.delete()
            //版本号
            .withVersion(-1)
            .forPath("/node1");
    }

    @Test
    public void delete3() throws Exception {
        client.delete()
            //删除包含子节点的节点
            .deletingChildrenIfNeeded()
            .forPath("/node1");
    }

4.2异步删除

 @Test
    public void delete4() throws Exception {
        client.delete()
            //删除包含子节点的节点
            .deletingChildrenIfNeeded()
            .withVersion(-1)
            .inBackground(new BackgroundCallback() {
                @Override
                public void processResult(CuratorFramework curatorFramework, CuratorEvent curatorEvent)
                    throws Exception {
                    //节点路径
                    System.out.println(curatorEvent.getPath());
                    //事件类型
                    System.out.println(curatorEvent.getType());
                }
            })
            .forPath("/node1");
        Thread.sleep(5000);
        System.out.println("删除结束");
    }
/node1
DELETE
删除结束

5.查看节点数据

5.1同步方式

  @Test
    public void getData1() throws Exception {
        //读取节点数据
        byte[] node2s = client.getData().forPath("/node2");
        System.out.println(new String(node2s));
    }

    @Test
    public void getData2() throws Exception {
        Stat stat = new Stat();
        //读取数据时读取节点的属性
        byte[] node2s = client.getData()
            .storingStatIn(stat).forPath("/node2");
        System.out.println(new String(node2s));
        System.out.println(stat.getVersion());

    }

5.2异步方式

@Test
    public void getData3() throws Exception {
        Stat stat = new Stat();
        //读取数据时读取节点的属性
        byte[] node2s = client.getData()
            .inBackground(new BackgroundCallback() {
                @Override
                public void processResult(CuratorFramework curatorFramework, CuratorEvent curatorEvent)
                    throws Exception {
                    //节点路径
                    System.out.println(curatorEvent.getPath());
                    //事件类型
                    System.out.println(curatorEvent.getType());
                    //数据
                    System.out.println(new String(curatorEvent.getData()));
                }
            }).forPath("/node2");
        Thread.sleep(5000);
    }
/node2
GET_DATA
node2

6.查看子节点

6.1同步方式

 @Test
    public void getChild1() throws Exception {
        List<String> list = client.getChildren().forPath("/node1");
        for (String s : list) {
            System.out.println(s);
        }
    }
node11

6.2 异步方式

@Test
    public void getChild2() throws Exception {
        client.getChildren()
            .inBackground(new BackgroundCallback() {
                @Override
                public void processResult(CuratorFramework curatorFramework, CuratorEvent curatorEvent)
                    throws Exception {
                    //节点路径
                    System.out.println(curatorEvent.getPath());
                    //事件类型
                    System.out.println(curatorEvent.getType());
                    List<String> list = curatorEvent.getChildren();
                    for (String s : list) {
                        System.out.println(s);
                    }
                }
            }).forPath("/node1");
        Thread.sleep(5000);
    }
/node1
CHILDREN
node11

7.是否存在

7.1同步方式

@Test
    public void exists1() throws Exception {
        Stat stat = client.checkExists().forPath("/node1");
        System.out.println(stat.getVersion());
    }

如果不存在，则stat为null

7.2异步方式

@Test
    public void exists2() throws Exception {
        client.checkExists()
            .inBackground(new BackgroundCallback() {
                @Override
                public void processResult(CuratorFramework curatorFramework, CuratorEvent curatorEvent)
                    throws Exception {
                    //节点路径
                    System.out.println(curatorEvent.getPath());
                    //事件类型
                    System.out.println(curatorEvent.getType());

                    System.out.println(curatorEvent.getStat().getVersion());
                }
            }).forPath("/node1");
    }
/node1
EXISTS
0

8.监视器

curator提供了两种watcher来监听节点的变化

  • NodeCache :之间听某一个特定的节点，监听节点的新增和修改
  • PathChildrenCache:监听一个znode的子节点，当一个子节点增加、更新、删除时PathChildrenCache会改变它的状态，会包含最新的子节点，子节点的数据和状态

监视器可重复使用

8.1监视当前节点

@Test
    public void watcher1() throws Exception {
        //监视某个节点的数据变化
        NodeCache nodeCache = new NodeCache(client, "/watcher");
        //开启监视器对象
        nodeCache.start();
        nodeCache.getListenable().addListener(new NodeCacheListener() {
            @Override
            public void nodeChanged() throws Exception {
                System.out.println(nodeCache.getCurrentData().getPath());
                System.out.println(new String(nodeCache.getCurrentData().getData()));
            }
        });
        Thread.sleep(60000);
        //关闭监视器对象
        nodeCache.close();
    }

首先该节点是没有的，当我们在命令窗口执行：create /create/watcher "111"  后，控制台输出：

/watcher
111

当我们在控制台再次执行：set /create/watcher "222" 后，控制台输出：

/watcher
222

8.2 监听子节点

@Test
    public void watcher2() throws Exception {
        //监视某个子节点的数据变化
        //第三个参数为事件中是否可以获取节点的数据
        PathChildrenCache pathChildrenCache = new PathChildrenCache(client, "/watcher",true);
        //开启监视器对象
        pathChildrenCache.start();
        pathChildrenCache.getListenable().addListener(new PathChildrenCacheListener() {
            @Override
            public void childEvent(CuratorFramework curatorFramework, PathChildrenCacheEvent pathChildrenCacheEvent)
                throws Exception {
                System.out.println(pathChildrenCacheEvent.getType());
                System.out.println(pathChildrenCacheEvent.getData().getPath());
                System.out.println(new String(pathChildrenCacheEvent.getData().getData()));
            }
        });
        Thread.sleep(60000);
        //关闭监视器对象
        pathChildrenCache.close();
    }

首先该节点是没有的，当我们在命令窗口执行：create /create/watcher/watcher1 "11"  后，控制台输出：

CHILD_ADDED
/watcher/watcher1
11

当我们在控制台再次执行： set /create/watcher/watcher1 "123" 后，控制台输出：

CHILD_UPDATED
/watcher/watcher1
123

当我们在控制台再次执行： delete /create/watcher/watcher1 后，控制台输出：

CHILD_REMOVED
/watcher/watcher1
123

9.事务

//事务
    @Test
    public void tra1() throws Exception {
        //开启事务
        client.inTransaction().create().forPath("/test1","test1".getBytes())
            .and()
            .setData().forPath("/notExistsNode","not exists".getBytes())
            .and()
            //提交事务
            .commit();
    }

10.分布式锁

package com.cjian.curator;

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;

public class CuratorLock {
    private static CuratorFramework client;


    public static void main(String[] args) throws InterruptedException {
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);
        client = CuratorFrameworkFactory.builder()
            .connectString("127.0.0.1:2181,127.0.0.1:2182,127.0.0.1:2183")
            .sessionTimeoutMs(5000)
            .retryPolicy(retryPolicy)
            //可选项
            .namespace("lock")
            .build();
        client.start();

          //排他锁
        InterProcessLock interProcessLock = new InterProcessMutex(client, "/lock1");
        //读写锁
        //InterProcessReadWriteLock interProcessReadWriteLock = new InterProcessReadWriteLock(client, "/lock1");

        Order order = new Order(0,interProcessLock);
        for (int i = 0; i < 5; i++) {
            new Thread(order).start();
        }
        Thread.sleep(10000);
        System.out.println(order.getNum());

    }
}
class  Order implements Runnable{
    private int num;
    private InterProcessLock interProcessLock;

    public Order(int num, InterProcessLock interProcessLock) {
        this.num = num;
        this.interProcessLock = interProcessLock;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            try {
                interProcessLock.acquire();
                num++;
                interProcessLock.release();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }
}

 

 

cj_eryue
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Zookeeper】使用Curator操作Zookeeper
鹏啊鹏
07-09 1080
学习黑马程序员的Zookeeper学习笔记，主要记录Java操作Zookeeper的一些增删改查以及监听机制。
分布式基础：Curator实现Zookeeper分布式锁
ReturnTmp的博客
07-21 2451
官网的说法curator是一个Java/JVM客户端库，用于zookeeper，一个分布式协调服务。它包括一个高级API框架和实用程序，使ApacheZooKeeper的使用更加简单和可靠。它还包括常见用例和扩展的方法，如服务发现和Java8异步DSL。Curator使用手册-腾讯云开发者社区-腾讯云配置zookeeper集群参考;https。...........................
【基础篇】详解Zookeeper客户端Curator
HackDaily
11-11 2448
详解Zookeeper客户端Curator基本API的使用，包括节点增加、删除、修改、数据查询，事务，异步处理等操作。
Zookeeper详解（三）——开源客户端curator
qq_43409401的博客
01-04 631
curator框架在zookeeper原生API接口上进行了包装，解决了很多zooKeeper客户端非常底层的细节开发。提供zooKeeper各种应用场景(比如：分布式锁服务、集群领导选举、共享计数器、缓存机制、分布式队列等)的抽象封装，实现了Fluent风格的API接口，是最好用，最流行的zookeeper的客户端。
Curator实现Zookeeper分布式锁
最新发布
一名编程小白的Java学习日志
09-03 347
Curator实现Zookeeper分布式锁
zookeeper开源客户端Curator
03-25
Curator是Netflix公司开源的一套ZooKeeper客户端框架，Curator解决了很多ZooKeeper客户端非常底层的细节开发工作，包括连接重连、反复注册Watcher和NodeExistsException异常等，实现了Fluent风格的API接口，目前已经...
浅谈Zookeeper开源客户端框架Curator
08-29
主要介绍了浅谈Zookeeper开源客户端框架Curator的相关内容，具有一定参考价值，需要的朋友可以了解下。
Zookeeper-Java客户端Curator
08-09
Zookeeper_Java客户端Curator
prettyZoo，zookeeper window客户端
10-27
快速查看zookeeper内容 ，git 地址 https://github.com/vran-dev/PrettyZoo/releases 能够记录zookeeper密码 支持内容修改
zookeeper客户端curator操作示例
04-12
zookeeper客户端curator操作示例
Curator操作Zookeeper
weixin_46016309的博客
03-03 260
Curator客户端通过java代码操作zookeeper
zookeeper的ACL
破老的博客
12-22 2675
在创建节点的时候会让你标识所创建节点的权限，举例： zk.create("/test", null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL); 其中ZooDefs.Ids.OPEN_ACL_UNSAFE标识节点/test的接入权限。 我将ZooDefs.Ids.OPEN_ACL_UNSAFE展开如下： pub
【进阶篇】详解Zookeeper客户端Curator
HackDaily
12-15 1007
详解Zookeeper客户端Curator在分布式锁和分布式队列上的特性和应用。
Zookeeper客户端curator使用详解
qq_40837310的博客
07-04 1077
简介 curator是Netflix公司开源的一个Zookeeper客户端框架，curator框架在Zookeeper原生的API接口上进行了封装，屏蔽了Zookeeper原生客户端非常底层的细节开发，使得使用更加方便。并且还提供了Zookeeper多种应用场景的封装，比如分布式锁服务、集群领导选举等场景实现的封装，还实现了Fluent风格的链式调用API，是最好用，最流行的Zookeeper客户端。 原生Zookeeper的不足： 连接对象异步创建，需要开发人员自行编码等待。 连接没有会话超时自动重连机
Zookeeper入门之使用curator连接zookeeper并且进行节点的增删改查及ACL
筑梦者
05-17 9971
我使用的是Maven添加的依赖地址如下:                                 org.apache.curator             curator-framework             2.8.0                   CuratorFramework Curator框架提供了一套高级的API， 简化了ZooKee
zookeeper的客户端介绍：zkclient和curator的基本使用
qq_41358574的博客
05-17 1154
zkclientcurator二者的基本使用使用zkclient:使用Curator单结点操作使用curator集群操作 zkclient ZkClient是一个开源客户端，在ZooKeeper原生API接口的基础上进行了包装，更便于开发人员使用。ZkClient客户端在一些著名的互联网开源项目中得到了应用，例如，阿里的分布式Dubbo框架对它进行了无缝集成。 ZkClient解决了ZooKeeper原生API接口的很多问题。例如，ZkClient提供了更加简洁的API，实现了会话超时重连、反复注册Wat.
Zookeeper——4、使用Curator操作Zookeeper
热门推荐
隔壁老王的专栏
12-05 1万+
为了更好的实现Java操作zookeeper服务器，后来出现了Curator框架，非常的强大，目前已经是Apache的顶级项目，里面提供了更多丰富的操作，例如session超时重连、主从选举、分布式计数器、分布式锁等等适用于各种复杂的zookeeper场景的API封装。 Curator所需的maven依赖： org.apache.curator curator-framework
【zookeeper】Apache curator的使用及zk分布式锁实现
老汉健身的博客
10-26 4923
接上篇,本篇主要讲Apache开源的curator的使用,有了curator,利用Java对zookeeper的操作变得极度便捷. 其实在学之前我也有个疑虑,我为啥要学curator,撇开涨薪这些外在的东西,就单技术层面来讲,学curator能帮我做些什么?这就不得不从zookeeper说起,上篇我已经大篇幅讲了zk是做什么的了,但真正要靠zk去实现多服务器自动拉取更新的配置文件等功能是非常难的...
第7章 Apache Curator客户端的使用
越努力越幸运的博客
12-03 756
Apache Curator客户端的使用7-1 curator简介与客户端之间的异同点7-2 搭建maven工程，建立curator与zkserver的连接 7-1 curator简介与客户端之间的异同点 7-2 搭建maven工程，建立curator与zkserver的连接 这个是需要引入的依赖： &amp;amp;lt;dependency&amp;amp;gt; &amp;amp;lt;groupId&amp;amp;gt;or...
linux如何进入zookeeper的客户端
05-25
要进入 ZooKeeper 的客户端，可以按照以下步骤操作： 1. 打开终端窗口，输入命令 `zkCli.sh`（或 `zkCli.bat`，Windows 系统下）启动 ZooKeeper 客户端。 2. 连接到 ZooKeeper 服务器。在客户端命令行中，输入命令...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值