作者：leesf    掌控之中，才会成功；掌控之外，注定失败； 出处：http://www.cnblogs.com/leesf456/ （尊重原创，感谢作者整理的这么好，作者的部分内容添加了我的理解和阐述，供大家一起学习讨论）

一、前言

　　上一篇博客我们通过命令行来操作Zookeper的客户端和服务端并进行相应的操作，这篇主要介绍如何通过API（JAVA）来操作Zookeeper。

二、开发环境配置

　　首先打开Zookeeper服务端（上一篇博客有具体的方法），方便客户端连接。

　　配置开发环境环境可以有两种方式：① 直接下载相关的依赖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包存放至此文件夹下）。

　　步骤三：在MyEclipse中添加依赖，选中项目右键-->build path -->Libraries-->Add JARs引入jar文件夹下的jar包；（需要加入log4j和slf4j-api俩个jar包）

　　

步骤四：新建包、Java类进行测试

　　Zookeeper_Constructor_Usage_Simple.java

  1. package com.hust.grid.leesf.examples;
  2.  
  3. import java.io.IOException;
  4. import java.util.concurrent.CountDownLatch;
  5. import org.apache.zookeeper.WatchedEvent;
  6. import org.apache.zookeeper.Watcher;
  7. import org.apache.zookeeper.ZooKeeper;
  8. import org.apache.zookeeper.Watcher.Event.KeeperState;
  9. /**
  10.  * 使用zookeeper的javaAPI实现客户端对zookeeper服务端的连接；
  11.  */
  12. public class Zookeeper_Constructor_Usage_Simple implements Watcher {
  13.  
  14. 	private static final int SESSION_TIMEOUT = 5000;
  15. 	//对执行中的线程进行管理，等待线程完成某些操作后，再对此线程做处理（起到过河拆桥、卸磨杀驴的作用）
  16. 	private static CountDownLatch connectedSemaphore = new CountDownLatch(1);
  17.  
  18. 	ZooKeeper zookeeper;
  19. 	/**
  20. 	 * 在连接函数中创建了zookeeper的实例;然后建立与服务器的连接;
  21. 	 * 建立连接函数会立即返回，所以我们需要等待连接建立成功后再进行其他的操作;
  22. 	 * 我们使用connectedSemaphore.await()来阻塞当前线程，直到zookeeper准备就绪;
  23. 	 */
  24. 	public void connect(String host) throws IOException, InterruptedException{
  25. 		/**
  26. 		 * host 127.0.0.1:2181，服务器端主机名称以及端口号；
  27. 		 * SESSION_TIMEOUT 客户端连接服务器session的超时时间；
  28. 		 * this 表示Watcher接口的一个实例，Watcher实例负责接收Zookeeper数据变化时产生的事件回调；
  29. 		 */
  30. 		zookeeper = new ZooKeeper(host, SESSION_TIMEOUT, this);
  31. 		System.out.println("zk的连接状态："+zookeeper.getState());
  32. 		connectedSemaphore.await();
  33. 		System.out.println("Zookeeper session established");
  34. 	}
  35. 	/**
  36. 	 * 当客户端连接上了zookeeper服务器，Watcher接口会使用process()方法接收一个连接成功的事件,
  37. 	 * 接下来调用CountDownLatch释放之前的阻塞；
  38. 	 */
  39. 	public void process(WatchedEvent event) {
  40. 		System.out.println("Receive watched event : " + event);
  41.         if (KeeperState.SyncConnected == event.getState()) {
  42.         	System.out.println("连接成功：不再阻塞当前线程");
  43.             connectedSemaphore.countDown();
  44.         }
  45. 	}
  46.  
  47. 	public static void main(String[] args) throws IOException, InterruptedException {
  48. 		Zookeeper_Constructor_Usage_Simple zookeeperConstructor = new Zookeeper_Constructor_Usage_Simple();
  49. 		zookeeperConstructor.connect("127.0.0.1:2181");
  50.     }
  51.  
  52. }

打印结果为下图所示：

表示客户端已经成功连接至服务器了。

　　可以看到方法一相对而言比较麻烦，需要手动管理不同的依赖jar包，可以采用更成熟的依赖管理方法，即使用maven来管理Jar包。

　　② 使用maven管理依赖

　　步骤一：新建maven项目，使用IDE工具直接创建即可；

直接next即可：

依然是Next：

依然是Next：

步骤二：配置pom.xml文件如下

  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3.   <modelVersion>4.0.0</modelVersion>
  4.   <groupId>com.hust.grid.leesf</groupId>
  5.   <artifactId>zookeeper_examples</artifactId>
  6.   <version>0.0.1-SNAPSHOT</version>
  7.   <packaging>jar</packaging>
  8.   <name>zookeeper_examples</name>
  9.   <url>http://maven.apache.org</url>
  10.   <properties>
  11.     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  12.   </properties>
  13.   <dependencies>
  14.     <dependency>
  15.       <groupId>junit</groupId>
  16.       <artifactId>junit</artifactId>
  17.       <version>3.8.1</version>
  18.       <scope>test</scope>
  19.     </dependency>
  20.     <dependency>
  21.     	<groupId>org.apache.zookeeper</groupId>
  22.     	<artifactId>zookeeper</artifactId>
  23.     	<version>3.4.6</version>
  24.     </dependency>
  25.     <dependency>
  26.     	<groupId>log4j</groupId>
  27.     	<artifactId>log4j</artifactId>
  28.     	<version>1.2.17</version>
  29.     	<type>bundle</type>
  30.     </dependency>
  31.     <dependency>
  32.     	<groupId>org.slf4j</groupId>
  33.     	<artifactId>slf4j-api</artifactId>
  34.     	<version>1.7.21</version>
  35.     </dependency>
  36.   </dependencies>
  37. </project>

步骤三：新建java类进行测试

　　Zookeeper_Constructor_Usage_Simple.java，代码同上（执行结果不在重复展示）。

先说一下CountDownLatch这个类，这是个很牛逼的门闩，可以对当前执行线程进行管理；我使用该类的源码做一个说明，模拟军队撤退的过程；

  1. package com.hust.grid.leesf.curator;
  2.  
  3. import java.util.concurrent.CountDownLatch;
  4.  
  5.  /**
  6.   * 模拟军队撤退过程：军官先跑，然后小兵再跑
  7.   * CountDownLatch类似于一个门闩，当计数器不为0，当前线程不能执行，使用await方法将线程关在门外；
  8.   * 执行一次countDown，计数器就减1，一旦计数器减完后是0，那么await方法立即打开门，让线程执行；
  9.   * @author songzl
  10.   *
  11.   */
  12. public class Driver {
  13. 	public static void main(String[] arg) throws InterruptedException {
  14.       CountDownLatch startSignal = new CountDownLatch(1);
  15.       CountDownLatch doneSignal = new CountDownLatch(5);
  16.  
  17.       for (int i = 0; i < 5; ++i){ // create and start threads
  18.     	  new Thread(new Worker(startSignal, doneSignal,i)).start();
  19.       }
  20.       //军座先跑
  21.       doSomethingElse("军座先撤退...");
  22.       //然后计算器减1
  23.       startSignal.countDown();//军座撤退完毕，打开门闩，让小兵开始跑
  24.       doSomethingElse("军座撤退成功，让小兵撤退...");
  25.       //清点人数，确认小兵是否全部撤退，若没有需要列队等待
  26.       doneSignal.await();           // wait for all to finish
  27.       System.out.println("全军撤退完毕！");
  28.     }
  29.  
  30. 	private static void doSomethingElse(String commond) {
  31. 		System.out.println(commond);
  32. 	}
  33. }
  34. class Worker implements Runnable {
  35. 	private final CountDownLatch startSignal;
  36. 	private final CountDownLatch doneSignal;
  37. 	private int count = 0;
  38.  
  39. 	public Worker(CountDownLatch startSignal, CountDownLatch doneSignal,int count) {
  40. 		this.startSignal = startSignal;
  41. 		this.doneSignal = doneSignal;
  42. 		this.count = count;
  43. 	}
  44. 	public void run() {
  45. 		try {
  46. 			System.out.println("第"+count+"个小兵试图逃跑，被要求滚回战场...");
  47. 			startSignal.await();
  48. 	        doWork(count);
  49. 	        doneSignal.countDown();
  50. 	    } catch (InterruptedException e) {
  51.     	   e.printStackTrace();
  52. 	    }
  53. 	}
  54. 	private void doWork(int count) {
  55. 		System.out.println("军座都跑完了，我们小兵也跑吧,第"+count+"个小兵逃跑："+Thread.currentThread().getName());
  56. 	}
  57.  
  58. }

　　

