Zookeeper（传统客户端，zkClient，Curator）三种客户端连接操作

最新推荐文章于 2024-04-26 17:01:33 发布
最新推荐文章于 2024-04-26 17:01:33 发布
阅读量1.3k 收藏 1
点赞数
分类专栏： # Zookeeper+Dubbo
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baiyan3212/article/details/88958026
版权

Zookeeper传统客户端

新建maven工程

加入依赖

<dependencies>
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.8</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.8.2</version>
        </dependency>
    </dependencies>

1. 创建会话

2. 创建节点

3. 读取数据

4. 更新数据

5. 检测节点是否存在

  public Stat / void exists(final String path, Watcher watcher, StatCallback cb, Object ctx)

6.  watch监听

  org.apache.zookeeper.Watcher（KeeperState、EventType）

（1）没有专门的API去注册watcher，依附于增删改查API;

  (2) watch是一次性产品

  (3) watch的process方法中，可对不同事件进行处理；

 

/**
 * 创建连接
 */
public class CreateSession {
	
	private final static String CONNECTIONSTR="192.168.25.200:2181";
	private static CountDownLatch countDownLatch= new CountDownLatch(1);
	public static void main(String[] args) throws Exception {
		//创建zk 连接地址，超时时间，监听
		ZooKeeper zooKeeper = new ZooKeeper(CONNECTIONSTR,5000,new Watcher() {
			public void process(WatchedEvent watchedEvent) {
				//如果已经连接了才继续执行创建等其他操作
				if(watchedEvent.getState()==Event.KeeperState.SyncConnected){
					countDownLatch.countDown();
					if(watchedEvent.getType() == EventType.NodeDataChanged){
						//如果节点发生了变化
						System.out.println("节点发生了变化,路径："+watchedEvent.getPath());
					}
				}
			}
		});
		//确定连接再操作	阻塞
		countDownLatch.await();
		System.out.println(zooKeeper.getState());
		//创建节点，节点路径，节点值，ACL权限，节点类型（持久or临时）
//		zooKeeper.create("/testnode1","xuxu".getBytes(),
//				ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
		
		//获取节点数据	watch=true  stat是状态信息
		Stat stat = new Stat();
		byte[] data = zooKeeper.getData("/testnode1", true, stat);
		System.out.println(new String(data));
		
		//修改数据 (这里的-1代表不进行版本控制)
		zooKeeper.setData("/testnode1", "xuxuupdate1".getBytes(),-1);
//		byte[] dataUpdate = zooKeeper.getData("/testnode1", true, stat);
//		System.out.println(new String(dataUpdate));
		
		//删除节点
//		zooKeeper.delete("/testnode1", -1);
		
		//获取节点下所有子节点
//		List<String> children = zooKeeper.getChildren("/testnode1", true);
//		System.out.println(children);
	}
}

Zookeeper原生客户端在开发支持上的弊端

1. 会话的连接是异步的 如果创建了连接需要监听连接上之后才能进行后续操作； ·

2. Watch需要重复注册 watch是一次性的，比如修改后，如果不使用byte[] data = zooKeeper.getData("/testnode1", true, stat)无法监听到节点是否变化；· 

3. Session重连机制；

4. 开发复杂性较高 比如要实现递归创建节点，或者级联删除就很麻烦；

zkClient

pom文件

<dependencies>
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.8</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.8.2</version>
        </dependency>
        <dependency>
			<groupId>com.101tec</groupId>
			<artifactId>zkclient</artifactId>
			<version>0.10</version>
		</dependency>
    </dependencies>

1. 创建会话（同步，重试）

public ZkClient(final String zkServers, final int sessionTimeout,

                final int connectionTimeout, final ZkSerializer zkSerializer,

                final long operationRetryTimeout)

2. 创建节点（同步，递归创建）

public String create(String path,Object data,final List<ACL> acl,CreateMode mode)

public void createPersistent(String path,boolean createParents,List<ACL> acl)

