Zookeeper的API操作

最新推荐文章于 2024-08-03 21:02:21 发布
最新推荐文章于 2024-08-03 21:02:21 发布
阅读量371 收藏 1
点赞数
分类专栏： # zookeeper 文章标签： zookeeper java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45316851/article/details/107055652
版权

Java API操作

6.1 原生 API

1）Maven依赖

 <!-- https://mvnrepository.com/artifact/org.apache.zookeeper/zookeeper -->
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.6</version>
            <type>pom</type>
        </dependency>

2）相关操作

（1）获得客户端对象
 private  ZooKeeper zooKeeper;

    @Before
    public void getCline() throws Exception{

         zooKeeper = new ZooKeeper("192.168.134.99:2181",2000,null);

    }
（2）获取节点值
 @Test
    public void getData()throws Exception{

        /*获取节点值*/
        byte[] data = zooKeeper.getData("/ba/123", null, null);
        System.out.println(new String(data));
    }
（3）获取节点孩子
  @Test
    public void getChild() throws Exception{

        /*获取当前输入节点下的子节点*/
        List<String> children = zooKeeper.getChildren("/ba/gjf", null);
        children.forEach((a)->{
            System.out.println(a);
        });

    }
（4）创建节点
    @Test
    public void createNode() throws Exception{


        /*创建持久节点*/

        Object value = null;

        value = "12312312";


        byte[] bytes = ((String) value).getBytes();


        String s = zooKeeper.create("/ba/123", bytes, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        System.out.println(s);




    }
（5）更新节点值
 @Test
    public void setData() throws Exception{

        Stat stat = zooKeeper.setData("/ba/123", new String("123123").getBytes(), -1);

        System.out.println(stat);


    }
（6）判断节点是否存在
 @Test
    public void exist() throws Exception{

        Stat stat = zooKeeper.exists("/ba/13", false);

        if (stat==null) {
            System.out.println("该节点不存在！");
        }else {
            System.out.println("该节点存在！");
        }

    }

6.2 zkCline API

1）Mavne依赖

<dependency>
    <groupId>com.101tec</groupId>
    <artifactId>zkclient</artifactId>
    <version>0.8</version>
</dependency>

2）核心API

 ZkClient client=new ZkClient("ip:port");

3）相关操作

package test;

import org.I0Itec.zkclient.ZkClient;

import java.util.List;

/**
 * Create by GuoJF on 2019/3/12
 */
public class Main {
    public static void main(String[] args) {


        ZkClient zkClient = new ZkClient("192.168.134.5:2181");


        /*
        * 获取根目录下所有的node信息
        *
        * */
        List<String> children = zkClient.getChildren("/");

        children.forEach((a)->{
            System.out.println(a);
        });

    }
}

（1）创建节点

    @Test
    public void createNode() {

        String result = zkClient.create("/ba/001", "001", CreateMode.PERSISTENT);

        System.out.println(result);

    }

（2）获取节点

 @Test
    public void getData() {
        Object readData = zkClient.readData("/ba/001");

        System.out.println(readData.toString());

    }

（3）更新节点值

 @Test
    public void setData() {
        zkClient.writeData("/ba/001", "123123");
    }

（4）删除节点

 @Test
    public void delNode() {

        boolean delete = zkClient.delete("/ba/001");
        if (delete) {
            System.out.println("删除成功！");
        } else {
            System.out.println("删除失败或者节点不存在！");
        }
    }

（5）判断节点是否存在

 @Test
    public void exist(){

        boolean exists = zkClient.exists("/ba/001");
        if (exists){
            System.out.println("该节点已经存在！");
        }else {
            System.out.println("该节点不存在！");
        }

    }

（6）获取孩子节点

 @Test
    public void getChild(){

        List<String> children = zkClient.getChildren("/ba");

        for (String child : children) {

            System.out.println(child);
        }
    }

6.3 Curator API

1）Maven依赖

 <dependency>
   <groupId>org.apache.curator</groupId>
   <artifactId>curator-framework</artifactId>
   <version>2.7.1</version>
 </dependency>

2）相关操作

（1）获取客户端对象
  private CuratorFramework curatorFramework;

    @Before
    public void getClient() {

        /*
         * 重连策略 四种实现
         *  ExponentialBackoffRetry、RetryNTimes、RetryOneTimes、RetryUntilElapsed
         * */


        ExponentialBackoffRetry backoffRetry = new ExponentialBackoffRetry(1000, 1000);

        curatorFramework = CuratorFrameworkFactory.newClient("192.168.134.99:2181", backoffRetry);

        curatorFramework.start();


    }
（2）创建节点
  @Test
    public void createNode() throws Exception {
    String s = curatorFramework.create().withMode(CreateMode.PERSISTENT).forPath("/ba/002", new String("123").getBytes());
        System.out.println(s);
    }
（3）获取节点
 @Test
    public void getData() throws Exception {

        byte[] bytes = curatorFramework.getData().forPath("/ba/002");

        System.out.println(new String(bytes));
    }
（4）更新节点值
@Test
    public void setData() {

        try {
            curatorFramework.setData().forPath("/ba/001", new String("123123").getBytes());

            System.out.println("更新成功！");
        } catch (KeeperException.NoNodeException e) {

            System.out.println("更新失败，该节点不存在！");
        } catch (Exception e) {
            e.printStackTrace();
        }


    }
（5）获取孩子节点
 @Test
    public void getChild() throws Exception {
        curatorFramework.getChildren().forPath("/ba").forEach((child) -> {
            System.out.println(child);
        });
    }
（6）删除节点
    @Test
    public void delNode() throws Exception {
        curatorFramework.delete().forPath("/ba/002");
    }

6.4 Watcher接口

1）原生API实现Watch接口

在这里使用的是原生的Apache的Java API

<!-- https://mvnrepository.com/artifact/org.apache.zookeeper/zookeeper -->
<dependency>
	<groupId>org.apache.zookeeper</groupId>
		<artifactId>zookeeper</artifactId>
	<version>3.4.6</version>
	<type>pom</type>
</dependency>

ZooKeeper Watcher监视使客户端能够接收来自ZooKeeper服务器的通知，并在发生时处理这些事件。 ZooKeeper Java API提供了一个名为Watcher的公共接口，客户端事件处理程序类必须实现该接口才能接收有关来自ZooKeeper服务器的事件通知。 以编程方式，使用这种客户端的应用程序通过向客户端注册回调(callback)对象来处理这些事件。

package test;

import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;

import java.io.IOException;
import java.util.UUID;

/**
 * Create by GuoJF on 2019/3/12
 */
public class DataUpdater  {

    private static String hostPort = "192.168.134.5:2181";
    private static String zooDataPath = "/ba/gjf";
    ZooKeeper zk;

    public DataUpdater() throws IOException {
        try {
            zk = new ZooKeeper(hostPort, 2000, null);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void run() throws InterruptedException, KeeperException {
        while (true) {
            String uuid = UUID.randomUUID().toString();
            byte zoo_data[] = uuid.getBytes();
            zk.setData(zooDataPath, zoo_data, -1);
            try {
                Thread.sleep(5000); // Sleep for 5 secs
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }

    public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
        DataUpdater dataUpdater = new DataUpdater();
        dataUpdater.run();
    }
}

package test;


import org.apache.zookeeper.*;

/**
 * Create by GuoJF on 2019/3/13
 */
public class DataWatcher implements Watcher,Runnable {


    ZooKeeper zooKeeper;

    public DataWatcher() {

        try {
              zooKeeper = new ZooKeeper("192.168.134.5:2181",2000,this);

              if (zooKeeper.exists("/ba/gjf",this)==null) {

                  zooKeeper.create("/ba/gjf", "get".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);

              }

        }catch (Exception e){
            e.printStackTrace();
        }

    }

    public static void main(String[] args) {

        DataWatcher dataWatcher = new DataWatcher();

        dataWatcher.run();

    }


    @Override
    public void process(WatchedEvent event) {

        if (event.getType() == Event.EventType.NodeDataChanged){
            System.out.println("数据发改变了吧");

            try {
                byte[] data = zooKeeper.getData("/ba/gjf", this, null);

                String s = new String(data);

                System.out.println(s);

            }catch (Exception e){

            }

        }

    }

    public void run() {
        try {
            synchronized (this) {
                while (true) {
                    wait();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
            Thread.currentThread().interrupt();
        }
    }
}

2）ZkClient实现Watcher接口

@Test
    public void watcherInterface() throws Exception {
        zkClient.subscribeDataChanges("/ba/gjf", new IZkDataListener() {
            @Override
            public void handleDataChange(String dataPath, Object data) throws Exception {
                System.out.println("节点名称：" + dataPath);
                System.out.println("节点名称：" + data.toString());

            }

            @Override
            public void handleDataDeleted(String dataPath) throws Exception {

            }
        });


        Thread.sleep(Integer.MAX_VALUE);
    }

3）Curator API实现Watcher接口

ZooKeeper原生的API支持通过注册Watcher来进行事件监听，但是Watcher通知是一次性的，因此开发过程中需要反复注册Watcher，比较繁琐。Curator引入了Cache来监听ZooKeeper服务端的事件。Cache对ZooKeeper事件监听进行了封装，能够自动处理反复注册监听，简化了ZooKeeper原生API繁琐的开发过程。

   		 <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-recipes</artifactId>
            <version>2.7.1</version>
        </dependency>
（1）NodeCache

​ 监听指定的数据变化

        /*
         *NodeCache
         *
         * */

        //在注册监听器的时候，如果传入此参数，当事件触发时，逻辑由线程池处理
        ExecutorService pool = Executors.newFixedThreadPool(2);

        NodeCache nodeCache = new NodeCache(curatorFramework, "/ba/gjf", false);

        nodeCache.start(true);

        nodeCache.getListenable().addListener(new NodeCacheListener() {
            @Override
            public void nodeChanged() throws Exception {
                System.out.println(new String(nodeCache.getCurrentData().getData()));
            }
        }, pool);
（2）PathChildrenCache

​ 监听指定节点下所有子节点的数据变化

        /**
         * 监听子节点的变化情况
         */
        PathChildrenCache childrenCache = new PathChildrenCache(curatorFramework, "/ba", true);
        childrenCache.start(PathChildrenCache.StartMode.POST_INITIALIZED_EVENT);
        childrenCache.getListenable().addListener(
                new PathChildrenCacheListener() {
                    @Override
                    public void childEvent(CuratorFramework client, PathChildrenCacheEvent event)
                            throws Exception {
                        switch (event.getType()) {
                            case CHILD_ADDED:
                                System.out.println("CHILD_ADDED: " + event.getData().getPath());
                                break;
                            case CHILD_REMOVED:
                                System.out.println("CHILD_REMOVED: " + event.getData().getPath());
                                break;
                            case CHILD_UPDATED:
                                System.out.println("CHILD_UPDATED: " + event.getData().getPath());
                                break;
                            default:
                                break;
                        }
                    }
                },
                pool
        );
人间小鲸鱼
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Zookeeper API操作
思变的博客
12-04 1309
pom引入： <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>RELEASE</version> </dependency> <depen
ZookeeperAPI操作
互联网知识分享
07-19 228
在这段代码中，我们首先创建了一个新的多操作。然后，我们添加了几个操作到这个多操作中，包括检查一个节点的版本、创建一个新的节点，和设置一个节点的数据。这个装饰器接受一个节点的路径作为参数，然后返回一个新的装饰器，我们可以使用这个装饰器来装饰我们的回调函数。每当节点的数据发生变化时，Zookeeper就会调用我们的回调函数，并传入新的数据和节点的状态。需要注意的是，Zookeeper的所有操作都是原子的，如果操作失败，那么不会有部分效果。在这段代码中，我们调用了set()方法，并传入了节点的路径和新的值。
ZooKeeper API操作
用心做事
02-05 1177
ZooKeeper集群中，客户端可以对ZooKeeper的命名空间写入数据，对数据进行各种操作。ZooKeeper API 接口如下表所示：操作接口名称 描述 create 创建指定的ZooKeeper命名空间（PATH）数据。 delete 创建指定的ZooKeeper命名空间（PATH）数据。 exists 检测节点是否存在 getChildren 获取节点孩子列表 g
zookeeper JavaAPI操作
weixin_45794641的博客
06-17 679
使用java对zookeeper进行操作，使用curator框架而不是原生的java API
ZooKeeper JavaAPI 操作
于小浩的博客
05-27 1117
ZooKeeper JavaAPI 操作
Zookeeper——客户端API的相关方法操作
★★光亭★★
05-08 5304
Zookeeper——客户端API的相关方法操作
Zookeeper集群及基础API
长沙老码农
02-18 1278
目录 1、Zookeeper简介 2、Zookeeper概念 2.1 重要概念 2.2 Session会话（心跳检测） 2.3 ZNode数据节点 2.4 ZNode数据版本 2.5 Watcher-事件监听器 2.6 ACL策略 3、Zookeeper集群安装配置 3.1 准备工作 3.2 下载解压 3.3 修改配置 3.4 启动测试 4、Zookeeper客户端操作命令 5、Zookeeper API操作 5.1 引入POM依赖坐标 5.2 创建Seesion会话.
Zookeeper JavaAPI操作
qq_54591711的博客
07-24 577
使用Curotar进行Zookeeper的javaAPI操作
ZooKeeper学习(三)ZooKeeper API操作
秘密的博客
11-24 3489
这里写目录标题API准备工作创建maven项目配置pom文件创建配置文件API操作测试zookeeper能否连接 API准备工作 创建maven项目 点击新建项目 随便写就行 配置pom文件 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-insta
ZooKeeper API 异步操作教学
06-20
ZooKeeper API 是 Apache ZooKeeper 的一套应用程序接口，它允许开发者在其应用程序中使用 ZooKeeper 集群提供的服务。ZooKeeper 是一个开源的分布式协调服务，常用于分布式应用程序中，用于解决共识、同步、组管理...
zookeeper C API中文文档
12-19
Zookeeper C API 中文文档 Zookeeper C API 是 Zookeeper 的一个 C 语言实现，提供了一个简洁的 API，让开发者可以轻松地使用 Zookeeper 的功能。本文档将详细介绍 Zookeeper C API 的使用方法和相关知识点。 ...
Zookeeper 原生api zkClient Curator操作
09-30
在Java开发中，我们通常使用三种方式来操作Zookeeper：原生API、zkClient和Curator。接下来，我们将详细探讨这三种方式。 **一、Zookeeper原生API** Zookeeper提供了Java API，可以直接与Zookeeper服务器进行交互...
zookeeper JAVA API.docx
06-01
总之，Apache ZooKeeper的Java API为开发者提供了丰富的操作接口，用于创建、管理、读取和修改Zookeeper中的数据，以及监控节点的变化。正确理解和使用这些API是构建分布式协调服务的关键。在实际应用中，还需要考虑...
zookeeper编程api
03-20
Zookeeper API提供了同步和异步两种操作方式。同步操作会阻塞直到操作完成，异步操作则立即返回，结果通过回调函数通知。 9. **一致性与序列化**： Zookeeper保证了强一致性模型，所有客户端看到的数据状态都是...
Flume系列之：把flume配置写入到zookeeper节点
zhengzaifeidelushang的博客
08-03 23
【代码】Flume系列之：把flume配置写入到zookeeper节点。
J031_使用TCP协议支持与多个客户端同时通信
最新发布
lzn20161229的博客
08-03 175
使用TCP协议支持与多个客户端同时通信。
SpringBoot+Vue图书(图书借阅)管理系统-附项目源码与配套文档
m0_74283290的博客
08-03 517
本论文阐述了一套先进的图书管理系统的设计与实现，该系统采用Java语言，结合现代Web开发框架和技术，旨在为图书馆提供高效、灵活且用户友好的资源管理解决方案。系统利用Spring Boot框架为核心，整合MyBatis ORM工具，以及MySQL数据库，构建了一个高性能、可扩展的后端服务。前端界面则采用了Vue.js框架，以提供流畅的用户交互体验。论文首先进行了详尽的需求分析，确定了系统的核心功能，包括图书的添加、编辑、删除、查询，读者的注册、登录、个人信息管理，以及图书的借阅、归还、续借流程。
社区养老服务小程序的设计
Karen198的博客
07-31 517
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
zookeeper的java api操作
03-16
Zookeeper的Java API操作是通过Java编程语言来实现对Zookeeper的访问和操作。它提供了一组丰富的API，可以用于创建、读取、更新和删除Zookeeper节点，以及监视节点的变化和事件的触发。通过Zookeeper的Java API，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值