三、操作示例

　　3.1  创建节点

　　创建节点有异步和同步两种方式。无论是异步或者同步，Zookeeper都不支持递归调用，即无法在父节点不存在的情况下创建一个子节点，如在/zk-ephemeral节点不存在的情况下创建/zk-ephemeral/ch1节点；并且如果一个节点已经存在，那么创建同名节点时，会抛出NodeExistsException异常。

　　① 同步方式

  1. package com.hust.grid.leesf.examples;
  2.  
  3. import java.io.IOException;
  4. import java.util.ArrayList;
  5. import java.util.concurrent.CountDownLatch;
  6.  
  7. import org.apache.zookeeper.CreateMode;
  8. import org.apache.zookeeper.KeeperException;
  9. import org.apache.zookeeper.WatchedEvent;
  10. import org.apache.zookeeper.Watcher;
  11. import org.apache.zookeeper.ZooKeeper;
  12. import org.apache.zookeeper.Watcher.Event.KeeperState;
  13. import org.apache.zookeeper.ZooDefs.Ids;
  14. import org.apache.zookeeper.data.ACL;
  15. /**
  16.  * 使用zookeeper的javaAPI实现客户端对zookeeper服务端的连接；并且给服务端创建znode节点
  17.  */
  18. public class Zookeeper_Constructor_Usage_Simple implements Watcher {
  19.  
  20. 	private static final int SESSION_TIMEOUT = 5000;
  21. 	//对执行中的线程进行管理，等待线程完成某些操作后，再对此线程做处理（起到过河拆桥、卸磨杀驴的作用）
  22. 	private static CountDownLatch connectedSemaphore = new CountDownLatch(1);
  23.  
  24. 	ZooKeeper zookeeper;
  25. 	/**
  26. 	 * 在连接函数中创建了zookeeper的实例;然后建立与服务器的连接;
  27. 	 * 建立连接函数会立即返回，所以我们需要等待连接建立成功后再进行其他的操作;
  28. 	 * 我们使用CountDownLatch来阻塞当前线程，直到zookeeper准备就绪;
  29. 	 */
  30. 	public void connect(String host) throws IOException, InterruptedException{
  31. 		/**
  32. 		 * host 127.0.0.1:2181，服务器端主机名称以及端口号；
  33. 		 * SESSION_TIMEOUT 客户端连接服务器session的超时时间；
  34. 		 * this 表示Watcher接口的一个实例，Watcher实例负责接收Zookeeper数据变化时产生的事件回调；
  35. 		 */
  36. 		zookeeper = new ZooKeeper(host, SESSION_TIMEOUT, this);
  37. 		System.out.println("zk的连接状态："+zookeeper.getState());
  38. 		connectedSemaphore.await();
  39. 		System.out.println("Zookeeper session established");
  40. 	}
  41. 	/**
  42. 	 * 当客户端连接上了zookeeper服务器，Watcher接口会使用process()方法接收一个连接成功的事件,
  43. 	 * 接下来调用CountDownLatch释放之前的阻塞；
  44. 	 */
  45. 	public void process(WatchedEvent event) {
  46. 		System.out.println("Receive watched event : " + event);
  47.         if (KeeperState.SyncConnected == event.getState()) {
  48.         	System.out.println("连接成功：不再阻塞当前线程");
  49.             connectedSemaphore.countDown();
  50.         }
  51. 	}
  52. 	/**
  53. 	 * 同步创建节点：方法中调用zookeeper实例的create()方法来创建一个znode;
  54. 	 * @param path znode节点的绝对路径
  55. 	 * @param bytes znode节点的内容（一个二进制数组）
  56. 	 * @param ACL access control list(ACL，访问控制列表，这里使用完全开放模式)
  57. 	 * @param createMode znode的性质，分为EPHEMERAL（临时）、PERSISTENT（持久）、EPHEMERAL_SEQUENTIAL临时顺序和PERSISTENT_SEQUENTIAL持久顺序
  58. 	 * @throws KeeperException
  59. 	 * @throws InterruptedException
  60. 	 */
  61. 	public void create(String path,byte[] bytes,ArrayList<ACL> ACL,CreateMode createMode) throws KeeperException, InterruptedException{
  62. 		String znodePath = zookeeper.create(path, bytes, ACL, createMode);
  63.         System.out.println("Success create znode: " + znodePath);
  64. 	}
  65. 	public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
  66. 		Zookeeper_Constructor_Usage_Simple zookeeperConstructor = new Zookeeper_Constructor_Usage_Simple();
  67. 		zookeeperConstructor.connect("127.0.0.1:2181");
  68. 		System.out.println("开始给zookeeper服务端创建节点=========");
  69. 		zookeeperConstructor.create("/zk-test-ephemeral-", "".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
  70. 		zookeeperConstructor.create("/zk-test-ephemeral-", "".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
  71.     }
  72.  
  73. }

运行结果如下：

结果表明已经成功创建了临时节点和临时顺序节点，在创建顺序节点时，系统会在后面自动增加一串数字。

② 异步方式

　　使用异步方式于同步方式的区别在于节点的创建过程（包括网络通信和服务端的节点创建过程）是异步的，在同步接口调用过程中，开发者需要关注接口抛出异常的可能，但是在异步接口中，接口本身不会抛出异常，所有异常都会在回调函数中通过Result Code来体现。

  1. package com.hust.grid.leesf.examples;
  2.  
  3. import java.io.IOException;
  4. import java.util.ArrayList;
  5. import java.util.concurrent.CountDownLatch;
  6.  
  7. import org.apache.zookeeper.AsyncCallback;
  8. import org.apache.zookeeper.CreateMode;
  9. import org.apache.zookeeper.KeeperException;
  10. import org.apache.zookeeper.WatchedEvent;
  11. import org.apache.zookeeper.Watcher;
  12. import org.apache.zookeeper.Watcher.Event.KeeperState;
  13. import org.apache.zookeeper.ZooDefs.Ids;
  14. import org.apache.zookeeper.data.ACL;
  15. import org.apache.zookeeper.ZooKeeper;
  16. /**
  17.  * 使用zookeeper的javaAPI实现客户端对zookeeper服务端的连接,并且使用异步方法创建znode节点
  18.  * @author songzl
  19.  */
  20. public class Zookeeper_Create_API_ASync_Usage implements Watcher {
  21.  
  22. private static final int SESSION_TIMEOUT = 5000;
  23. 	//对执行中的线程进行管理，等待线程完成某些操作后，再对此线程做处理（起到过河拆桥、卸磨杀驴的作用）
  24. 	private static CountDownLatch connectedSemaphore = new CountDownLatch(1);
  25.  
  26. 	ZooKeeper zookeeper;
  27. 	/**
  28. 	 * 在连接函数中创建了zookeeper的实例;然后建立与服务器的连接;
  29. 	 * 建立连接函数会立即返回，所以我们需要等待连接建立成功后再进行其他的操作;
  30. 	 * 我们使用CountDownLatch来阻塞当前线程，直到zookeeper准备就绪;
  31. 	 */
  32. 	public void connect(String host) throws IOException, InterruptedException{
  33. 		/**
  34. 		 * host 127.0.0.1:2181，服务器端主机名称以及端口号；
  35. 		 * SESSION_TIMEOUT 客户端连接服务器session的超时时间；
  36. 		 * this 表示Watcher接口的一个实例，Watcher实例负责接收Zookeeper数据变化时产生的事件回调；
  37. 		 */
  38. 		zookeeper = new ZooKeeper(host, SESSION_TIMEOUT, this);
  39. 		System.out.println("zk的连接状态："+zookeeper.getState());
  40. 		connectedSemaphore.await();
  41. 		System.out.println("Zookeeper session established");
  42. 	}
  43. 	/**
  44. 	 * 当客户端连接上了zookeeper服务器，Watcher接口会使用process()方法接收一个连接成功的事件,
  45. 	 * 接下来调用CountDownLatch释放之前的阻塞；
  46. 	 */
  47. 	public void process(WatchedEvent event) {
  48. 		System.out.println("Receive watched event : " + event);
  49.         if (KeeperState.SyncConnected == event.getState()) {
  50.         	System.out.println("连接成功：不再阻塞当前线程");
  51.             connectedSemaphore.countDown();
  52.         }
  53. 	}
  54. 	/**
  55. 	 * 异步创建节点：方法中调用zookeeper实例的create()方法来创建一个znode;
  56. 	 * @param path znode节点的绝对路径
  57. 	 * @param bytes znode节点的内容（一个二进制数组）
  58. 	 * @param ACL access control list(ACL，访问控制列表，这里使用完全开放模式)
  59. 	 * @param createMode znode的性质，分为EPHEMERAL（临时）、PERSISTENT（持久）、EPHEMERAL_SEQUENTIAL临时顺序和PERSISTENT_SEQUENTIAL持久顺序
  60. 	 * @param string 一个java的字符串
  61. 	 * @param iStringCallback 回调函数
  62. 	 * @throws KeeperException
  63. 	 * @throws InterruptedException
  64. 	 */
  65. 	public void create(String path,byte[] bytes,ArrayList<ACL> ACL,CreateMode createMode, IStringCallback iStringCallback, String string) throws KeeperException, InterruptedException{
  66. 		String znodePath = zookeeper.create(path, bytes, ACL, createMode);
  67.         System.out.println("Success create znode: " + znodePath);
  68. 	}
  69.  
  70.     public static void main(String[] args) throws Exception {
  71.     	Zookeeper_Create_API_ASync_Usage zookeeperCreateAPIASyncUsage = new Zookeeper_Create_API_ASync_Usage();
  72.     	zookeeperCreateAPIASyncUsage.connect("127.0.0.1:2181");
  73.     	//异步创建临时节点
  74.     	zookeeperCreateAPIASyncUsage.create("/zk-test-ephemeral-", "".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL,
  75.                 new IStringCallback(), "I am context. ");
  76.     	//异步创建临时顺序节点
  77.     	zookeeperCreateAPIASyncUsage.create("/zk-test-ephemeral-", "".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL,
  78.                 new IStringCallback(), "I am context. ");
  79.     	//如果不阻塞线程，session超时后临时节点会自动删除
  80.         Thread.sleep(Integer.MAX_VALUE);
  81.     }
  82.  
  83. }
  84. class IStringCallback implements AsyncCallback.StringCallback {
  85.     public void processResult(int rc, String path, Object ctx, String name) {
  86.         System.out.println("Create path result: [" + rc + ", " + path + ", " + ctx + ", real path name: " + name);
  87.     }
  88. }

运行结果如下：

3.2 删除节点　

　　只允许删除叶子节点，即一个节点如果有子节点，那么该节点将无法直接删除，必须先删掉其所有子节点。同样也有同步和异步两种方式。　

　　同步和异步方式

  1. package com.hust.grid.leesf.examples;
  2.  
  3. import java.io.IOException;
  4. import java.util.ArrayList;
  5. import java.util.concurrent.CountDownLatch;
  6.  
  7. import org.apache.zookeeper.AsyncCallback;
  8. import org.apache.zookeeper.AsyncCallback.VoidCallback;
  9. import org.apache.zookeeper.CreateMode;
  10. import org.apache.zookeeper.KeeperException;
  11. import org.apache.zookeeper.WatchedEvent;
  12. import org.apache.zookeeper.Watcher;
  13. import org.apache.zookeeper.Watcher.Event.EventType;
  14. import org.apache.zookeeper.Watcher.Event.KeeperState;
  15. import org.apache.zookeeper.ZooDefs.Ids;
  16. import org.apache.zookeeper.data.ACL;
  17. import org.apache.zookeeper.ZooKeeper;
  18.  
  19. public class Delete_API_Sync_Usage implements Watcher{
  20.  
  21. 	private static final int SESSION_TIMEOUT = 5000;
  22. 	//对执行中的线程进行管理，等待线程完成某些操作后，再对此线程做处理（起到过河拆桥、卸磨杀驴的作用）
  23. 	private static CountDownLatch connectedSemaphore = new CountDownLatch(1);
  24.  
  25.     private static ZooKeeper zookeeper;
  26.  
  27.     /**
  28. 	 * 在连接函数中创建了zookeeper的实例;然后建立与服务器的连接;
  29. 	 * 建立连接函数会立即返回，所以我们需要等待连接建立成功后再进行其他的操作;
  30. 	 * 我们使用CountDownLatch来阻塞当前线程，直到zookeeper准备就绪;
  31. 	 */
  32. 	public void connect(String host) throws IOException, InterruptedException{
  33. 		/**
  34. 		 * host 127.0.0.1:2181，服务器端主机名称以及端口号；
  35. 		 * SESSION_TIMEOUT 客户端连接服务器session的超时时间；
  36. 		 * this 表示Watcher接口的一个实例，Watcher实例负责接收Zookeeper数据变化时产生的事件回调；
  37. 		 */
  38. 		zookeeper = new ZooKeeper(host, SESSION_TIMEOUT, this);
  39. 		System.out.println("zk的连接状态："+zookeeper.getState());
  40. 		connectedSemaphore.await();
  41. 		System.out.println("Zookeeper session established");
  42. 	}
  43. 	/**
  44. 	 * 当客户端连接上了zookeeper服务器，Watcher接口会使用process()方法接收一个连接成功的事件,
  45. 	 * 接下来调用CountDownLatch释放之前的阻塞；
  46. 	 */
  47. 	public void process(WatchedEvent event) {
  48.         if (KeeperState.SyncConnected == event.getState()) {
  49.             if (EventType.None == event.getType() && null == event.getPath()) {
  50.                 connectedSemaphore.countDown();
  51.             }
  52.         }
  53.     }
  54. 	/**
  55. 	 * 方法中调用zookeeper实例的create()方法来创建一个znode;
  56. 	 * @param path znode节点的绝对路径
  57. 	 * @param bytes znode节点的内容（一个二进制数组）
  58. 	 * @param ACL access control list(ACL，访问控制列表，这里使用完全开放模式)
  59. 	 * @param createMode znode的性质，分为EPHEMERAL（临时）、PERSISTENT（持久）、EPHEMERAL_SEQUENTIAL临时顺序和PERSISTENT_SEQUENTIAL持久顺序
  60. 	 * @throws KeeperException
  61. 	 * @throws InterruptedException
  62. 	 */
  63. 	public void create(String path,byte[] bytes,ArrayList<ACL> ACL,CreateMode createMode) throws KeeperException, InterruptedException{
  64. 		String znodePath = zookeeper.create(path, bytes, ACL, createMode);
  65.         System.out.println("Success create znode: " + znodePath);
  66. 	}
  67. 	/**
  68. 	 * 同步删除znode的节点方法
  69. 	 * @param path znode节点的绝对路径
  70. 	 * @param version znode节点的版本号（-1表示不匹配版本号）
  71. 	 * @throws InterruptedException
  72. 	 * @throws KeeperException
  73. 	 */
  74. 	public void syncDelete(String path,int version) throws InterruptedException, KeeperException{
  75. 		zookeeper.delete(path, version);
  76. 	}
  77. 	/**
  78. 	 * 异步删除znode的节点方法
  79. 	 * @param path znode节点的绝对路径
  80. 	 * @param version znode节点的版本号（-1表示不匹配版本号）
  81. 	 * @param cb
  82. 	 * @param ctx
  83. 	 * @throws InterruptedException
  84. 	 * @throws KeeperException
  85. 	 */
  86. 	public void AsyncDelete(String path, int version, VoidCallback cb, Object ctx) throws InterruptedException, KeeperException{
  87. 		zookeeper.delete(path, version, cb, ctx);
  88. 	}
  89.  
  90.     public static void main(String[] args) throws Exception {
  91.         String path = "/zk-book";
  92.         Delete_API_Sync_Usage delete_API_Sync_Usage = new Delete_API_Sync_Usage();
  93.         delete_API_Sync_Usage.connect("127.0.0.1:2181");
  94.         //创建path为"/zk-book"的节点
  95.         delete_API_Sync_Usage.create(path, "".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
  96.         System.out.println("success create znode: " + path);
  97.         //创建path为"/zk-book/c1"的节点
  98.         delete_API_Sync_Usage.create(path + "/c1", "".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
  99.         System.out.println("success create znode: " + path + "/c1");
  100.         //============调用同步删除节点开始=======================================
  101.         try {
  102.         	//直接删除path为"/zk-book"的节点失败，因为包含子节点
  103.         	delete_API_Sync_Usage.syncDelete(path, -1);
  104.         } catch (Exception e) {
  105.             System.out.println("fail to delete znode: " + path);
  106.         }
  107.         //先删除子节点
  108.         delete_API_Sync_Usage.syncDelete(path + "/c1", -1);
  109.         System.out.println("success delete znode: " + path + "/c1");
  110.         //再删除父节点
  111.         delete_API_Sync_Usage.syncDelete(path, -1);
  112.         System.out.println("success delete znode: " + path);
  113.         //============调用同步删除节点结束=======================================
  114.  
  115.         //============调用异步步删除节点开始=======================================
  116.         delete_API_Sync_Usage.AsyncDelete(path, -1, new IVoidCallback(), null);
  117.         delete_API_Sync_Usage.AsyncDelete(path + "/c1", -1, new IVoidCallback(), null);
  118.         delete_API_Sync_Usage.AsyncDelete(path, -1, new IVoidCallback(), null); 
  119.  
  120.         Thread.sleep(Integer.MAX_VALUE);
  121.     }
  122. }
  123. /**
  124.  * 异步删除时，接口的一个回调函数
  125.  * 参数rc表示返回码;
  126.  * 参数path和ctx与客户端调用的方法中的参数相等,这两个参数通常用来确定回调中获得的响应是来自于哪个请求的；
  127.  * 参数ctx可以是任意对象，只有当path参数不能消灭请求的歧义时才会用到，如果不需要参数ctx，可以设置为null
  128.  */
  129. class IVoidCallback implements AsyncCallback.VoidCallback {
  130.     public void processResult(int rc, String path, Object ctx) {
  131.         System.out.println(rc + ", " + path + ", " + ctx);
  132.     }
  133. }

　　备注：ZooKeeper的API提供一个delete()方法来删除一个znode。我们通过输入znode的path和版本号（version number）来删除想要删除的znode。除了使用path来定位我们要删除的znode，还需要一个参数是版本号。只有当我们指定要删除的本版号，与znode当前的版本号一致时，ZooKeeper才允许我们将znode删除掉。这是一种optimistic locking（乐观锁）机制，用来处理znode的读写冲突。我们也可以忽略版本号一致检查，做法就是版本号赋值为-1。

3.3 子节点获取

　　读取节点的子节点列表，同样可以使用同步和异步的方式进行操作。

  1. package com.hust.grid.leesf.examples;
  2.  
  3. import java.io.IOException;
  4. import java.util.ArrayList;
  5. import java.util.List;
  6. import java.util.concurrent.CountDownLatch;
  7.  
  8. import org.apache.zookeeper.CreateMode;
  9. import org.apache.zookeeper.KeeperException;
  10. import org.apache.zookeeper.WatchedEvent;
  11. import org.apache.zookeeper.Watcher;
  12. import org.apache.zookeeper.Watcher.Event.EventType;
  13. import org.apache.zookeeper.Watcher.Event.KeeperState;
  14. import org.apache.zookeeper.ZooDefs.Ids;
  15. import org.apache.zookeeper.data.ACL;
  16. import org.apache.zookeeper.ZooKeeper;
  17. /**
  18.  * 获取zookeeper的子节点：创建一个父节点和三个子节点
  19.  */
  20. public class Zookeeper_GetChildren_API_Sync_Usage implements Watcher {
  21.  
  22. 	private static final int SESSION_TIMEOUT = 5000;
  23. 	//对执行中的线程进行管理，等待线程完成某些操作后，再对此线程做处理（起到过河拆桥、卸磨杀驴的作用）
  24. 	private static CountDownLatch connectedSemaphore = new CountDownLatch(1);
  25.  
  26. 	private static ZooKeeper zookeeper;
  27. 	/**
  28. 	 * 在连接函数中创建了zookeeper的实例;然后建立与服务器的连接;
  29. 	 * 建立连接函数会立即返回，所以我们需要等待连接建立成功后再进行其他的操作;
  30. 	 * 我们使用CountDownLatch来阻塞当前线程，直到zookeeper准备就绪;
  31. 	 */
  32. 	public void connect(String host) throws IOException, InterruptedException{
  33. 		/**
  34. 		 * host 127.0.0.1:2181，服务器端主机名称以及端口号；
  35. 		 * SESSION_TIMEOUT 客户端连接服务器session的超时时间；
  36. 		 * this 表示Watcher接口的一个实例，Watcher实例负责接收Zookeeper数据变化时产生的事件回调；
  37. 		 */
  38. 		zookeeper = new ZooKeeper(host, SESSION_TIMEOUT, this);
  39. 		System.out.println("zk的连接状态："+zookeeper.getState());
  40. 		connectedSemaphore.await();
  41. 		System.out.println("Zookeeper session established");
  42. 	}
  43. 	public void process(WatchedEvent event) {
  44. 		if (KeeperState.SyncConnected == event.getState()) {
  45.             if (EventType.None == event.getType() && null == event.getPath()) {
  46.                 connectedSemaphore.countDown();
  47.             } else if (event.getType() == EventType.NodeChildrenChanged) {
  48.                 try {
  49.                 	//获取子节点
  50.                     System.out.println("ReGet Child:" + zookeeper.getChildren(event.getPath(), true));
  51.                 } catch (Exception e) {
  52.                 }
  53.             }
  54.         }
  55. 	}
  56. 	/**
  57. 	 * 方法中调用zookeeper实例的create()方法来创建一个znode;
  58. 	 * @param path znode节点的绝对路径
  59. 	 * @param bytes znode节点的内容（一个二进制数组）
  60. 	 * @param ACL access control list(ACL，访问控制列表，这里使用完全开放模式)
  61. 	 * @param createMode znode的性质，分为EPHEMERAL（临时）、PERSISTENT（持久）、EPHEMERAL_SEQUENTIAL临时顺序和PERSISTENT_SEQUENTIAL持久顺序
  62. 	 * @throws KeeperException
  63. 	 * @throws InterruptedException
  64. 	 */
  65. 	public void create(String path,byte[] bytes,ArrayList<ACL> ACL,CreateMode createMode) throws KeeperException, InterruptedException{
  66. 		String znodePath = zookeeper.create(path, bytes, ACL, createMode);
  67.         System.out.println("Success create znode: " + znodePath);
  68. 	}
  69. 	public static void main(String[] args) throws KeeperException, InterruptedException, IOException {
  70. 		Zookeeper_GetChildren_API_Sync_Usage zookeeper_GetChildren_API_Sync_Usage = new Zookeeper_GetChildren_API_Sync_Usage();
  71. 		zookeeper_GetChildren_API_Sync_Usage.connect("127.0.0.1:2181");
  72. 		String path = "/zk-book-1";
  73. 		//创建父节点
  74. 		zookeeper_GetChildren_API_Sync_Usage.create(path, "".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
  75. 		//创建子节点
  76. 		zookeeper_GetChildren_API_Sync_Usage.create(path + "/c1", "".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
  77. 		List<String> childrenList = zookeeper.getChildren(path, true);
  78. 		System.out.println(childrenList);
  79. 		zookeeper_GetChildren_API_Sync_Usage.create(path + "/c2", "".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
  80. 		Thread.sleep(1000);
  81. 		zookeeper_GetChildren_API_Sync_Usage.create(path + "/c3", "".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
  82. 		Thread.sleep(Integer.MAX_VALUE);
  83. 	}
  84.  
  85. }

值得注意的是，Watcher通知是一次性的，即一旦触发一次通知后，该Watcher就失效了，因此客户端需要反复注册Watcher，即程序中在process里面又注册了Watcher，否则，将无法获取c3节点的创建而导致子节点变化的事件。

3.4 数据节点获取（不再展示异步的获取方式）

  1. package com.hust.grid.leesf.examples;
  2.  
  3. import java.io.IOException;
  4. import java.util.ArrayList;
  5. import java.util.concurrent.CountDownLatch;
  6.  
  7. import org.apache.zookeeper.CreateMode;
  8. import org.apache.zookeeper.KeeperException;
  9. import org.apache.zookeeper.WatchedEvent;
  10. import org.apache.zookeeper.Watcher;
  11. import org.apache.zookeeper.ZooDefs.Ids;
  12. import org.apache.zookeeper.ZooKeeper;
  13. import org.apache.zookeeper.Watcher.Event.EventType;
  14. import org.apache.zookeeper.Watcher.Event.KeeperState;
  15. import org.apache.zookeeper.data.ACL;
  16. import org.apache.zookeeper.data.Stat;
  17. /**
  18.  * 数据节点获取
  19.  */
  20. public class GetData_API_Sync_Usage implements Watcher{
  21.  
  22. 	private static final int SESSION_TIMEOUT = 5000;
  23.  
  24. 	private static CountDownLatch connectedSemaphore = new CountDownLatch(1);
  25.  
  26. 	private static ZooKeeper zookeeper;
  27.  
  28. 	private static Stat stat = new Stat();
  29.  
  30. 	/**
  31. 	 * 在连接函数中创建了zookeeper的实例;然后建立与服务器的连接;
  32. 	 * 建立连接函数会立即返回，所以我们需要等待连接建立成功后再进行其他的操作;
  33. 	 * 我们使用CountDownLatch来阻塞当前线程，直到zookeeper准备就绪;
  34. 	 */
  35. 	public void connect(String host) throws IOException, InterruptedException{
  36. 		/**
  37. 		 * host 127.0.0.1:2181，服务器端主机名称以及端口号；
  38. 		 * SESSION_TIMEOUT 客户端连接服务器session的超时时间；
  39. 		 * this 表示Watcher接口的一个实例，Watcher实例负责接收Zookeeper数据变化时产生的事件回调；
  40. 		 */
  41. 		zookeeper = new ZooKeeper(host, SESSION_TIMEOUT, this);
  42. 		System.out.println("zk的连接状态："+zookeeper.getState());
  43. 		connectedSemaphore.await();
  44. 		System.out.println("Zookeeper session established");
  45. 	}
  46. 	public void process(WatchedEvent event) {
  47.         if (KeeperState.SyncConnected == event.getState()) {
  48.             if (EventType.None == event.getType() && null == event.getPath()) {
  49.                 connectedSemaphore.countDown();
  50.             } else if (event.getType() == EventType.NodeDataChanged) {//NodeDeleted表示本节点被变动
  51.                 try {
  52.                     System.out.println("the data of znode " + event.getPath() + " is : " + new String(zookeeper.getData(event.getPath(), true, stat)));
  53.                     System.out.println("czxID: " + stat.getCzxid() + ", mzxID: " + stat.getMzxid() + ", version: " + stat.getVersion());
  54.                 } catch (Exception e) {
  55.                 }
  56.             }
  57.         }
  58.     }
  59. 	/**
  60. 	 * 方法中调用zookeeper实例的create()方法来创建一个znode;
  61. 	 * @param path znode节点的绝对路径
  62. 	 * @param bytes znode节点的内容（一个二进制数组）
  63. 	 * @param ACL access control list(ACL，访问控制列表，这里使用完全开放模式)
  64. 	 * @param createMode znode的性质，分为EPHEMERAL（临时）、PERSISTENT（持久）、EPHEMERAL_SEQUENTIAL临时顺序和PERSISTENT_SEQUENTIAL持久顺序
  65. 	 * @throws KeeperException
  66. 	 * @throws InterruptedException
  67. 	 */
  68. 	public void create(String path,byte[] bytes,ArrayList<ACL> ACL,CreateMode createMode) throws KeeperException, InterruptedException{
  69. 		String znodePath = zookeeper.create(path, bytes, ACL, createMode);
  70.         System.out.println("Success create znode: " + znodePath);
  71. 	}
  72. 	public static void main(String[] args) throws Exception, InterruptedException {
  73. 		String path = "/zk-book";
  74. 		GetData_API_Sync_Usage getData_API_Sync_Usage = new GetData_API_Sync_Usage();
  75. 		getData_API_Sync_Usage.connect("127.0.0.1:2181");
  76. 		//create启动的观察模式
  77. 		zookeeper.create(path, "123".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
  78.         System.out.println("success create znode: " + path);
  79.  
  80.         System.out.println("the data of znode " + path + " is : " + new String(zookeeper.getData(path, true, stat)));
  81.         System.out.println("czxID: " + stat.getCzxid() + ", mzxID: " + stat.getMzxid() + ", version: " + stat.getVersion());
  82.         //setData启动的观察模式
  83.         zookeeper.setData(path, "123".getBytes(), -1);
  84.  
  85.         Thread.sleep(Integer.MAX_VALUE);
  86. 	}
  87. }

3.5 更新数据

　　在更新数据时，setData方法存在一个version参数，其用于指定节点的数据版本，表明本次更新操作是针对指定的数据版本进行的，但是，在getData方法中，并没有提供根据指定数据版本来获取数据的接口，那么，这里为何要指定数据更新版本呢，这里方便理解，可以等效于CAS（compare and swap），对于值V，每次更新之前都会比较其值是否是预期值A，只有符合预期，才会将V原子化地更新到新值B。Zookeeper的setData接口中的version参数可以对应预期值，表明是针对哪个数据版本进行更新，假如一个客户端试图进行更新操作，它会携带上次获取到的version值进行更新，而如果这段时间内，Zookeeper服务器上该节点的数据已经被其他客户端更新，那么其数据版本也会相应更新，而客户端携带的version将无法匹配，无法更新成功，因此可以有效地避免分布式更新的并发问题。

  1. package com.hust.grid.leesf.examples;
  2.  
  3. import java.io.IOException;
  4. import java.util.ArrayList;
  5. import java.util.concurrent.CountDownLatch;
  6.  
  7. import org.apache.zookeeper.CreateMode;
  8. import org.apache.zookeeper.KeeperException;
  9. import org.apache.zookeeper.WatchedEvent;
  10. import org.apache.zookeeper.Watcher;
  11. import org.apache.zookeeper.ZooDefs.Ids;
  12. import org.apache.zookeeper.ZooKeeper;
  13. import org.apache.zookeeper.Watcher.Event.EventType;
  14. import org.apache.zookeeper.Watcher.Event.KeeperState;
  15. import org.apache.zookeeper.data.ACL;
  16. import org.apache.zookeeper.data.Stat;
  17.  
  18. public class SetData_API_Sync_Usage implements Watcher {
  19.  
  20. 	private static final int SESSION_TIMEOUT = 5000;
  21. 	//对执行中的线程进行管理，等待线程完成某些操作后，再对此线程做处理（起到过河拆桥、卸磨杀驴的作用）
  22. 	private static CountDownLatch connectedSemaphore = new CountDownLatch(1);
  23.  
  24. 	private static ZooKeeper zookeeper;
  25.  
  26. 	/**
  27. 	 * 在连接函数中创建了zookeeper的实例;然后建立与服务器的连接;
  28. 	 * 建立连接函数会立即返回，所以我们需要等待连接建立成功后再进行其他的操作;
  29. 	 * 我们使用CountDownLatch来阻塞当前线程，直到zookeeper准备就绪;
  30. 	 */
  31. 	public void connect(String host) throws IOException, InterruptedException{
  32. 		/**
  33. 		 * host 127.0.0.1:2181，服务器端主机名称以及端口号；
  34. 		 * SESSION_TIMEOUT 客户端连接服务器session的超时时间；
  35. 		 * this 表示Watcher接口的一个实例，Watcher实例负责接收Zookeeper数据变化时产生的事件回调；
  36. 		 */
  37. 		zookeeper = new ZooKeeper(host, SESSION_TIMEOUT, this);
  38. 		System.out.println("zk的连接状态："+zookeeper.getState());
  39. 		connectedSemaphore.await();
  40. 		System.out.println("Zookeeper session established");
  41. 	}
  42. 	/**
  43. 	 * 方法中调用zookeeper实例的create()方法来创建一个znode;
  44. 	 * @param path znode节点的绝对路径
  45. 	 * @param bytes znode节点的内容（一个二进制数组）
  46. 	 * @param ACL access control list(ACL，访问控制列表，这里使用完全开放模式)
  47. 	 * @param createMode znode的性质，分为EPHEMERAL（临时）、PERSISTENT（持久）、EPHEMERAL_SEQUENTIAL临时顺序和PERSISTENT_SEQUENTIAL持久顺序
  48. 	 * @throws KeeperException
  49. 	 * @throws InterruptedException
  50. 	 */
  51. 	public void create(String path,byte[] bytes,ArrayList<ACL> ACL,CreateMode createMode) throws KeeperException, InterruptedException{
  52. 		String znodePath = zookeeper.create(path, bytes, ACL, createMode);
  53.         System.out.println("Success create znode: " + znodePath);
  54. 	}
  55. 	public void process(WatchedEvent event) {
  56. 		if (KeeperState.SyncConnected == event.getState()) {
  57.             if (EventType.None == event.getType() && null == event.getPath()) {
  58.                 connectedSemaphore.countDown();
  59.             }
  60.         }
  61. 	}
  62. 	public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
  63. 		SetData_API_Sync_Usage setData_API_Sync_Usage = new SetData_API_Sync_Usage();
  64. 		setData_API_Sync_Usage.connect("127.0.0.1:2181");
  65. 		String path = "/zk-book";
  66. 		setData_API_Sync_Usage.create(path, "songzl".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
  67. 		zookeeper.getData(path, true, null);
  68. 		Stat stat = zookeeper.setData(path, "wangxn".getBytes(), -1);
  69. 		System.out.println("czxID: " + stat.getCzxid() + ", mzxID: " + stat.getMzxid() + ", version: " + stat.getVersion());
  70.         Stat stat2 = zookeeper.setData(path, "songcy".getBytes(), stat.getVersion());
  71.         System.out.println("czxID: " + stat2.getCzxid() + ", mzxID: " + stat2.getMzxid() + ", version: " + stat2.getVersion());
  72.         try {
  73.         	zookeeper.setData(path, "456".getBytes(), stat.getVersion());
  74.         } catch (KeeperException e) {
  75.             System.out.println("Error: " + e.code() + "," + e.getMessage());
  76.         }
  77.         Thread.sleep(Integer.MAX_VALUE);
  78. 	}
  79. }

　　运行结果如下　

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

　　结果表明由于携带的数据版本不正确，而无法成功更新节点。其中，setData中的version参数设置-1含义为客户端需要基于数据的最新版本进行更新操作。

3.6 检测节点是否存在

　　在调用接口时注册Watcher的话，还可以对节点是否存在进行监听，一旦节点被创建、被删除、数据更新，都会通知客户端。

  1. package com.hust.grid.leesf.examples;
  2.  
  3. import java.io.IOException;
  4. import java.util.ArrayList;
  5. import java.util.concurrent.CountDownLatch;
  6.  
  7. import org.apache.zookeeper.CreateMode;
  8. import org.apache.zookeeper.KeeperException;
  9. import org.apache.zookeeper.WatchedEvent;
  10. import org.apache.zookeeper.Watcher;
  11. import org.apache.zookeeper.ZooDefs.Ids;
  12. import org.apache.zookeeper.ZooKeeper;
  13. import org.apache.zookeeper.Watcher.Event.EventType;
  14. import org.apache.zookeeper.Watcher.Event.KeeperState;
  15. import org.apache.zookeeper.data.ACL;
  16. import org.apache.zookeeper.data.Stat;
  17.  
  18. /**
  19.  * 检查节点是否存在
  20.  */
  21. public class Exist_API_Sync_Usage implements Watcher{
  22.  
  23. 	private static final int SESSION_TIMEOUT = 5000;
  24. 	//对执行中的线程进行管理，等待线程完成某些操作后，再对此线程做处理（起到过河拆桥、卸磨杀驴的作用）
  25. 	private static CountDownLatch connectedSemaphore = new CountDownLatch(1);
  26.  
  27. 	private static ZooKeeper zookeeper;
  28.  
  29. 	/**
  30. 	 * 在连接函数中创建了zookeeper的实例;然后建立与服务器的连接;
  31. 	 * 建立连接函数会立即返回，所以我们需要等待连接建立成功后再进行其他的操作;
  32. 	 * 我们使用CountDownLatch来阻塞当前线程，直到zookeeper准备就绪;
  33. 	 */
  34. 	public void connect(String host) throws IOException, InterruptedException{
  35. 		/**
  36. 		 * host 127.0.0.1:2181，服务器端主机名称以及端口号；
  37. 		 * SESSION_TIMEOUT 客户端连接服务器session的超时时间；
  38. 		 * this 表示Watcher接口的一个实例，Watcher实例负责接收Zookeeper数据变化时产生的事件回调；
  39. 		 */
  40. 		zookeeper = new ZooKeeper(host, SESSION_TIMEOUT, this);
  41. 		System.out.println("zk的连接状态："+zookeeper.getState());
  42. 		connectedSemaphore.await();
  43. 		System.out.println("Zookeeper session established");
  44. 	}
  45. 	/**
  46. 	 * 方法中调用zookeeper实例的create()方法来创建一个znode;
  47. 	 * @param path znode节点的绝对路径
  48. 	 * @param bytes znode节点的内容（一个二进制数组）
  49. 	 * @param ACL access control list(ACL，访问控制列表，这里使用完全开放模式)
  50. 	 * @param createMode znode的性质，分为EPHEMERAL（临时）、PERSISTENT（持久）、EPHEMERAL_SEQUENTIAL临时顺序和PERSISTENT_SEQUENTIAL持久顺序
  51. 	 * @throws KeeperException
  52. 	 * @throws InterruptedException
  53. 	 */
  54. 	public void create(String path,byte[] bytes,ArrayList<ACL> ACL,CreateMode createMode) throws KeeperException, InterruptedException{
  55. 		String znodePath = zookeeper.create(path, bytes, ACL, createMode);
  56.         System.out.println("Success create znode: " + znodePath);
  57. 	}
  58. 	/**
  59. 	 * 当客户端连接上了zookeeper服务器，Watcher接口会使用process()方法接收一个连接成功的事件,
  60. 	 * 接下来调用CountDownLatch释放之前的阻塞；若对节点有变动也会根据状态触发该事件；
  61. 	 */
  62. 	public void process(WatchedEvent event) {
  63. 		try {
  64.             if (KeeperState.SyncConnected == event.getState()) {//判断状态是否已成功连接
  65.                 if (EventType.None == event.getType() && null == event.getPath()) {
  66.                     connectedSemaphore.countDown();
  67.                     System.out.println("连接服务器成功，关闭阻塞线程");
  68.                 } else if (EventType.NodeCreated == event.getType()) {//创建节点时触发
  69.                     System.out.println("success create znode: " + event.getPath());
  70.                     zookeeper.exists(event.getPath(), true);
  71.                 } else if (EventType.NodeDeleted == event.getType()) {//删除节点时触发
  72.                     System.out.println("success delete znode: " + event.getPath());
  73.                     zookeeper.exists(event.getPath(), true);
  74.                 } else if (EventType.NodeDataChanged == event.getType()) {//变更当前节点时触发
  75.                     System.out.println("data changed of znode: " + event.getPath());
  76.                     zookeeper.exists(event.getPath(), true);
  77.                 }
  78.             }
  79.         } catch (Exception e) {
  80.         	e.printStackTrace();
  81.         }
  82. 	}
  83. 	public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
  84. 		String path = "/zk-book";
  85. 		Exist_API_Sync_Usage exist_API_Sync_Usage = new Exist_API_Sync_Usage();
  86. 		exist_API_Sync_Usage.connect("127.0.0.1:2181");
  87. 		//若节点不存在返回null,否则返回节点的状态，参数传true是给节点添加观察事件，当节点变动时触发观察事件
  88. 		Stat stat = zookeeper.exists(path, true);
  89. 		zookeeper.create(path, "".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
  90. 		zookeeper.setData(path, "123".getBytes(), -1);
  91.  
  92. 		zookeeper.create(path + "/c1", "".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
  93.         System.out.println("success create znode: " + path + "/c1");
  94.  
  95.         zookeeper.delete(path + "/c1", -1);
  96.         zookeeper.delete(path, -1);
  97.  
  98.         Thread.sleep(Integer.MAX_VALUE);
  99. 	}
  100.  
  101. }

运行结果如下：

结果表明：

　　· 无论节点是否存在，都可以通过exists接口注册Watcher。

　　· 注册的Watcher，对节点创建、删除、数据更新事件进行监听。

　　· 对于指定节点的子节点的各种变化，不会通知客户端（因为指有父节点调用exists了）。

3.7 权限控制

　　通过设置Zookeeper服务器上数据节点的ACL控制，就可以对其客户端对该数据节点的访问权限：如果符合ACL控制，则可以进行访问，否则无法访问。

　　① 使用无权限信息的Zookeeper会话访问含权限信息的数据节点　

  1. package com.hust.grid.leesf.examples;
  2.  
  3. import org.apache.zookeeper.CreateMode;
  4. import org.apache.zookeeper.ZooDefs.Ids;
  5. import org.apache.zookeeper.ZooKeeper;
  6.  
  7. public class AuthSample_Get {
  8.     final static String PATH = "/zk-book-auth_test";
  9.  
  10.     public static void main(String[] args) throws Exception {
  11.  
  12.         ZooKeeper zookeeper1 = new ZooKeeper("127.0.0.1:2181", 5000, null);
  13.         zookeeper1.addAuthInfo("digest", "foo:true".getBytes());
  14.         zookeeper1.create(PATH, "init".getBytes(), Ids.CREATOR_ALL_ACL, CreateMode.EPHEMERAL);
  15.         System.out.println("success create znode: " + PATH);
  16.         ZooKeeper zookeeper2 = new ZooKeeper("127.0.0.1:2181", 5000, null);
  17.         zookeeper2.getData(PATH, false, null);
  18.     }
  19. }

运行结果如下：表示权限不够，不能进行操作

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

② 删除带权限控制的节点

　

  1. package com.hust.grid.leesf.examples;
  2.  
  3. import org.apache.zookeeper.CreateMode;
  4. import org.apache.zookeeper.ZooDefs.Ids;
  5. import org.apache.zookeeper.ZooKeeper;
  6.  
  7. public class AuthSample_Delete {
  8.     final static String PATH = "/zk-book-auth_test";
  9.     final static String PATH2 = "/zk-book-auth_test/child";
  10.  
  11.     public static void main(String[] args) throws Exception {
  12.         ZooKeeper zookeeper1 = new ZooKeeper("127.0.0.1:2181", 5000, null);
  13.         zookeeper1.addAuthInfo("digest", "foo:true".getBytes());
  14.         zookeeper1.create(PATH, "init".getBytes(), Ids.CREATOR_ALL_ACL, CreateMode.PERSISTENT);
  15.  
  16.         zookeeper1.create(PATH2, "init".getBytes(), Ids.CREATOR_ALL_ACL, CreateMode.EPHEMERAL);
  17.  
  18.         try {
  19.             ZooKeeper zookeeper2 = new ZooKeeper("127.0.0.1:2181", 5000, null);
  20.             zookeeper2.delete(PATH2, -1);
  21.         } catch (Exception e) {
  22.             System.out.println("fail to delete: " + e.getMessage());
  23.         }
  24.  
  25.         ZooKeeper zookeeper3 = new ZooKeeper("127.0.0.1:2181", 5000, null);
  26.         zookeeper3.addAuthInfo("digest", "foo:true".getBytes());
  27.         zookeeper3.delete(PATH2, -1);
  28.         System.out.println("success delete znode: " + PATH2);
  29.  
  30.         ZooKeeper zookeeper4 = new ZooKeeper("127.00.1:2181", 5000, null);
  31.         zookeeper4.delete(PATH, -1);
  32.         System.out.println("success delete znode: " + PATH);
  33.     }
  34. }

总结：

1、应该使用同步API还是异步API

两种API提供了相同的功能，需要使用哪种API取决于你程序的模式。例如，你设计的程序模式是一个事件驱动模式的程序，那么你最好使用异步API。异步API也可以被用在追求一个比较好的数据吞吐量的场景。想象一下，如果你需要得去大量的znode数据，并且依靠独立的进程来处理他们。如果使用同步API,每次读取操作都会被阻塞住，直到返回结果。不如使用异步API，读取操作可以不必等待返回结果，继续执行。而使用另外的线程来处理返回结果。　　

2、观察模式触发器 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表示本节点删除。

zookeeper系列（二）zookeeper的使用--javaAPI的更多相关文章

  1. Zookeeper系列二：分布式架构详解、分布式技术详解、分布式事务

    一.分布式架构详解 1.分布式发展历程 1.1 单点集中式 特点:App.DB.FileServer都部署在一台机器上.并且访问请求量较少 1.2  应用服务和数据服务拆分  特点:App.DB.Fi ...

  2. zookeeper系列之六—zookeeper之应用

    http://www.cnblogs.com/sharpxiajun/archive/2013/06/02/3113923.html Zookeeper是hadoop的一个子项目,虽然源自hadoop ...

  3. 【Zookeeper系列】ZooKeeper一致性原理（转）

    原文链接:https://www.cnblogs.com/sunddenly/p/4138580.html 一.ZooKeeper 的实现 1.1 ZooKeeper处理单点故障 我们知道可以通过Zo ...

  4. 【Zookeeper系列】ZooKeeper机制架构（转）

    原文链接:https://www.cnblogs.com/sunddenly/p/4133784.html 一.ZooKeeper权限管理机制 1.1 权限管理ACL(Access Control L ...

  5. 【Zookeeper系列】ZooKeeper管理分布式环境中的数据（转）

    原文地址:https://www.cnblogs.com/sunddenly/p/4092654.html 引言 本节本来是要介绍ZooKeeper的实现原理,但是ZooKeeper的原理比较复杂,它 ...

  6. 【Zookeeper系列】Zookeeper命令操作（转）

    原文链接:https://www.cnblogs.com/sunddenly/p/4031881.html 一.Zookeeper的四字命令 Zookeeper支持某些特定的四字命令字母与其的交互.他 ...

  7. 【Zookeeper系列】ZooKeeper安装配置（转）

    原文链接:https://www.cnblogs.com/sunddenly/p/4018459.html 一.Zookeeper的搭建方式 Zookeeper安装方式有三种,单机模式和集群模式以及伪 ...

  8. 【Zookeeper系列】Zookeeper简单介绍（转）

    原文链接:https://www.cnblogs.com/sunddenly/p/4033574.html 一.分布式协调技术 在给大家介绍ZooKeeper之前先来给大家介绍一种技术——分布式协调技 ...

  9. 【Zookeeper系列】zookeeper面试题（转）

    原文链接:https://segmentfault.com/a/1190000014479433 1.ZooKeeper是什么? ZooKeeper是一个分布式的,开放源码的分布式应用程序协调服务,是 ...

  10. 服务注册中心之ZooKeeper系列(二) 实现一个简单微服务之间调用的例子

    上一篇文章简单介绍了ZooKeeper,讲了分布式中,每个微服务都会部署到多台服务器上,那服务之间的调用是怎么样的呢?如图: 1.集群A中的服务调用者如何发现集群B中的服务提供者呢? 2.集群A中的服 ...

随机推荐

  1. Navicat连接CentOS7中的MariaDB

    Step 1:首先登录数据库设置开启远程连接 mysql -u root -p Step 2:使用改表法实现远程连接 use mysql; update user set host = '%' whe ...

  2. Qt常用快捷键

    F1        查看帮助F2        跳转到函数定义(和Ctrl+鼠标左键一样的效果)Shift+F2    声明和定义之间切换F4        头文件和源文件之间切换Ctrl+1     ...

  3. linux core文件的打开和分析

    1. core文件生成打开方式: ulimit -c unlimited echo "1" > /proc/sys/kernel/core_uses_pid 看下服务器上是否 ...

  4. md加密 16位 32位

    16位大写 //生成MD5 public static String getMD5(String message) { String md5 = ""; try { Message ...

  5. 第十五章、Python多线程同步锁，死锁和递归锁

    目录 第十五章.Python多线程同步锁,死锁和递归锁 1. 引子: 2.同步锁 3.死锁 引子: 4.递归锁RLock 原理: 不多说,放代码 总结: 5. 大总结 第十五章.Python多线程同步 ...

  6. 怎么处理U盘无法正常弹出的情况？

    我们都知道U盘和移动硬盘在使用完毕后需要点击“安全删除硬件并弹出”后才能拔出,这样可以避免U盘还在工作时被拔出而造成的故障. 但有时我们点击“安全删除硬件并弹出”时,系统会提示U盘正在工作,没有办法停 ...

  7. sql注入搞事情（连载一）

    SQL注入搞事情(连载一) 概述 写在最前面 为了有个合理的训练计划,山人准备长期开放自己的训练计划以及内容以供大家参考.山人专业是信息对抗技术,不是web方向的博客保证句句手打,如有问题请及时小窗. ...

  8. 前端入门Js笔记

    T 001 ____________--信息页面展示 需求分析: 有一个页面,在页面上有很多文字信息,且格式不一. 技术分析: html: 文字标签: 字体标签: 标题标签: 其他标签: 排版标签: ...

  9. 十三，k8s集群web端管理工具dashboard部署

    目录 部署 dashboard 由于会被墙, 所以要加一步拉取镜像 正式开始安装dashboard 查看 开放访问 配置dashboard用户 1. token 令牌认证 创建一个 serviceAc ...

  10. 【转】Qt 资源图片删除后，错误 needed by `debug/qrc_image.cpp'. Stop. 的终极解决办法

    @2019-06-13 [小记] Qt项目做完了把资源文件夹下已经不用的图片文件删掉,运行时报错(编译不报错):No rule to make target `images/图片文件名', neede ...