public void createPersistent(String path, Object data, List<ACL> acl)

public String createPersistentSequential(String path,Object data,List<ACL> acl)

public void createEphemeral(String path, Object data, List<ACL> acl)

public String createEphemeralSequential(String path,Object data,List<ACL> acl)

3. 删除节点（同步,递归删除）

public boolean delete(String path,int version)

public boolean deleteRecursive(String path)

4.获取节点（同步，避免不存在异常）

public List<String> getChildren(String path)

public <T> T readData(String path, boolean returnNullIfPathNotExists)

public <T> T readData(String path, Stat stat)

5. 更新节点（同步，实现CAS,状态返回）

public void writeData(String path, Object datat, int expectedVersion)

public Stat writeDataReturnStat(String path,Object datat,int expectedVersion)

6. 检测节点存在（同步）

public boolean exists(String path)

7.权限控制（同步）

public void addAuthInfo(String scheme, final byte[] auth);

public void setAcl(final String path, final List<ACL> acl);

8. 监听器

package com.xuxu;

import java.util.concurrent.TimeUnit;
import org.I0Itec.zkclient.IZkDataListener;
import org.I0Itec.zkclient.ZkClient;

/**
 * 使用zkClient
 */
public class ZkClientTest {
	private final static String CONNECTIONSTR="192.168.25.200:2181";
	public static void main(String[] args) {
		//zk服务器地址，超时时间
		ZkClient client = new ZkClient(CONNECTIONSTR,5000);
		System.out.println(client+"--success");
		
		//创建节点 路径，数据，数据类型（持久化节点）
//		client.create("/zknodetest2", "111",CreateMode.PERSISTENT);
		
		//持续递归创建节点	boolean createParents:true 是否创建父节点
//		client.createPersistent("/zknodetest3/test1/test2", true);
		
		//获取单个节点
//		String data =client.readData("/zknodetest2");
//		System.out.println(data);
		
		//获取所有子节点
//		List<String> children = client.getChildren("/zknodetest3");
//		System.out.println(children);
		
		//删除单个子节点
//		boolean delete = client.delete("/zknodetest2");
//		System.out.println(delete);
		
		//递归删除子节点
//		boolean deleteRecursive = client.deleteRecursive("/zknodetest3");
//		System.out.println(deleteRecursive);
		
		//监听(订阅数据改变)相比于原始客户端连接 监听可以复用
		client.subscribeDataChanges("/test00", new IZkDataListener() {

			@Override
			public void handleDataChange(String dataPath, Object data) throws Exception {
				System.out.println("节点名称："+dataPath+"->节点修改后的值"+data);	
			}

			@Override
			public void handleDataDeleted(String dataPath) throws Exception {
			}
		});
		try {
			//修改 可以被上面监听到
			client.writeData("/test00","xuxu");
			//如果不休眠一秒 存在延迟 看不到效果	节点名称：/test00->节点修改后的值xuxu
			TimeUnit.SECONDS.sleep(1);
			client.writeData("/test00","xuxu1");
			//节点名称：/test00->节点修改后的值xuxu1
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
//		client.subscribeChildChanges("/test00",new IZkChildListener() {
//			@Override
//			public void handleChildChange(String parentPath, List<String> currentChilds) throws Exception {
//				System.out.println("节点名称："+parentPath+"->"+"当前的节点列表："+currentChilds);
//			}
//		});
//		client.delete("/zknodetest3/test1");;
	}
}

Curator

pom文件中添加

