apache curetor zookeeper 工具类

最新推荐文章于 2024-09-23 15:09:53 发布
最新推荐文章于 2024-09-23 15:09:53 发布
阅读量7.9w 收藏 2
点赞数
文章标签： zookeeper apache curator 
package com.cloud.serviceclient.curator;

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.recipes.cache.ChildData;
import org.apache.curator.framework.recipes.cache.NodeCache;
import org.apache.curator.framework.recipes.cache.PathChildrenCache;
import org.apache.curator.framework.recipes.cache.PathChildrenCacheListener;
import org.apache.curator.framework.recipes.cache.TreeCache;
import org.apache.curator.framework.recipes.cache.TreeCacheListener;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.data.Stat;

import java.text.MessageFormat;
import java.util.List;

/**
 * Apache Curator的基本操作
 *
 */
public class ZookeeperService {
    private static Logger logger = LogManager.getLogger(ZookeeperService.class);

    //创建连接实例
    private CuratorFramework client = null;

    public ZookeeperService(CuratorFramework client) {
        this.client = client;
        //启动
        client.start();
    }

    /**
     * 创建永久Zookeeper节点
     * @author han
     *  2018/8/1 14:31
     * @since 1.0.0
     * @param nodePath 节点路径（如果父节点不存在则会自动创建父节点），如：/curator
     * @param nodeValue 节点数据
     * @return java.lang.String 返回创建成功的节点路径
     */
    public String createPersistentNode(String nodePath, String nodeValue){
        try {
            return client.create().creatingParentsIfNeeded()
                    .forPath(nodePath,nodeValue.getBytes());
        } catch (Exception e) {
            logger.error(MessageFormat.format("创建永久Zookeeper节点失败,nodePath:{0},nodeValue:{1}",nodePath,nodeValue),e);
        }
        return null;
    }

    /**
     * 创建永久有序Zookeeper节点
     * @author han
     *  2018/8/1 14:31
     * @since 1.0.0
     * @param nodePath 节点路径（如果父节点不存在则会自动创建父节点），如：/curator
     * @param nodeValue 节点数据
     * @return java.lang.String 返回创建成功的节点路径
     */
    public String createSequentialPersistentNode(String nodePath, String nodeValue){
        try {
            return client.create().creatingParentsIfNeeded()
                    .withMode(CreateMode.PERSISTENT_SEQUENTIAL)
                    .forPath(nodePath,nodeValue.getBytes());
        } catch (Exception e) {
            logger.error(MessageFormat.format("创建永久有序Zookeeper节点失败,nodePath:{0},nodeValue:{1}",nodePath,nodeValue),e);
        }
        return null;
    }

    /**
     * 创建临时Zookeeper节点
     * @author han
     *  2018/8/1 14:31
     * @since 1.0.0
     * @param nodePath 节点路径（如果父节点不存在则会自动创建父节点），如：/curator
     * @param nodeValue 节点数据
     * @return java.lang.String 返回创建成功的节点路径
     */
    public String createEphemeralNode(String nodePath, String nodeValue){
        try {
            return client.create().creatingParentsIfNeeded()
                    .withMode(CreateMode.EPHEMERAL)
                    .forPath(nodePath,nodeValue.getBytes());
        } catch (Exception e) {
            logger.error(MessageFormat.format("创建临时Zookeeper节点失败,nodePath:{0},nodeValue:{1}",nodePath,nodeValue),e);
        }
        return null;
    }

    /**
     * 创建临时有序Zookeeper节点
     * @author han
     *  2018/8/1 14:31
     * @since 1.0.0
     * @param nodePath 节点路径（如果父节点不存在则会自动创建父节点），如：/curator
     * @param nodeValue 节点数据
     * @return java.lang.String 返回创建成功的节点路径
     */
    public String createSequentialEphemeralNode(String nodePath, String nodeValue){
        try {
            return client.create().creatingParentsIfNeeded()
                    .withMode(CreateMode.EPHEMERAL_SEQUENTIAL)
                    .forPath(nodePath,nodeValue.getBytes());
        } catch (Exception e) {
            logger.error(MessageFormat.format("创建临时有序Zookeeper节点失败,nodePath:{0},nodeValue:{1}",nodePath,nodeValue),e);
        }
        return null;
    }

