zookeeper系列（二）zookeeper的使用--javaAPI

時間 2019-11-09

標籤 zookeeper 系列使用 javaapi 欄目 Zookeeper 简体版

原文原文鏈接

做者：leesf 掌控之中，纔會成功；掌控以外，註定失敗； 出處：http://www.cnblogs.com/leesf456/ （尊重原創，感謝做者整理的這麼好，做者的部份內容添加了個人理解和闡述，供你們一塊兒學習討論）html

1、前言java

　　上一篇博客咱們經過命令行來操做Zookeper的客戶端和服務端並進行相應的操做，這篇主要介紹如何經過API（JAVA）來操做Zookeeper。node

2、開發環境配置apache

　　首先打開Zookeeper服務端（上一篇博客有具體的方法），方便客戶端鏈接。api

　　配置開發環境環境能夠有兩種方式：① 直接下載相關的依賴Jar包，而後在IDE中添加依賴 ② 創建maven項目，使用maven進行依賴管理。數組

　　① 手動添加依賴至IDE服務器

　　步驟一：點擊這裏下載對應版本的Jar包，包括（jar、javadoc.jar、sources.jar），筆者對應下載的Zookeeper3.4.6版本。網絡

　　步驟二：打開IDE（我用的是MyEclipse），新建名爲zookeeper_examples_none_maven的java項目。因爲須要單獨添加依賴，爲了方便管理，筆者在項目下新建了jar文件夾，用於存放本項目的jar包（將步驟一下載的3個jar包存放至此文件夾下）。session

　　步驟三：在MyEclipse中添加依賴，選中項目右鍵-->build path -->Libraries-->Add JARs引入jar文件夾下的jar包；（須要加入log4j和slf4j-api倆個jar包）併發

步驟四：新建包、Java類進行測試

　　Zookeeper_Constructor_Usage_Simple.java

package com.hust.grid.leesf.examples;

import java.io.IOException;
import java.util.concurrent.CountDownLatch;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.Watcher.Event.KeeperState;
/**
 * 使用zookeeper的javaAPI實現客戶端對zookeeper服務端的鏈接；
 */
public class Zookeeper_Constructor_Usage_Simple implements Watcher {
	
	private static final int SESSION_TIMEOUT = 5000;
	//對執行中的線程進行管理，等待線程完成某些操做後，再對此線程作處理（起到過河拆橋、卸磨殺驢的做用）
	private static CountDownLatch connectedSemaphore = new CountDownLatch(1);
	
	ZooKeeper zookeeper;
	/**
	 * 在鏈接函數中建立了zookeeper的實例;而後創建與服務器的鏈接;
	 * 創建鏈接函數會當即返回，因此咱們須要等待鏈接創建成功後再進行其餘的操做;
	 * 咱們使用connectedSemaphore.await()來阻塞當前線程，直到zookeeper準備就緒;
	 */
	public void connect(String host) throws IOException, InterruptedException{
		/**
		 * host 127.0.0.1:2181，服務器端主機名稱以及端口號；
		 * SESSION_TIMEOUT 客戶端鏈接服務器session的超時時間；
		 * this 表示Watcher接口的一個實例，Watcher實例負責接收Zookeeper數據變化時產生的事件回調；
		 */
		zookeeper = new ZooKeeper(host, SESSION_TIMEOUT, this);
		System.out.println("zk的鏈接狀態："+zookeeper.getState());
		connectedSemaphore.await();
		System.out.println("Zookeeper session established");
	}
	/**
	 * 當客戶端鏈接上了zookeeper服務器，Watcher接口會使用process()方法接收一個鏈接成功的事件,
	 * 接下來調用CountDownLatch釋放以前的阻塞；
	 */
	public void process(WatchedEvent event) {
		System.out.println("Receive watched event : " + event);
        if (KeeperState.SyncConnected == event.getState()) {
        	System.out.println("鏈接成功：再也不阻塞當前線程");
            connectedSemaphore.countDown();
        }
	}
	
	public static void main(String[] args) throws IOException, InterruptedException {
		Zookeeper_Constructor_Usage_Simple zookeeperConstructor = new Zookeeper_Constructor_Usage_Simple();
		zookeeperConstructor.connect("127.0.0.1:2181");
    }

}

打印結果爲下圖所示：

表示客戶端已經成功鏈接至服務器了。

　　能夠看到方法一相對而言比較麻煩，須要手動管理不一樣的依賴jar包，能夠採用更成熟的依賴管理方法，即便用maven來管理Jar包。

　　② 使用maven管理依賴

　　步驟一：新建maven項目，使用IDE工具直接建立便可；

直接next便可：

依然是Next：

步驟二：配置pom.xml文件以下

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.hust.grid.leesf</groupId>
  <artifactId>zookeeper_examples</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>
  <name>zookeeper_examples</name>
  <url>http://maven.apache.org</url>
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    <dependency>
    	<groupId>org.apache.zookeeper</groupId>
    	<artifactId>zookeeper</artifactId>
    	<version>3.4.6</version>
    </dependency>
    <dependency>
    	<groupId>log4j</groupId>
    	<artifactId>log4j</artifactId>
    	<version>1.2.17</version>
    	<type>bundle</type>
    </dependency>
    <dependency>
    	<groupId>org.slf4j</groupId>
    	<artifactId>slf4j-api</artifactId>
    	<version>1.7.21</version>
    </dependency>
  </dependencies>
</project>

步驟三：新建java類進行測試

　　Zookeeper_Constructor_Usage_Simple.java，代碼同上（執行結果不在重複展現）。

先說一下CountDownLatch這個類，這是個很牛逼的門閂，能夠對當前執行線程進行管理；我使用該類的源碼作一個說明，模擬軍隊撤退的過程；

package com.hust.grid.leesf.curator;

