Zookeeper（五）JAVA API (转)

 

org.apache.zookeeper.ZooKeeper类 主要方法列表

 

方法名称描述
String create(final String path, byte data[], List acl, CreateMode createMode)

创建一个znode节点，

参数： 路径、 znode内容，ACL(访问控制列表)、 znode创建类型
void delete(final String path, int version)

删除一个znode节点，

参数： 路径、版本号；如果版本号与znode的版本号不一致，将无法删除，是一种乐观加锁机制；如果将版本号设置为-1，不会去检测版本，直接删除；
Stat exists(final String path, Watcher watcher)

判断某个znode节点是否存在

参数： 路径、Watcher(监视器)；当这个znode节点被改变时，将会触发当前Watcher
Stat exists(String path, boolean watch)

判断某个znode节点是否存在

参数： 路径、并设置是否监控这个目录节点，这里的 watcher 是在创建 ZooKeeper 实例时指定的 watcher
Stat setData(final String path, byte data[], int version)

设置某个znode上的数据

参数： 路径、数据、版本号；如果为-1，跳过版本检查
byte[] getData(final String path, Watcher watcher, Stat stat)

获取某个znode上的数据

参数： 路径、监视器、数据版本等信息
List getChildren(final String path, Watcher watcher)

获取某个节点下的所有子节点

参数： 路径、监视器;该方法有多个重载

 

 znode创建类型(CreateMode)：

PERSISTENT               持久化节点
   
PERSISTENT_SEQUENTIAL     顺序自动编号持久化节点，这种节点会根据当前已存在的节点数自动加 1
   
EPHEMERAL    临时节点， 客户端session超时这类节点就会被自动删除
  

EPHEMERAL_SEQUENTIAL   临时自动编号节点


