七：zooKeeper开源客户端ZkClient的api测试

ZkClient是Gitthub上一个开源的ZooKeeper客户端。ZKClient在ZooKeeper原生API接口之上进行了包装，是一个更加易用的ZooKeeper客户端。同时ZKClient在内部实现诸如Session超时重连，Watcher反复注册等功能。

一：maven依赖

  <dependency>
       <groupId>org.apache.zookeeper</groupId>
       <artifactId>zookeeper</artifactId>
       <version>3.4.6</version>
     </dependency>
     <dependency>
       <groupId>com.101tec</groupId>
       <artifactId>zkclient</artifactId>
       <version>0.5</version>
     </dependency>

二：一个java存储实体

 package com.yeepay.sxf.testZkClient;

 import java.io.Serializable;

 /**
  * 用户对象
  * @author sxf
  *
  */
 public class User implements Serializable{
     private int id;
     private String name;
     private String address;

     public int getId() {
         return id;
     }
     public void setId(int id) {
         this.id = id;
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public String getAddress() {
         return address;
     }
     public void setAddress(String address) {
         this.address = address;
     }

 }

三：测试源代码

 package com.yeepay.sxf.testZkClient;

 import java.util.List;

 import org.I0Itec.zkclient.IZkChildListener;
 import org.I0Itec.zkclient.IZkDataListener;
 import org.I0Itec.zkclient.ZkClient;
 import org.I0Itec.zkclient.serialize.BytesPushThroughSerializer;
 import org.apache.zookeeper.CreateMode;
 import org.apache.zookeeper.data.Stat;
 /**
  * zkclient的api测试
  * acl权限相关操作和原生zookeeper客户端一样
  * @author sxf
  *
  */
 public class CreateSession {

     public static void main(String[] args) throws InterruptedException {
         //第一个参数：zk的ip：端口号
         //会话过期时间
         //链接超时时间
         //序列化器（将java对象转化成byte数组，得到时从byte数组反序列化成java对象）这个序列化器在事件订阅上，修改数据一定要保持一致，否则无效果
         //ZkClient zkClient=new ZkClient("10.151.30.75:2181", 10000, 10000, new SerializableSerializer());

         //这个客户端链接，传入的序列化器皿等于什么都没做
         ZkClient zkClient=new ZkClient("10.151.30.75:2181", 10000, 10000, new BytesPushThroughSerializer());

         //创建一个节点
         //createNode(zkClient);

         //获取一个节点中存取的值
         //getNodeValue(zkClient);

         //获取一个节点下的子节点列表
         //getNodeChildList(zkClient);

         //判断一个节点是否存在
         //isNodeExists(zkClient);

         //删除一个节点
         //deleteNode(zkClient);

         //修改一个节点的数据
         //updateNodeValue(zkClient);

         //为某个节点的子节点列表发生变化订阅一个事件
         //whenChildListChangeThenDoSomeThing(zkClient);

         //为某个节点存储的值发生变化或者节点被删除订阅一个事件
         whenNodeValueChangeThenDoThing(zkClient);

         Thread.sleep(Integer.MAX_VALUE);
     }

     /**
      * 创建一个node节点
      * @param zkClient
      */
     public static void createNode(ZkClient zkClient){
         //user 对象必须实现序列化接口Serializable
         User user=new User();
         user.setId(1);
         user.setName("shangxiaofei");
         user.setAddress("smx");
         //（节点路径，节点数据，持久节点）
         String path=zkClient.create("/node_131", user, CreateMode.PERSISTENT);
         System.out.println("CreateSession.createNode(创建节点路径为：)"+path);
     }

     /**
      * 获取一个节点中存取的值
      * @param zkClient
      */
     public static void getNodeValue(ZkClient zkClient){

         Stat stat=new Stat();
         //获取一个节点中存取的值
         User user=zkClient.readData("/node_131",stat);
         System.out.println("CreateSession.getNodeValue(id==>)"+user.getId());
         System.out.println("CreateSession.getNodeValue(name==>)"+user.getName());
         System.out.println("CreateSession.getNodeValue(address==>)"+user.getAddress());
         System.out.println("CreateSession.getNodeValue(节点状态==>)"+stat);
     }

     /**
      * 获取某个节点的子节点列表
      * @param zkClient
      */
     public static void getNodeChildList(ZkClient zkClient){

         List<String> nodesList=zkClient.getChildren("/");
         System.out.println("CreateSession.getNodeChildList(“/”下的子节点列表为=>)"+nodesList);
     }

     /**
      * 检测某一个节点是否存在
      * @param zkClient
      */
     public static void isNodeExists(ZkClient zkClient){
         boolean flag=zkClient.exists("/node_132");
         System.out.println("CreateSession.isNodeExists(节点是否存在的结果)"+flag);
     }

     /**
      * 删除一个节点或删除存在子节点的节点
      * @param zkClient
      */
     public static void deleteNode(ZkClient zkClient){
         //删除无子节点的节点。如果存在子节点，抛出异常
         boolean flag=zkClient.delete("/node_131");
         System.out.println("CreateSession.deleteNode(删除无子节点的节点结果==>)"+flag);

         //删除存在子节点的节点。先深入子节点，删除掉所有子节点的节点，再删除当前节点
         boolean flag2=zkClient.deleteRecursive("/node_131");
         System.out.println("CreateSession.deleteNode(删除存在子节点的节点结果==>)"+flag2);
     }

     /**
      * 修改一个数据节点中存储的值
      * @param zkClient
      */
     public static void updateNodeValue(ZkClient zkClient){
         User user=new User();
         user.setId(100);
         user.setName("shangxiaoshuai");
         user.setAddress("smxcyxzyc");
         //修改一个节点中存储的数据
         zkClient.writeData("/node_131", user);

         //修改一个节点中存储的数据，实现类似乐观锁的功能
         zkClient.writeData("/node_131", user, 1);
     }

     /**
      * 当子节点列表发生变化，则触发一个事件
      */
     public static void whenChildListChangeThenDoSomeThing(ZkClient zkClient){
         /**
          * 可以监听（1）子节点列表发生变化，增加新子节点，删除子节点
          * （2）节点本身被删除
          *    （3）节点本身被创建，意味着可以订阅一个并不存在的节点的监听事件
          */

         zkClient.subscribeChildChanges("/node_132", new WhenChildChangeThing());
     }
     /**
      * 当子节点列表发生变化的事件实现类
      * @author sxf
      *
      */
     private static class WhenChildChangeThing implements IZkChildListener{

         @Override
         public void handleChildChange(String parentPath,List<String> currentChilds) throws Exception {
                 System.out.println("节点列表变化的父节点路径==>"+parentPath);
                 System.out.println("当前的节点列表==>"+currentChilds);
         }

     }

     /**
      * 为节点数据内容发生变化订阅一个事件
      * @param zkClient
      */
     public static void whenNodeValueChangeThenDoThing(ZkClient zkClient){
         zkClient.subscribeDataChanges("/node_132", new WhenNodeValueChange());
     }
     /**
      * 当数据节点存储的值发生变化的事件监听类
      * @author sxf
      *
      */
     private static class WhenNodeValueChange implements IZkDataListener{

         //当节点数据内容发生变化这个函数被调用
         @Override
         public void handleDataChange(String dataPath, Object data)
                 throws Exception {
             System.out.println("节点数据内容发生变化，变化后的值为==>"+data);
             System.out.println("节点数据内容发生变化，变化节点的路径==>"+dataPath);
         }

         //当节点被删除时这个函数被调用
         @Override
         public void handleDataDeleted(String dataPath) throws Exception {
             System.out.println("节点被删除的路径为==>"+dataPath);
         }

     }
 }