14.ZooKeeper Java API 使用样例

转自：http://www.aboutyun.com/thread-7332-1-1.html

 package com.taobao.taokeeper.research.sample; 

 import java.io.IOException;
 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.KeeperState;
 import org.apache.zookeeper.ZooDefs.Ids;
 import org.apache.zookeeper.ZooKeeper; 

 import common.toolkit.java.util.ObjectUtil; 

 /**
  * ZooKeeper Java Api 使用样例<br>
  * ZK Api Version: 3.4.3
  *
  * @author nileader/nileader@gmail.com
  */
 public class JavaApiSample implements Watcher { 

     private static final int SESSION_TIMEOUT = 10000;
     private static final String CONNECTION_STRING = "test.zookeeper.connection_string:2181";
     private static final String ZK_PATH = "/nileader";
     private ZooKeeper zk = null; 

     private CountDownLatch connectedSemaphore = new CountDownLatch( 1 ); 

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

     /**
      * 关闭ZK连接
      */
     public void releaseConnection() {
         if ( !ObjectUtil.isBlank( this.zk ) ) {
             try {
                 this.zk.close();
             } catch ( InterruptedException e ) {
                 // ignore
                 e.printStackTrace();
             }
         }
     } 

     /**
      *  创建节点
      * @param path 节点path
      * @param data 初始数据内容
      * @return
      */
     public boolean createPath( String path, String data ) {
         try {
             System.out.println( "节点创建成功, Path: "
                     + this.zk.create( path, //
                                               data.getBytes(), //
                                               Ids.OPEN_ACL_UNSAFE, //
                                               CreateMode.EPHEMERAL )
                     + ", content: " + data );
         } catch ( KeeperException e ) {
             System.out.println( "节点创建失败，发生KeeperException" );
             e.printStackTrace();
         } catch ( InterruptedException e ) {
             System.out.println( "节点创建失败，发生 InterruptedException" );
             e.printStackTrace();
         }
         return true;
     } 

     /**
      * 读取指定节点数据内容
      * @param path 节点path
      * @return
      */
     public String readData( String path ) {
         try {
             System.out.println( "获取数据成功，path：" + path );
             return new String( this.zk.getData( path, false, 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 节点path
      * @param data  数据内容
      * @return
      */
     public boolean writeData( String path, String data ) {
         try {
             System.out.println( "更新数据成功，path：" + path + ", stat: " +
                                                         this.zk.setData( path, data.getBytes(), -1 ) );
         } catch ( KeeperException e ) {
             System.out.println( "更新数据失败，发生KeeperException，path: " + path  );
             e.printStackTrace();
         } catch ( InterruptedException e ) {
             System.out.println( "更新数据失败，发生 InterruptedException，path: " + path  );
             e.printStackTrace();
         }
         return false;
     } 

     /**
      * 删除指定节点
      * @param path 节点path
      */
     public void deleteNode( String path ) {
         try {
             this.zk.delete( path, -1 );
             System.out.println( "删除节点成功，path：" + path );
         } catch ( KeeperException e ) {
             System.out.println( "删除节点失败，发生KeeperException，path: " + path  );
             e.printStackTrace();
         } catch ( InterruptedException e ) {
             System.out.println( "删除节点失败，发生 InterruptedException，path: " + path  );
             e.printStackTrace();
         }
     } 

     public static void main( String[] args ) { 

         JavaApiSample sample = new JavaApiSample();
         sample.createConnection( CONNECTION_STRING, SESSION_TIMEOUT );
         if ( sample.createPath( ZK_PATH, "我是节点初始内容" ) ) {
             System.out.println();
             System.out.println( "数据内容: " + sample.readData( ZK_PATH ) + "\n" );
             sample.writeData( ZK_PATH, "更新后的数据" );
             System.out.println( "数据内容: " + sample.readData( ZK_PATH ) + "\n" );
             sample.deleteNode( ZK_PATH );
         } 

         sample.releaseConnection();
     } 

     /**
      * 收到来自Server的Watcher通知后的处理。
      */
     @Override
     public void process( WatchedEvent event ) {
         System.out.println( "收到事件通知：" + event.getState() +"\n"  );
         if ( KeeperState.SyncConnected == event.getState() ) {
             connectedSemaphore.countDown();
         } 

     } 

 }
 输出结果：
 收到事件通知：SyncConnected 

 节点创建成功, Path: /nileader, content: 我是节点初始内容 

 获取数据成功，path：/nileader
 数据内容: 我是节点初始内容 

 更新数据成功，path：/nileader, stat: 42950186407,42950186408,1350820182392,1350820182406,1,0,0,232029990722229433,18,0,42950186407 

 获取数据成功，path：/nileader
 数据内容: 更新后的数据 

 删除节点成功，path：/nileader