SpringBoot 整合zookeeper

最新推荐文章于 2024-03-05 23:00:42 发布
最新推荐文章于 2024-03-05 23:00:42 发布
阅读量2.5k 收藏 3
点赞数
分类专栏： SpringBoot 文章标签： zookeeper apache java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27242695/article/details/121925078
版权

文章目录

SpringBoot 整合zookeeper

Zookeeper原生Java API、ZKClient和Apache Curator 区别对比

1 ZkClient

1.1 相关依赖

    <properties>
        <zookeeper.version>3.6.0</zookeeper.version>
    </properties>

      <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>${zookeeper.version}</version>
            <!--需要排查日志，否则会冲突 -->
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

1.2 ZookeeperConfig

  1. application.properties
zookeeper.address=127.0.0.1:2181
zookeeper.timeout=10000
  1. ZookeeperConfig.java
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.beans.factory.annotation.Value;

import java.util.concurrent.CountDownLatch;

@Configuration
public class ZookeeperConfig {

    private static final Logger logger = LoggerFactory.getLogger(ZookeeperConfig.class);

    /**
     * zookeeper 地址
     */
    @Value("${zookeeper.address}")
    private String connect;

    /**
     * connect 超时时间
     */
    @Value("${zookeeper.timeout}")
    private int timeout;

    /**
     * zookeeper client
     * @return
     */
    @Bean(name = "zkClient")
    public ZooKeeper zkClient() {
        ZooKeeper zooKeeper = null;
        try {
            final CountDownLatch countDownLatch = new CountDownLatch(1);
            //连接成功后，会回调watcher监听，此连接操作是异步的，执行完new语句后，直接调用后续代码
            // 可指定多台服务地址 127.0.0.1:2181,127.0.0.1:2182,127.0.0.1:2183
            zooKeeper = new ZooKeeper(connect, timeout, new Watcher() {
                @Override
                public void process(WatchedEvent event) {
                    if (Event.KeeperState.SyncConnected == event.getState()) {
                        //如果收到了服务端的响应事件,连接成功
                        countDownLatch.countDown();
                    }
                }
            });
            countDownLatch.await();
            logger.info("【初始化ZooKeeper连接状态....】={}", zooKeeper.getState());

        } catch (Exception e) {
            logger.error("初始化ZooKeeper连接异常....】={}", e);
        }
        return zooKeeper;
    }

}

1.3 ZkService

