Zookeeper客户端使用（使用原生zookeeper）

Zookeeper客户端使用

一、使用原生zookeeper

在pom.xml中加入依赖

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

直接上代码：

 /**
  * Project Name:mk-project <br>
  * Package Name:com.suns.zookeeper <br>
  *
  * @author mk<br>
  * Date:2018-10-31 9:09 <br>
  */

 package com.suns.zookeeper;

 import org.apache.zookeeper.*;
 import org.apache.zookeeper.data.Stat;

 import java.util.List;
 import java.util.concurrent.CountDownLatch;

 /**
  * 原生的zookeeper客户端
  * 1.连接是异步的，使用时需要注意。增加watcher，监听事件如果为SyncConnected,那么才做其他的操作。（利用CountDownLatch控制）
  * 2.监听事件是一次性的，如果操作多次需要注册多次（可以通过getData等方法）
  * ClassName: ZookeeperNative <br>
  * Description:  <br>
  * @author mk
  * @Date 2018-10-31 9:09 <br>
  * @version
  */
 public class ZookeeperNative {

     public static final String connect = "127.0.0.1:2181";
     private static ZooKeeper zookeeper = null;
     private static CountDownLatch cdl = new CountDownLatch(0);
     private static String nodePath = "/native1";
     private static String nodeChildPath = "/native1/n1/n11/n111/n1111";

     public static void main(String[] args) throws Exception {

         //初始化
         init(connect,5000);

         //新增
         create(nodePath,"n1");
         //递归新增
         createRecursion(nodeChildPath,"n1");

         //查询
         query(nodePath);

         //修改
         update(nodePath,"n11");

         //单个节点删除
 //        delete(nodePath);
         //递归删除
         deleteRecursion(nodePath);
     }

     private static void deleteRecursion(String nodePath) throws KeeperException, InterruptedException {
         Stat exists = zookeeper.exists(nodePath, true);
         if(null == exists){
             System.out.println(nodePath+"不存在");
             return ;
         }

         List<String> list = zookeeper.getChildren(nodePath, true);
         if(null == list || list.size() == 0){
             delete(nodePath);
             String parentPath = nodePath.substring(0,nodePath.lastIndexOf("/"));
             System.out.println("parentPath="+parentPath);
             if(!"".equals(parentPath)){
                 deleteRecursion(parentPath);
             }
         }else{
             for(String child : list){
                 deleteRecursion(nodePath+"/"+child);
             }
         }
     }

     private static void delete(String path) throws KeeperException, InterruptedException {
         query(path);//为了让watcher能被监听，在这里查询一次
         zookeeper.delete(path,-1);
         System.out.println("delete:"+"["+path+"]");
     }

     private static void update(String path, String data) throws KeeperException, InterruptedException {
         Stat stat = zookeeper.setData(path, data.getBytes(), -1);//versoin=-1代表不记录版本
         System.out.println("setData:"+"["+path+"],stat:"+stat);
     }

     private static void query(String path) throws KeeperException, InterruptedException {
         Stat stat = new Stat();
         byte[] data = zookeeper.getData(path, true, stat);
         System.out.println("query:"+"["+path+"],result:"+new String(data) + ",stat:"+stat);
     }

     private static void createRecursion(String path,String data) throws KeeperException, InterruptedException {
         if(null == path || "".equals(path)){
             System.out.println("节点["+path+"]为空");
             return;
         }
         String paths[] = path.substring(1,path.length()).split("/");
         for(int i=0;i<paths.length;i++){
             String childPath = "";
             for(int j=0;j<=i;j++){
                 childPath += "/" + paths[j];
             }
             create(childPath,data);
         }

         Stat exists = zookeeper.exists(path, true);
         if(null != exists){
             System.out.println("节点["+path+"]已存在，不能新增");
             return;
         }
         String result = zookeeper.create(path, data.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
         System.out.println("create:"+"["+path+"-->"+data+"],result:"+result);
     }

     private static void create(String path,String data) throws KeeperException, InterruptedException {
         Stat exists = zookeeper.exists(path, true);
         if(null != exists){
             System.out.println("节点["+path+"]已存在，不能新增");
             return;
         }
         String result = zookeeper.create(path, data.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
         System.out.println("create:"+"["+path+"-->"+data+"],result:"+result);
     }

     private static void init(final String connectStr, int sessionTimeout) throws Exception {
 //        zookeeper = new ZooKeeper(connectStr, sessionTimeout, null);
         //由于zookeeper连接是异步的，如果new ZooKeeper(connectStr, sessionTimeout, null)完之后马上使用，有可能会报错。
         //解决办法：增加watcher，监听事件如果为SyncConnected,那么才做其他的操作。（利用CountDownLatch控制）
         zookeeper = new ZooKeeper(connectStr, sessionTimeout, new Watcher() {
             @Override
             public void process(WatchedEvent watchedEvent) {
                 if(watchedEvent.getState() == Event.KeeperState.SyncConnected) {
 //                    System.out.println("zookeeper已连接["+connectStr+"]成功");
                     cdl.countDown();
                 }
                 if(watchedEvent.getType() == Event.EventType.NodeCreated){
                     System.out.println("zookeeper有新节点创建"+watchedEvent.getPath());
                 }
                 if(watchedEvent.getType() == Event.EventType.NodeDataChanged){
                     System.out.println("zookeeper有节点数据变化"+watchedEvent.getPath());
                 }
                 if(watchedEvent.getType() == Event.EventType.NodeDeleted){
                     System.out.println("zookeeper有节点被删除"+watchedEvent.getPath());
                 }
                 if(watchedEvent.getType() == Event.EventType.NodeChildrenChanged){
                     System.out.println("zookeeper有子节点变化"+watchedEvent.getPath());
                 }
             }
         });
         cdl.await();
         System.out.println("init start :" +zookeeper);
     }

 }

运行结果：