PERSISTENT                    持久化节点
PERSISTENT_SEQUENTIAL        顺序自动编号持久化节点，这种节点会根据当前已存在的节点数自动加 1
EPHEMERAL                     临时节点， 客户端session超时这类节点就会被自动删除
EPHEMERAL_SEQUENTIAL         临时自动编号节点

package cn.liuzhiw.zoo;

import org.apache.zookeeper.*;
import org.apache.zookeeper.Watcher.Event.EventType;
import org.apache.zookeeper.Watcher.Event.KeeperState;
import org.apache.zookeeper.data.Stat;


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

/**
 * Created by 刘志威 on 2018/4/25.
 */
public class ZooClient2 implements Watcher {
    //zk链接地址
    private final String PORT="127.0.0.1:2181";
    //zk会话的超时时间
    private final int SESSION_TIMEOUT=2000;
    // 信号量,阻塞程序执行,用户等待zookeeper连接成功,发送成功信号，
    private static final CountDownLatch countDownLatch = new CountDownLatch(1);
    //zk客服端
    private ZooKeeper zooKeeper;
    //创建链接
    public void crateConnection(){
        try {
            zooKeeper=new ZooKeeper(PORT,SESSION_TIMEOUT,this);
            System.out.println("zk 开始启动连接服务器....");
            //进行阻塞
            countDownLatch.await();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //process() 是 Watch 接口中的回调方法。当 ZooKeeper 向客户端发送一个 Watcher 时间通知时，
    public void process(WatchedEvent watchedEvent) {
        //获取事件的状态
        KeeperState state = watchedEvent.getState();
        //获取事件的类型
        EventType type = watchedEvent.getType();
        //获取事件路径
        String path = watchedEvent.getPath();
        System.out.println("进入到process方法,事件通知 Path:" + path);
        if (KeeperState.SyncConnected == state) {
            if (EventType.None == type) {
                // 建立连接状态
                System.out.println("zk开始连接...");
                //利用它可以实现类似计数器的功能。比如有一个任务A，它要等待其他4个任务执行完毕之后才能执行，
                // 此时就可以利用CountDownLatch来实现这种功能了。
                countDownLatch.countDown();
                //等待链接解成功了才可以走下面的方法
            } else if (EventType.NodeCreated == type) {
                System.out.println("事件通知,新增note节点:" + path);
            } else if (EventType.NodeDataChanged == type) {
                System.out.println("事件通知,当前node节点" + path + "被修改....");
            } else if (EventType.NodeDeleted == type) {
                System.out.println("事件通知,当前node节点" + path + "被删除....");
            }

        }
    }
    //创建一个新的持久节点
    public boolean crateNode(String path,String data){
        //创建持久节点,开放权限
        try {
            exists(path,true);
            this.zooKeeper.create(path, data.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
            System.out.println("节点创建成功, Path:" + path + ",data:" + data);
            return true;
        }catch (Exception e){
            return false;
        }
    }
    //判断节点是否存在
    public Stat exists(String path, boolean needWatch) {
        try {
            return this.zooKeeper.exists(path, needWatch);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    //删除节点
    public boolean deleteNode(){
        return false;
    }
    //修改节点
    public boolean updateNode(String path, String data) throws KeeperException, InterruptedException {
        exists(path, true);
        this.zooKeeper.setData(path, data.getBytes(), -1);
        return false;
    }
}

package cn.liuzhiw.app;

import cn.liuzhiw.zoo.ZooClient;
import cn.liuzhiw.zoo.ZooClient2;
import org.apache.zookeeper.KeeperException;

import java.io.IOException;

/**
 * 启动类
 * Created by 刘志威 on 2018/4/25.
 */
public class App {
    public static void main(String[] args) throws KeeperException, InterruptedException {
        ZooClient2 zooClient=new ZooClient2();
        zooClient.crateConnection();
        zooClient.updateNode("/liuzhiwei","刘爸爸");
    }
}