七：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);
        }
        
    }
}