    /**
     * 检查Zookeeper节点是否存在
     * @author han
     *  2018/8/1 17:06
     * @since 1.0.0
     * @param nodePath 节点路径
     * @return boolean 如果存在则返回true
     */
    public boolean checkExists(String nodePath){
        try {
            Stat stat = client.checkExists().forPath(nodePath);

            return stat != null;
        } catch (Exception e) {
            logger.error(MessageFormat.format("检查Zookeeper节点是否存在出现异常,nodePath:{0}",nodePath),e);
        }
        return false;
    }

    /**
     * 获取某个Zookeeper节点的所有子节点
     * @author han
     *  2018/8/1 17:06
     * @since 1.0.0
     * @param nodePath 节点路径
     * @return java.util.List<java.lang.String> 返回所有子节点的节点名
     */
    public List<String> getChildren(String nodePath){
        try {
            return client.getChildren().forPath(nodePath);
        } catch (Exception e) {
            logger.error(MessageFormat.format("获取某个Zookeeper节点的所有子节点出现异常,nodePath:{0}",nodePath),e);
        }
        return null;
    }

    /**
     * 获取某个Zookeeper节点的数据
     * @author han
     *  2018/8/1 17:06
     * @since 1.0.0
     * @param nodePath 节点路径
     * @return java.lang.String
     */
    public String getData(String nodePath){
        try {
            return new String(client.getData().forPath(nodePath));
        } catch (Exception e) {
            logger.error(MessageFormat.format("获取某个Zookeeper节点的数据出现异常,nodePath:{0}",nodePath),e);
        }
        return null;
    }

    /**
     * 设置某个Zookeeper节点的数据
     * @author han
     *  2018/8/1 17:06
     * @since 1.0.0
     * @param nodePath 节点路径
     */
    public void setData(String nodePath, String newNodeValue){
        try {
            client.setData().forPath(nodePath, newNodeValue.getBytes());
        } catch (Exception e) {
            logger.error(MessageFormat.format("设置某个Zookeeper节点的数据出现异常,nodePath:{0}",nodePath),e);
        }
    }

    /**
     * 删除某个Zookeeper节点
     * @author han
     *  2018/8/1 17:06
     * @since 1.0.0
     * @param nodePath 节点路径
     */
    public void delete(String nodePath){
        try {
            client.delete().guaranteed().forPath(nodePath);
        } catch (Exception e) {
            logger.error(MessageFormat.format("删除某个Zookeeper节点出现异常,nodePath:{0}",nodePath),e);
        }
    }

    /**
     * 级联删除某个Zookeeper节点及其子节点
     * @author han
     *  2018/8/1 17:06
     * @since 1.0.0
     * @param nodePath 节点路径
     */
    public void deleteChildrenIfNeeded(String nodePath){
        try {
            client.delete().guaranteed().deletingChildrenIfNeeded().forPath(nodePath);
        } catch (Exception e) {
            logger.error(MessageFormat.format("级联删除某个Zookeeper节点及其子节点出现异常,nodePath:{0}",nodePath),e);
        }
    }

    /**
     * <p><b>注册节点监听器</b></p>
     * NodeCache: 对一个节点进行监听，监听事件包括指定路径的增删改操作
     * @author han
     *  2018/8/1 19:08
     * @since 1.0.0
     * @param nodePath 节点路径
     * @return void
     */
    public NodeCache registerNodeCacheListener(String nodePath){
        try {
            //1. 创建一个NodeCache
            NodeCache nodeCache = new NodeCache(client, nodePath);

            //2. 添加节点监听器
            nodeCache.getListenable().addListener(() -> {
                ChildData childData = nodeCache.getCurrentData();
                if(childData != null){
                    System.out.println("Path: " + childData.getPath());
                    System.out.println("Stat:" + childData.getStat());
                    System.out.println("Data: "+ new String(childData.getData()));
                }
            });

            //3. 启动监听器
            nodeCache.start();

            //4. 返回NodeCache
            return nodeCache;
        } catch (Exception e) {
            logger.error(MessageFormat.format("注册节点监听器出现异常,nodePath:{0}",nodePath),e);
        }
        return null;
    }