import java.util.concurrent.CountDownLatch;

 /**
  * 模擬軍隊撤退過程：軍官先跑，而後小兵再跑
  * CountDownLatch相似於一個門閂，當計數器不爲0，當前線程不能執行，使用await方法將線程關在門外；
  * 執行一次countDown，計數器就減1，一旦計數器減完後是0，那麼await方法當即打開門，讓線程執行；
  * @author songzl
  *
  */
public class Driver {
	public static void main(String[] arg) throws InterruptedException {
      CountDownLatch startSignal = new CountDownLatch(1);
      CountDownLatch doneSignal = new CountDownLatch(5);
 
      for (int i = 0; i < 5; ++i){ // create and start threads
    	  new Thread(new Worker(startSignal, doneSignal,i)).start();
      }
      //軍座先跑
      doSomethingElse("軍座先撤退...");
      //而後計算器減1
      startSignal.countDown();//軍座撤退完畢，打開門閂，讓小兵開始跑
      doSomethingElse("軍座撤退成功，讓小兵撤退...");
      //清點人數，確認小兵是否所有撤退，若沒有須要列隊等待
      doneSignal.await();           // wait for all to finish
      System.out.println("全軍撤退完畢！");
    }

	private static void doSomethingElse(String commond) {
		System.out.println(commond);
	}
}
class Worker implements Runnable {
	private final CountDownLatch startSignal;
	private final CountDownLatch doneSignal;
	private int count = 0;

	public Worker(CountDownLatch startSignal, CountDownLatch doneSignal,int count) {
		this.startSignal = startSignal;
		this.doneSignal = doneSignal;
		this.count = count;
	}
	public void run() {
		try {
			System.out.println("第"+count+"個小兵試圖逃跑，被要求滾回戰場...");
			startSignal.await();
	        doWork(count);
	        doneSignal.countDown();
	    } catch (InterruptedException e) {
    	   e.printStackTrace();
	    } 
	}
	private void doWork(int count) {
		System.out.println("軍座都跑完了，咱們小兵也跑吧,第"+count+"個小兵逃跑："+Thread.currentThread().getName());
	}

}

3、操做示例

　　3.1 建立節點

　　建立節點有異步和同步兩種方式。不管是異步或者同步，Zookeeper都不支持遞歸調用，即沒法在父節點不存在的狀況下建立一個子節點，如在/zk-ephemeral節點不存在的狀況下建立/zk-ephemeral/ch1節點；而且若是一個節點已經存在，那麼建立同名節點時，會拋出NodeExistsException異常。

　　① 同步方式

package com.hust.grid.leesf.examples;

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

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.Watcher.Event.KeeperState;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.data.ACL;
/**
 * 使用zookeeper的javaAPI實現客戶端對zookeeper服務端的鏈接；而且給服務端建立znode節點
 */
public class Zookeeper_Constructor_Usage_Simple implements Watcher {
	
	private static final int SESSION_TIMEOUT = 5000;
	//對執行中的線程進行管理，等待線程完成某些操做後，再對此線程作處理（起到過河拆橋、卸磨殺驢的做用）
	private static CountDownLatch connectedSemaphore = new CountDownLatch(1);
	
	ZooKeeper zookeeper;
	/**
	 * 在鏈接函數中建立了zookeeper的實例;而後創建與服務器的鏈接;
	 * 創建鏈接函數會當即返回，因此咱們須要等待鏈接創建成功後再進行其餘的操做;
	 * 咱們使用CountDownLatch來阻塞當前線程，直到zookeeper準備就緒;
	 */
	public void connect(String host) throws IOException, InterruptedException{
		/**
		 * host 127.0.0.1:2181，服務器端主機名稱以及端口號；
		 * SESSION_TIMEOUT 客戶端鏈接服務器session的超時時間；
		 * this 表示Watcher接口的一個實例，Watcher實例負責接收Zookeeper數據變化時產生的事件回調；
		 */
		zookeeper = new ZooKeeper(host, SESSION_TIMEOUT, this);
		System.out.println("zk的鏈接狀態："+zookeeper.getState());
		connectedSemaphore.await();
		System.out.println("Zookeeper session established");
	}
	/**
	 * 當客戶端鏈接上了zookeeper服務器，Watcher接口會使用process()方法接收一個鏈接成功的事件,
	 * 接下來調用CountDownLatch釋放以前的阻塞；
	 */
	public void process(WatchedEvent event) {
		System.out.println("Receive watched event : " + event);
        if (KeeperState.SyncConnected == event.getState()) {
        	System.out.println("鏈接成功：再也不阻塞當前線程");
            connectedSemaphore.countDown();
        }
	}
	/**
	 * 同步建立節點：方法中調用zookeeper實例的create()方法來建立一個znode;
	 * @param path znode節點的絕對路徑
	 * @param bytes znode節點的內容（一個二進制數組）
	 * @param ACL access control list(ACL，訪問控制列表，這裏使用徹底開放模式)
	 * @param createMode znode的性質，分爲EPHEMERAL（臨時）、PERSISTENT（持久）、EPHEMERAL_SEQUENTIAL臨時順序和PERSISTENT_SEQUENTIAL持久順序
	 * @throws KeeperException
	 * @throws InterruptedException
	 */
	public void create(String path,byte[] bytes,ArrayList<ACL> ACL,CreateMode createMode) throws KeeperException, InterruptedException{
		String znodePath = zookeeper.create(path, bytes, ACL, createMode);    
        System.out.println("Success create znode: " + znodePath);
	}
	public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
		Zookeeper_Constructor_Usage_Simple zookeeperConstructor = new Zookeeper_Constructor_Usage_Simple();
		zookeeperConstructor.connect("127.0.0.1:2181");
		System.out.println("開始給zookeeper服務端建立節點=========");
		zookeeperConstructor.create("/zk-test-ephemeral-", "".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL); 
		zookeeperConstructor.create("/zk-test-ephemeral-", "".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL); 
    }

}

