Zookeeper節點操作-1

Zookeeper客戶端api有三種方式：
1、原生api

2、客戶端client

3、第三方curator

原生api使用起來麻煩點，首先事件註冊在事件觸發後就失效，又必須重新註冊，汽車刪除節點沒有原生迭代刪除api。

這裏用原生api寫的增刪該查的簡單例子。

package enjoy.zook;

import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;
import java.io.IOException;
import java.util.concurrent.CountDownLatch;

public class TestZook01 implements Watcher {
    //使用逗號，不適用分號，分號直接報錯了
    public static String CONNECTION_URL = "192.168.249.138:2181,192.168.249.139:2181,192.168.249.140:2181";
    public static int SESSION_TIME_OUT = 5000;
    private  CountDownLatch connectedSemaphore =  new CountDownLatch(1);
    public ZooKeeper zooKeeper = null;

    public static void main(String[] args) throws InterruptedException {
        TestZook01 zook = new TestZook01();
        String root = "/root";
        String path ="/root/water";
        zook.createConnection();

        if(zook.exsits(root,true) == null){
            zook.createPersistNode(root,"節點初始化");//創建持久節點
        }

        if(zook.exsits(path,true) == null){
            zook.createEphemeralNode(path,"節點初始化");//創建臨時節點
        }else{
            zook.deleteNode(path);//刪除節點
        }

        //修改數據
        if(zook.exsits(path,true) != null){
            zook.writeData(path,"hello World".getBytes());
        }

        //獲取數據
        zook.readData(path);

        //刪除節點
        if(zook.exsits(path,true) != null){
            zook.deleteNode(path);//刪除節點
        }

        //刪除節點
        if(zook.exsits(root,true) != null){
            zook.deleteNode(root);//刪除節點
        }
    }

    /**
     * 連接到服務器
     */
    public void createConnection(){
        this.releaseConnection();
        if(this.zooKeeper == null) {
            try {
                this.zooKeeper = new ZooKeeper(CONNECTION_URL, SESSION_TIME_OUT, this);
                this.connectedSemaphore.await();
            } catch (InterruptedException e) {
                System.out.println("連接創建失敗，發生InterruptedException");
                e.printStackTrace();
            }catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 釋放連接
     */
    public void releaseConnection(){
        if(this.zooKeeper != null){
            try {
                this.zooKeeper.close();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 創建持久節點
     * @param path
     * @param data
     */
    public  void createPersistNode(String path,String data){
        try {
            System.out.println("節點創建成功，path："
                    +this.zooKeeper.create(path//節點路徑
                    ,data.getBytes()//節點數據
                    , ZooDefs.Ids.OPEN_ACL_UNSAFE//節點權限
                    , CreateMode.PERSISTENT));//節點類型
        } catch (KeeperException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 創建臨時節點
     * @param path
     * @param data
     */
    public void createEphemeralNode(String path,String data){
        try {
            System.out.println("節點創建成功，path："
                    +this.zooKeeper.create(path//節點路徑
                    ,data.getBytes()//節點數據
                    , ZooDefs.Ids.OPEN_ACL_UNSAFE//節點權限
                    , CreateMode.EPHEMERAL));//節點類型
        } catch (KeeperException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 讀取節點數據
     * @param path
     * @return
     */
    public  String readData(String path){
        try {
            System.out.println("獲取數據成功，path：" + path);
            return new String(zooKeeper.getData(path,this,null));
        } catch (KeeperException e) {
            System.out.println("讀取數據失敗，發生KeeperException，path: " + path);
            e.printStackTrace();
            return "";
        } catch (InterruptedException e) {
            System.out.println("讀取數據失敗，發生 InterruptedException，path: " + path);
            e.printStackTrace();
            return "";
        }
    }
    /**
     * 更新節點數據內容
     * @param path
     * @param bytes
     */
    public void writeData(String path,byte[] bytes){
        try {
            System.out.println("更新數據成功，path：" + path + ", stat: " +
                    this.zooKeeper.setData(path, bytes, -1));
        } catch (KeeperException e) {
            System.out.println("更新數據失敗，發生KeeperException，path: " + path);
            e.printStackTrace();
        } catch (InterruptedException e) {
            System.out.println("更新數據失敗，發生KeeperException，path: " + path);
            e.printStackTrace();
        }
    }

    /**
     * 刪除節點
     * @param path
     */
    public void deleteNode(String path){
        try {
            zooKeeper.delete(path,-1);
            System.out.println("刪除節點成功，path：" + path);
        } catch (KeeperException e) {
            e.printStackTrace();
            System.out.println("刪除節點失敗，發生KeeperException，path: " + path);
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("刪除節點失敗，InterruptedException，path: " + path);
        }
    }

    /**
     * 節點是否存在
     * @param path
     */
    public Stat exsits(String path,boolean watch){
        Stat stat = null;
        try {
            stat = zooKeeper.exists(path,watch);
           System.out.println("節點是否存在，path:"+path+","+"Stat:"+stat);
        } catch (KeeperException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return stat;
    }

    public void process(WatchedEvent event) {
        System.out.print("event:"+event+">>>");
        if(Event.EventType.None.equals(event.getType())
            && event.getState() == Event.KeeperState.SyncConnected){
            System.out.println("連接到服務器...");
            this.connectedSemaphore.countDown();
        }else if(Event.EventType.NodeCreated.equals(event.getType())){
            System.out.println("監聽到節點創建...");
        }else if(Event.EventType.NodeDeleted.equals(event.getType())){
            System.out.println("監聽到節點刪除...");
        }else if(Event.EventType.NodeDataChanged.equals(event.getType())){
            System.out.println("監聽到節點更新...");
        }else if(Event.EventType.NodeChildrenChanged.equals(event.getType())){
            System.out.println("監聽到子節點刪除...");
        }
    }
}

運行結果：

event:WatchedEvent state:SyncConnected type:None path:null>>>連接到服務器...
節點是否存在，path:/root,Stat:null
event:WatchedEvent state:SyncConnected type:NodeCreated path:/root>>>監聽到節點創建...
節點創建成功，path：/root
節點是否存在，path:/root/water,Stat:null
event:WatchedEvent state:SyncConnected type:NodeCreated path:/root/water>>>監聽到節點創建...
節點創建成功，path：/root/water
節點是否存在，path:/root/water,Stat:47244640282,47244640282,1566111376602,1566111376602,0,0,0,216176252308881408,15,0,47244640282

event:WatchedEvent state:SyncConnected type:NodeDataChanged path:/root/water>>>監聽到節點更新...
更新數據成功，path：/root/water, stat: 47244640282,47244640283,1566111376602,1566111376618,1,0,0,216176252308881408,11,0,47244640282

獲取數據成功，path：/root/water
節點是否存在，path:/root/water,Stat:47244640282,47244640283,1566111376602,1566111376618,1,0,0,216176252308881408,11,0,47244640282

event:WatchedEvent state:SyncConnected type:NodeDeleted path:/root/water>>>監聽到節點刪除...
刪除節點成功，path：/root/water
節點是否存在，path:/root,Stat:47244640281,47244640281,1566111376564,1566111376564,0,2,0,0,15,0,47244640284

event:WatchedEvent state:SyncConnected type:NodeDeleted path:/root>>>監聽到節點刪除...
刪除節點成功，path：/root