zookeeper+zKClient客户端的API使用

简介：

zkClient是一个开源的zookeeper客户端，内部针对zookeeper原生API进行了封装，让操作zookeeper更加的简单；同时zkClient内部还实现了诸如：Session超时重连；Warcher反复注册机制；

导入依赖：

     <!--zKClient -zookeeperApi调用-->
        <dependency>
            <groupId>com.101tec</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.2</version>
        </dependency>

常用操作：

package com.example.liunx_demo.zookeeper.zkclient;

import org.I0Itec.zkclient.IZkChildListener;
import org.I0Itec.zkclient.IZkDataListener;
import org.I0Itec.zkclient.ZkClient;

import java.util.List;

/**
 * @program: liunx_demo
 * @description:
 * @author: chenhu
 * @create: 2021-01-06 10:22
 **/
public class test {

    public static void main(String[] args) {

        /*连接会话
         * 创建一个zkClient实例就可以完成会话的连接
         * serverstring:连接的地址：ip:端口号
         * */
        ZkClient zkClient = new ZkClient("192.168.10.80:2181");
        System.err.println("会话创建成功");

        //==========================1：创建节点，同时递归创建子节点===========================================
        /*
            创建节点，同时递归创建子节点
            createParents:代表是否创建父节点，值为true代表先创建父节点在创建子节点，如果为false 代表只创建子节点
         */
        zkClient.createPersistent("/zkclient-data01/01-c2", true);
        System.err.println("节点递归创建完成");

        //===========================2：删除节点==========================================
        /*删除节点：递归删除节点，先删除该节点下的子节点，然后在删除该节点*/
//        zkClient.deleteRecursive("/zkclient-data01");
//        System.err.println("递归删除完成");

        //===========================3：获取某节点的子节点列表==========================================
        /*获取某节点的子节点列表*/
        List<String> children = zkClient.getChildren("/zkclient-data01");
        System.err.println(children);

        /*注册监听事件,
            path:代表为哪一个节点注册监听事件，当该节点发生变化时会调用handleChildChange()方法
            该方法可以对不存在的节点进行监听，当该节点的子节点列表或者该节点发生变更，会触发此监听
         */
        zkClient.subscribeChildChanges("/zkclient-data01", new IZkChildListener() {
            /*
                s :代表当前监听节点的所有父节点，也就是路径
                list ：变化后的子节点列表
             */
            @Override
            public void handleChildChange(String s, List<String> list) throws Exception {
                System.err.println("s" + "的子节点列表发生了变化，变化后的子节点列表为：" + list);
            }
        });

        //============================5：判断节点是否存在=========================================
        /*判断节点是否存在*/
        boolean exists = zkClient.exists("/zkclient-data01");

        //============================6：创建节点，并给节点赋值=========================================
        /*创建节点，并给节点赋值*/
        zkClient.createPersistent("/zkclient-data02", "12345");

        //============================6：读取节点内容=========================================
        /*读取节点内容*/
        zkClient.readData("/zkclient-data02");

        /*注册监听事件,
            path:代表为哪一个节点注册监听事件，当该节点发生变化时会调用handleChildChange()方法
            该方法可以对存在的节点进行监听，当该节点的子节点列表或者该节点发生变更，会触发此监听
         */
        zkClient.subscribeDataChanges("/zkclient-data01", new IZkDataListener() {
            /*
                当节点数据内容发生变化时，执行的方法
                s:监听的节点
                o :节点变化后的内容
             */
            @Override
            public void handleDataChange(String s, Object o) throws Exception {
                System.err.println(s + "该节点内容被更新,更新后的内容：" + o);
            }

            /*
                当节点被删除时，执行的方法
                s:监听的节点
             */
            @Override
            public void handleDataDeleted(String s) throws Exception {
                System.err.println(s + "该节点内容被删除");
            }
    });
}
}

封装的工具类

package com.zk.zkclient;

import org.I0Itec.zkclient.IZkChildListener;
import org.I0Itec.zkclient.IZkDataListener;
import org.I0Itec.zkclient.ZkClient;

import java.util.List;

/**
 * @Author: hu.chen
 * @Description:
 * @DateTime: 2021/12/29 10:15 AM
 **/
public class ZkClientUtils {

    private static ZkClient zkClient;

    private static final String address = "192.168.73.131:2191,192.168.73.131:2192,192.168.73.131:2193";

    static {
         /**
         * 连接会话
         * 第一个参数：zk服务器地址列表--连接的地址：ip:端口号
         * 第二个参数：会话超时时间
         * 第三个参数：连接超时时间
         */
        zkClient = new ZkClient(address, 30000, 50000);

    }


    /**
     * 创建持久节点，同时递归创建子节点
     * createParents:代表是否创建父节点，值为true代表先创建父节点在创建子节点，如果为false 代表只创建子节点
     */
    public static void createPersistent(String path) {
        zkClient.createPersistent(path, true);
    }

    /**
     * 创建持久节点，并给节点添加内容
     *
     * @param path
     * @param data
     */
    public static void createPersistent(String path, String data) {
        zkClient.createPersistent(path, data);
    }

