Zookeeper API操作Demo

命令行操作ZK

##### 客户端登录zk
bash bin/zkCli.sh -server 192.168.31.162:2181

##### 执行 help 查看帮助说明
create /rest hello  >>> 创建/rest节点，并设置hello数据信息
create /test null   >>> 创建/test节点，并设置为空
create /test/child null    >>> 创建/test/child子节点
set /rest abc123    >>> 给/rest节点设置数据信息
delete /rest  >>> 删除/rest节点，被删除的节点必须是空节点，不能有子节点，可以有数据
rmr /rest     >>> 删除/rest节点
quit          >>> 退出客户端

Apache 官方接口API

引入maven依赖

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

package com.pwx.test;

import org.apache.zookeeper.*;
import org.junit.Before;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.concurrent.CountDownLatch;

/**
 * Desc: Apache Zookeeper API 使用
 * Creator: pengweixiang
 * Date: 2019-06-14
 */
public class ZkClientDemo
{
    private static final Logger LOGGER = LoggerFactory.getLogger(ZkClientDemo.class);

    private static final int SESSION_TIME_OUT = 6000;
    private static final String CONNECT_STRING = "192.168.31.162:2181";
    private static final String WATCH_PATH = "/test";
    private ZooKeeper zkClient;
    private CountDownLatch connectedSemaphore = new CountDownLatch(1);

    @Before
    public void init() throws Exception
    {
        zkClient = new ZooKeeper(CONNECT_STRING, SESSION_TIME_OUT, new Watcher()
        {
            @Override
            public void process(WatchedEvent event)
            {
                if (connectedSemaphore.getCount() > 0 && event.getState() == Watcher.Event.KeeperState.SyncConnected)
                {
                    // 已连接ZK
                    connectedSemaphore.countDown();
                }
                if (event.getType() == Watcher.Event.EventType.NodeDataChanged && WATCH_PATH.equals(event.getPath()))
                {
                    System.out.println("Path: " + event.getPath());
                    try
                    {
                        byte[] data = zkClient.getData(WATCH_PATH, true, null);
                        System.out.println("New data: " + new String(data));
                    }
                    catch (Exception e)
                    {
                        e.printStackTrace();
                    }
                }
            }
        });
        //等待zk连接
        connectedSemaphore.await();
    }

    /**
     * 创建znode节点
     * @throws Exception exception
     */
    @Test
    public void create() throws Exception
    {
        zkClient.create(WATCH_PATH, "null".getBytes("UTF-8"), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
    }

    /**
     * 修改znode的值
     * @throws Exception exception
     */
    @Test
    public void setData() throws Exception
    {
        zkClient.setData(WATCH_PATH, "ShenZhen".getBytes("UTF-8"), -1);
    }

    /**
     * 获取znode的值
     * @throws Exception exception
     */
    @Test
    public void getData() throws Exception
    {
        byte[] data = zkClient.getData(WATCH_PATH, false, null);
        LOGGER.info("Read znode data: {}", new String(data));
    }
}

I0Itec zk 第三方客户端

引入maven依赖

<dependency>
    <groupId>com.101tec</groupId>
    <artifactId>zkclient</artifactId>
    <version>0.10</version>
</dependency>

package com.pwx.test;

import org.I0Itec.zkclient.IZkChildListener;
import org.I0Itec.zkclient.IZkDataListener;
import org.I0Itec.zkclient.ZkClient;
import org.I0Itec.zkclient.serialize.BytesPushThroughSerializer;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.UnsupportedEncodingException;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * Desc: I0Itec zk 第三方客户端
 * Creator: pengweixiang
 * Date: 2019-06-16
 */
public class ZKClient3rdDemo
{
    private static final Logger LOGGER = LoggerFactory.getLogger(ZKClient3rdDemo.class);

    private static final int SESSION_TIME_OUT = 6000;
    private static final int CONNECT_TIME_OUT = 6000;
    private static final String CONNECT_STRING = "192.168.31.162:2181";
    private static final String WATCH_PATH = "/rest";
    private static final String WATCH_PATH_DIR1 = "/rest/dir1";
    private static final String WATCH_PATH_DIR2 = "/rest/dir2";

