连接Zookeeper操作

public class ZKConnector implements Watcher{
    private static final Logger logger =LoggerFactory.getLogger(ZKConnector.class);

    private CountDownLatch connectedSemaphore = new CountDownLatch(1);
    private ZooKeeper zk =null;

    /**
     * 释放zookeeper连接
     */
    public void releaseConnection() {
        if (this.zk!=null) {
            try {
                this.zk.close();
            } catch ( InterruptedException e ) {
                e.printStackTrace();
            }
        }
    } 

    /**
     * 创建zookeeper的连接
     * @param connectString zookeeper服务器地址列表
     * @param sessionTimeout Session超时时间
     */
     public void createConnection(String connectString, int sessionTimeout) {
             //先释放zookeeper连接
            this.releaseConnection();
            try {
                zk = new ZooKeeper( connectString, sessionTimeout, this);
                connectedSemaphore.await();
            } catch ( InterruptedException e ) {
                logger.info( "连接创建失败，发生 InterruptedException");
                e.printStackTrace();
            } catch (IOException e ) {
                logger.info( "连接创建失败，发生 IOException" );
                e.printStackTrace();
            }
        } 

     /**
      * 检查Znode是否为空
      */
     public boolean check(String zNode){
        try {
            return this.zk.exists(zNode, false).getDataLength()>0;
        } catch (KeeperException | InterruptedException e) {
            e.printStackTrace();
        }
        return false;
     }

     /**
      * 检查zNode是否存在
      * 不为空 返回true
      * 为空，则返回false
      */
     public boolean exist(String zNode){
        try {
                Stat stat =this.zk.exists(zNode, false);
                return stat==null?false:true;
            } catch (KeeperException | InterruptedException e) {
                e.printStackTrace();
            }
            return true;
     }

     /**
      * 读取zNode的数据
      */
     public String readData(String path){
         try {
                if(this.zk.exists(path, false) == null){
                    return "";
                }
                return new String( this.zk.getData(path, false, null));
            } catch ( KeeperException e){
                logger.info("读取数据失败，发生KeeperException，path: " + path);
                e.printStackTrace();
                return "";
            } catch ( InterruptedException e){
                logger.info("读取数据失败，发生 InterruptedException，path: " + path);
                e.printStackTrace();
                return "";
            }
     }

     /**
      * 更新zNode的数据
      */
     public boolean writeData(String path,String data){
         try {
                if(this.zk.exists(path, false) == null){
                    return createPersistNode(path,data);
                }else{
                    deleteNode(path);
                    createPersistNode(path,data);
                }
            } catch ( KeeperException e ) {
                logger.info( "更新数据失败，发生KeeperException，path: " + path  );
                e.printStackTrace();
            } catch ( InterruptedException e ) {
                logger.info( "更新数据失败，发生 InterruptedException，path: " + path  );
                e.printStackTrace();
            }
            return false;
     }

     /**
      * 获取子节点数据
      */
     public List<String> getChildren(String node){
         try {
            List<String> subNodes = this.zk.getChildren(node, false);
            return subNodes;
        } catch (KeeperException | InterruptedException e) {
            e.printStackTrace();
        }
        return null;
     }

    /**
     * 创建持久化节点
     * @param path 节点path
     * @param data    初始数据内容
     * @return
     */
    public  boolean createPersistNode(String path, String data) {
         try {
                String createpath =this.zk.create(path,data.getBytes(),Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT );
                logger.info("节点创建成功, Path: "
                        + createpath
                        + ", content: " + data );
                return true;
            } catch ( KeeperException e ) {
                logger.info( "节点创建失败，发生KeeperException" );
                e.printStackTrace();
            } catch ( InterruptedException e ) {
                logger.info( "节点创建失败，发生 InterruptedException" );
                e.printStackTrace();
            }
            return false;
    }

    /**
     * 创建短暂序列化节点
     * @param path 节点path
     * @param data 初始数据内容
     * @param needWatch
     * @return
     */
    public  String createEsquentialNode(String path, String data) {
         String esquentialNode = null;
         try {
                 esquentialNode =this.zk.create(path,data.getBytes(),Ids.OPEN_ACL_UNSAFE,CreateMode.EPHEMERAL_SEQUENTIAL);
                logger.info("节点创建成功, Path: "
                        + esquentialNode
                        + ", content: " + data );
                return esquentialNode;
            } catch ( KeeperException e ) {
                logger.info( "节点创建失败，发生KeeperException" );
                e.printStackTrace();
            } catch ( InterruptedException e ) {
                logger.info( "节点创建失败，发生 InterruptedException" );
                e.printStackTrace();
            }
            return null;
    }

    /**
     * 删除节点
     */
     public void deleteNode(String path) {
        try {
            if(this.zk.exists(path, false) == null){
                logger.info("该节点不存在！不做任何操作" );
            }else{
                this.zk.delete(path, -1);
                logger.info("删除节点成功，path："+ path);
            }
        } catch ( KeeperException e ) {
            logger.info("删除节点失败，发生KeeperException，path: " + path);
            e.printStackTrace();
        } catch ( InterruptedException e ) {
            logger.info("删除节点失败，发生 InterruptedException，path: " + path);
            e.printStackTrace();
        }
    } 

    @Override
    public void process(WatchedEvent event) {
        logger.info( "收到事件通知：" + event.getState() +"\n"  );
        if ( KeeperState.SyncConnected == event.getState() ) {
            connectedSemaphore.countDown();
        }
    }

}