zookeeper JAVA API 简单操作

---

 package org.admln.program.Zoo_Test;

 import java.io.IOException;
 import java.security.NoSuchAlgorithmException;
 import java.util.ArrayList;
 import java.util.List;

 import org.apache.zookeeper.CreateMode;
 import org.apache.zookeeper.WatchedEvent;
 import org.apache.zookeeper.Watcher;
 import org.apache.zookeeper.ZooDefs;
 import org.apache.zookeeper.ZooDefs.Ids;
 import org.apache.zookeeper.ZooKeeper;
 import org.apache.zookeeper.data.ACL;
 import org.apache.zookeeper.data.Id;
 import org.apache.zookeeper.data.Stat;
 import org.apache.zookeeper.server.auth.DigestAuthenticationProvider;
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 /**
  * Test Method {create/exists/delete/getChildren/setData/getData/addAuthInfo/setACL/getACL}
  *
  * @author admln
  * @date 2015年5月12日 上午9:35:48
  */
 public class ZooJavaApi {

     private static final int SESSION_TIMEOUT = 1000;

     public static final Logger LOGGER = LoggerFactory.getLogger(ZooJavaApi.class);

     public static final String HOST = "localhost:2181";

     private Watcher watcher = new Watcher() {
         public void process(WatchedEvent we) {
             LOGGER.info("process:" + we.getType());
         }
     };

     private ZooKeeper zookeeper;

     /*
      * 开启服务器连接
      */
     @Before
     public void connect() throws IOException {
         zookeeper = new ZooKeeper(HOST, SESSION_TIMEOUT, watcher);
     }

     /*
      * 关闭服务器连接
      */
     @After
     public void close() {
         try {
             zookeeper.close();
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }

     /*
      * 测试创建节点方法；
      * 调用zookeeper的 String create(final String path, byte data[], List<ACL> acl,CreateMode createMode)方法；
      * path 创建节点名；
      * data[] 节点的数据信息，字节数组类型；
      * acl 访问权限，List数组类型；
      * createMode 节点持久化类型；
      * Assert.fail() 方法加在期望中不可能到达的地方，一旦到达，表明测试失败，结果与预期不同
      */
     @Test
     public void testCreate() {
         String createNode = "/zk001";
         String createNodeData = "zk001Data";
         String result = null;
         try {
             result = zookeeper.create(createNode, createNodeData.getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
         } catch (Exception e) {
             LOGGER.error(e.getMessage());
             e.printStackTrace();
             Assert.fail();
         }
         System.out.println("成功创建了NODE：" + result);
     }

     /*
      * 测试删除节点方法;
      * 调用zookeeper的delete(final String path, int version)方法;
      * path 节点名；
      * version 节点版本；
      * 版本为 -1 的话匹配所有版本
      */
     @Test
     public void testDelete() {
         String deleteNode = "/zk001";
         try {
             zookeeper.delete(deleteNode, -1);
         } catch (Exception e) {
             LOGGER.error(e.getMessage());
             e.printStackTrace();
             Assert.fail();
         }
         System.out.println("成功删除节点：" + deleteNode);
     }

     /*
      * 测试获取节点数据方法；
      * 调用zookeeper的getData(final String path, Watcher watcher, Stat stat)方法;
      * path 节点名称；
      * watcher 获取节点信息时设置Watcher;
      * stat 数据的版本等信息可以通过 stat 来指定;
      */
     @Test
     public void testGetData() {
         String getDataNode = "/zk001";
         String result = null;
         try {
             byte[] bytes = zookeeper.getData(getDataNode, null, null);
             result = new String(bytes);
         } catch (Exception e) {
             LOGGER.error(e.getMessage());
             e.printStackTrace();
             Assert.fail();
         }
         System.out.println("获取节点数据：" + result);
     }

     /*
      * 测试设置节点数据方法；
      * 调用zookeeper的setData(final String path, byte data[], int version)方法
      * path 节点名称；
      * data[] 节点数据；
      * version 节点版本；
      * 版本设为-1则匹配所有版本;
      * 返回 Stat 类型实例，通过Stat可以获取节点各种信息，例如版本
      */
     @Test
     public void testSetData() {
         String setDataNode = "/zk001";
         String setNodeData = "/zk001DataSetTest";
         Stat tempStat = null;
         try {
             tempStat = zookeeper.setData(setDataNode, setNodeData.getBytes(), -1);

         } catch (Exception e) {
             LOGGER.error(e.getMessage());
             e.printStackTrace();
             Assert.fail();
         }
         System.out.println("成功设置数据：" + setNodeData + "; 设置后的版本为：" + tempStat.getVersion());
     }

     /*
      * 测试判断节点是否存在方法；
      * 调用zookeeper的exists(String path, boolean watch)方法；
      * path 节点名；
      * watch 是否监听;
      * 返回Stat类型的实例，可以获取各种信息;
      */
     @Test
     public void testExists() {
         String existsNode = "/zk001";
         Stat tempStat = null;
         try {
             tempStat = zookeeper.exists(existsNode, false);
         } catch (Exception e) {
             LOGGER.error(e.getMessage());
             e.printStackTrace();
             Assert.fail();
         }
         System.out.println(tempStat.getCzxid() == 0 ? "节点是否存在:否":"节点是否存在:是");
     }

     /*
      * 测试获取子节点方法;
      * 调用zookeeper的getChildren(String path, boolean watch)方法；
      * path 节点名称；
      * watch 是否设置监听;
      * 返回值为一个String类型的List;
      */
     @Test
     public void testGetChildren() {
         String parentNode = "/zk001";
         List<String> list = null;
         try {
             list = zookeeper.getChildren(parentNode, false);
         } catch (Exception e) {
             LOGGER.error(e.getMessage());
             e.printStackTrace();
             Assert.fail();
         }
         if(list.isEmpty()) {
             System.out.println(parentNode + "无子节点");
         }else {
             System.out.print(parentNode + "的子节点有：");
             for(String str : list) {
                 System.out.print(" " + str);
             }
         }
     }

     /*
      * 测试设置节点访问权限方法；
      * 调用zookeeper的setACL(final String path, List<ACL> acl, int version)方法；
      * path 节点名称；
      * acl 设置的权限信息；
      * version 设置权限的版本；
      * 返回Stat类型的尸体，可以查看节点信息；
      */
     @Test
     public void testSetAcl() {
         String aclNode = "/zk001/zk002";
         String scheme = "digest";
         String authInfo = "admln:admln";
         List<ACL> acls = new ArrayList<ACL>();
         try {
             Id id1 = new Id(scheme,DigestAuthenticationProvider.generateDigest(authInfo));
             ACL acl1 = new ACL(ZooDefs.Perms.ALL, id1);
             acls.add(acl1);
             Id id2 = new Id(scheme,DigestAuthenticationProvider.generateDigest("guest:guest"));
             ACL acl2 = new ACL(ZooDefs.Perms.READ, id2);
             acls.add(acl2);
         } catch (NoSuchAlgorithmException e) {
             e.printStackTrace();
         }
         try {
             zookeeper.setACL(aclNode, acls, -1);
         } catch (Exception e) {
             LOGGER.error(e.getMessage());
             e.printStackTrace();
             Assert.fail();
         }
         System.out.println("成功为" + aclNode + "添加了ACL,scheme为：" + scheme + ",验证信息为：" + authInfo);
     }

     /*
      * 测试获取节点权限信息方法；
      * 调用zookeeper的getACL(final String path, Stat stat)方法；
      * path 节点名称;
      * stat 节点状态信息；
      * 返回一个ACL列表;
      */
     @Test
     public void testGetAcl() {
         String getAclNode = "/zk001/zk002";
         List<ACL> list = null;
         try {
             list = zookeeper.getACL(getAclNode, new Stat());
         } catch (Exception e) {
             LOGGER.error(e.getMessage());
             e.printStackTrace();
             Assert.fail();
         }
         if(list.isEmpty()) {
             System.out.println(getAclNode + " 没有ACL权限设置");
         }else {
             System.out.println(getAclNode + " 的ACL权限信息： ");
             for(ACL acl : list) {
                 System.out.print("\t" + acl.toString());
             }
         }
     }
     /*
      * 测试权限验证方法；
      * 调用zookeeper的addAuthInfo(String scheme, byte auth[])方法；
      * scheme 权限类型；
      * auth[] 权限信息；
      */
     @Test
     public void testAddAuthInfo() {
         String addAuthInfoNode = "/zk001/zk002";
         String scheme = "digest";
         String authInfo = "admln:admln";
         String result = null;
         try {
             byte[] bytes = zookeeper.getData(addAuthInfoNode, null, null);
             result = new String(bytes);
         } catch (Exception e) {
             System.out.println("没有提供验证信息前获取节点信息：" + result + " ,返回错误信息：" + e.getMessage());
         }
         zookeeper.addAuthInfo(scheme, authInfo.getBytes());
         try {
             byte[] bytes = zookeeper.getData(addAuthInfoNode, null, null);
             result = new String(bytes);
         } catch (Exception e) {
             System.out.println("没有提供验证信息前获取节点信息：" + result + " ,返回错误信息：" + e.getMessage());
         }
         System.out.println("提供验证信息后获取节点信息：" + result);
     }
 }

---

方法简介：

String create(String path, byte[] data, List<ACL> acl,CreateMode createMode)	创建一个给定的目录节点 path, 并给它设置数据，CreateMode 标识有四种形式的目录节点，分别是 PERSISTENT：持久化目录节点，这个目录节点存储的数据不会丢失；PERSISTENT_SEQUENTIAL：顺序自动编号的目录节点，这种目录节点会根据当前已近存在的节点数自动加 1，然后返回给客户端已经成功创建的目录节点名；EPHEMERAL：临时目录节点，一旦创建这个节点的客户端与服务器端口也就是 session 超时，这种节点会被自动删除；EPHEMERAL_SEQUENTIAL：临时自动编号节点
Stat exists(String path, boolean watch)	判断某个 path 是否存在，并设置是否监控这个目录节点，这里的 watcher 是在创建 ZooKeeper 实例时指定的 watcher，exists方法还有一个重载方法，可以指定特定的watcher
Stat exists(String path,Watcher watcher)	重载方法，这里给某个目录节点设置特定的 watcher，Watcher 在 ZooKeeper 是一个核心功能，Watcher 可以监控目录节点的数据变化以及子目录的变化，一旦这些状态发生变化，服务器就会通知所有设置在这个目录节点上的 Watcher，从而每个客户端都很快知道它所关注的目录节点的状态发生变化，而做出相应的反应
void delete(String path, int version)	删除 path 对应的目录节点，version 为 -1 可以匹配任何版本，也就删除了这个目录节点所有数据
List<String>getChildren(String path, boolean watch)	获取指定 path 下的所有子目录节点，同样 getChildren方法也有一个重载方法可以设置特定的 watcher 监控子节点的状态
Stat setData(String path, byte[] data, int version)	给 path 设置数据，可以指定这个数据的版本号，如果 version 为 -1 怎可以匹配任何版本
byte[] getData(String path, boolean watch, Stat stat)	获取这个 path 对应的目录节点存储的数据，数据的版本等信息可以通过 stat 来指定，同时还可以设置是否监控这个目录节点数据的状态
voidaddAuthInfo(String scheme, byte[] auth)	客户端将自己的授权信息提交给服务器，服务器将根据这个授权信息验证客户端的访问权限。
Stat setACL(String path,List<ACL> acl, int version)	给某个目录节点重新设置访问权限，需要注意的是 Zookeeper 中的目录节点权限不具有传递性，父目录节点的权限不能传递给子目录节点。目录节点 ACL 由两部分组成：perms 和 id。 Perms 有 ALL、READ、WRITE、CREATE、DELETE、ADMIN 几种  而 id 标识了访问目录节点的身份列表，默认情况下有以下两种： ANYONE_ID_UNSAFE = new Id("world", "anyone") 和 AUTH_IDS = new Id("auth", "") 分别表示任何人都可以访问和创建者拥有访问权限。
List<ACL>getACL(String path,Stat stat)	获取某个目录节点的访问权限列表

部分内容参考自：

http://www.cnblogs.com/ggjucheng/p/3370359.html

http://jm-blog.aliapp.com/?p=947

---