    private ZkClient zkClient;

    @Before
    public void init()
    {
        //注意Kafka中使用的是BytesPushThroughSerializer序列化，读取写入时byte数组
        zkClient = new ZkClient(CONNECT_STRING, SESSION_TIME_OUT, CONNECT_TIME_OUT, new BytesPushThroughSerializer());
    }

    @Test
    public void createZnode()
    {
        if (zkClient.exists(WATCH_PATH_DIR1))
        {
            LOGGER.warn("Znode exist: {}", WATCH_PATH_DIR1);
            return;
        }
        //创建递归节点，不担心不存在父节点
        zkClient.createPersistent(WATCH_PATH_DIR1, true);


        if (zkClient.exists(WATCH_PATH_DIR2))
        {
            LOGGER.warn("Znode exist: {}", WATCH_PATH_DIR2);
            return;
        }
        //创建递归节点，不担心不存在父节点
        zkClient.createPersistent(WATCH_PATH_DIR2, true);
    }

    @Test
    public void readZnode()
    {
        byte[] data = zkClient.readData(WATCH_PATH_DIR1);
        try
        {
            LOGGER.info("Read znode value: {}", new String(data, "UTF-8"));
        }
        catch (UnsupportedEncodingException e)
        {
            e.printStackTrace();
        }
    }

    @Test
    public void writeZnode()
    {
        try
        {
            //可将JavaBean序列化成json字符串写入
            zkClient.writeData(WATCH_PATH_DIR1, String.valueOf("hello world!").getBytes("UTF-8"));
        }
        catch (UnsupportedEncodingException e)
        {
            e.printStackTrace();
        }
    }

    @Test
    public void queryChildren()
    {
        List<String> children = zkClient.getChildren("/rest");
        children.forEach(path -> LOGGER.info("Children path: {}", path));
    }

    @Test
    public void deleteZnode()
    {
        zkClient.delete(WATCH_PATH_DIR1);
        zkClient.delete(WATCH_PATH_DIR2);
    }

    /**
     * 监听znode节点
     * @throws Exception exception
     */
    @Test
    public void watchZnode() throws Exception
    {
        zkClient.subscribeChildChanges(WATCH_PATH, new IZkChildListener()
        {
            @Override
            public void handleChildChange(String parentPath, List<String> currentChilds) throws Exception
            {
                LOGGER.info("Parent path: {}, children path: {}", parentPath, currentChilds);
            }
        });

        zkClient.subscribeDataChanges(WATCH_PATH_DIR1, new IZkDataListener()
        {
            @Override
            public void handleDataChange(String dataPath, Object data) throws Exception
            {
                LOGGER.info("Data path: {}, new value: {}", dataPath, data);
            }

            @Override
            public void handleDataDeleted(String dataPath) throws Exception
            {
                LOGGER.info("Delete data path: {}", dataPath);
            }
        });

        zkClient.subscribeDataChanges(WATCH_PATH_DIR2, new IZkDataListener()
        {
            @Override
            public void handleDataChange(String dataPath, Object data) throws Exception
            {
                LOGGER.info("Data path: {}, new value: {}", dataPath, data);
            }

            @Override
            public void handleDataDeleted(String dataPath) throws Exception
            {
                LOGGER.info("Delete data path: {}", dataPath);
            }
        });

        Thread.sleep(TimeUnit.SECONDS.toMillis(1));
        zkClient.createPersistent(WATCH_PATH_DIR1, true);
        zkClient.createPersistent(WATCH_PATH_DIR2, true);

        Thread.sleep(TimeUnit.SECONDS.toMillis(1));
        zkClient.writeData(WATCH_PATH_DIR1, "dir1");
        zkClient.writeData(WATCH_PATH_DIR2, "dir2");

        Thread.sleep(TimeUnit.SECONDS.toMillis(1));
        zkClient.delete(WATCH_PATH_DIR1);
        zkClient.delete(WATCH_PATH_DIR2);

        Thread.sleep(TimeUnit.SECONDS.toMillis(1000));
    }

    @After
    public void closeZkClient()
    {
        zkClient.close();
    }
}