• zookeeper JAVA API 简单操作



      1 package org.admln.program.Zoo_Test;
      2 
      3 import java.io.IOException;
      4 import java.security.NoSuchAlgorithmException;
      5 import java.util.ArrayList;
      6 import java.util.List;
      7 
      8 import org.apache.zookeeper.CreateMode;
      9 import org.apache.zookeeper.WatchedEvent;
     10 import org.apache.zookeeper.Watcher;
     11 import org.apache.zookeeper.ZooDefs;
     12 import org.apache.zookeeper.ZooDefs.Ids;
     13 import org.apache.zookeeper.ZooKeeper;
     14 import org.apache.zookeeper.data.ACL;
     15 import org.apache.zookeeper.data.Id;
     16 import org.apache.zookeeper.data.Stat;
     17 import org.apache.zookeeper.server.auth.DigestAuthenticationProvider;
     18 import org.junit.After;
     19 import org.junit.Assert;
     20 import org.junit.Before;
     21 import org.junit.Test;
     22 import org.slf4j.Logger;
     23 import org.slf4j.LoggerFactory;
     24 
     25 
     26 /**
     27  * Test Method {create/exists/delete/getChildren/setData/getData/addAuthInfo/setACL/getACL}
     28  * 
     29  * @author admln
     30  * @date 2015年5月12日 上午9:35:48
     31  */
     32 public class ZooJavaApi {
     33 
     34     private static final int SESSION_TIMEOUT = 1000;
     35     
     36     public static final Logger LOGGER = LoggerFactory.getLogger(ZooJavaApi.class);
     37     
     38     public static final String HOST = "localhost:2181";
     39     
     40     private Watcher watcher = new Watcher() {
     41         public void process(WatchedEvent we) {
     42             LOGGER.info("process:" + we.getType());
     43         }
     44     };
     45     
     46     private ZooKeeper zookeeper;
     47     
     48     /*
     49      * 开启服务器连接
     50      */
     51     @Before
     52     public void connect() throws IOException {
     53         zookeeper = new ZooKeeper(HOST, SESSION_TIMEOUT, watcher);
     54     }
     55     
     56     /*
     57      * 关闭服务器连接
     58      */
     59     @After
     60     public void close() {
     61         try {
     62             zookeeper.close();
     63         } catch (InterruptedException e) {
     64             e.printStackTrace();
     65         }
     66     }
     67     
     68     /*
     69      * 测试创建节点方法;
     70      * 调用zookeeper的 String create(final String path, byte data[], List<ACL> acl,CreateMode createMode)方法;
     71      * path 创建节点名;
     72      * data[] 节点的数据信息,字节数组类型;
     73      * acl 访问权限,List数组类型;
     74      * createMode 节点持久化类型;
     75      * Assert.fail() 方法加在期望中不可能到达的地方,一旦到达,表明测试失败,结果与预期不同
     76      */
     77     @Test
     78     public void testCreate() {
     79         String createNode = "/zk001";
     80         String createNodeData = "zk001Data";
     81         String result = null;
     82         try {
     83             result = zookeeper.create(createNode, createNodeData.getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
     84         } catch (Exception e) {
     85             LOGGER.error(e.getMessage());
     86             e.printStackTrace();
     87             Assert.fail();
     88         }
     89         System.out.println("成功创建了NODE:" + result);
     90     }
     91     
     92     /*
     93      * 测试删除节点方法;
     94      * 调用zookeeper的delete(final String path, int version)方法;
     95      * path 节点名;
     96      * version 节点版本;
     97      * 版本为 -1 的话匹配所有版本
     98      */
     99     @Test
    100     public void testDelete() {
    101         String deleteNode = "/zk001";
    102         try {
    103             zookeeper.delete(deleteNode, -1);
    104         } catch (Exception e) {
    105             LOGGER.error(e.getMessage());
    106             e.printStackTrace();
    107             Assert.fail();  
    108         }
    109         System.out.println("成功删除节点:" + deleteNode);
    110     }
    111     
    112     /*
    113      * 测试获取节点数据方法;
    114      * 调用zookeeper的getData(final String path, Watcher watcher, Stat stat)方法;
    115      * path 节点名称;
    116      * watcher 获取节点信息时设置Watcher;
    117      * stat 数据的版本等信息可以通过 stat 来指定;
    118      */
    119     @Test
    120     public void testGetData() {
    121         String getDataNode = "/zk001";
    122         String result = null;
    123         try {
    124             byte[] bytes = zookeeper.getData(getDataNode, null, null);
    125             result = new String(bytes);
    126         } catch (Exception e) {
    127             LOGGER.error(e.getMessage());
    128             e.printStackTrace();
    129             Assert.fail();
    130         }
    131         System.out.println("获取节点数据:" + result);
    132     }
    133     
    134     /*
    135      * 测试设置节点数据方法;
    136      * 调用zookeeper的setData(final String path, byte data[], int version)方法
    137      * path 节点名称;
    138      * data[] 节点数据;
    139      * version 节点版本;
    140      * 版本设为-1则匹配所有版本;
    141      * 返回 Stat 类型实例,通过Stat可以获取节点各种信息,例如版本
    142      */
    143     @Test
    144     public void testSetData() {
    145         String setDataNode = "/zk001";
    146         String setNodeData = "/zk001DataSetTest";
    147         Stat tempStat = null;
    148         try {
    149             tempStat = zookeeper.setData(setDataNode, setNodeData.getBytes(), -1);
    150             
    151         } catch (Exception e) {
    152             LOGGER.error(e.getMessage());
    153             e.printStackTrace();
    154             Assert.fail();
    155         }
    156         System.out.println("成功设置数据:" + setNodeData + "; 设置后的版本为:" + tempStat.getVersion());
    157     }
    158     
    159     /*
    160      * 测试判断节点是否存在方法;
    161      * 调用zookeeper的exists(String path, boolean watch)方法;
    162      * path 节点名;
    163      * watch 是否监听;
    164      * 返回Stat类型的实例,可以获取各种信息;
    165      */
    166     @Test
    167     public void testExists() {
    168         String existsNode = "/zk001";
    169         Stat tempStat = null; 
    170         try {
    171             tempStat = zookeeper.exists(existsNode, false);
    172         } catch (Exception e) {
    173             LOGGER.error(e.getMessage());
    174             e.printStackTrace();
    175             Assert.fail();
    176         }
    177         System.out.println(tempStat.getCzxid() == 0 ? "节点是否存在:否":"节点是否存在:是");
    178     }
    179     
    180     /*
    181      * 测试获取子节点方法;
    182      * 调用zookeeper的getChildren(String path, boolean watch)方法;
    183      * path 节点名称;
    184      * watch 是否设置监听;
    185      * 返回值为一个String类型的List;
    186      */
    187     @Test
    188     public void testGetChildren() {
    189         String parentNode = "/zk001";
    190         List<String> list = null; 
    191         try {
    192             list = zookeeper.getChildren(parentNode, false);
    193         } catch (Exception e) {
    194             LOGGER.error(e.getMessage());
    195             e.printStackTrace();
    196             Assert.fail();
    197         }
    198         if(list.isEmpty()) {
    199             System.out.println(parentNode + "无子节点");
    200         }else {
    201             System.out.print(parentNode + "的子节点有:");
    202             for(String str : list) {
    203                 System.out.print(" " + str);
    204             }
    205         }
    206     }
    207     
    208     /*
    209      * 测试设置节点访问权限方法;
    210      * 调用zookeeper的setACL(final String path, List<ACL> acl, int version)方法;
    211      * path 节点名称;
    212      * acl 设置的权限信息;
    213      * version 设置权限的版本;
    214      * 返回Stat类型的尸体,可以查看节点信息;
    215      */
    216     @Test
    217     public void testSetAcl() {
    218         String aclNode = "/zk001/zk002";
    219         String scheme = "digest";
    220         String authInfo = "admln:admln";
    221         List<ACL> acls = new ArrayList<ACL>();
    222         try {
    223             Id id1 = new Id(scheme,DigestAuthenticationProvider.generateDigest(authInfo));
    224             ACL acl1 = new ACL(ZooDefs.Perms.ALL, id1);
    225             acls.add(acl1);
    226             Id id2 = new Id(scheme,DigestAuthenticationProvider.generateDigest("guest:guest"));
    227             ACL acl2 = new ACL(ZooDefs.Perms.READ, id2);
    228             acls.add(acl2);
    229         } catch (NoSuchAlgorithmException e) {
    230             e.printStackTrace();
    231         }
    232         try {
    233             zookeeper.setACL(aclNode, acls, -1);
    234         } catch (Exception e) {
    235             LOGGER.error(e.getMessage());
    236             e.printStackTrace();
    237             Assert.fail();
    238         }
    239         System.out.println("成功为" + aclNode + "添加了ACL,scheme为:" + scheme + ",验证信息为:" + authInfo);
    240     }
    241     
    242     /*
    243      * 测试获取节点权限信息方法;
    244      * 调用zookeeper的getACL(final String path, Stat stat)方法;
    245      * path 节点名称;
    246      * stat 节点状态信息;
    247      * 返回一个ACL列表;
    248      */
    249     @Test
    250     public void testGetAcl() {
    251         String getAclNode = "/zk001/zk002";
    252         List<ACL> list = null;
    253         try {
    254             list = zookeeper.getACL(getAclNode, new Stat());
    255         } catch (Exception e) {
    256             LOGGER.error(e.getMessage());
    257             e.printStackTrace();
    258             Assert.fail();
    259         }
    260         if(list.isEmpty()) {
    261             System.out.println(getAclNode + " 没有ACL权限设置");
    262         }else {
    263             System.out.println(getAclNode + " 的ACL权限信息: ");
    264             for(ACL acl : list) {
    265                 System.out.print("	" + acl.toString());
    266             }
    267         }
    268     }
    269     /*
    270      * 测试权限验证方法;
    271      * 调用zookeeper的addAuthInfo(String scheme, byte auth[])方法;
    272      * scheme 权限类型;
    273      * auth[] 权限信息;
    274      */
    275     @Test
    276     public void testAddAuthInfo() {
    277         String addAuthInfoNode = "/zk001/zk002";
    278         String scheme = "digest";
    279         String authInfo = "admln:admln";
    280         String result = null;
    281         try {
    282             byte[] bytes = zookeeper.getData(addAuthInfoNode, null, null);
    283             result = new String(bytes);
    284         } catch (Exception e) {
    285             System.out.println("没有提供验证信息前获取节点信息:" + result + " ,返回错误信息:" + e.getMessage());
    286         }
    287         zookeeper.addAuthInfo(scheme, authInfo.getBytes());
    288         try {
    289             byte[] bytes = zookeeper.getData(addAuthInfoNode, null, null);
    290             result = new String(bytes);
    291         } catch (Exception e) {
    292             System.out.println("没有提供验证信息前获取节点信息:" + result + " ,返回错误信息:" + e.getMessage());
    293         }
    294         System.out.println("提供验证信息后获取节点信息:" + result);
    295     }
    296 }

    方法简介:

    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


  • 相关阅读:
    php获取真实ip地址原理及实现
    关于DateTime计算某个日期过后的多少天之后的日期
    关于get_include_path()和set_include_path()的问题
    LinQ In Action 学习第三章
    LinQ In Action 学习第二章
    LinQ in Action 学习第一章 例子。
    asp.net create windows application and setup service.
    JS alert()、confirm()、prompt()的区别
    php获取用户 地区 、ip地址
    购物车相关 js
  • 原文地址:https://www.cnblogs.com/admln/p/zookeeper-java-api-simple-oprate.html
Copyright © 2020-2023  润新知