運行結果以下：

結果代表已經成功建立了臨時節點和臨時順序節點，在建立順序節點時，系統會在後面自動增長一串數字。

② 異步方式

　　使用異步方式於同步方式的區別在於節點的建立過程（包括網絡通訊和服務端的節點建立過程）是異步的，在同步接口調用過程當中，開發者須要關注接口拋出異常的可能，可是在異步接口中，接口自己不會拋出異常，全部異常都會在回調函數中經過Result Code來體現。

package com.hust.grid.leesf.examples;

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

import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.Watcher.Event.KeeperState;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.data.ACL;
import org.apache.zookeeper.ZooKeeper;
/**
 * 使用zookeeper的javaAPI實現客戶端對zookeeper服務端的鏈接,而且使用異步方法建立znode節點
 * @author songzl
 */
public class Zookeeper_Create_API_ASync_Usage implements Watcher {

private static final int SESSION_TIMEOUT = 5000;
	//對執行中的線程進行管理，等待線程完成某些操做後，再對此線程作處理（起到過河拆橋、卸磨殺驢的做用）
	private static CountDownLatch connectedSemaphore = new CountDownLatch(1);
	
	ZooKeeper zookeeper;
	/**
	 * 在鏈接函數中建立了zookeeper的實例;而後創建與服務器的鏈接;
	 * 創建鏈接函數會當即返回，因此咱們須要等待鏈接創建成功後再進行其餘的操做;
	 * 咱們使用CountDownLatch來阻塞當前線程，直到zookeeper準備就緒;
	 */
	public void connect(String host) throws IOException, InterruptedException{
		/**
		 * host 127.0.0.1:2181，服務器端主機名稱以及端口號；
		 * SESSION_TIMEOUT 客戶端鏈接服務器session的超時時間；
		 * this 表示Watcher接口的一個實例，Watcher實例負責接收Zookeeper數據變化時產生的事件回調；
		 */
		zookeeper = new ZooKeeper(host, SESSION_TIMEOUT, this);
		System.out.println("zk的鏈接狀態："+zookeeper.getState());
		connectedSemaphore.await();
		System.out.println("Zookeeper session established");
	}
	/**
	 * 當客戶端鏈接上了zookeeper服務器，Watcher接口會使用process()方法接收一個鏈接成功的事件,
	 * 接下來調用CountDownLatch釋放以前的阻塞；
	 */
	public void process(WatchedEvent event) {
		System.out.println("Receive watched event : " + event);
        if (KeeperState.SyncConnected == event.getState()) {
        	System.out.println("鏈接成功：再也不阻塞當前線程");
            connectedSemaphore.countDown();
        }
	}
	/**
	 * 異步建立節點：方法中調用zookeeper實例的create()方法來建立一個znode;
	 * @param path znode節點的絕對路徑
	 * @param bytes znode節點的內容（一個二進制數組）
	 * @param ACL access control list(ACL，訪問控制列表，這裏使用徹底開放模式)
	 * @param createMode znode的性質，分爲EPHEMERAL（臨時）、PERSISTENT（持久）、EPHEMERAL_SEQUENTIAL臨時順序和PERSISTENT_SEQUENTIAL持久順序
	 * @param string 一個java的字符串
	 * @param iStringCallback 回調函數
	 * @throws KeeperException
	 * @throws InterruptedException
	 */
	public void create(String path,byte[] bytes,ArrayList<ACL> ACL,CreateMode createMode, IStringCallback iStringCallback, String string) throws KeeperException, InterruptedException{
		String znodePath = zookeeper.create(path, bytes, ACL, createMode);    
        System.out.println("Success create znode: " + znodePath);
	}

    public static void main(String[] args) throws Exception {
    	Zookeeper_Create_API_ASync_Usage zookeeperCreateAPIASyncUsage = new Zookeeper_Create_API_ASync_Usage();
    	zookeeperCreateAPIASyncUsage.connect("127.0.0.1:2181");
    	//異步建立臨時節點
    	zookeeperCreateAPIASyncUsage.create("/zk-test-ephemeral-", "".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL,
                new IStringCallback(), "I am context. ");
    	//異步建立臨時順序節點
    	zookeeperCreateAPIASyncUsage.create("/zk-test-ephemeral-", "".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL,
                new IStringCallback(), "I am context. ");
    	//若是不阻塞線程，session超時後臨時節點會自動刪除
        Thread.sleep(Integer.MAX_VALUE);
    }

}
class IStringCallback implements AsyncCallback.StringCallback {
    public void processResult(int rc, String path, Object ctx, String name) {
        System.out.println("Create path result: [" + rc + ", " + path + ", " + ctx + ", real path name: " + name);
    }
}

運行結果以下：

3.2 刪除節點　

　　只容許刪除葉子節點，即一個節點若是有子節點，那麼該節點將沒法直接刪除，必須先刪掉其全部子節點。一樣也有同步和異步兩種方式。　

　　同步和異步方式

package com.hust.grid.leesf.examples;

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

import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.AsyncCallback.VoidCallback;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.Watcher.Event.EventType;
import org.apache.zookeeper.Watcher.Event.KeeperState;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.data.ACL;
import org.apache.zookeeper.ZooKeeper;

public class Delete_API_Sync_Usage implements Watcher{
	
	private static final int SESSION_TIMEOUT = 5000;
	//對執行中的線程進行管理，等待線程完成某些操做後，再對此線程作處理（起到過河拆橋、卸磨殺驢的做用）
	private static CountDownLatch connectedSemaphore = new CountDownLatch(1);
	
    private static ZooKeeper zookeeper;