import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class ZkService {

    private static final Logger logger = LoggerFactory.getLogger(ZkService.class);

    @Autowired
    private ZooKeeper zkClient;


    /**
     * 判断指定节点是否存在
     *
     * @param path
     * @param needWatch 指定是否复用zookeeper中默认的Watcher
     * @return
     */
    public Stat exists(String path, boolean needWatch) {
        try {
            return zkClient.exists(path, needWatch);
        } catch (Exception e) {
            logger.error("【断指定节点是否存在异常】{},{}", path, e);
            return null;
        }
    }

    /**
     * 检测结点是否存在 并设置监听事件
     * 三种监听类型： 创建，删除，更新
     *
     * @param path
     * @param watcher 传入指定的监听类
     * @return
     */
    public Stat exists(String path, Watcher watcher) {
        try {
            return zkClient.exists(path, watcher);
        } catch (Exception e) {
            logger.error("【断指定节点是否存在异常】{},{}", path, e);
            return null;
        }
    }

    /**
     * 创建持久化节点
     *
     * @param path
     * @param data
     */
    public boolean createNode(String path, String data) {
        try {
            zkClient.create(path, data.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
            return true;
        } catch (Exception e) {
            logger.error("【创建持久化节点异常】{},{},{}", path, data, e);
            return false;
        }
    }


    /**
     * 修改持久化节点
     *
     * @param path
     * @param data
     */
    public boolean updateNode(String path, String data) {
        try {
            //zk的数据版本是从0开始计数的。如果客户端传入的是-1，则表示zk服务器需要基于最新的数据进行更新。如果对zk的数据节点的更新操作没有原子性要求则可以使用-1.
            //version参数指定要更新的数据的版本, 如果version和真实的版本不同, 更新操作将失败. 指定version为-1则忽略版本检查
            zkClient.setData(path, data.getBytes(), -1);
            return true;
        } catch (Exception e) {
            logger.error("【修改持久化节点异常】{},{},{}", path, data, e);
            return false;
        }
    }

    /**
     * 删除持久化节点
     *
     * @param path
     */
    public boolean deleteNode(String path) {
        try {
            //version参数指定要更新的数据的版本, 如果version和真实的版本不同, 更新操作将失败. 指定version为-1则忽略版本检查
            zkClient.delete(path, -1);
            return true;
        } catch (Exception e) {
            logger.error("【删除持久化节点异常】{},{}", path, e);
            return false;
        }
    }

    /**
     * 获取当前节点的子节点(不包含孙子节点)
     *
     * @param path 父节点path
     */
    public List<String> getChildren(String path) throws KeeperException, InterruptedException {
        List<String> list = zkClient.getChildren(path, false);
        return list;
    }

    /**
     * 获取指定节点的值
     *
     * @param path
     * @return
     */
    public String getData(String path, Watcher watcher) {
        try {
            Stat stat = new Stat();
            byte[] bytes = zkClient.getData(path, watcher, stat);
            return new String(bytes);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

}

2 Apache Curator（推荐使用）

2.1 相关依赖


    <properties>
        <curator.version>4.3.0</curator.version>
    </properties>

		<dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-recipes</artifactId>
            <version>${curator.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
            <version>${curator.version}</version>
        </dependency>

2.2 ZkCuratorConfiguration

  1. application.properties
#重试次数
curator.retryCount=5
#重试间隔时间
curator.elapsedTimeMs=5000
# zookeeper 地址
curator.address=127.0.0.1:2181
# session超时时间
curator.sessionTimeoutMs=60000
# 连接超时时间
curator.connectionTimeoutMs=5000
  1. ZkCuratorConfiguration.java
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.retry.RetryNTimes;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.beans.factory.annotation.Value;


@Configuration
public class ZkCuratorConfiguration {

    // 重试次数
    @Value("${curator.retryCount}")
    private int retryCount;

    // 重试间隔时间
    @Value("${curator.elapsedTimeMs}")
    private int elapsedTimeMs;

    // zookeeper 地址
    @Value("${curator.address}")
    private String address;

    // session超时时间
    @Value("${curator.sessionTimeoutMs}")
    private int sessionTimeoutMs;

    // 连接超时时间
    @Value("${curator.connectionTimeoutMs}")
    private int connectionTimeoutMs;

    @Bean(initMethod = "start")
    public CuratorFramework curatorFramework() {
        return CuratorFrameworkFactory.newClient(
                address,
                sessionTimeoutMs,
                connectionTimeoutMs,
                new RetryNTimes(retryCount, elapsedTimeMs));
    }

}

2.3 ZkCurator api

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.recipes.nodes.PersistentEphemeralNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

@Service
public class ZkCuratorService {

    private static Logger logger = LoggerFactory.getLogger(ZkCuratorService.class);

    @Value("${service.index}")
    private String index;

    public static String CHARSET_NAME = "utf-8";

    @Autowired
    private CuratorFramework client;

    /**
     * 创建节点(若创建节点的父节点不存在会先创建父节点再创建子节点)
     * @param path  节点路径
     * @param value  值
     * @param modeType 节点类型
     */
    public void createNode(String path, String value, String modeType) throws Exception {
        if (null == client.checkExists().forPath(path)) {
            if(CreateMode.PERSISTENT.equals(modeType)) {
                // 持久型节点
                client.create().creatingParentsIfNeeded().withMode(CreateMode.PERSISTENT).forPath(path,value.getBytes(CHARSET_NAME));
            } else if(CreateMode.EPHEMERAL.equals(modeType)) {
                //临时节点
                client.create().creatingParentsIfNeeded().withMode(CreateMode.EPHEMERAL).forPath(path,value.getBytes(CHARSET_NAME));
            } else if(CreateMode.PERSISTENT_SEQUENTIAL.equals(modeType)) {
                // 持久类型顺序性节点
                client.create().creatingParentsIfNeeded().withMode(CreateMode.PERSISTENT_SEQUENTIAL).forPath(path,value.getBytes(CHARSET_NAME));
            } else if(CreateMode.EPHEMERAL_SEQUENTIAL.equals(modeType)) {
                // 临时类型顺序性节点
                client.create().creatingParentsIfNeeded().withMode(CreateMode.EPHEMERAL_SEQUENTIAL).forPath(path,value.getBytes(CHARSET_NAME));
            }
        }
    }

    //创建节点
    public void createNodeSimple(String path) throws Exception {
        if (null == client.checkExists().forPath(path)) {
            client.create().creatingParentsIfNeeded().forPath(path);
        }
    }

    //删除节点
    public void deleteNodeSimple(String path) throws Exception {
        if (null != client.checkExists().forPath(path)) {
            client.delete().deletingChildrenIfNeeded().forPath(path);
        }
    }

    //设置数据
    public void setData(String path, String data) throws Exception {
        if(null == client.checkExists().forPath(path)) return;
        client.setData().forPath(path, data.getBytes(CHARSET_NAME));
    }

    //添加临时节点数据
    public void appendPersistentData(String path, String data) throws Exception {
        PersistentEphemeralNode node = new PersistentEphemeralNode(client, PersistentEphemeralNode.Mode.EPHEMERAL, path, data.getBytes(CHARSET_NAME));
        node.start();
        node.waitForInitialCreate(3, TimeUnit.SECONDS);
    }

    // 删除节点及其子节点
    public void deletingChildrenIfNeeded(String path) throws Exception {
        if (null == client.checkExists().forPath(path)) return;
        // 递归删除节点
        client.delete().deletingChildrenIfNeeded().forPath(path);
    }



}

3. Curator 事件监听

  1. Curator 事件有两种模式，一种是标准的观察模式，一种是缓存监听模式。标准的监听模式是使用Watcher 监听器。第二种缓存监听模式引入了一种本地缓存视图的Cache机制，来实现对Zookeeper服务端事件监听。
  2. Cache事件监听可以理解为一个本地缓存视图与远程Zookeeper视图的对比过程。Cache提供了反复注册的功能。Cache是一种缓存机制，可以借助Cache实现监听。简单来说，Cache在客户端缓存了znode的各种状态，当感知到zk集群的znode状态变化，会触发event事件，注册的监听器会处理这些事件。
  3. Cache事件监听的种类有3种Path Cache，Node Cache，Tree Cache。

3.1 NodeCache 节点缓存的监听

  1. Curator引入的Cache缓存实现，是一个系列，包括了Node Cache 、Path Cache、Tree Cache三组类。其中Node Cache节点缓存可以用于ZNode节点的监听，Path Cache子节点缓存用于ZNode的子节点的监听，而Tree Cache树缓存是Path Cache的增强，不光能监听子节点，也能监听ZNode节点自身。
  2. Node Cache，可以用于监控本节点的新增，删除，更新。
  3. 流程代码
        // 1. 创建NodeCache 实例
        NodeCache nodeCache = new NodeCache(client, "/path");
        // 2. 添加监听事件
        nodeCache.getListenable().addListener(new NodeCacheListener() {

            // 当监听的节点发生变化(增 删 改),触发执行
            @Override
            public void nodeChanged() throws Exception {
                
                ChildData childData = nodeCache.getCurrentData();
                logger.info("ZNode节点状态改变, path={}", childData.getPath());
                logger.info("ZNode节点状态改变, data={}", new String(childData.getData(), "Utf-8"));
                logger.info("ZNode节点状态改变, stat={}", childData.getStat());
            }
        });
        // 3. 开启监听
        nodeCache.start();

3.2 PathChildrenCache 子节点监听

  1. 只能监听子节点，监听不到当前节点
  2. 不能递归监听，子节点下的子节点不能递归监控
3.2.1 重载方法介绍
public PathChildrenCache(CuratorFramework client, String path,boolean cacheData)

public PathChildrenCache(CuratorFramework client, String path,boolean cacheData, 
         boolean dataIsCompressed,final ExecutorService executorService)

public PathChildrenCache(CuratorFramework client, String path,boolean cacheData,
         boolean dataIsCompressed,ThreadFactory threadFactory)

public PathChildrenCache(CuratorFramework client, String path,boolean cacheData,
         ThreadFactory threadFactory)

参数介绍:

  1. CuratorFramework：Curator的客户端
  2. path：监听的节点路径
  3. cacheData：表示是否把节点内容缓存起来，如果cacheData为true，那么接收到节点列表变更事件的同时，会将获得节点内容。
  4. dataIsCompressed：表示是否对节点数据进行压缩
  5. executorService 和threadFactory：线程池工厂，当PathChildrenCache内部需要开启新的线程执行时，使用该线程池工厂来创建线程，通过传入的线程池或者线程工厂，来异步处理监听事件
3.2.2 启动模式
  1. NORMAL：启动时，异步初始化cache，完成后不会发出通知。
  2. BUILD_INITIAL_CACHE：启动时，同步初始化cache，以及创建cache后，就从服务器拉取对应的数据。
  3. POST_INITIALIZED_EVENT：启动时，异步初始化cache，初始化完成触发PathChildrenCacheEvent.Type#INITIALIZED事件，cache中Listener会收到该事件的通知。
3.2.3 代码实例
        // 1. 创建PathChildrenCache实例
        PathChildrenCache pathChildrenCache = new PathChildrenCache(client, "/path", true);
        // 2. 添加监听时间
        pathChildrenCache.getListenable().addListener(new PathChildrenCacheListener() {
            @Override
            public void childEvent(CuratorFramework client, PathChildrenCacheEvent event) throws Exception {
                logger.info("事件:" + event.getType().toString().toUpperCase());
                logger.info("触发节点:" + event.getData().getPath());
                if (Objects.nonNull(event.getData())) {
                    logger.info("触发节点数据:" + new String(event.getData().getData()));
                }
            }
        });
        // 3. 启动 并设置启动模式 默认：StartMode.NORMAL
        pathChildrenCache.start(PathChildrenCache.StartMode.NORMAL);

3.3 Tree Cache 节点树缓存

Tree Cache可以看做是上两种的合体，Tree Cache观察的是当前ZNode节点的所有数据。而TreeCache节点树缓存是PathChildrenCache的增强，不光能监听子节点，也能监听节点自身。

3.3.1 代码示例
        // 1. 创建TreeCache实例
        TreeCache treeCache = new TreeCache(client, "/path");
        // 2. 添加监听事件
        treeCache.getListenable().addListener(new TreeCacheListener() {
            @Override
            public void childEvent(CuratorFramework client, TreeCacheEvent event) throws Exception {
                logger.info("事件:" + event.getType().toString().toUpperCase());
                logger.info("触发节点:" + event.getData().getPath());
                if (Objects.nonNull(event.getData())) {
                    logger.info("触发节点数据:" + new String(event.getData().getData()));
                }
            }
        });
        // 3. 启动
        treeCache.start();

最后，说明下事件的类型，对应于节点的增加、修改、删除，TreeCache 的事件类型为：
（1）NODE_ADDED
（2）NODE_UPDATED
（3）NODE_REMOVED
这一点，与Path Cache 的事件类型不同，与Path Cache 的事件类型为：
（1）CHILD_ADDED
（2）CHILD_UPDATED
（3）CHILD_REMOVED

老鼠扛刀满街找猫@
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot整合zookeeper权限控制.zip
06-18
java的spring-boot工程使用digest方式对zookeeper进行权限控制，包括初始化zk,以及增删改查等
SpringBoot整合Dubbo zookeeper过程解析
08-25
主要介绍了SpringBoot整合Dubbo zookeeper过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
2.Zookeeper集成springboot操作节点，事件监听，分布式锁实现
最新发布
huangchong0107的博客
03-05 1059
1.Springboot项目中添加zookeeper 已经对应的客户端依赖 ，pom.xml文件如下。2.application.yml 文件中配置zookeeper连接的相关配置信息。3.java配置的方式添加zookeeper相关的配置。4.Zookeeper基础操作服务和分布式锁服务编码。5.watcher机制事件处理抽象封装。6.基本操作的单元测试代码。
fat：基于springboot，zookeeper，redis分布式事务强一致性方案
02-06
脂肪 FAT，基于springboot，使用zookeeper，redis，spring异步，spring transactionManager的强一致性分布式事务解决方案 框架介绍 纯编码方式，强一致性。使用redis / zookeeper作为注册中心，代理事务的执行，使用spring async异步处理事务线程。基于注解使用，对业务代码可以说是零入侵，目前内置适配spring-cloud（Feign调用），dubbo。同时具有一定的扩展性与兼容性，因为存在自定义的服务框架，或者以后会涌现出更多的流行分布式服务框架，所以会提供一些组件适应自定义服务框架。 Maven依赖 < depende
springboot整合zookeeper项目源代码
07-16
springboot整合zookeeper项目源代码
基于ZooKeeper的服务注册实现
jrn1012的专栏
08-09 9043
本文介绍了在Linux本地环境部署ZooKeeper伪集群，并基于ZooKeeper实现了服务的注册
springboot整合zookeeper
huaxinzhang的博客
03-29 1934
springboot整合zookeeper
Spring Boot整合Zookeeper详细教程
热门推荐
怪咖@的博客
06-25 1万+
注意我这里用的是官方最稳定的版本3.7.1，版本之间有个别命令是有差距的！本篇文章的示例SpringBoot和Zookeeper客户端以及zookeeper都是最新版本！Curator是Netflix公司开源的⼀套zookeeper客户端框架，Curator是对Zookeeper⽀持最好的客户端框架。Curator封装了⼤部分Zookeeper的功能，⽐如Leader选举、分布式锁等，减少了技术⼈员在使⽤Zookeeper时的底层细节开发⼯作。 4.application.yml配置⽂件 applicati
【SpringBoot整合Dubbo和Zookeeper】
蛋饼吧的博客
01-10 2309
Apache Dubbo 是一款 RPC 服务开发框架，用于解决微服务架构下的服务治理与通信问题，官方提供了 Java、Golang 等多语言 SDK 实现。使用 Dubbo 开发的微服务原生具备相互之间的远程地址发现与通信能力， 利用 Dubbo 提供的丰富服务治理特性，可以实现诸如服务发现、负载均衡、流量调度等服务治理诉求。Dubbo 被设计为高度可扩展，用户可以方便的实现流量拦截、选址的各种定制逻辑。
Ubuntu上安装和使用ZooKeeper的超详细教程
沐雨橙风ιε的博客
07-13 6500
Ubuntu上安装和使用ZooKeeper的超详细教程
【SpringBoot 玩具配置中心】
w1170913576的博客
01-21 1090
前言 配置中心的一些想法： 在 Zookeeper 的节点中保存配置。 然后通过SpringBoot 提供的配置扩展接口 EnvironmentPostProcessor 从Zookeeper 中获取初始化需要的配置。 后续监听 Zookeeper 节点的变化，对配置进行更新。 zkClient的依赖如下： <dependency> <groupId>com.101tec</groupId> <artifactId>zkclient</
springboot整合dubbo+zookeeper案例
12-08
包括案例代码dubbo-demo-parent，apache-tomcat-8.5.60，apache-zookeeper-3.5.8-bin，dubbo-admin-2.5.10.war
Spring Boot整合Zookeeper实现配置中心
CodersCoder的博客
06-30 4870
简介 使用背景 说到配置中心，目前市面上用的较多的配置中心都广为人知，比如百度的Disconf、Spring Cloud Config、携程的Apollo、阿里的Nacos等。由于项目组一直是使用的zookeeper作为配置中心，所以来学习使用。 实现原理 在Zookeeper建立一个根节点，比如/CONFIG，代表某个配置文件。将配置文件中的信息作为根节点的子节点存储，比如配置项timeout=3000，在Zookeeper中展现为：/CONFIG/timeout ，节点内容是3000。然后让所有使用到
SpringBoot-ZkClient-守护线程
dark
10-24 2043
接到一个需求，在现有的功能中启动一个后台线程，来实时监听目标ZooKeeper的某一Node的下各个配置的子节点变化(包括子节点的数据变化),并提供外围接口来获取最新的子节点信息。 + cfg - cfg1 - cfg2 - cfg3 Zookeeper的开源客户端有许多如:ZkClient，Curator,我们这里使用ZkClient，maven依赖如下： &amp;amp;lt;depende...
Springboot使用Curator 集成zk
南国的技术栈
03-14 4942
前言 Curator是Apache提供的一个zk的工具包，简化了 ZooKeeper 的操作。它增加了很多使用 ZooKeeper 开发的特性，可以处理 ZooKeeper 集群复杂的连接管理和重试机制。这里我们使用springboot 集成curator来操作zk。 假设你的服务已经正确添加了zk的相关依赖，Curator maveny依赖如下， <!-- curator-framework --> <dependency> <groupId>org.apach
Spring Boot 集成 Zookeeper
boy_gg_fly的博客
04-07 414
提前准备： Spring Boot项目、搭建完成的Zookeeper 虚拟机 该文章前面都有写过。 直接上代码 package com.test.zookeeper; import org.apache.zookeeper.*; import org.apache.zookeeper.data.Stat; import org.junit.Before; import org.junit.Test; import java.io.IOException; import java.util..
Spring Boot 整合Zookeeper组件
woaiwojialanxi的专栏
03-06 3028
Spring Boot 整合Zookeeper组件
【SpringBoot】整合Zookeeper
lushixuan12345的博客
12-07 1486
引入依赖、编写客户端、ZookeeperConfig、ZookeeperWatches、ZookeeperController
Spring Boot 使用 ZkClient 操作 ZooKeeper
一叶知秋的博客
10-21 7449
本文主要介绍使用 ZkClient 访问 ZooKeeper 的一些基本方法。这里安装的 ZooKeeper 版本是 zookeeper-3.4.14 稳定版。需要注意的是，ZkClient 已经将 ZooKeeper 原生 API 中的异步处理进行了同步化。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值