    /**
     * 创建持久顺序节点，并给节点添加内容
     *
     * @param path
     * @param data
     */
    public static void createPersistentSequential(String path, String data) {
        zkClient.createPersistentSequential(path, data);
    }


    /**
     * 创建临时节点
     *
     * @param path 节点名称
     */
    public static void createEphemeral(String path) {
        zkClient.createEphemeral(path);
    }

    /**
     * 创建临时节点，并给节点添加内容
     *
     * @param path
     * @param data
     */
    public static void createEphemeral(String path, String data) {
        zkClient.createEphemeral(path, data);
    }

    /**
     * 创建临时顺序节点，并给节点添加内容
     *
     * @param path
     * @param data
     */
    public static void createEphemeralSequential(String path, String data) {
        zkClient.createEphemeralSequential(path, data);
    }

    /**
     * 删除节点：删除节点
     */
    public static void delete(String path) {
        zkClient.delete(path);
    }

    /**
     * 删除节点：递归删除节点，先删除该节点下的子节点，然后在删除该节点
     */
    public static void deleteRecursive(String path) {
        zkClient.deleteRecursive(path);
    }
    
        /**
     * 更改节点内容
     * @param path
     * @param data
     * @throws Exception
     */
    public static void updataNode(String path,String data) throws Exception {

        zkClient.writeData(path,data);
    }

    /**
     * 获取某节点的子节点列表
     */
    public static List<String> getNodes(String path) {
        List<String> nodes = zkClient.getChildren(path);
        return nodes;
    }

    /**
     * 给某个节点添加事件监听，当此节点的子节点列表发生变化时，会触发里面的 handleChildChange() 方法
     * 注意：原生的zkAPI的监听是一次性的,在监听触发后之前注册的监听就会失效，所以需要重新注册
     * 但是 ZkClient 实现了 反复注册监听的功能，所以再触发监听后不需要在重新注册
     * 
     * 
     *  new IZkChildListener() {
     *                     // s :代表当前监听节点的所有父节点，也就是路径
     *                     // list ：变化后的子节点列表
     *                     @Override
     *                     public void handleChildChange(String path, List<String> list) throws Exception {
     *                         System.err.println(path + ": 的子节点列表发生了变化，变化后的子节点列表为：" + list);
     *
     *
     *                     }
     *                 }
     */
    public static void addNodeListener(String path, IZkChildListener childListener) {
        zkClient.subscribeChildChanges(path,childListener);
    }

    /**
     * 给某个节点添加事件监听，当此节点的子节点列表发生变化时，会触发里面的 handleChildChange() 方法
     * 注意：设置监听是一次性的，在监听触发后之前注册的监听就会失效，所以需要重新注册
     * 
     * new IZkDataListener() {
     *         // 当节点数据内容发生变化时，执行的方法
     *         // s:监听的节点
     *         // o :节点变化后的内容
     *         @Override
     *         public void handleDataChange (String s, Object o) throws Exception {
     *             System.err.println(s + "该节点内容被更新,更新后的内容：" + o);
     *
     *         }
     *
     *         // 当节点被删除时，执行的方法
     *         // s:监听的节点
     *         @Override
     *         public void handleDataDeleted (String s) throws Exception {
     *             System.err.println(s + "该节点内容被删除");
     *         }
     *     }
     */
    public static void addContentListener(String path, IZkDataListener dataListener) {
        zkClient.subscribeDataChanges(path,dataListener);
    }


    /**
     * 判断节点是否存在
     *
     * @param path
     * @return
     */
    public static boolean exists(String path) {

        return zkClient.exists(path);
    }

    /**
     * 读取节点内容
     *
     * @return
     */
    public static String readNode(String path) {
        Object o = zkClient.readData(path);
        return (String) o;
    }


}

测试调用工具类：

package com.zk.zkclient;

import org.I0Itec.zkclient.IZkChildListener;
import org.I0Itec.zkclient.IZkDataListener;
import org.I0Itec.zkclient.ZkClient;

import java.util.List;

/**
 * @Author: hu.chen
 * @Description:
 * @DateTime: 2021/12/29 9:57 AM
 **/
public class Test {
    public static void main(String[] args) throws InterruptedException {


        List<String> nodes = ZkClientUtils.getNodes("/test-javaapi");

        // 给此节点注册子节点列表变更事件，当子节点列表发生变更时触发
        ZkClientUtils.addNodeListener("/test-javaapi", new IZkChildListener() {
            @Override
            public void handleChildChange(String s, List<String> list) throws Exception {
                System.err.println(s + "节点的子节点列表变更为：" + list);
            }
        });

        // 删除节点--非递归删除
//        ZkClientUtils.delete("/test-javaapi/c1");

        // 创建持久节点--递归创建
        ZkClientUtils.createPersistent("/test-javaapi/c1");

        Thread.sleep(5000);

//        ZkClientUtils.delete("/test-javaapi/c2");

        ZkClientUtils.createPersistent("/test-javaapi/c2");

        Thread.sleep(5000);
//        ZkClientUtils.delete("/test-javaapi/c3");

        ZkClientUtils.createPersistent("/test-javaapi/c3");

        System.err.println(nodes);

        Thread.sleep(Integer.MAX_VALUE);
    }

}