        <!-- curator依赖 -->
		<dependency>
		    <groupId>org.apache.curator</groupId>
		    <artifactId>curator-framework</artifactId>
		    <version>4.0.0</version>
		</dependency>

连接方式

package curator;

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


public class CuratorCreateSessionDemo {
    private final static String CONNECTSTRING="192.168.25.200:2181";
    public static void main(String[] args) {
        //创建会话的两种方式 normal
//        CuratorFramework curatorFramework= CuratorFrameworkFactory.
//                newClient(CONNECTSTRING,5000,5000,
//                        new ExponentialBackoffRetry(1000,3));
//        curatorFramework.start(); //start方法启动连接

//        //fluent链式风格	ExponentialBackoffRetry(1000,3)失败重连3次
        CuratorFramework curatorFramework1=CuratorFrameworkFactory.builder().connectString(CONNECTSTRING).sessionTimeoutMs(5000).
                retryPolicy(new ExponentialBackoffRetry(1000,3)).
                build();

        curatorFramework1.start();
        System.out.println("success");
    }
}

获取会话工具类

package curator;

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


public class CuratorClientUtils {

    private static CuratorFramework curatorFramework;
    private final static String CONNECTSTRING="192.168.25.200:2181";


    public static CuratorFramework getInstance(){
        curatorFramework= CuratorFrameworkFactory.
                newClient(CONNECTSTRING,5000,5000,
                        new ExponentialBackoffRetry(1000,3));
        curatorFramework.start();
        return curatorFramework;
    }
}

操作类

package curator;

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.api.BackgroundCallback;
import org.apache.curator.framework.api.CuratorEvent;
import org.apache.curator.framework.api.transaction.CuratorTransactionResult;
import org.apache.curator.retry.ExponentialBackoffRetry;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.data.Stat;

import java.util.Collection;
import java.util.Collections;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


public class CuratorOperatorDemo {

