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 plain copy print ?

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. }