Zookeeper的实际使用

y_bccl27

已于 2022-10-05 12:41:47 修改

阅读量674

点赞数

分类专栏： ZooKeeper 文章标签： zookeeper

于 2022-10-05 12:40:53 首次发布

本文链接：https://blog.csdn.net/y_bccl27/article/details/127157496

版权

本文详细介绍了Zookeeper的实际使用，包括创建会话、节点操作、Watcher机制、ACL权限控制和实际应用场景。通过示例代码展示了如何创建、获取、修改和删除节点，并解释了Zookeeper Watcher的特性，以及ZKClient的使用方法，如监听节点变化和数据变化。

摘要由CSDN通过智能技术生成

一、使用apache提供的zookeeper依赖包进行操作

首先在pom.xml中引入下述依赖：

<dependency>
  <groupId>org.apache.zookeeper</groupId>
  <artifactId>zookeeper</artifactId>
  <version>3.8.0</version>
</dependency>

1、创建会话

public ZooKeeper(String connectString, int sessionTimeout, Watcher watcher);

创建会话方法：客户端可以通过创建一个zookeeper实例来连接zookeeper服务器

connectString：连接服务器列表，以“,”分割

sessionTimeout：心跳检测时间周期(毫秒)

watcher：事件处理通知器

import java.util.concurrent.CountDownLatch;

import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.Watcher.Event.EventType;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.Watcher.Event.KeeperState;

public class ZookeeperBase {

    /**
     * zookeeper地址
     */
    static final String CONNECT_ADDR = "192.168.1.105:2181,192.168.1.106:2181,192.168.1.107:2181";

    /**
     * session超时时间，单位是毫秒
     */
    static final int SESSION_OUTTIME = 2000;

    /**
     * 信号量，阻塞程序执行，用于等待zookeeper连接成功，发送成功信号
     */
    static final CountDownLatch connectedSemaphore = new CountDownLatch(1);

    public static void main(String[] args) throws Exception {
        ZooKeeper zk = new ZooKeeper(CONNECT_ADDR, SESSION_OUTTIME, new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                // 获取事件的状态
                KeeperState keeperState = event.getState();
                // 获取事件的类型
                EventType eventType = event.getType();
                if (KeeperState.SyncConnected == keeperState) {
                    if (EventType.None == eventType) {
                        //如果建立连接成功，则发送信号量，让后续阻塞程序向下执行
                        System.out.println("zk 建立连接");
                        connectedSemaphore.countDown();
                    }
                }
            }
        });

        //进行阻塞
        connectedSemaphore.await();
        System.out.println("执行啦...");
     
        zk.close();   
    }
}

执行上述代码，其输出结果为：

zk 建立连接
执行啦...

特别注意：zookeeper客户端和服务器端会话的建立是一个异步的过程，也就是说在程序中，我们程序方法在处理完客户端初始化后立即返回（也就是说程序往下执行代码，这样，大多数情况下我们并没有真正构建好一个可用会话，在会话的生命周期处于"CONNECTING"时才算真正建立完毕，所以我们需要使用多线程中的工具类CountDownLatch)

2、创建节点

创建节点的方法为create，提供了两套创建节点的方法：同步和异步

同步方式：

参数1，节点路径(名称)：InodeName(不允许递归创建节点，也就是说在父节点不存在的情况下，不允许创建子节点)

参数2，节点内容：要求类型是字节数组

参数3，节点权限：使用lds.OPEN_ACL_UNSAFE开放权限即可。(这个参数一般在权限没有太高要求的场景下，没必要关注)

参数4，节点类型：创建节点的类型：CreateMode.*，提供四种节点类型

PERSISTENT(持久节点)

PERSISTENT_SEQUENTIAL（持久顺序节点）

EPHEMERAL（临时节点)

EPHEMERAL_SEQUENTIAL（临时顺序节点)

import java.util.concurrent.CountDownLatch;

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.Watcher.Event.EventType;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.Watcher.Event.KeeperState;
import org.apache.zookeeper.ZooDefs.Ids;

public class ZookeeperBase {

    /**
     * zookeeper地址
     */
    static final String CONNECT_ADDR = "192.168.1.105:2181,192.168.1.106:2181,192.168.1.107:2181";

    /**
     * session超时时间，单位是毫秒
     */
    static final int SESSION_OUTTIME = 2000;

    /**
     * 信号量，阻塞程序执行，用于等待zookeeper连接成功，发送成功信号
     */
    static final CountDownLatch connectedSemaphore = new CountDownLatch(1);

    public static void main(String[] args) throws Exception {
        ZooKeeper zk = new ZooKeeper(CONNECT_ADDR, SESSION_OUTTIME, new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                // 获取事件的状态
                KeeperState keeperState = event.getState();
                // 获取事件的类型
                EventType eventType = event.getType();
                if (KeeperState.SyncConnected == keeperState) {
                    if (EventType.None == eventType) {
                        //如果建立连接成功，则发送信号量，让后续阻塞程序向下执行
                        System.out.println("zk 建立连接");
                        connectedSemaphore.countDown();
                    }
                }
            }
        });

        //进行阻塞
        connectedSemaphore.await();
        System.out.println("执行啦...");

        //创建父节点
		zk.create("/testRoot", "testRoot".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);

        //创建子节点
		zk.create("/testRoot/children", "children data".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);

        zk.close();
    }
}