[java] view plaincopyprint?
    1. /* 
    2.  * ZookeeperTest.java 
    3.  */  
    4. package com.x.zookeeper;  
    5.   
    6. import java.io.IOException;  
    7. import java.util.List;  
    8.   
    9. import org.apache.zookeeper.CreateMode;  
    10. import org.apache.zookeeper.WatchedEvent;  
    11. import org.apache.zookeeper.Watcher;  
    12. import org.apache.zookeeper.ZooKeeper;  
    13. import org.apache.zookeeper.ZooDefs.Ids;  
    14. import org.apache.zookeeper.data.Stat;  
    15. import org.junit.After;  
    16. import org.junit.Assert;  
    17. import org.junit.Before;  
    18. import org.junit.Test;  
    19. import org.slf4j.Logger;  
    20. import org.slf4j.LoggerFactory;  
    21.   
    22. /** 
    23.  *  
    24.  * @author http://blog.csdn.net/java2000_wl 
    25.  * @version <b>1.0</b> 
    26.  */  
    27. public class ZookeeperTest {  
    28.       
    29.     private static final int SESSION_TIMEOUT = 30000;  
    30.       
    31.     public static final Logger LOGGER = LoggerFactory.getLogger(ZookeeperTest.class);  
    32.       
    33.     private Watcher watcher =  new Watcher() {  
    34.   
    35.         public void process(WatchedEvent event) {  
    36.             LOGGER.info("process : " + event.getType());  
    37.         }  
    38.     };  
    39.       
    40.     private ZooKeeper zooKeeper;  
    41.       
    42.     /** 
    43.      *  连接zookeeper 
    44.      * <br>------------------------------<br> 
    45.      * @throws IOException 
    46.      */  
    47.     @Before  
    48.     public void connect() throws IOException {  
    49.         zooKeeper  = new ZooKeeper("localhost:2181,localhost:2182,localhost:2183", SESSION_TIMEOUT, watcher);  
    50.     }  
    51.       
    52.     /** 
    53.      *  关闭连接 
    54.      * <br>------------------------------<br> 
    55.      */  
    56.     @After  
    57.     public void close() {  
    58.         try {  
    59.             zooKeeper.close();  
    60.         } catch (InterruptedException e) {  
    61.             e.printStackTrace();  
    62.         }  
    63.     }  
    64.   
    65.     /** 
    66.      * 创建一个znode  
    67.      *  1.CreateMode 取值   
    68.      *  PERSISTENT：持久化，这个目录节点存储的数据不会丢失 
    69.      *  PERSISTENT_SEQUENTIAL：顺序自动编号的目录节点，这种目录节点会根据当前已近存在的节点数自动加 1，然后返回给客户端已经成功创建的目录节点名； 
    70.      *  EPHEMERAL：临时目录节点，一旦创建这个节点的客户端与服务器端口也就是 session过期超时，这种节点会被自动删除 
    71.      *  EPHEMERAL_SEQUENTIAL：临时自动编号节点 
    72.      * <br>------------------------------<br> 
    73.      */  
    74.     @Test  
    75.     public void testCreate() {  
    76.         String result = null;  
    77.          try {  
    78.              result = zooKeeper.create("/zk001", "zk001data".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);  
    79.         } catch (Exception e) {  
    80.              LOGGER.error(e.getMessage());  
    81.              Assert.fail();  
    82.         }  
    83.          LOGGER.info("create result : {}", result);  
    84.      }  
    85.       
    86.     /** 
    87.      * 删除节点  忽略版本 
    88.      * <br>------------------------------<br> 
    89.      */  
    90.     @Test  
    91.     public void testDelete() {  
    92.          try {  
    93.             zooKeeper.delete("/zk001", -1);  
    94.         } catch (Exception e) {  
    95.              LOGGER.error(e.getMessage());  
    96.              Assert.fail();  
    97.         }  
    98.     }  
    99.       
    100.     /** 
    101.      *   获取数据 
    102.      * <br>------------------------------<br> 
    103.      */  
    104.     @Test  
    105.     public void testGetData() {  
    106.         String result = null;  
    107.          try {  
    108.              byte[] bytes = zooKeeper.getData("/zk001", null, null);  
    109.              result = new String(bytes);  
    110.         } catch (Exception e) {  
    111.              LOGGER.error(e.getMessage());  
    112.              Assert.fail();  
    113.         }  
    114.          LOGGER.info("getdata result : {}", result);  
    115.     }  
    116.       
    117.     /** 
    118.      *   获取数据  设置watch 
    119.      * <br>------------------------------<br> 
    120.      */  
    121.     @Test  
    122.     public void testGetDataWatch() {  
    123.         String result = null;  
    124.          try {  
    125.              byte[] bytes = zooKeeper.getData("/zk001", new Watcher() {  
    126.                 public void process(WatchedEvent event) {  
    127.                     LOGGER.info("testGetDataWatch  watch : {}", event.getType());  
    128.                 }  
    129.              }, null);  
    130.              result = new String(bytes);  
    131.         } catch (Exception e) {  
    132.              LOGGER.error(e.getMessage());  
    133.              Assert.fail();  
    134.         }  
    135.          LOGGER.info("getdata result : {}", result);  
    136.            
    137.          // 触发wacth  NodeDataChanged  
    138.          try {  
    139.              zooKeeper.setData("/zk001", "testSetData".getBytes(), -1);  
    140.         } catch (Exception e) {  
    141.              LOGGER.error(e.getMessage());  
    142.              Assert.fail();  
    143.         }  
    144.     }  
    145.       
    146.     /** 
    147.      *    判断节点是否存在 
    148.      *    设置是否监控这个目录节点，这里的 watcher 是在创建 ZooKeeper实例时指定的 watcher 
    149.      * <br>------------------------------<br> 
    150.      */  
    151.     @Test  
    152.     public void testExists() {  
    153.         Stat stat = null;  
    154.          try {  
    155.              stat = zooKeeper.exists("/zk001", false);  
    156.         } catch (Exception e) {  
    157.              LOGGER.error(e.getMessage());  
    158.              Assert.fail();  
    159.         }  
    160.          Assert.assertNotNull(stat);  
    161.          LOGGER.info("exists result : {}", stat.getCzxid());  
    162.     }  
    163.       
    164.     /** 
    165.      *     设置对应znode下的数据  ,  -1表示匹配所有版本 
    166.      * <br>------------------------------<br> 
    167.      */  
    168.     @Test  
    169.     public void testSetData() {  
    170.         Stat stat = null;  
    171.          try {  
    172.              stat = zooKeeper.setData("/zk001", "testSetData".getBytes(), -1);  
    173.         } catch (Exception e) {  
    174.              LOGGER.error(e.getMessage());  
    175.              Assert.fail();  
    176.         }  
    177.          Assert.assertNotNull(stat);  
    178.          LOGGER.info("exists result : {}", stat.getVersion());    
    179.     }  
    180.       
    181.     /** 
    182.      *    判断节点是否存在,  
    183.      *    设置是否监控这个目录节点，这里的 watcher 是在创建 ZooKeeper实例时指定的 watcher 
    184.      * <br>------------------------------<br> 
    185.      */  
    186.     @Test  
    187.     public void testExistsWatch1() {  
    188.         Stat stat = null;  
    189.          try {  
    190.              stat = zooKeeper.exists("/zk001", true);  
    191.         } catch (Exception e) {  
    192.              LOGGER.error(e.getMessage());  
    193.              Assert.fail();  
    194.         }  
    195.          Assert.assertNotNull(stat);  
    196.            
    197.          try {  
    198.             zooKeeper.delete("/zk001", -1);  
    199.         } catch (Exception e) {  
    200.             e.printStackTrace();  
    201.         }  
    202.     }  
    203.       
    204.     /** 
    205.      *    判断节点是否存在,  
    206.      *    设置监控这个目录节点的 Watcher 
    207.      * <br>------------------------------<br> 
    208.      */  
    209.     @Test  
    210.     public void testExistsWatch2() {  
    211.         Stat stat = null;  
    212.          try {  
    213.              stat = zooKeeper.exists("/zk002", new Watcher() {  
    214.                 @Override  
    215.                 public void process(WatchedEvent event) {  
    216.                     LOGGER.info("testExistsWatch2  watch : {}", event.getType());  
    217.                 }  
    218.              });  
    219.         } catch (Exception e) {  
    220.              LOGGER.error(e.getMessage());  
    221.              Assert.fail();  
    222.         }  
    223.          Assert.assertNotNull(stat);  
    224.            
    225.          // 触发watch 中的process方法   NodeDataChanged  
    226.          try {  
    227.             zooKeeper.setData("/zk002", "testExistsWatch2".getBytes(), -1);  
    228.         } catch (Exception e) {  
    229.             e.printStackTrace();  
    230.         }  
    231.            
    232.          // 不会触发watch 只会触发一次  
    233.          try {  
    234.             zooKeeper.delete("/zk002", -1);  
    235.         } catch (Exception e) {  
    236.             e.printStackTrace();  
    237.         }  
    238.     }  
    239.       
    240.     /** 
    241.      *  获取指定节点下的子节点 
    242.      * <br>------------------------------<br> 
    243.      */  
    244.     @Test  
    245.     public void testGetChild() {  
    246.          try {  
    247.              zooKeeper.create("/zk/001", "001".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);  
    248.              zooKeeper.create("/zk/002", "002".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);  
    249.                
    250.              List<String> list = zooKeeper.getChildren("/zk", true);  
    251.             for (String node : list) {  
    252.                 LOGGER.info("node {}", node);  
    253.             }  
    254.         } catch (Exception e) {  
    255.              LOGGER.error(e.getMessage());  
    256.              Assert.fail();  
    257.         }  
    258.     }  
    259. }
posted on 2015-04-21 09:47  胡杂子  阅读(115)  评论(0)    收藏  举报
博客园  ©  2004-2026
浙公网安备 33010602011771号 浙ICP备2021040463号-3