devbox
思考机器
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基于Springboot整合zookeeper实现对节点的创建、监听与判断_springboot程序注册到zookeeper上进行监控

作者：思考机器 | 2024-02-01 14:02:42

赞

踩

springboot程序注册到zookeeper上进行监控

文章目录

Springboot整合zookeeper教程

1.环境准备

2.代码编写

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

2.2.API测试

3.全部代码

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>
  7.  
  8.    <!--引入日志-->
  9.         <dependency>
  10.             <groupId>org.apache.logging.log4j</groupId>
  11.             <artifactId>log4j-to-slf4j</artifactId>
  12.             <version>2.17.2</version>
  13.         </dependency>
  14.  
  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;
  2.  
  3. import org.apache.zookeeper.*;
  4. import org.apache.zookeeper.data.Stat;
  5. import org.junit.Before;
  6. import org.junit.Test;
  7.  
  8. import java.io.IOException;
  9. import java.util.List;
  10.  
  11. //创建对应的zookeeper客户端
  12. public class ZkClient {
  13.  
  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;
  20.  
  21.  
  22.     //初始化
  23.     @Test
  24.     public void init() throws IOException {
  25.         zkClient = new ZooKeeper(connectString, sessionTimeout, new Watcher() {
  26.             @Override
  27.             public void process(WatchedEvent watchedEvent) {
  28.  
  29.             }
  30.         });
  31.     }
  32.  
  33. }

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

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) {
  8.  
  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("-------------------------");
  19.  
  20.             }
  21.         });
  22.     }

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

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

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

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

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/article/detail/53962
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号