    /**
	 * 在鏈接函數中建立了zookeeper的實例;而後創建與服務器的鏈接;
	 * 創建鏈接函數會當即返回，因此咱們須要等待鏈接創建成功後再進行其餘的操做;
	 * 咱們使用CountDownLatch來阻塞當前線程，直到zookeeper準備就緒;
	 */
	public void connect(String host) throws IOException, InterruptedException{
		/**
		 * host 127.0.0.1:2181，服務器端主機名稱以及端口號；
		 * SESSION_TIMEOUT 客戶端鏈接服務器session的超時時間；
		 * this 表示Watcher接口的一個實例，Watcher實例負責接收Zookeeper數據變化時產生的事件回調；
		 */
		zookeeper = new ZooKeeper(host, SESSION_TIMEOUT, this);
		System.out.println("zk的鏈接狀態："+zookeeper.getState());
		connectedSemaphore.await();
		System.out.println("Zookeeper session established");
	}
	/**
	 * 當客戶端鏈接上了zookeeper服務器，Watcher接口會使用process()方法接收一個鏈接成功的事件,
	 * 接下來調用CountDownLatch釋放以前的阻塞；
	 */
	public void process(WatchedEvent event) {
        if (KeeperState.SyncConnected == event.getState()) {
            if (EventType.None == event.getType() && null == event.getPath()) {
                connectedSemaphore.countDown();
            }
        }
    }
	/**
	 * 方法中調用zookeeper實例的create()方法來建立一個znode;
	 * @param path znode節點的絕對路徑
	 * @param bytes znode節點的內容（一個二進制數組）
	 * @param ACL access control list(ACL，訪問控制列表，這裏使用徹底開放模式)
	 * @param createMode znode的性質，分爲EPHEMERAL（臨時）、PERSISTENT（持久）、EPHEMERAL_SEQUENTIAL臨時順序和PERSISTENT_SEQUENTIAL持久順序
	 * @throws KeeperException
	 * @throws InterruptedException
	 */
	public void create(String path,byte[] bytes,ArrayList<ACL> ACL,CreateMode createMode) throws KeeperException, InterruptedException{
		String znodePath = zookeeper.create(path, bytes, ACL, createMode);    
        System.out.println("Success create znode: " + znodePath);
	}
	/**
	 * 同步刪除znode的節點方法
	 * @param path znode節點的絕對路徑
	 * @param version znode節點的版本號（-1表示不匹配版本號）
	 * @throws InterruptedException
	 * @throws KeeperException
	 */
	public void syncDelete(String path,int version) throws InterruptedException, KeeperException{
		zookeeper.delete(path, version);
	}
	/**
	 * 異步刪除znode的節點方法
	 * @param path znode節點的絕對路徑
	 * @param version znode節點的版本號（-1表示不匹配版本號）
	 * @param cb
	 * @param ctx
	 * @throws InterruptedException
	 * @throws KeeperException
	 */
	public void AsyncDelete(String path, int version, VoidCallback cb, Object ctx) throws InterruptedException, KeeperException{
		zookeeper.delete(path, version, cb, ctx);
	}
	
