zookeeper客户端使用原生JavaApi操作节点

• 引入依赖

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

• 创建会话

 package com.karat.cn.zookeeper.javaApi;

 import java.io.IOException;
 import java.util.concurrent.CountDownLatch;

 import org.apache.zookeeper.WatchedEvent;
 import org.apache.zookeeper.Watcher;
 import org.apache.zookeeper.ZooKeeper;

 /**
  * 创建会话(连接zookeeper)
  * @author 开发
  *
  */
 public class CreateSessionDemo {

     private final static String CONNECTSTRING="47.107.121.215:2181";

     private static CountDownLatch countDownLatch=new CountDownLatch(1);

     public static void main(String []args) throws IOException, InterruptedException{
         ZooKeeper zooKeeper=new ZooKeeper(CONNECTSTRING, 5000,new Watcher() {
             @Override
             public void process(WatchedEvent event) {
                 //如果当前的连接状态是连接成功的，那么通过计数器去控制
                 if(event.getState()==Event.KeeperState.SyncConnected){
                     countDownLatch.countDown();
                     System.out.println(event.getState());
                 }
             }
         });
         countDownLatch.await();
         System.out.println(zooKeeper.getState());
     }
 }

• 节点的操作

 package com.karat.cn.zookeeper.javaApi;

 import java.io.IOException;
 import java.util.List;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;

 import org.apache.zookeeper.CreateMode;
 import org.apache.zookeeper.KeeperException;
 import org.apache.zookeeper.WatchedEvent;
 import org.apache.zookeeper.Watcher;
 import org.apache.zookeeper.ZooDefs;
 import org.apache.zookeeper.ZooKeeper;
 import org.apache.zookeeper.data.Stat;

 /**
  * java的api对节点的操作
  * @author 开发
  *
  */
 public class CreateDodeDemo implements Watcher{

     private final static String CONNECTSTRING="47.107.121.215:2181";

     private static CountDownLatch countDownLatch=new CountDownLatch(1);

     private static ZooKeeper zooKeeper;

     private static Stat stat=new Stat();

     public static void main(String []args) throws IOException, InterruptedException, KeeperException{
         /*zooKeeper=new ZooKeeper(CONNECTSTRING, 5000,new Watcher() {
             @Override
             public void process(WatchedEvent event) {
                 //如果当前的连接状态是连接成功的，那么通过计数器去控制
                 if(event.getState()==Event.KeeperState.SyncConnected){
                     if(Event.EventType.None==event.getType()&&null==event.getPath()){
                         countDownLatch.countDown();
                         System.out.println(event.getState()+"->"+event.getType());
                     }else if(event.getType()== Event.EventType.NodeDataChanged){//数据变更触发路径
                         try {
                             System.out.println("数据变更触发路径："+event.getPath()+"->改变后的值："+
                                     zooKeeper.getData(event.getPath(),true,stat));
                         } catch (KeeperException e) {
                             e.printStackTrace();
                         } catch (InterruptedException e) {
                             e.printStackTrace();
                         }
                     }else if(event.getType()== Event.EventType.NodeChildrenChanged){//子节点的数据变化会触发
                         try {
                             System.out.println("子节点数据变更路径："+event.getPath()+"->节点的值："+
                                     zooKeeper.getData(event.getPath(),true,stat));
                         } catch (KeeperException e) {
                             e.printStackTrace();
                         } catch (InterruptedException e) {
                             e.printStackTrace();
                         }
                     }else if(event.getType()== Event.EventType.NodeCreated){//创建子节点的时候会触发
                         try {
                             System.out.println("节点创建路径："+event.getPath()+"->节点的值："+
                                     zooKeeper.getData(event.getPath(),true,stat));
                         } catch (KeeperException e) {
                             e.printStackTrace();
                         } catch (InterruptedException e) {
                             e.printStackTrace();
                         }
                     }else if(event.getType()== Event.EventType.NodeDeleted){//子节点删除会触发
                         System.out.println("节点删除路径："+event.getPath());
                     }
                     System.out.println(event.getType());
                 }
             }
         });*/
         zooKeeper=new ZooKeeper(CONNECTSTRING, 5000,new CreateDodeDemo());//上面代码改成这一行代码

         countDownLatch.await();
         System.out.println(zooKeeper.getState());

         //连接成功创建节点
         String result=zooKeeper.create("/app","app节点创建".getBytes(),ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
         //注册
         zooKeeper.getData("/app", true, stat);
         System.out.println("创建成功->"+result);
         //修改数据
         zooKeeper.setData("/app", "修改第一次".getBytes(),-1);
         //睡眠2秒
         Thread.sleep(2000);
         //修改数据
         zooKeeper.setData("/app", "修改第二次".getBytes(),-1);
         //睡眠2秒
         Thread.sleep(2000);
         //删除
         //zooKeeper.delete("/app", -1);
         //睡眠2秒
         //Thread.sleep(2000);
         //创建节点和子节点(临时节点下不能挂子节点)
         String path="/node";

         zooKeeper.create(path, "节点node".getBytes(),ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
         TimeUnit.SECONDS.sleep(1);

         Stat stat=zooKeeper.exists(path+"/app",true);
         if(stat==null){//表示节点不存在
             zooKeeper.create(path+"/app","node子节点".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT);
             TimeUnit.SECONDS.sleep(1);
         }
         //修改子路径
         zooKeeper.setData(path+"/app","修改后的".getBytes(),-1);
         TimeUnit.SECONDS.sleep(1);

         //获取指定节点下的子节点
         List<String> list=zooKeeper.getChildren("/node", true);//第二个参数表示获取是否监控
         System.out.println(list);

     }

     /**
      * 实现接口Watcher中的process抽象方法
      */
     public void process(WatchedEvent watchedEvent) {
         //如果当前的连接状态是连接成功的，那么通过计数器去控制
         if(watchedEvent.getState()==Event.KeeperState.SyncConnected){
             if(Event.EventType.None==watchedEvent.getType()&&null==watchedEvent.getPath()){
                 countDownLatch.countDown();
                 System.out.println(watchedEvent.getState()+"-->"+watchedEvent.getType());
             }else if(watchedEvent.getType()== Event.EventType.NodeDataChanged){
                 try {
                     System.out.println("数据变更触发路径："+watchedEvent.getPath()+"->改变后的值："+
                             zooKeeper.getData(watchedEvent.getPath(),true,stat));
                 } catch (KeeperException e) {
                     e.printStackTrace();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }else if(watchedEvent.getType()== Event.EventType.NodeChildrenChanged){//子节点的数据变化会触发
                 try {
                     System.out.println("子节点数据变更路径："+watchedEvent.getPath()+"->节点的值："+
                             zooKeeper.getData(watchedEvent.getPath(),true,stat));
                 } catch (KeeperException e) {
                     e.printStackTrace();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }else if(watchedEvent.getType()== Event.EventType.NodeCreated){//创建子节点的时候会触发
                 try {
                     System.out.println("节点创建路径："+watchedEvent.getPath()+"->节点的值："+
                             zooKeeper.getData(watchedEvent.getPath(),true,stat));
                 } catch (KeeperException e) {
                     e.printStackTrace();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }else if(watchedEvent.getType()== Event.EventType.NodeDeleted){//子节点删除会触发
                 System.out.println("节点删除路径："+watchedEvent.getPath());
             }
             System.out.println(watchedEvent.getType());
         }

     }
 }

• 权限控制模式

schema：授权对象
ip     : 192.168.1.1
Digest  : username:password
world  : 开放式的权限控制模式，数据节点的访问权限对所有用户开放。 world:anyone
super  ：超级用户，可以对zookeeper上的数据节点进行操作

• 连接状态

KeeperStat.Expired  在一定时间内客户端没有收到服务器的通知， 则认为当前的会话已经过期了。
KeeperStat.Disconnected  断开连接的状态
KeeperStat.SyncConnected  客户端和服务器端在某一个节点上建立连接，并且完成一次version、zxid同步
KeeperStat.authFailed  授权失败

• 事件类型

NodeCreated  当节点被创建的时候，触发
NodeChildrenChanged  表示子节点被创建、被删除、子节点数据发生变化
NodeDataChanged    节点数据发生变化
NodeDeleted        节点被删除
None   客户端和服务器端连接状态发生变化的时候，事件类型就是None