我们在zookeeper的服务端进行查看：

异步方式的创建暂时仅知道有这个一个场景即可，后续若有必要再研究

3、获取节点的值

package com.bhz.zookeeper.base;

import java.util.concurrent.CountDownLatch;

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.Watcher.Event.EventType;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.Watcher.Event.KeeperState;
import org.apache.zookeeper.ZooDefs.Ids;

public class ZookeeperBase {

    /**
     * zookeeper地址
     */
    static final String CONNECT_ADDR = "192.168.1.105:2181,192.168.1.106:2181,192.168.1.107:2181";

    /**
     * session超时时间，单位是毫秒
     */
    static final int SESSION_OUTTIME = 2000;

    /**
     * 信号量，阻塞程序执行，用于等待zookeeper连接成功，发送成功信号
     */
    static final CountDownLatch connectedSemaphore = new CountDownLatch(1);

    public static void main(String[] args) throws Exception {
        ZooKeeper zk = new ZooKeeper(CONNECT_ADDR, SESSION_OUTTIME, new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                // 获取事件的状态
                KeeperState keeperState = event.getState();
                // 获取事件的类型
                EventType eventType = event.getType();
                if (KeeperState.SyncConnected == keeperState) {
                    if (EventType.None == eventType) {
                        //如果建立连接成功，则发送信号量，让后续阻塞程序向下执行
                        System.out.println("zk 建立连接");
                        connectedSemaphore.countDown();
                    }
                }
            }
        });

        //进行阻塞
        connectedSemaphore.await();

        //获取节点的值
		byte[] data = zk.getData("/testRoot", false, null);
		System.out.println(new String(data));
		//获取节点的子节点
		System.out.println(zk.getChildren("/testRoot", false));

        zk.close();
    }
}

执行上述代码，其输出内容为：

zk 建立连接
testRoot
[children]

4、修改节点的值

package com.bhz.zookeeper.base;

import java.util.concurrent.CountDownLatch;

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.Watcher.Event.EventType;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.Watcher.Event.KeeperState;
import org.apache.zookeeper.ZooDefs.Ids;

public class ZookeeperBase {

    /**
     * zookeeper地址
     */
    static final String CONNECT_ADDR = "192.168.1.105:2181,192.168.1.106:2181,192.168.1.107:2181";

    /**
     * session超时时间，单位是毫秒
     */
    static final int SESSION_OUTTIME = 2000;

    /**
     * 信号量，阻塞程序执行，用于等待zookeeper连接成功，发送成功信号
     */
    static final CountDownLatch connectedSemaphore = new CountDownLatch(1);

    public static void main(String[] args) throws Exception {
        ZooKeeper zk = new ZooKeeper(CONNECT_ADDR, SESSION_OUTTIME, new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                // 获取事件的状态
                KeeperState keeperState = event.getState();
                // 获取事件的类型
                EventType eventType = event.getType();
                if (KeeperState.SyncConnected == keeperState) {
                    if (EventType.None == eventType) {
                        //如果建立连接成功，则发送信号量，让后续阻塞程序向下执行
                        System.out.println("zk 建立连接");
                        connectedSemaphore.countDown();
                    }
                }
            }
        });

        //进行阻塞
        connectedSemaphore.await();

        //修改节点的值
		zk.setData("/testRoot", "modify data root".getBytes(), -1);
		byte[] data = zk.getData("/testRoot", false, null);
		System.out.println(new String(data));

        zk.close();
    }
}

执行上述代码，其输出内容为：

zk 建立连接
modify data root

5、判断节点是否存在

package com.bhz.zookeeper.base;

import java.util.concurrent.CountDownLatch;

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.Watcher.Event.EventType;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.Watcher.Event.KeeperState;
import org.apache.zookeeper.ZooDefs.Ids;

public class ZookeeperBase {

    /**
     * zookeeper地址
     */
    static final String CONNECT_ADDR = "192.168.1.105:2181,192.168.1.106:2181,192.168.1.107:2181";

    /**
     * session超时时间，单位是毫秒
     */
    static final int SESSION_OUTTIME = 2000;

    /**
     * 信号量，阻塞程序执行，用于等待zookeeper连接成功，发送成功信号
     */
    static final CountDownLatch connectedSemaphore = new CountDownLatch(1);

    public static void main(String[] args) throws Exception {
        ZooKeeper zk = new ZooKeeper(CONNECT_ADDR, SESSION_OUTTIME, new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                // 获取事件的状态
                KeeperState keeperState = event.getState();
                // 获取事件的类型
                EventType eventType = event.getType();
                if