    /**
     * <p><b>注册子目录监听器</b></p>
     * PathChildrenCache：对指定路径节点的一级子目录监听，不对该节点的操作监听，对其子目录的增删改操作监听
     * @author han
     *  2018/8/2 10:01
     * @since 1.0.0
     * @param nodePath 节点路径
     * @param listener 监控事件的回调接口
     * @return org.apache.curator.framework.recipes.cache.PathChildrenCache
     */
    public PathChildrenCache registerPathChildListener(String nodePath, PathChildrenCacheListener listener){
        try {
            //1. 创建一个PathChildrenCache
            PathChildrenCache pathChildrenCache = new PathChildrenCache(client, nodePath, true);

            //2. 添加目录监听器
            pathChildrenCache.getListenable().addListener(listener);

            //3. 启动监听器
            pathChildrenCache.start(PathChildrenCache.StartMode.BUILD_INITIAL_CACHE);

            //4. 返回PathChildrenCache
            return pathChildrenCache;
        } catch (Exception e) {
            logger.error(MessageFormat.format("注册子目录监听器出现异常,nodePath:{0}",nodePath),e);
        }
        return null;
    }

    /**
     * <p><b>注册目录监听器</b></p>
     * TreeCache：综合NodeCache和PathChildrenCahce的特性，可以对整个目录进行监听，同时还可以设置监听深度
     * @author han
     *  2018/8/2 10:01
     * @since 1.0.0
     * @param nodePath 节点路径
     * @param maxDepth 自定义监控深度
     * @param listener 监控事件的回调接口
     * @return org.apache.curator.framework.recipes.cache.TreeCache
     */
    public TreeCache registerTreeCacheListener(String nodePath, int maxDepth, TreeCacheListener listener){
        try {
            //1. 创建一个TreeCache
            TreeCache treeCache = TreeCache.newBuilder(client, nodePath)
                    .setCacheData(true)
                    .setMaxDepth(maxDepth)
                    .build();

            //2. 添加目录监听器
            treeCache.getListenable().addListener(listener);

            //3. 启动监听器
            treeCache.start();

            //4. 返回TreeCache
            return treeCache;
        } catch (Exception e) {
            logger.error(MessageFormat.format("注册目录监听器出现异常,nodePath:{0},maxDepth:{1}",nodePath),e);
        }
        return null;
    }


}

package com.cloud.serviceclient.curator;

import org.apache.curator.framework.recipes.cache.ChildData;
import org.apache.curator.framework.recipes.cache.NodeCache;
import org.apache.curator.framework.recipes.cache.PathChildrenCache;
import org.apache.curator.framework.recipes.cache.TreeCache;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.List;

/**
 * 测试zookeeper的基本用法
 *
 * @author han
 * @since 1.0.0
 */