    public static void main(String[] args) throws Exception {
        String path = "/zk-book";
        Delete_API_Sync_Usage delete_API_Sync_Usage = new Delete_API_Sync_Usage();
        delete_API_Sync_Usage.connect("127.0.0.1:2181");
        //建立path爲"/zk-book"的節點
        delete_API_Sync_Usage.create(path, "".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        System.out.println("success create znode: " + path);
        //建立path爲"/zk-book/c1"的節點
        delete_API_Sync_Usage.create(path + "/c1", "".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        System.out.println("success create znode: " + path + "/c1");
        //============調用同步刪除節點開始=======================================
        try {
        	//直接刪除path爲"/zk-book"的節點失敗，由於包含子節點
        	delete_API_Sync_Usage.syncDelete(path, -1);
        } catch (Exception e) {
            System.out.println("fail to delete znode: " + path);
        }
        //先刪除子節點
        delete_API_Sync_Usage.syncDelete(path + "/c1", -1);
        System.out.println("success delete znode: " + path + "/c1");
        //再刪除父節點
        delete_API_Sync_Usage.syncDelete(path, -1);        
        System.out.println("success delete znode: " + path);
        //============調用同步刪除節點結束=======================================
        
        //============調用異步步刪除節點開始=======================================
        delete_API_Sync_Usage.AsyncDelete(path, -1, new IVoidCallback(), null);        
        delete_API_Sync_Usage.AsyncDelete(path + "/c1", -1, new IVoidCallback(), null);
        delete_API_Sync_Usage.AsyncDelete(path, -1, new IVoidCallback(), null); 
        
        Thread.sleep(Integer.MAX_VALUE);
    }
}
/**
 * 異步刪除時，接口的一個回調函數
 * 參數rc表示返回碼;
 * 參數path和ctx與客戶端調用的方法中的參數相等,這兩個參數一般用來肯定回調中得到的響應是來自於哪一個請求的；
 * 參數ctx能夠是任意對象，只有當path參數不能消滅請求的歧義時纔會用到，若是不須要參數ctx，能夠設置爲null
 */
class IVoidCallback implements AsyncCallback.VoidCallback {
    public void processResult(int rc, String path, Object ctx) {
        System.out.println(rc + ", " + path + ", " + ctx);
    }
}

　　備註：ZooKeeper的API提供一個delete()方法來刪除一個znode。咱們經過輸入znode的path和版本號（version number）來刪除想要刪除的znode。除了使用path來定位咱們要刪除的znode，還須要一個參數是版本號。只有當咱們指定要刪除的本版號，與znode當前的版本號一致時，ZooKeeper才容許咱們將znode刪除掉。這是一種optimistic locking（樂觀鎖）機制，用來處理znode的讀寫衝突。咱們也能夠忽略版本號一致檢查，作法就是版本號賦值爲-1。

3.3 子節點獲取

　　讀取節點的子節點列表，一樣可使用同步和異步的方式進行操做。

package com.hust.grid.leesf.examples;

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

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.Watcher.Event.EventType;
import org.apache.zookeeper.Watcher.Event.KeeperState;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.data.ACL;
import org.apache.zookeeper.ZooKeeper;
/**
 * 獲取zookeeper的子節點：建立一個父節點和三個子節點
 */
public class Zookeeper_GetChildren_API_Sync_Usage implements Watcher {
	
	private static final int SESSION_TIMEOUT = 5000;
	//對執行中的線程進行管理，等待線程完成某些操做後，再對此線程作處理（起到過河拆橋、卸磨殺驢的做用）
	private static CountDownLatch connectedSemaphore = new CountDownLatch(1);
	
	private static ZooKeeper zookeeper;
	/**
	 * 在鏈接函數中建立了zookeeper的實例;而後創建與服務器的鏈接;
	 * 創建鏈接函數會當即返回，因此咱們須要等待鏈接創建成功後再進行其餘的操做;
	 * 咱們使用CountDownLatch來阻塞當前線程，直到zookeeper準備就緒;
	 */
	public void connect(String host) throws IOException, InterruptedException{
		/**
		 * host 127.0.0.1:2181，服務器端主機名稱以及端口號；
		 * SESSION_TIMEOUT 客戶端鏈接服務器session的超時時間；
		 * this 表示Watcher接口的一個實例，Watcher實例負責接收Zookeeper數據變化時產生的事件回調；
		 */
		zookeeper = new ZooKeeper(host, SESSION_TIMEOUT, this);
		System.out.println("zk的鏈接狀態："+zookeeper.getState());
		connectedSemaphore.await();
		System.out.println("Zookeeper session established");
	}
	public void process(WatchedEvent event) {
		if (KeeperState.SyncConnected == event.getState()) {
            if (EventType.None == event.getType() && null == event.getPath()) {
                connectedSemaphore.countDown();
            } else if (event.getType() == EventType.NodeChildrenChanged) {
                try {
                	//獲取子節點
                    System.out.println("ReGet Child:" + zookeeper.getChildren(event.getPath(), true));
                } catch (Exception e) {
                }
            }
        }
	}
	/**
	 * 方法中調用zookeeper實例的create()方法來建立一個znode;
	 * @param path znode節點的絕對路徑
	 * @param bytes znode節點的內容（一個二進制數組）
	 * @param ACL access control list(ACL，訪問控制列表，這裏使用徹底開放模式)
	 * @param createMode znode的性質，分爲EPHEMERAL（臨時）、PERSISTENT（持久）、EPHEMERAL_SEQUENTIAL臨時順序和PERSISTENT_SEQUENTIAL持久順序
	 * @throws KeeperException
	 * @throws InterruptedException
	 */
	public void create(String path,byte[] bytes,ArrayList<ACL> ACL,CreateMode createMode) throws KeeperException, InterruptedException{
		String znodePath = zookeeper.create(path, bytes, ACL, createMode);    
        System.out.println("Success create znode: " + znodePath);
	}
	public static void main(String[] args) throws KeeperException, InterruptedException, IOException {
		Zookeeper_GetChildren_API_Sync_Usage zookeeper_GetChildren_API_Sync_Usage = new Zookeeper_GetChildren_API_Sync_Usage();
		zookeeper_GetChildren_API_Sync_Usage.connect("127.0.0.1:2181");
		String path = "/zk-book-1";
		//建立父節點
		zookeeper_GetChildren_API_Sync_Usage.create(path, "".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
		//建立子節點
		zookeeper_GetChildren_API_Sync_Usage.create(path + "/c1", "".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
		List<String> childrenList = zookeeper.getChildren(path, true);
		System.out.println(childrenList);
		zookeeper_GetChildren_API_Sync_Usage.create(path + "/c2", "".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
		Thread.sleep(1000);
		zookeeper_GetChildren_API_Sync_Usage.create(path + "/c3", "".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
		Thread.sleep(Integer.MAX_VALUE);
	}

}

值得注意的是，Watcher通知是一次性的，即一旦觸發一次通知後，該Watcher就失效了，所以客戶端須要反覆註冊Watcher，即程序中在process裏面又註冊了Watcher，不然，將沒法獲取c3節點的建立而致使子節點變化的事件。

3.4 數據節點獲取（再也不展現異步的獲取方式）

package com.hust.grid.leesf.examples;

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

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.Watcher.Event.EventType;
import org.apache.zookeeper.Watcher.Event.KeeperState;
import org.apache.zookeeper.data.ACL;
import org.apache.zookeeper.data.Stat;
/**
 * 數據節點獲取
 */
public class GetData_API_Sync_Usage implements Watcher{
	
	private static final int SESSION_TIMEOUT = 5000;
	
	private static CountDownLatch connectedSemaphore = new CountDownLatch(1);
	
	private static ZooKeeper zookeeper;
	
	private static Stat stat = new Stat();
	
	/**
	 * 在鏈接函數中建立了zookeeper的實例;而後創建與服務器的鏈接;
	 * 創建鏈接函數會當即返回，因此咱們須要等待鏈接創建成功後再進行其餘的操做;
	 * 咱們使用CountDownLatch來阻塞當前線程，直到zookeeper準備就緒;
	 */
	public void connect(String host) throws IOException, InterruptedException{
		/**
		 * host 127.0.0.1:2181，服務器端主機名稱以及端口號；
		 * SESSION_TIMEOUT 客戶端鏈接服務器session的超時時間；
		 * this 表示Watcher接口的一個實例，Watcher實例負責接收Zookeeper數據變化時產生的事件回調；
		 */
		zookeeper = new ZooKeeper(host, SESSION_TIMEOUT, this);
		System.out.println("zk的鏈接狀態："+zookeeper.getState());
		connectedSemaphore.await();
		System.out.println("Zookeeper session established");
	}
	public void process(WatchedEvent event) {
        if (KeeperState.SyncConnected == event.getState()) {
            if (EventType.None == event.getType() && null == event.getPath()) {
                connectedSemaphore.countDown();
            } else if (event.getType() == EventType.NodeDataChanged) {//NodeDeleted表示本節點被變更
                try {
                    System.out.println("the data of znode " + event.getPath() + " is : " + new String(zookeeper.getData(event.getPath(), true, stat)));
                    System.out.println("czxID: " + stat.getCzxid() + ", mzxID: " + stat.getMzxid() + ", version: " + stat.getVersion());
                } catch (Exception e) {
                }
            }
        }
    }
	/**
	 * 方法中調用zookeeper實例的create()方法來建立一個znode;
	 * @param path znode節點的絕對路徑
	 * @param bytes znode節點的內容（一個二進制數組）
	 * @param ACL access control list(ACL，訪問控制列表，這裏使用徹底開放模式)
	 * @param createMode znode的性質，分爲EPHEMERAL（臨時）、PERSISTENT（持久）、EPHEMERAL_SEQUENTIAL臨時順序和PERSISTENT_SEQUENTIAL持久順序
	 * @throws KeeperException
	 * @throws InterruptedException
	 */
	public void create(String path,byte[] bytes,ArrayList<ACL> ACL,CreateMode createMode) throws KeeperException, InterruptedException{
		String znodePath = zookeeper.create(path, bytes, ACL, createMode);    
        System.out.println("Success create znode: " + znodePath);
	}
	public static void main(String[] args) throws Exception, InterruptedException {
		String path = "/zk-book";
		GetData_API_Sync_Usage getData_API_Sync_Usage = new GetData_API_Sync_Usage();
		getData_API_Sync_Usage.connect("127.0.0.1:2181");
		//create啓動的觀察模式
		zookeeper.create(path, "123".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
        System.out.println("success create znode: " + path);
        
        System.out.println("the data of znode " + path + " is : " + new String(zookeeper.getData(path, true, stat)));
        System.out.println("czxID: " + stat.getCzxid() + ", mzxID: " + stat.getMzxid() + ", version: " + stat.getVersion());
        //setData啓動的觀察模式
        zookeeper.setData(path, "123".getBytes(), -1);

        Thread.sleep(Integer.MAX_VALUE);
	}
}

3.5 更新數據

　　在更新數據時，setData方法存在一個version參數，其用於指定節點的數據版本，代表本次更新操做是針對指定的數據版本進行的，可是，在getData方法中，並無提供根據指定數據版原本獲取數據的接口，那麼，這裏爲什麼要指定數據更新版本呢，這裏方便理解，能夠等效於CAS（compare and swap），對於值V，每次更新以前都會比較其值是不是預期值A，只有符合預期，纔會將V原子化地更新到新值B。Zookeeper的setData接口中的version參數能夠對應預期值，代表是針對哪一個數據版本進行更新，假如一個客戶端試圖進行更新操做，它會攜帶上次獲取到的version值進行更新，而若是這段時間內，Zookeeper服務器上該節點的數據已經被其餘客戶端更新，那麼其數據版本也會相應更新，而客戶端攜帶的version將沒法匹配，沒法更新成功，所以能夠有效地避免分佈式更新的併發問題。

package com.hust.grid.leesf.examples;

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

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.Watcher.Event.EventType;
import org.apache.zookeeper.Watcher.Event.KeeperState;
import org.apache.zookeeper.data.ACL;
import org.apache.zookeeper.data.Stat;

public class SetData_API_Sync_Usage implements Watcher {
	
	private static final int SESSION_TIMEOUT = 5000;
	//對執行中的線程進行管理，等待線程完成某些操做後，再對此線程作處理（起到過河拆橋、卸磨殺驢的做用）
	private static CountDownLatch connectedSemaphore = new CountDownLatch(1);
	
	private static ZooKeeper zookeeper;
	
	/**
	 * 在鏈接函數中建立了zookeeper的實例;而後創建與服務器的鏈接;
	 * 創建鏈接函數會當即返回，因此咱們須要等待鏈接創建成功後再進行其餘的操做;
	 * 咱們使用CountDownLatch來阻塞當前線程，直到zookeeper準備就緒;
	 */
	public void connect(String host) throws IOException, InterruptedException{
		/**
		 * host 127.0.0.1:2181，服務器端主機名稱以及端口號；
		 * SESSION_TIMEOUT 客戶端鏈接服務器session的超時時間；
		 * this 表示Watcher接口的一個實例，Watcher實例負責接收Zookeeper數據變化時產生的事件回調；
		 */
		zookeeper = new ZooKeeper(host, SESSION_TIMEOUT, this);
		System.out.println("zk的鏈接狀態："+zookeeper.getState());
		connectedSemaphore.await();
		System.out.println("Zookeeper session established");
	}
	/**
	 * 方法中調用zookeeper實例的create()方法來建立一個znode;
	 * @param path znode節點的絕對路徑
	 * @param bytes znode節點的內容（一個二進制數組）
	 * @param ACL access control list(ACL，訪問控制列表，這裏使用徹底開放模式)
	 * @param createMode znode的性質，分爲EPHEMERAL（臨時）、PERSISTENT（持久）、EPHEMERAL_SEQUENTIAL臨時順序和PERSISTENT_SEQUENTIAL持久順序
	 * @throws KeeperException
	 * @throws InterruptedException
	 */
	public void create(String path,byte[] bytes,ArrayList<ACL> ACL,CreateMode createMode) throws KeeperException, InterruptedException{
		String znodePath = zookeeper.create(path, bytes, ACL, createMode);    
        System.out.println("Success create znode: " + znodePath);
	}
	public void process(WatchedEvent event) {
		if (KeeperState.SyncConnected == event.getState()) {
            if (EventType.None == event.getType() && null == event.getPath()) {
                connectedSemaphore.countDown();
            }
        }
	}
	public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
		SetData_API_Sync_Usage setData_API_Sync_Usage = new SetData_API_Sync_Usage();
		setData_API_Sync_Usage.connect("127.0.0.1:2181");
		String path = "/zk-book";
		setData_API_Sync_Usage.create(path, "songzl".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
		zookeeper.getData(path, true, null);
		Stat stat = zookeeper.setData(path, "wangxn".getBytes(), -1);
		System.out.println("czxID: " + stat.getCzxid() + ", mzxID: " + stat.getMzxid() + ", version: " + stat.getVersion());
        Stat stat2 = zookeeper.setData(path, "songcy".getBytes(), stat.getVersion());
        System.out.println("czxID: " + stat2.getCzxid() + ", mzxID: " + stat2.getMzxid() + ", version: " + stat2.getVersion());
        try {
        	zookeeper.setData(path, "456".getBytes(), stat.getVersion());
        } catch (KeeperException e) {
            System.out.println("Error: " + e.code() + "," + e.getMessage());
        }
        Thread.sleep(Integer.MAX_VALUE);
	}
}

　　運行結果以下　

success create znode: /zk-book
czxID: 2936, mzxID: 2937, version: 1
czxID: 2936, mzxID: 2938, version: 2
Error: BADVERSION,KeeperErrorCode = BadVersion for /zk-book

　　結果代表因爲攜帶的數據版本不正確，而沒法成功更新節點。其中，setData中的version參數設置-1含義爲客戶端須要基於數據的最新版本進行更新操做。

3.6 檢測節點是否存在

　　在調用接口時註冊Watcher的話，還能夠對節點是否存在進行監聽，一旦節點被建立、被刪除、數據更新，都會通知客戶端。

package com.hust.grid.leesf.examples;

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

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.Watcher.Event.EventType;
import org.apache.zookeeper.Watcher.Event.KeeperState;
import org.apache.zookeeper.data.ACL;
import org.apache.zookeeper.data.Stat;

/**
 * 檢查節點是否存在
 */
public class Exist_API_Sync_Usage implements Watcher{

	private static final int SESSION_TIMEOUT = 5000;
	//對執行中的線程進行管理，等待線程完成某些操做後，再對此線程作處理（起到過河拆橋、卸磨殺驢的做用）
	private static CountDownLatch connectedSemaphore = new CountDownLatch(1);
	
	private static ZooKeeper zookeeper;
	
	/**
	 * 在鏈接函數中建立了zookeeper的實例;而後創建與服務器的鏈接;
	 * 創建鏈接函數會當即返回，因此咱們須要等待鏈接創建成功後再進行其餘的操做;
	 * 咱們使用CountDownLatch來阻塞當前線程，直到zookeeper準備就緒;
	 */
	public void connect(String host) throws IOException, InterruptedException{
		/**
		 * host 127.0.0.1:2181，服務器端主機名稱以及端口號；
		 * SESSION_TIMEOUT 客戶端鏈接服務器session的超時時間；
		 * this 表示Watcher接口的一個實例，Watcher實例負責接收Zookeeper數據變化時產生的事件回調；
		 */
		zookeeper = new ZooKeeper(host, SESSION_TIMEOUT, this);
		System.out.println("zk的鏈接狀態："+zookeeper.getState());
		connectedSemaphore.await();
		System.out.println("Zookeeper session established");
	}
	/**
	 * 方法中調用zookeeper實例的create()方法來建立一個znode;
	 * @param path znode節點的絕對路徑
	 * @param bytes znode節點的內容（一個二進制數組）
	 * @param ACL access control list(ACL，訪問控制列表，這裏使用徹底開放模式)
	 * @param createMode znode的性質，分爲EPHEMERAL（臨時）、PERSISTENT（持久）、EPHEMERAL_SEQUENTIAL臨時順序和PERSISTENT_SEQUENTIAL持久順序
	 * @throws KeeperException
	 * @throws InterruptedException
	 */
	public void create(String path,byte[] bytes,ArrayList<ACL> ACL,CreateMode createMode) throws KeeperException, InterruptedException{
		String znodePath = zookeeper.create(path, bytes, ACL, createMode);    
        System.out.println("Success create znode: " + znodePath);
	}
	/**
	 * 當客戶端鏈接上了zookeeper服務器，Watcher接口會使用process()方法接收一個鏈接成功的事件,
	 * 接下來調用CountDownLatch釋放以前的阻塞；若對節點有變更也會根據狀態觸發該事件；
	 */
	public void process(WatchedEvent event) {
		try {
            if (KeeperState.SyncConnected == event.getState()) {//判斷狀態是否已成功鏈接
                if (EventType.None == event.getType() && null == event.getPath()) {
                    connectedSemaphore.countDown();
                    System.out.println("鏈接服務器成功，關閉阻塞線程");
                } else if (EventType.NodeCreated == event.getType()) {//建立節點時觸發
                    System.out.println("success create znode: " + event.getPath());
                    zookeeper.exists(event.getPath(), true);
                } else if (EventType.NodeDeleted == event.getType()) {//刪除節點時觸發
                    System.out.println("success delete znode: " + event.getPath());
                    zookeeper.exists(event.getPath(), true);
                } else if (EventType.NodeDataChanged == event.getType()) {//變動當前節點時觸發
                    System.out.println("data changed of znode: " + event.getPath());
                    zookeeper.exists(event.getPath(), true);
                }
            }
        } catch (Exception e) {
        	e.printStackTrace();
        }
	}
	public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
		String path = "/zk-book";
		Exist_API_Sync_Usage exist_API_Sync_Usage = new Exist_API_Sync_Usage();
		exist_API_Sync_Usage.connect("127.0.0.1:2181");
		//若節點不存在返回null,不然返回節點的狀態，參數傳true是給節點添加觀察事件，當節點變更時觸發觀察事件
		Stat stat = zookeeper.exists(path, true);
		zookeeper.create(path, "".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
		zookeeper.setData(path, "123".getBytes(), -1);

		zookeeper.create(path + "/c1", "".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        System.out.println("success create znode: " + path + "/c1");

        zookeeper.delete(path + "/c1", -1);
        zookeeper.delete(path, -1);

        Thread.sleep(Integer.MAX_VALUE);
	}

}

運行結果以下：

結果代表：

　　· 不管節點是否存在，均可以經過exists接口註冊Watcher。

　　· 註冊的Watcher，對節點建立、刪除、數據更新事件進行監聽。

　　· 對於指定節點的子節點的各類變化，不會通知客戶端（由於指有父節點調用exists了）。

3.7 權限控制

　　經過設置Zookeeper服務器上數據節點的ACL控制，就能夠對其客戶端對該數據節點的訪問權限：若是符合ACL控制，則能夠進行訪問，不然沒法訪問。

　　① 使用無權限信息的Zookeeper會話訪問含權限信息的數據節點　

package com.hust.grid.leesf.examples;

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.ZooKeeper;

public class AuthSample_Get {
    final static String PATH = "/zk-book-auth_test";

    public static void main(String[] args) throws Exception {

        ZooKeeper zookeeper1 = new ZooKeeper("127.0.0.1:2181", 5000, null);
        zookeeper1.addAuthInfo("digest", "foo:true".getBytes());
        zookeeper1.create(PATH, "init".getBytes(), Ids.CREATOR_ALL_ACL, CreateMode.EPHEMERAL);
        System.out.println("success create znode: " + PATH);
        ZooKeeper zookeeper2 = new ZooKeeper("127.0.0.1:2181", 5000, null);
        zookeeper2.getData(PATH, false, null);
    }
}

運行結果以下：表示權限不夠，不能進行操做

success create znode: /zk-book-auth_test
Exception in thread "main" org.apache.zookeeper.KeeperException$NoAuthException: KeeperErrorCode = NoAuth for /zk-book-auth_test
    at org.apache.zookeeper.KeeperException.create(KeeperException.java:113)
    at org.apache.zookeeper.KeeperException.create(KeeperException.java:51)
    at org.apache.zookeeper.ZooKeeper.getData(ZooKeeper.java:1155)
    at org.apache.zookeeper.ZooKeeper.getData(ZooKeeper.java:1184)
    at com.hust.grid.leesf.examples.AuthSample_Get.main(AuthSample_Get.java:17)

② 刪除帶權限控制的節點

package com.hust.grid.leesf.examples;

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.ZooKeeper;

public class AuthSample_Delete {
    final static String PATH = "/zk-book-auth_test";
    final static String PATH2 = "/zk-book-auth_test/child";

    public static void main(String[] args) throws Exception {
        ZooKeeper zookeeper1 = new ZooKeeper("127.0.0.1:2181", 5000, null);
        zookeeper1.addAuthInfo("digest", "foo:true".getBytes());
        zookeeper1.create(PATH, "init".getBytes(), Ids.CREATOR_ALL_ACL, CreateMode.PERSISTENT);
        
        zookeeper1.create(PATH2, "init".getBytes(), Ids.CREATOR_ALL_ACL, CreateMode.EPHEMERAL);

        try {
            ZooKeeper zookeeper2 = new ZooKeeper("127.0.0.1:2181", 5000, null);
            zookeeper2.delete(PATH2, -1);
        } catch (Exception e) {
            System.out.println("fail to delete: " + e.getMessage());
        }

        ZooKeeper zookeeper3 = new ZooKeeper("127.0.0.1:2181", 5000, null);
        zookeeper3.addAuthInfo("digest", "foo:true".getBytes());
        zookeeper3.delete(PATH2, -1);
        System.out.println("success delete znode: " + PATH2);

        ZooKeeper zookeeper4 = new ZooKeeper("127.00.1:2181", 5000, null);
        zookeeper4.delete(PATH, -1);
        System.out.println("success delete znode: " + PATH);
    }
}

總結：

一、應該使用同步API仍是異步API

兩種API提供了相同的功能，須要使用哪一種API取決於你程序的模式。例如，你設計的程序模式是一個事件驅動模式的程序，那麼你最好使用異步API。異步API也能夠被用在追求一個比較好的數據吞吐量的場景。想象一下，若是你須要得去大量的znode數據，而且依靠獨立的進程來處理他們。若是使用同步API,每次讀取操做都會被阻塞住，直到返回結果。不如使用異步API，讀取操做能夠沒必要等待返回結果，繼續執行。而使用另外的線程來處理返回結果。　　

二、觀察模式觸發器 Watch triggers

讀操做，例如：exists、getChildren、getData會在znode上開啓觀察模式，而且寫操做會觸發觀察模式事件，例如：create、delete和setData。可是ACL(Access Control List)操做不會啓動觀察模式。觀察模式被觸發時，會生成一個事件，這個事件的類型取決於觸發他的操做：

● exists啓動的觀察模式，由建立znode，刪除znode和更新znode操做來觸發。

● getData啓動的觀察模式，由刪除znode和更新znode操做觸發。建立znode不會觸發，是由於getData操做成功的前提是znode必須已經存在。

● getChildren啓動的觀察模式，由子節點建立和刪除，或者本節點被刪除時纔會被觸發。咱們能夠經過事件的類型來判斷是本節點被刪除仍是子節點被刪除：NodeChildrenChanged表示子節點被刪除，而NodeDeleted表示本節點刪除。