0
0

基于Springboot整合zookeeper实现对节点的创建、监听与判断

Springboot整合zookeeper教程

1.环境准备

  • zookeeper集群环境

  • 一个简单的springboot项目环境

不懂如何搭建zookeeper集群的小伙伴可以移步到我的另一篇文章喔，里面有详细的zookeeper集群搭建教程~
zookeeper集群搭建步骤（超详细）https://blog.csdn.net/weixin_47025166/article/details/125415538?spm=1001.2014.3001.5502

2.代码编写

2.1.在pom.xml文件中增加zookeeper依赖（记得跟自己的zookeeper版本对应）

除此之外，我们也引入junit和log4j方便我们后面的测试

  1.    <!--引入对应的zookeeper -->
  2.         <dependency>
  3.             <groupId>org.apache.zookeeper</groupId>
  4.             <artifactId>zookeeper</artifactId>
  5.             <version>3.7.1</version>
  6.         </dependency>
  8.    <!--引入日志-->
  9.         <dependency>
  10.             <groupId>org.apache.logging.log4j</groupId>
  11.             <artifactId>log4j-to-slf4j</artifactId>
  12.             <version>2.17.2</version>
  13.         </dependency>
  15.    <!--引入junit测试-->
  16.         <dependency>
  17.             <groupId>junit</groupId>
  18.             <artifactId>junit</artifactId>
  19.             <version>RELEASE</version>
  20.         </dependency>

2.2.API测试

我们创建zkClient类用于实现对zookeeper中节点的操作：

** 1.客户端初始化**

  1. package com.canrioyuan.zookeepertest;
  3. import org.apache.zookeeper.*;
  4. import org.apache.zookeeper.data.Stat;
  5. import org.junit.Before;
  6. import org.junit.Test;
  8. import java.io.IOException;
  9. import java.util.List;
  11. //创建对应的zookeeper客户端
  12. public class ZkClient {
  14.     //对应的zookeeper客户端连接,连接之间不能存在空格
  15.     private String connectString = "192.168.154.133:2181,192.168.154.134:2181,192.168.154.135:2181";
  16.     //即超时时间，我们设置成2s
  17.     private int sessionTimeout = 2000;
  18.     //声明zookeeper客户端
  19.     private ZooKeeper zkClient;
  21.     //初始化
  22.     @Test
  23.     public void init() throws IOException {
  24.         zkClient = new ZooKeeper(connectString, sessionTimeout, new Watcher() {
  25.             @Override
  26.             public void process(WatchedEvent watchedEvent) {
  28.             }
  29.         });
  30.     }
  32. }

运行测试，成功后如会出现下图所示结果：

