(4)zookeeper原生java api基本使用介绍

最新推荐文章于 2024-06-27 13:31:06 发布

没头脑遇到不高兴

最新推荐文章于 2024-06-27 13:31:06 发布

阅读量3.4k

点赞数 1

分类专栏： ZooKeeper 文章标签： zookeeper原生java api

本文链接：https://blog.csdn.net/u012988901/article/details/82589617

版权

ZooKeeper 专栏收录该内容

8 篇文章 2 订阅

订阅专栏

本节介绍

本节里面，将会利用zookeeper官方的原生java api进行连接，然后演示一些创建、删除、修改、查询节点的操作。其实有两个比较好用的第三方客户端zkclient和curator，可以弥补原生api的很多不足，使用也比较简便，但是这两个东西也都是在原生api的基础上封装的，所以了解原生api的使用方法还是很有必要的，后面有时间的话会跟大家介绍一下另外两个客户端。

zookeeper 原生api 使用介绍

先给大家贴一张图，里面介绍了zookeeper原生java api的一些基础用法，可以先简单了解一下，下面会写一个demo程序对这几个方法进行逐个介绍。

准备

创建一个maven工程zkTest，然后添加zookeeper、log4j的maven依赖。

<dependency>
           <groupId>org.apache.zookeeper</groupId>
           <artifactId>zookeeper</artifactId>
           <version>3.4.6</version>
       </dependency>
<dependency>
           <groupId>log4j</groupId>
           <artifactId>log4j</artifactId>
           <version>1.2.15</version>
</dependency>

将下面的log4j.properties配置文件放到src/main/resources下面即可

log4j.rootLogger = info,stdout,D
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = %d %t [%c{2}] %L [%-5p] %m%n
log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
log4j.appender.D.File = ../logs/log.log
log4j.appender.D.Append = true
log4j.appender.D.Threshold = info
log4j.appender.D.DatePattern= '_'yyyy-MM-dd'.log'
log4j.appender.D.layout = org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern = %d %t [%c{2}] %L [%-5p] %m%n

zookeeper客户端处理类

package com.wkp.test.zookeeper.base;

import java.io.IOException;
import java.util.List;
import java.util.concurrent.CountDownLatch;

import org.apache.log4j.Logger;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.Watcher.Event.EventType;
import org.apache.zookeeper.Watcher.Event.KeeperState;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;

public class ZookeeperBase {

   private static Logger logger=Logger.getLogger(ZookeeperBase.class);

   private ZooKeeper zookeeper;
   private String connectString;//连接zk服务端的ip:port,如果多个格式为 ip:port,ip:port......
   private int sessionTimeout;//客户端连接超时时间单位 ms
   /** 信号量，阻塞程序执行，用于等待zookeeper连接成功，发送成功信号 */
   private CountDownLatch countDown=new CountDownLatch(1);

   public ZookeeperBase(String connectString,int sessionTimeout) throws IOException{
       this.connectString=connectString;
       this.sessionTimeout=sessionTimeout;

       zookeeper=new ZooKeeper(this.connectString, this.sessionTimeout, new Watcher() {

           public void process(WatchedEvent event) {
               //影响的路径
               String path = event.getPath();
               //获取事件的状态
               KeeperState state = event.getState();
               //获取事件的类型
               EventType type = event.getType();
               if(KeeperState.SyncConnected.equals(state)){
                   if(EventType.None.equals(type)){
                       //连接建立成功，则释放信号量，让阻塞的程序继续向下执行
                       countDown.countDown();
                       logger.info("zk建立连接成功========");
                   }
               }
           }
       });
   }

   public ZooKeeper getZkClient() throws InterruptedException{
       //计数器到达0之前，一直阻塞，只有当信号量被释放，才会继续向下执行
       countDown.await();
       return zookeeper;
   }

   public void closeClient() throws InterruptedException{
       if(zookeeper!=null){
           zookeeper.close();
           logger.info("zk关闭连接成功=======");
       }
   }

