原生Zookeeper客户端 - 增删改查

Zookeeper 类是zk核心类，用于与zk服务创建连接以及进行数据处理。

CreateMode中指定创建的节点类型：持久节点（PERSISTENT），持久顺序节点（PERSISTENT_SEQUENTIAL），临时节点（EPHEMERAL），临时顺序节点（EPHEMERAL_SEQUENTIAL）等。

ZooDefs用于设置权限等

package com.hebi.study.zookeeper.primary;

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.ZooDefs;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class PrimaryZkShow {
    
    private final static String ZK_HOST = "127.0.0.1:2181";
    
    private static final Logger logger = LoggerFactory.getLogger(PrimaryZkShow.class);
    
    private static CountDownLatch lantch = new CountDownLatch(1);
    
    private static ZooKeeper zkClient;
    
    public static void main(String[] args) throws Exception {
        
        try {
            Watcher watcher = getWatcher();
            zkClient = new ZooKeeper(ZK_HOST, 6000, watcher);
            
            // 阻塞等待连接建立
            lantch.await();
            String path = "/Lily";
            
            Stat stat = zkClient.exists(path, watcher);
            
            if (stat == null) {
                String response = zkClient.create(path, "My name is Lily.".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
                logger.info("create /Lily is : {}" , response);
            }
            
            logger.info(path + " content : {}", getNodeData(path, watcher));
            
            String request = "I'm a good student.";
            setNodeData(path, request.getBytes("UTF-8"));
            
            logger.info(path + " content : {}", getNodeData(path, watcher));
        } finally {
            closeZk(zkClient);
        }
    }
    
    /**
     * Disc  : 关闭客户端连接 
     * @title: closeZk
     * @param  zkClient
     * @throws InterruptedException
     * @date 2019-08-16 10:21:13
     * @version 1.0.0
     */
    private static void closeZk(ZooKeeper zkClient) throws InterruptedException {
        if (zkClient != null) {
            zkClient.close();
        }
    }
    
    /**
     * Disc    获取节点内容
     * @title  getNodeData
     * @param  path    节点
     * @return String  返回
     * @throws Exception
     * @date   2019-08-16 10:17:33
     * @version 1.0.0
     */
    private static String getNodeData(String path, Watcher watcher) throws Exception {
        logger.info("start 读取 Node 数据。");
        String result = null;
        Stat stat = zkClient.exists(path, watcher);
        if (stat != null) {
            byte[] datas = zkClient.getData(path, getWatcher(), null);
            result = new String(datas);
        }
        return result;
    }
    
    /**
     * @Disc  更新节点内容
     * @title setNodeData
     * @param path
     * @param datas
     * @date  2019-08-16 10:25:30
     * @version 1.0.0
     * @throws Exception 
     */
    public static void setNodeData(String path, byte[] datas) throws Exception {
        logger.info("开始 update node 内容");
        Stat stat = zkClient.setData(path, datas, -1);
        if (stat == null) {
            logger.error("node {} update 失败，stat : {}", path, stat);
        }
    }
    
    /**
     * @Disc   获取监听器
     * @title  getWatcher
     * @date   2019-08-16 10:26:07
     * @version 1.0.0
     */
    public static Watcher getWatcher() {
        return new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                // 事件状态 （已连接）
                if (event.getState() == Event.KeeperState.SyncConnected) {
                    EventType type = event.getType();
                    
                    if (EventType.None == type) {
                        // 连接建立成功
                        lantch.countDown();
                        logger.info("连接成功，触发开锁。");
                    }
                }
            }
        };
    }
    
}