2.创建节点

  1.     //创建节点
  2.     @Test
  3.     public void create() throws InterruptedException, KeeperException {
  4.         //public String create(String path, byte[] data, List<ACL> acl, CreateMode createMode)
  5.         //上图中从左到右的参数分别对应着：你所要创建的节点的名字，节点的值，节点的权限，节点的类型（持久有序，持久无序，临时有序，临时无序）
  6.         zkClient.create("/class", "LiHua".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
  7.     }

运行测试，你会发现，程序报了这样的错误;

** 这是因为我们测试方法是互相独立的，此时运行测试，客户端处于未初始化的状态。因此，我们在客户端类的init方法中将@Test注解改成@Before注解，表示在每个测试执行之前都必须执行初始化方法。**

  1.   //初始化
  2.     @Before
  3. //    @Test
  4.     public void init() throws IOException {
  5.         zkClient = new ZooKeeper(connectString, sessionTimeout, new Watcher() {
  6.             @Override
  7.             public void process(WatchedEvent watchedEvent) {
  9.             }
  10.         });
  11.     }

这时候我们再运行，会提示运行成功

** 我们来到任意一台zookeeper客户端中查看节点，会发现已经创建成功**

3.监听节点的状态

一次监听只能生效一次，而为了能够持续监听，我们对初始化方法再做出调整，保证每次初始化都有一次监听生效。

  1.  @Before
  2.     public void init() throws IOException {
  3.         zkClient = new ZooKeeper(connectString, sessionTimeout, new Watcher() {
  4.             @Override   //process中即为监听后做出的处理
  5.             public void process(WatchedEvent watchedEvent) {
  6.                 List<String> children = null;
  7.                 try {
  8.                     children = zkClient.getChildren("/", true);
  9.                 } catch (KeeperException e) {
  10.                     e.printStackTrace();
  11.                 } catch (InterruptedException e) {
  12.                     e.printStackTrace();
  13.                 }
  14.                 System.out.println("-------------------------");
  15.                 for (String child : children) {
  16.                     System.out.println(child);
  17.                 }
  18.                 System.out.println("-------------------------");
  20.             }
  21.         });
  22.     }

然后在监听节点代码中进行延时操作

  1.  //监听节点
  2.     @Test
  3.     public void getChildren() throws InterruptedException, KeeperException {
  5.         //正常一次监听只会生效一次，因此我们设置延时监听，确保能够持续监听节点的变化。
  6.         Thread.sleep(Long.MAX_VALUE);
  7.     }

此时我们可以看到控制台输出了zookeeper中的节点：

** 我们进入zookeeper客户端对节点进行操作**

增加一个节点school

** 返回控制台，此时已经监听到了节点的变化： **

** 我们再对school这个节点进行删除操作**

此时控制台同样监听到了节点的变化：

** 4.判断节点是否存在**

  1.  //判断节点是否存在
  2.     @Test
  3.     public void status() throws InterruptedException, KeeperException {
  4.         Stat status = zkClient.exists("/class", false);
  5.         System.out.println(status == null ? "no exist" : "exist");
  6.     }

此时zookeeper中的节点;

测试结果：

3.全部代码

  1. package com.canrioyuan.zookeepertest;
  3. import org.apache.zookeeper.*;
  4. import org.apache.zookeeper.data.Stat;
  5. import org.junit.Before;
  6. import org.junit.Test;
  8. import java.io.IOException;
  9. import java.util.List;
  11. //创建对应的zookeeper客户端
  12. public class ZkClient {
  14.     //对应的zookeeper客户端连接,连接之间不能存在空格
  15.     private String connectString = "192.168.154.133:2181,192.168.154.134:2181,192.168.154.135:2181";
  16.     //即超时时间，我们设置成2s
  17.     private int sessionTimeout = 2000;
  18.     //声明zookeeper客户端
  19.     private ZooKeeper zkClient;
  21.     //初始化
  22. //    @Test
  23.     @Before
  24.     public void init() throws IOException {
  25.         zkClient = new ZooKeeper(connectString, sessionTimeout, new Watcher() {
  26.             @Override   //process中即为监听后做出的处理
  27.             public void process(WatchedEvent watchedEvent) {
  28.                 List<String> children = null;
  29.                 try {
  30.                     children = zkClient.getChildren("/", true);
  31.                 } catch (KeeperException e) {
  32.                     e.printStackTrace();
  33.                 } catch (InterruptedException e) {
  34.                     e.printStackTrace();
  35.                 }
  36.                 System.out.println("-------------------------");
  37.                 for (String child : children) {
  38.                     System.out.println(child);
  39.                 }
  40.                 System.out.println("-------------------------");
  42.             }
  43.         });
  44.     }
  46.     //创建节点
  47.     @Test
  48.     public void create() throws InterruptedException, KeeperException {
  49.         //public String create(String path, byte[] data, List<ACL> acl, CreateMode createMode)
  50.         //上图中从左到右的参数分别对应着：你所要创建的节点的名字，节点的值，节点的权限，节点的类型（持久有序，持久无序，临时有序，临时无序）
  51.         zkClient.create("/class", "LiHua".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
  52.     }
  54.     //监听节点
  55.     @Test
  56.     public void getChildren() throws InterruptedException, KeeperException {
  58.         //正常一次监听只会生效一次，因此我们设置延时监听，确保能够持续监听节点的变化。
  59.         Thread.sleep(Long.MAX_VALUE);
  60.     }
  62.     //判断节点是否存在
  63.     @Test
  64.     public void status() throws InterruptedException, KeeperException {
  65.         Stat status = zkClient.exists("/class", false);
  66.         System.out.println(status == null ? "no exist" : "exist");
  67.     }
  69. }

至此，我们基于Springboot整合zookeeper实现对节点的创建、监听与判断教程就结束啦~

感谢您的阅读,希望我的文章能给你带来帮助！！！

标签： spring boot java-zookeeper zookeeper
本文转载自: https://blog.csdn.net/weixin_47025166/article/details/125425882
版权归原作者 啊陈晓 所有， 如有侵权，请联系我们删除。
登录后发布评论

“基于Springboot整合zookeeper实现对节点的创建、监听与判断”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？