    public static void main(String[] args) throws InterruptedException {
        CuratorFramework curatorFramework=CuratorClientUtils.getInstance();
        System.out.println("连接成功.........");

        //fluent风格 创建节点
//        try {
//            String result=curatorFramework.create().creatingParentsIfNeeded().withMode(CreateMode.PERSISTENT).
//                    forPath("/curator/curator1/curator11","123".getBytes());
//
//            System.out.println(result);
//            //结果输出：
//            //  /curator/curator1/curator11
//            //  /demo1->CREATE
//            //  /demo1->SET_DATA
//        } catch (Exception e) {
//            e.printStackTrace();
//        }

        /**
         * 删除节点
         */
//        try {
//            //默认情况下，version为-1
//            curatorFramework.delete().deletingChildrenIfNeeded().forPath("/curator");
//
//        } catch (Exception e) {
//            e.printStackTrace();
//        }

        /**
         * 查询
         */
//        Stat stat=new Stat();
//        try {
//            byte[] bytes=curatorFramework.getData().storingStatIn(stat).forPath("/node11");
//            System.out.println(new String(bytes)+"-->stat:"+stat);
//        } catch (Exception e) {
//            e.printStackTrace();
//        }

        /**
         * 更新
         */

//        try {
//            Stat stat=curatorFramework.setData().forPath("/node11","123".getBytes());
//            System.out.println(stat);
//        } catch (Exception e) {
//            e.printStackTrace();
//        }


        /**
         * 异步操作
         */
//        ExecutorService service= Executors.newFixedThreadPool(1);
//        CountDownLatch countDownLatch=new CountDownLatch(1);
//        try {
//            curatorFramework.create().creatingParentsIfNeeded().withMode(CreateMode.EPHEMERAL).
//                    inBackground(new BackgroundCallback() {
//                        @Override
//                        public void processResult(CuratorFramework curatorFramework, CuratorEvent curatorEvent) throws Exception {
//                            System.out.println(Thread.currentThread().getName()+"->resultCode:"+curatorEvent.getResultCode()+"->"
//                            +curatorEvent.getType());
//                            countDownLatch.countDown();
//                        }
//                    },service).forPath("/enjoy","deer".getBytes());
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//        countDownLatch.await();
//        service.shutdown();

        /**
         * 事务操作（curator独有的）
         */

//        try {
//            Collection<CuratorTransactionResult> resultCollections=curatorFramework.inTransaction().create().forPath("/demo1","111".getBytes()).and().
//                    setData().forPath("/demo1","111".getBytes()).and().commit();
//            for (CuratorTransactionResult result:resultCollections){
//                System.out.println(result.getForPath()+"->"+result.getType());
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
    }
}

 

 

 

踟蹰千年
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Dubbo源码分析之CuratorZookeeperClient与CuratorZookeeperTransporter
qq_33513250的博客
11-01 3652
一、概述 Dubbo使用Zookeeper作为service注册中心时，provider发布是在zookeeper服务器上创建/dubbo父节点，然后再在上面创建以url为路径的子节点，Customer获取子节点路径进行解析，建立Netty连接，调用服务，获取结果。Dubbo默认使用开源的Curator作为zookeeper的客户端，并进行了基本的API封装,下面我们来分析CuratorZook...
Apache curator-client详解
weixin_34217773的博客
12-12 351
 Apache curator框架中curator-client组件可以作为zookeeper client来使用,它提供了zk实例创建/重连机制等,简单便捷.不过直接使用curator-client并不能减少太多的开发量,因为它相对比较底层,稍后我们继续了解curator-framework组件提供的更多的便捷特性.   一.核心API     1. CuratorZookeeperClient...
Zookeeper整合JAVA应用之Curator开源客户端使用案例
yaya_jn的博客
05-17 829
Curator是Netflix公司开源的一套ZooKeeper客户端框架，和ZkClient一样它解决了非常底层的细节开发工作，包括连接、重连、反复注册Watcher的问题以及NodeExistsException异常等。 Curator是Apache基金会的顶级项目之一，Curator具有更加完善的文档，另外还提供了一套易用性和可读性更强的Fluent风格的客户端API框架。 Curator还为ZooKeeper客户端框架提供了一些比较普遍的、开箱即用的、分布式开发用的解决方案，例如Recipe、共享
客户端连接ZK失败处理方案
最新发布
梦幻通灵
04-26 767
zookeeper连接异常处理
zookeeper的客户端介绍：zkclient和curator的基本使用
qq_41358574的博客
05-17 1169
zkclientcurator二者的基本使用使用zkclient:使用Curator单结点操作使用curator集群操作 zkclient ZkClient是一个开源客户端，在ZooKeeper原生API接口的基础上进行了包装，更便于开发人员使用。ZkClient客户端在一些著名的互联网开源项目中得到了应用，例如，阿里的分布式Dubbo框架对它进行了无缝集成。 ZkClient解决了ZooKeeper原生API接口的很多问题。例如，ZkClient提供了更加简洁的API，实现了会话超时重连、反复注册Wat.
Zookeeper客户端ZkClient、Curator的使用，史上最详细的教程来啦~
zhaoshuangjian
03-08 3765
Zookeeper客户端ZkClient、Curator的使用，史上最详细的教程来啦~
Zookeeper 原生api zkClient Curator操作
09-30
ZkClient是一个轻量级的Zookeeper客户端，它对原生API进行了封装，使得操作更加简单易用。主要特点包括： 1. **更友好的API**：ZkClient提供了一些简洁的接口，如`createEphemeral()`、`readData()`、`writeData()`...
zookeeper两种客户端demo
12-14
《Zookeeper两种客户端实战解析》 Zookeeper，作为分布式协调...以上就是关于Zookeeper的ZkClient和Curator客户端的介绍，希望对初学者和进阶者都有所启发。通过实践，相信你能更好地驾驭Zookeeper这个强大的工具。
4、zookeeper的java三种客户端介绍-Curator（crud、事务操作、监听、分布式计数器、分布式锁）
05-29
这篇文章主要介绍了Zookeeper的三种Java客户端：原生Java API、ZkClient以及Apache Curator，并着重讨论了Curator的特性与优势。 一、Zookeeper原生Java API Zookeeper的原生Java API提供了基本的CRUD（创建、读取...
zookeeper_demo maven项目：包含原生API、zkclient、Curator操作
11-10
在本项目`zookeeper_demo`中，我们将深入探讨Zookeeper的三种主要客户端库——原生API、ZkClient和Curator的操作方式，以及它们在集群配置和分布式锁等实际场景中的应用。 1. **Zookeeper原生API** Zookeeper原生...
zookeeper Java api - curator 5.6.0
02-04
CuratorFramework 是 Curator 的核心，它封装了 ZooKeeper 连接的创建、会话管理以及操作执行等。 3. **连接管理**：使用 `CuratorFrameworkFactory` 工厂类，你可以创建一个 ZooKeeper 客户端实例。例如： ```...
Zookeeper分布式一致性原理（七）：Curator客户端
Master-TJ的个人博客
01-18 723
1. Curator简介 Curator是Netfix公司开源的一套Zookeeper客户端。Curator解决了很多Zookeeper客户端非常底层的细节开发工作，包括重连、反复注册Watcher和NodeExistsException异常等。目前已经成为Apache的顶级项目，是全世界范围内使用最广泛的Zookeeper客户端 Curator Maven依赖 &lt;!-- https:/...
zookeeper客户端框架Curator
LINBE_blazers的博客
09-08 244
Curator是Netflix公司开源的一套zookeeper客户端框架，解决了很多Zookeeper客户端非常底层的细节开发工作，包括连接重连、反复注册Watcher和NodeExistsException异常等等。 Zookeeper的节点创建模式： PERSISTENT：持久化 PERSISTENT_SEQUENTIAL：持久化并且带序列号 EPHEMERAL：临...
Zookeeper Curator使用指南
迩熙
03-11 559
CuratorFramework是一个Apache ZooKeeper的客户端的jar包，它提供一些高层次的API框架来简化ZooKeeper的使用，并且使代码更加可高。使用CuratorFramework获取连接    CuratorFramework对ZooKeeper进行封装，并赋予其连接管理和重试策略。通常情况下，Zookeeper连接会有一些异常情况，这要求ZooKeeper客户端需要去...
Zookeeper客户端Curator详解
Charge8的博客
05-23 2950
Zookeeper客户端Curator详解
Zookeeper系列 (三） [单机版连接客户端]
11-19 1156
进入zookeeper的 bin目录 运行脚本:Ctrl + C 就可以停止下来 拒绝连接的原因是zookeeper还没有启动启动命令:然后再使用连接。
Zookeeper_Zookeeper客户端连接(含集群方式)
迎难而上
06-27 8262
zookeeper 连接地址，zookeeper 的连接方式多种多样，这里展示3种连接方式 1.命令行连接 2.jar程序连接 3.IDE 插件 一、zkCli.sh / zookeeper-client 连接方式 命令行连接 zookeeper-client -server cdh-manager:2181,cdh-node1:2181,cdh-node2:2181 连接后的信息 [root@cdh-manager /]# zookeeper-client -serve...
Zkclient操作zookeeper案例
爆裂无球的程序空间
03-24 861
Zkclient操作zookeeper 每天多学一点点~ 话不多说，这就开始吧… 文章目录Zkclient操作zookeeper1.Zookeeper的Java客户端API2.代码2.1. pom依赖2.2. zkCilent的序列化2.3 zkCilent的curd2.4 zkCilent的监听3.结语 1.Zookeeper的Java客户端API 有三种方式 原生 （1）Zookeeper...
ZooKeeper（四）-- 第三方客户端 ZkClient的使用
u010821757的博客
06-04 479
前言zkClient主要做了两件事情:一件是在session loss和session expire时自动创建新的ZooKeeper实例进行重连。另一件是将一次性watcher包装为持久...
ZooKeeper Java客户端实战：官方API与Curator
内容涵盖Zookeeper官方API的局限性，以及第三方客户端如Curator的优势。此外，还探讨了Zookeeper的Watcher机制和会话超时问题，以及客户端在异常处理和数据序列化方面的不足。" Zookeeper作为一个分布式协调框架，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值