   /**
   * 创建节点
   * @param path 节点path
   * @param data 节点数据
   * @return
   * @throws InterruptedException
   * @throws KeeperException
   */
   public String createNode(String path,String data) throws InterruptedException, KeeperException{
       ZooKeeper zk = this.getZkClient();
       String str = zk.create(path, data.getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
       return str;
   }

   /**
   * 更新节点数据
   * @param path 节点path
   * @param data 节点数据
   * @return
   * @throws InterruptedException
   * @throws KeeperException
   */
   public Stat updateNode(String path,String data) throws InterruptedException, KeeperException{
       ZooKeeper zk = this.getZkClient();
       Stat stat = zk.setData(path, data.getBytes(),-1);
       return stat;
   }

   /**
   * 获得节点数据
   * @param path 节点path
   * @return
   * @throws KeeperException
   * @throws InterruptedException
   */
   public String getData(String path) throws KeeperException, InterruptedException{
       ZooKeeper zk = this.getZkClient();
       byte[] data = zk.getData(path, false, null);
       return new String(data);
   }

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

   /**
   * 判断节点是否存在
   * @param path
   * @return
   * @throws KeeperException
   * @throws InterruptedException
   */
   public Stat exists(String path) throws KeeperException, InterruptedException{
       ZooKeeper zk = this.getZkClient();
       Stat stat = zk.exists("/", false);
       return stat;
   }

   /**
   * 删除节点
   * @param path
   * @throws InterruptedException
   * @throws KeeperException
   */
   public void deleteNode(String path) throws InterruptedException, KeeperException{
       ZooKeeper zk = this.getZkClient();
       zk.delete(path, -1);
       logger.info("删除 "+path+" 节点成功");
   }

   public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
       ZookeeperBase base = new ZookeeperBase("192.168.74.4:2181,192.168.74.5:2181,192.168.74.6:2181", 2000);
ZooKeeper zkClient = base.getZkClient();
        System.out.println("sessionId:"+zkClient.getSessionId()+",sessionTimeOut:"+zkClient.getSessionTimeout());
       base.closeClient();
   }
}

1、建立客户端连接

ZooKeeper(String connectString, int sessionTimeout, Watcher watcher)

我们看到Zookeeper的构造方法需要三个参数，第一个connectString是连接字符串，格式为"ip:port,ip:port......"，例如上面代码中的"192.168.74.4:2181,192.168.74.5:2181,192.168.74.6:2181"，sessionTimeout为连接超时时间，单位毫秒，watcher是一个监听对象，zookeeper中对数据的变更操作都会有对应的事件，如果对节点注册了监听，当节点状态发生变化时就会被注册的监听对象监控到（关于zookeeper的事件监听机制下一节会有专门的介绍）。

我们看到代码中用到了一个多线程辅助类CountDownLatch，CountDownLatch是一个同步辅助类，构造方法初始化计数器值为1，当CountDownLatch值为0之前，其await()方法会一直阻塞，countDown()方法会将计数器的值减1（关于CountDownLatch的详细使用方法可以自行查询一下）。我们看到获取zookeeper客户端对象的方法中调用了CountDownLatch的await方法，就会一直等待watcher对象中监听的连接事件被监听到了，并且调用countDown方法后await方法才会被放行，这时候才可以获取到zookeeper客户端对象。至于为什么要使用这个同步计数器呢，其实是因为java中new Zookeeper创建对象立马就会返回了，而客户端连接到服务端是耗时的，这个时候并没有真正的连接成功，如果这个时候拿zk客户端对象去做操作会报错，所以我们要等待连接建立成功的时候才能使用客户端对象。

通过zkClient.getSessionId()可以获取到当前连接对象的ID，运行main方法会看到控制台出现下面结果（去掉了环境变量的无用日志输出）

2018-09-16 16:06:33,215 main [zookeeper.ZooKeeper] 438 [INFO ] Initiating client connection, connectString=192.168.74.4:2181,192.168.74.5:2181,192.168.74.6:2181 sessionTimeout=2000 watcher=com.wkp.test.zookeeper.base.ZookeeperBase$1@15c8132a
2018-09-16 16:06:33,342 main-SendThread(192.168.74.6:2181) [zookeeper.ClientCnxn] 975 [INFO ] Opening socket connection to server 192.168.74.6/192.168.74.6:2181. Will not attempt to authenticate using SASL (unknown error)
2018-09-16 16:06:33,347 main-SendThread(192.168.74.6:2181) [zookeeper.ClientCnxn] 852 [INFO ] Socket connection established to 192.168.74.6/192.168.74.6:2181, initiating session
2018-09-16 16:06:33,431 main-SendThread(192.168.74.6:2181) [zookeeper.ClientCnxn] 1235 [INFO ] Session establishment complete on server 192.168.74.6/192.168.74.6:2181, sessionid = 0x265e106a0720002, negotiated timeout = 4000
2018-09-16 16:06:33,438 main-EventThread [base.ZookeeperBase] 45 [INFO ] zk建立连接成功========
sessionId:172791579301511170,sessionTimeOut:4000
2018-09-16 16:06:33,462 main [zookeeper.ZooKeeper] 684 [INFO ] Session: 0x265e106a0720002 closed
2018-09-16 16:06:33,463 main-EventThread [zookeeper.ClientCnxn] 512 [INFO ] EventThread shut down
2018-09-16 16:06:33,464 main [base.ZookeeperBase] 61 [INFO ] zk关闭连接成功=======