@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class TestCurator {

    @Autowired
    private ZookeeperService zookeeperService;

    /**
     * 测试创建节点
     */
    @Test
    public void testCreate(){
        System.out.println(zookeeperService.createPersistentNode("/curator/test_1","测试数据"));;
//        System.out.println(zookeeperService.createEphemeralNode("/curator/test_2","测试临时节点"));
//        System.out.println(zookeeperService.createSequentialEphemeralNode("/curator/test_3","测试临时节点"));

    }

    /**
     * 测试判断节点是否存在
     */
    @Test
    public void testCheckExists(){
        System.out.println(zookeeperService.checkExists("/curator/test_1"));
        System.out.println(zookeeperService.checkExists("/curator/test_xxxxx"));
    }

    /**
     * 测试获取某个Zookeeper节点的所有子节点
     */
    @Test
    public void testGetChildren(){
        List<String> list = zookeeperService.getChildren("/curator");
        list.forEach(System.out::println);
    }

    /**
     * 测试设置和获取值
     */
    @Test
    public void testSetAndGet(){
        //重新赋值
        zookeeperService.setData("/curator/test_1","新的测试数据");
        //获取值
        System.out.println(zookeeperService.getData("/curator/test_1"));
    }

    /**
     * 测试普通删除和级联删除
     */
    @Test
    public void testDelete(){
        zookeeperService.delete("/curator/test_1");
        //遍历
        testGetChildren();

        zookeeperService.deleteChildrenIfNeeded("/curator");
        //再次遍历
        testGetChildren();
    }

    /**
     * 测试节点监听器
     */
    @Test
    public void testNodeCacheListener() throws Exception {
        NodeCache nodeCache = zookeeperService.registerNodeCacheListener("/curator/test_nodeCache");

        //节点不存在，set（不触发监听）
        zookeeperService.setData("/curator/test_nodeCache","nodeCache_value_1");
        //节点不存在，create（触发监听）
        zookeeperService.createPersistentNode("/curator/test_nodeCache","nodeCache_value_2");
        //节点存在，set（触发监听）
        zookeeperService.setData("/curator/test_nodeCache","nodeCache_value_3");
        //节点存在，delete（触发监听）
        zookeeperService.delete("/curator/test_nodeCache");

        Thread.sleep(20000);

        //关闭NodeCache
        nodeCache.close();
    }

    /**
     * 测试子目录监听器
     */
    @Test
    public void testPathChildListener() throws Exception {
        PathChildrenCache pathChildrenCache = zookeeperService.registerPathChildListener("/curator", (client, event) -> {
            ChildData childData = event.getData();

            if(childData != null){
                System.out.println("Path: " + childData.getPath());
                System.out.println("Stat:" + childData.getStat());
                System.out.println("Data: "+ new String(childData.getData()));
            }

            switch (event.getType()){
                case CHILD_ADDED:
                    System.out.println("正在新增子节点：" + childData.getPath());
                    //获取子节点
                    List<String> list = zookeeperService.getChildren("/curator");
                    list.forEach(System.out::println);

                    break;
                case CHILD_UPDATED:
                    System.out.println("正在更新子节点："  + childData.getPath());
                    break;
                case CHILD_REMOVED:
                    System.out.println("子节点被删除");
                    break;
                case CONNECTION_LOST:
                    System.out.println("连接丢失");
                    break;
                case CONNECTION_SUSPENDED:
                    System.out.println("连接被挂起");
                    break;
                case CONNECTION_RECONNECTED:
                    System.out.println("恢复连接");
                    break;
            }

        });

        //子节点不存在，set（不触发监听）
        zookeeperService.setData("/curator/test_pathChildrenCache","pathChildrenCache_value_1");
        //子节点不存在，create（触发监听）
        zookeeperService.createPersistentNode("/curator/test_pathChildrenCache","pathChildrenCache_value_2");
        Thread.sleep(2000);

        //子节点存在，set（触发监听）
        zookeeperService.setData("/curator/test_pathChildrenCache","pathChildrenCache_value_3");
        //子节点存在，create子节点的子节点（不触发监听）
        zookeeperService.createPersistentNode("/curator/test_pathChildrenCache/aaaa","child_value_4");
        //子节点存在，delete（触发监听）
        zookeeperService.deleteChildrenIfNeeded("/curator/test_pathChildrenCache");

        Thread.sleep(20000);

        //关闭PathChildrenCache
        pathChildrenCache.close();
    }

    /**
     * 测试目录监听器
     */
    @Test
    public void testTreeCacheListener() throws Exception {
        TreeCache treeCache = zookeeperService.registerTreeCacheListener("/curator", 2, (client, event) -> {
            ChildData childData = event.getData();

            if(childData != null){
                System.out.println("Path: " + childData.getPath());
                System.out.println("Stat:" + childData.getStat());
                System.out.println("Data: "+ new String(childData.getData()));
            }

            switch (event.getType()){
                case NODE_ADDED:
                    System.out.println("正在新增子节点：" + childData.getPath());
                    //获取子节点
                    List<String> list = zookeeperService.getChildren("/curator");
                    list.forEach(System.out::println);

                    break;
                case NODE_UPDATED:
                    System.out.println("正在更新节点："  + childData.getPath());
                    break;
                case NODE_REMOVED:
                    System.out.println("节点被删除：" + childData.getPath());
                    break;
                case CONNECTION_LOST:
                    System.out.println("连接丢失");
                    break;
                case CONNECTION_SUSPENDED:
                    System.out.println("连接被挂起");
                    break;
                case CONNECTION_RECONNECTED:
                    System.out.println("恢复连接");
                    break;
            }

        });

        //子节点不存在，set（不触发监听）
        zookeeperService.setData("/curator/test_pathChildrenCache","pathChildrenCache_value_1");
        //子节点不存在，create（触发监听）
        zookeeperService.createPersistentNode("/curator/test_pathChildrenCache","pathChildrenCache_value_2");
        Thread.sleep(2000);

        //子节点存在，set（触发监听）
        zookeeperService.setData("/curator/test_pathChildrenCache","pathChildrenCache_value_3");
        //子节点存在，create子节点的子节点（触发监听）
        zookeeperService.createPersistentNode("/curator/test_pathChildrenCache/aaaa","child_value_4");
        //子节点存在，delete（触发监听）
        zookeeperService.deleteChildrenIfNeeded("/curator/test_pathChildrenCache");

        Thread.sleep(5000);


        //set监听的根节点（触发监听）
        zookeeperService.setData("/curator","curator_value_aaa");
        Thread.sleep(2000);

        //delete监听的根节点（触发监听）
        zookeeperService.deleteChildrenIfNeeded("/curator");

        //关闭TreeCache
        treeCache.close();
    }
}

 

