ZooKeeper常用操作的代码实现

package com.shsxt.zookeeper;

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

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ZookeeperTest {
    // 会话时间
    private static final int SESSION_TIMEOUT = 30000;
    // 操作日志
    public static final Logger LOGGER = LoggerFactory.getLogger(ZookeeperTest.class);

    private Watcher watcher = new Watcher() {

        public void process(WatchedEvent event) {
            LOGGER.info("process*************************______________ : " + event.getType());
        }
    };

    private ZooKeeper zooKeeper;

    /**
     * 连接zookeeper
     * 
     * @throws IOException
     */
    @Before
    public void connect() throws IOException {
        //
        zooKeeper = new ZooKeeper("node011:2181,node012:2181,node013:2181", SESSION_TIMEOUT, watcher);
    }

    /**
     * 关闭连接
     */
    @After
    public void close() {
        try {
            zooKeeper.close();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 创建一个znode 1.CreateMode 取值 PERSISTENT：持久化，这个目录节点存储的数据不会丢失
     * PERSISTENT_SEQUENTIAL：顺序自动编号的目录节点，这种目录节点会根据当前已近存在的节点数自动加
     * 1，然后返回给客户端已经成功创建的目录节点名； EPHEMERAL：临时目录节点，一旦创建这个节点的客户端与服务器端口也就是
     * session过期超时，这种节点会被自动删除 EPHEMERAL_SEQUENTIAL：临时自动编号节点 <br>
     * ------------------------------<br>
     * 
     * CreateMode.EPHEMERAL：临时会话 persistent：持久会话
     * 
     * 
     * 客户端的Session ： 客户端与Server建立TCP连接后得到一个Session
     * 如果连接的Server挂掉后，没有超过timeout时间之内，可以连接其他节点 同一时期内Session的特性保持不变
     * 
     * 
     */
    @Test
    public void testCreate() {
        String result = null;
        try {
            // CreateMode.EPHEMERAL临时会话
            result = zooKeeper.create("/eeee", "zk001data123".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
            // 监控
            // 睡眠30s，之后自动关闭
            Thread.sleep(30000);
        } catch (Exception e) {
            LOGGER.error(e.getMessage());
            Assert.fail();
        }
        LOGGER.info("create result : {}", result);
    }

    /**
     * 删除节点 忽略版本
     * 
     * 存在子节点，删除不了，
     * 
     * 
     * 
     */
    @Test
    public void testDelete() {
        try {
            zooKeeper.delete("/test/hi0000000001", -1);

        } catch (Exception e) {
            LOGGER.error(e.getMessage());
            Assert.fail();
        }
    }

    /**
     * 获取数据
     */
    @Test
    public void testGetData() {
        String result = null;
        try {
            byte[] bytes = zooKeeper.getData("/test", null, null);
            result = new String(bytes);
        } catch (Exception e) {
            LOGGER.error(e.getMessage());
            Assert.fail();
        }
        LOGGER.info("getdata result : {}", result);
    }

    /**
     * 获取数据 设置watch 监听一次
     */
    @Test
    public void testGetDataWatch() {
        String result = null;
        try {
            // 一次性的！！！
            byte[] bytes = zooKeeper.getData("/test", new Watcher() {
                // 匿名内部类
                public void process(WatchedEvent event) {
                    LOGGER.info("testGetDataWatch  watch -----: {}", event.getType());// NodeDateChanged
                }
            }, null);
            result = new String(bytes);
        } catch (Exception e) {
            LOGGER.error(e.getMessage());
            Assert.fail();
        }
        LOGGER.info("getdata result : {}", result);

        // 触发wacth NodeDataChanged
        try {
            // watcher一次
            zooKeeper.setData("/test", "testSetDatavales123123".getBytes(), -1);
            System.out.println("==========================================================");
            // 不在触发监听器
            zooKeeper.setData("/test", "testSetDatavales54325".getBytes(), -1);
        } catch (Exception e) {
            LOGGER.error(e.getMessage());
            Assert.fail();
        }
    }

    /**
     * 判断节点是否存在 设置是否监控这个目录节点，这里的 watcher 是在创建 ZooKeeper实例时指定的 watcher
     */
    @Test
    public void testExists() {
        Stat stat = null;
        try {
            stat = zooKeeper.exists("/test", false);
        } catch (Exception e) {
            LOGGER.error(e.getMessage());
            Assert.fail();
        }
        Assert.assertNotNull(stat);
        LOGGER.info("exists result : {}", stat.getCzxid());
    }

    /**
     * 设置对应znode下的数据 , -1表示匹配所有版本
     */
    @Test
    public void testSetData() {
        Stat stat = null;
        try {
            stat = zooKeeper.setData("/test", "testSetData".getBytes(), -1);
        } catch (Exception e) {
            LOGGER.error(e.getMessage());
            Assert.fail();
        }
        Assert.assertNotNull(stat);
        LOGGER.info("exists result : {}", stat.getVersion());
    }

    /**
     * 判断节点是否存在, 设置是否监控这个目录节点，这里的 watcher 是在创建 ZooKeeper实例时指定的 watcher
     */
    @Test
    public void testExistsWatch1() {
        Stat stat = null;
        try {
            // testCreate();
            stat = zooKeeper.exists("/test/hi0000000004", true);// true参数启用观察回调
        } catch (Exception e) {
            LOGGER.error(e.getMessage());
            Assert.fail();
        }
        Assert.assertNotNull(stat);
        try {
            zooKeeper.delete("/test/hi0000000004", -1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 判断节点是否存在, 设置监控这个目录节点的 Watcher
     */
    @Test
    public void testExistsWatch2() {
        Stat stat = null;
        try {
            stat = zooKeeper.exists("/test/hi0000000000", new Watcher() {
                @Override
                public void process(WatchedEvent event) {
                    LOGGER.info("testExistsWatch2  watch : {}", event.getType());
                }
            });
        } catch (Exception e) {
            LOGGER.error(e.getMessage());
            Assert.fail();
        }
        Assert.assertNotNull(stat);

        // 触发watch 中的process方法 NodeDataChanged
        try {
            zooKeeper.setData("/test/hi0000000000", "testExistsWatch2".getBytes(), -1);
        } catch (Exception e) {
            e.printStackTrace();
        }

        // 不会触发watch 只会触发一次
        try {
            zooKeeper.delete("/test/hi0000000000", -1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取指定节点下的子节点
     */
    @Test
    public void testGetChild() {
        try {
            zooKeeper.create("/test/001", "001".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
            zooKeeper.create("/test/002", "002".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);

            List<String> list = zooKeeper.getChildren("/test", true);
            for (String node : list) {
                LOGGER.info("fffffff {}", node);
            }
            Thread.sleep(300000);
        } catch (Exception e) {
            LOGGER.error(e.getMessage());
            Assert.fail();
        }
    }
}