2、创建节点

我们调用createNode方法创建节点，path为 "/testRoot"，value为 "rootValue"

        ZookeeperBase base = new ZookeeperBase("192.168.74.4:2181,192.168.74.5:2181,192.168.74.6:2181", 2000);
       String result = base.createNode("/testRoot", "rootValue");
       System.out.println(result);
       base.closeClient();

然后会看到控制台输出了刚才创建的节点路径 "/testRoot"，假如我们再运行一次上面的创建节点的程序的话，会报org.apache.zookeeper.KeeperException$NodeExistsException: KeeperErrorCode = NodeExists for /testRoot，由此可见不能重复创建节点，否则会报节点已经存在的异常。

创建节点的方法create(String path, byte[] data, List<ACL> acl, CreateMode createMode)，需要接收四个参数，path是节点路径，data是节点值，ACL是zookeeper的权限相关的，我们查看上面createNode()方法中传的是Ids.OPEN_ACL_UNSAFE，表示开放所有权限（具体的下一节做详细介绍），createMode表示节点的类型，我们查看CreateMode的源码发现其是一个枚举类，里面定义了四种节点类型，从前到后分别是持久化节点、持久化有序节点、临时节点、临时有序节点。

接下来我们尝试创建一个a节点下的b节点即 "/a/b"，此时a节点还没有创建

        ZookeeperBase base = new ZookeeperBase("192.168.74.4:2181,192.168.74.5:2181,192.168.74.6:2181", 2000);
       String result = base.createNode("/a/b", "test");
       System.out.println(result);
       base.closeClient();

此时控制台会报org.apache.zookeeper.KeeperException$NoNodeException: KeeperErrorCode = NoNode for /a/b，然后我们尝试给testRoot节点创建一个子节点 children 即 "/testRoot/children"，

ZookeeperBase base = new ZookeeperBase("192.168.74.4:2181,192.168.74.5:2181,192.168.74.6:2181", 2000);
String result = base.createNode("/testRoot/children", "childrenValue");
System.out.println(result);

经运行发现children节点创建成功，由此可见：zookeeper的原生java api是不会自动递归创建节点的，即当父节点不存在事不可以创建子节点（下面的方法我没有写具体的调用，您可以自己参照上面代码调用验证哦）

3、更新节点

更新节点数据调用的方法是 setData(String path, byte[] data, int version)，前两个参数跟前面创建节点的一样这里就不解释了，最后一个version参数代表希望变更的节点的版本号（前面的章节有介绍过，随着变更节点版本号也会变更），如果版本号与节点实际版本号不对应会报异常（org.apache.zookeeper.KeeperException$BadVersionException: KeeperErrorCode = BadVersion for /testRoot/children），如果version传递值为 "-1"，则表示忽略版本号限制。

4、判断节点是否存在

判断节点是否存在调用 exists(String path, boolean watch) 方法，如果存在会返回对应节点，第二个参数是一个布尔类型，true表示需要对当前节点进行监听，false表示不需要监听，具体的会在下一节介绍。

5、获取节点数据

获取节点数据方法getData(String path, boolean watch, Stat stat)

6、获取当前节点的所有子节点数据

调用方法getChildren(String path, boolean watch)会返回所有子节点数据的集合，注意是返回所有子节点的数据，不会返回孙子节点的数据，如果想获取当前节点下的所有子节点、孙子节点、重孙子节点......需要自己写程序进行递归获取。

7、删除节点

删除节点调用方法 delete(String path, int version) ，注意删除节点是不能递归删除节点，即如果当前节点有子节点，必须先把子节点删除，才可以删除父节点，否则会报 org.apache.zookeeper.KeeperException$NotEmptyException: KeeperErrorCode = Directory not empty for /testRoot

下一节会介绍一下zookeeper的监听机制即本节中的watcher，还会对zookeeper的ACL做个简单介绍。