Amy##
关注
Zookeeper工具
03-19
Zookeeper工具，常用工具，可用于分布式；Zookeeper工具，常用工具，可用于分布式；Zookeeper工具，常用工具，可用于分布式
Zookeeper--Curator常用工具类
吴声子夜歌的博客
05-12 653
ZKPaths ZKPaths提供了一些简单的API来构建ZNode路径、递归创建和删除节点等，其使用方式如下： //工具类ZKPaths使用示例 public class ZKPaths_Sample { static String path = "/curator_zkpath_sample"; static CuratorFramework client = CuratorFrameworkFactory .builder() .conn
Zookeeper
最新发布
YCyjs的博客
09-23 3143
zookeeper。
Zookeeper工具类
阿达丶
07-12 948
import java.io.StringWriter; import java.util.ArrayList; import java.util.List; import org.apache.zookeeper.CreateMode; import org.apache.zookeeper.ZooDefs; import org.apache.zookeeper.ZooDefs.Ids; i
zookeeper工具类
Fisher_yu01的博客
06-29 1373
import org.apache.zookeeper.CreateMode; import org.apache.zookeeper.KeeperException; import org.apache.zookeeper.ZooDefs; import org.apache.zookeeper.ZooKeeper; import org.apache.zookeeper.data.Stat; ...
16.Zookeeper工具类
zlx
01-25 1656
import lombok.extern.slf4j.Slf4j; import org.apache.curator.framework.CuratorFramework; import org.apache.curator.framework.recipes.cache.CuratorCache; import org.apache.curator.framework.recipes.locks.InterProcessMutex; import org.apache.zookeeper.Create.
apache-zookeeper-3.8.4-bin.tar
04-10
Apache ZooKeeper是一个分布式的，开放源码的分布式应用程序协调服务，它是集群的管理者，监视着分布式应用程序，提供了诸如配置维护、命名服务、分布式同步、组服务等这些分布式基础服务。Zookeeper是Apache Hadoop...
apache-zookeeper（apache-zookeeper-3.7.1-bin.tar.gz）
05-04
apache-zookeeper分布式框架，压缩包内容：（apache-zookeeper-3.7.1-bin.tar.gz、apache-zookeeper-3.7.1.tar.gz、apache-zookeeper-3.6.4-bin.tar.gz、apache-zookeeper-3.6.4.tar.gz、apache-zookeeper-3.5.10-...
apache-zookeeper-3.5.6-bin.tar
09-02
总结来说，Apache ZooKeeper 是一个强大的分布式协调工具，通过 `apache-zookeeper-3.5.6-bin.tar` 压缩包，我们可以获取到部署和运行 ZooKeeper 3.5.6 版本所需的所有文件。理解其核心概念、部署步骤以及在分布式...
apache-zookeeper-3.6.3版本的压缩包，直接下载到本地，解压后即可使用
07-02
ZooKeeper 顾名思义 动物园管理员，他是拿来管大象 (Hadoop) 、 蜜蜂 (Hive) 、 小猪 (Pig) 的管理员， Apache Hbase和 Apache Solr 以及LinkedIn sensei 等项目中都采用到了 Zookeeper。
apache-zookeeper-3.6.3-bin.tar的压缩包，解压到本地即可使用，还有zk.sh的脚本以及zoo.cfg
06-18
apache-zookeeper-3.6.3-bin.tar的压缩包，解压到本地即可使用，还有zk.sh的脚本以及zoo.cfg和xsync。ZooKeeper 是一个分布式协调服务 ，由 Apache 进行维护。ZooKeeper 可以视为一个高可用的文件系统。ZooKeeper ...
zookeeper工具
05-09
zookeeper Dubbo，zookeeper Dubbozookeeper Dubbozookeeper Dubbo
zookeeper连接工具
11-29
该工具可用于查询、新增、删除、修改zookeeper数据，单个zookeeper直接输入IP即可（前提是端口默认未2181），多zookeeper集群按照ip:port,ip:port格式即可
zookeeperUtils---.zip
12-19
该jar是用java编写的一个操作zookeeper的工具类，能快速的将远程zk服务节点中的数据导出来，也能快速将数据上传到zk中去！
curator zookeeper
11-27
curator zookeeper 3.4.6 2.9.1
zookeeperHelper
05-16
zookeeper的创建Znode，设置数据，取数据，以及删除数据的操作
Zookeeper 分布式锁工具类
huangyueranbbc的博客
11-27 1107
ZK分布式锁工具类： package com.hyr.lock.zkcurator; import org.apache.curator.RetryPolicy; import org.apache.curator.framework.CuratorFramework; import org.apache.curator.framework.CuratorFrameworkFactory...
Zookeeper后端开发工具Curator的使用 | Curator对节点的增删改查 | ACL权限控制 | 分布式锁 | 分布式计数器 | 附带最新版本下载
热门推荐
血煞长虹 的专栏
12-21 1万+
本文系统全面的介绍zookeeper客户端工具Curator的最常用的用法，主要包含：​ 1.使用curator建立与zk的连接 2.使用curator(递归)增/删除节点 3.使用curator ACL权限控制 4.使用curator 监听节点的变化（利用了​Curator高级API特性） 5.基于curator实现Zookeeper分布式锁(需要掌握基本的多线程知识) 6.基于curator实现分布式计数器 另外Curator还有一些高端的用法：分布式屏障—Barrier、Double-barrier，
curator的使用(将Zookeeper封装的客户端)
jlhde123的博客
05-23 474
curator 是介于Zk基本API 的一些缺点而开发的一个封装，主要弥补了ZK客户端的递归创建、同步异步问题、和wacher的缺陷， 当然也提供了其他的一些便利的API ，使用fluent风格写起来感觉很像js 以下是有关操作的一些代码 package com.jlh.curator; import java.util.List; import org.ap
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值