ZooKeeper安装与操作实例

单机安装

 

下载zookeeper3.4.3，解压缩至/usr/zookeeper.

复制conf/zoo_sample.cfg重命名为conf/zoo.cfg，执行命令 > sudo cp conf/zoo_sample.cfg conf/zoo.cfg

 

修改zoo.cfg文件，编辑为如下：

 

tickTime=2000 #心跳间隔

dataDir=/home/sulin/zookeeper #数据存放目录

dataLogDir=/usr/zookeeper/logs #日志存放目录，手动存在。如果没有貌似启动不成功

clientPort=2181 #客户端连接端口

# 此时已经可以通过“bin/zkServer.sh start”命令启动zookeeper，然后通过shell访问了zookeeper了

 

----------后面的配置是为了上面配置的单机版能让其他主机也能访问此zookeeper（其实也是伪分布式）

server.1=218.196.207.186:2888:3888 #2888是zookeeper服务之间的通信端口，3888是zookeeper与其他应用程序之间通信端口。

手动创建数据存放目录（/home/sulin/zookeeper），然后在目录中创建一个叫做"myid"的文件，文件内容为“1”。此处的1与上面的1对应。

 

分布式配置

和上面的伪分布式配置是一样的，如果是三台的话，zoo.cfg配置为：

 

tickTime=2000

dataDir=/home/sulin/zookeeper

dataLogDir=/usr/zookeeper/logs

clientPort=2181

server.1=218.196.207.186:2888:3888

server.2=218.196.207.185:2888:3888

server.3=218.196.207.184:2888:3888

 

然后可以使用rsync指令将第一台机器上的zookeeper文件夹发送至其他两台

 

> sudo rsync -a /usr/zookeeper UbuntuB:/usr

> sudo rsync -a /usr/zookeeper UbuntuC:/usr

 

之后在其余两台机器上面手动创建dataDir文件夹，并且新建myid文件，写入自己的序号1/2/3。

 

然后分别在三台机器上面启动zookeeper服务：> bin/zooService.sh start

 

注意：一定要谨记将logs文件夹重建，因为里面的version-2里面会保存原有记录，此记录有可能与新集群有冲突。

注意：还有dataDir也要重建，原有的节点快照都会导致新集群出现问题。下面就是dataDir忘记重建出现的读取快照失败错误

 

 

 

下面是一个比较简单的测试程序，此程序改编自ZooKeeper官方文档中的例子：

 

Java代码  

1. package net.sulin.hbase.test;  
2.   
3. import java.io.IOException;  
4. import java.util.ArrayList;  
5. import java.util.List;  
6.   
7. import org.apache.hadoop.hbase.util.Bytes;  
8. import org.apache.zookeeper.AsyncCallback.StatCallback;  
9. import org.apache.zookeeper.CreateMode;  
10. import org.apache.zookeeper.KeeperException;  
11. import org.apache.zookeeper.KeeperException.Code;  
12. import org.apache.zookeeper.WatchedEvent;  
13. import org.apache.zookeeper.Watcher;  
14. import org.apache.zookeeper.ZooDefs;  
15. import org.apache.zookeeper.ZooKeeper;  
16. import org.apache.zookeeper.data.ACL;  
17. import org.apache.zookeeper.data.Id;  
18. import org.apache.zookeeper.data.Stat;  
19.   
20. /** 
21.  *  
22.  * @author sulin 
23.  * @date 2012-8-2 上午08:59:50 
24.  */  
25. @SuppressWarnings("deprecation")  
26. public class ZooKeeperTest01 implements Watcher, Runnable, StatCallback{  
27.   
28.     private static String znode = "/test";  
29.       
30.     public ZooKeeper zk;  
31.     public Stat stat;  
32.       
33.     public ZooKeeperTest01(String hostPort, String znode, String filename) {  
34.         try {  
35.             zk = new ZooKeeper(hostPort, 5000, this);  
36.         } catch (IOException e) {  
37.             e.printStackTrace();  
38.         }  
39.         try {  
40.             if(zk.exists(znode, false) == null){  
41.                 // 创建节点，权限随便设置了。  
42.                 Id id = new Id("ip", "218.196.207.187");  
43.                 ACL acl = new ACL(ZooDefs.Perms.ALL, id);  
44.                 List<ACL> acls = new ArrayList<ACL>();  
45.                 acls.add(acl);  
46.                 zk.create(znode, Bytes.toBytes("这是第一次放入的数据"), acls, CreateMode.PERSISTENT);  
47.             }  
48.             stat = new Stat();  
49.             System.out.println("第一次读到的数据： " + Bytes.toString(zk.getData(znode,true,stat)));  
50.         } catch (KeeperException e) {  
51.             e.printStackTrace();  
52.         } catch (InterruptedException e) {  
53.             e.printStackTrace();  
54.         }  
55.     }  
56.       
57.     public static void main(String[] args) {  
58.         ZooKeeperTest01 temp = new ZooKeeperTest01("218.196.207.185:2181,218.196.207.184:2181,218.196.207.186:2181", znode, "");  
59.         new Thread(temp).start();  
60.         // 其他线程已启动  
61.         try {  
62.             temp.zk.setData(znode, Bytes.toBytes("第二次放入的数据"), temp.stat.getVersion());  
63.         } catch (KeeperException e) {  
64.             e.printStackTrace();  
65.         } catch (InterruptedException e) {  
66.             e.printStackTrace();  
67.         }  
68.           
69.         synchronized (temp) {  
70.             try {  
71.                 temp.wait();  
72.             } catch (InterruptedException e) {  
73.                 e.printStackTrace();  
74.             }  
75.         }  
76.     }  
77.   
78.     public void run() {  
79.         synchronized(this){  
80.             try {  
81.                 wait();  
82.             } catch (InterruptedException e) {  
83.                   
84.             }  
85.         }  
86.     }  
87.       
88.     public void close(){  
89.         synchronized(this){  
90.             this.notifyAll();  
91.         }  
92.     }  
93.   
94.     /** 
95.      * 监视事件被触发时执行此方法。 
96.      */  
97.     public void process(WatchedEvent event) {  
98.         String path = event.getPath();  
99.         if(event.getType() == Event.EventType.None){  
100.             // 节点没有发生改变，无节点创建、无接点删除、节点数据未改变、子节点未改变  
101.             // 那么说明可能是会话状态发生了改变  
102.             switch(event.getState()){  
103.             case SyncConnected:  
104.                 // 此客户端处于连接状态，不需要做任何事  
105.                 break;  
106.             case Expired:  
107.                 // 会话失效，结束  
108.                 this.close();  
109.                 break;  
110.             }  
111.         }else{  
112.             // 状态改变了，检查是否znode节点值改变。如果改变则取出  
113.             if(path != null && path.equals(znode)){  
114.                 zk.exists(znode, true, this, null);  
115.             }  
116.         }  
117.     }  
118.   
119.     /** 
120.      * 状态回调方法，此方法被执行的触发条件是 
121.      * 在异步请求exists方法时，如果节点状态已经改变则执行此方法。 
122.      */  
123.     public void processResult(int rc, String path, Object ctx, Stat stat) {  
124.         boolean exists = false;  
125.         /** 
126.          * 现在ZooKeeper已经将异常代码换为枚举类型而不是静态int常量 
127.          * 可以用KeeperException.Code.get(rc)获取rc的枚举类型。 
128.          */  
129.         switch(rc){  
130.         case Code.Ok:  
131.             // 一切完好  
132.             exists = true;  
133.             break;  
134.         case Code.NoNode:  
135.             // 节点不存在  
136.             exists = false;  
137.             break;  
138.         case Code.SessionExpired:  
139.         case Code.NoAuth:  
140.             // 结束  
141.             this.close();  
142.             break;  
143.         default:  
144.             // 其他错误，重新尝试。。。  
145.             zk.exists(znode, false, this, null);  
146.             return ;  
147.         }  
148.           
149.         byte[] buf = null;  
150.         if(exists){  
151.             try {  
152.                 buf = zk.getData(znode, false, null);  
153.             } catch (KeeperException e) {  
154.                 // 前面已经处理了此异常，此处不必处理  
155.             } catch (InterruptedException e) {  
156.                 // 线程中断？事件线程中断？  
157.                 return;  
158.             }  
159.         }  
160.         // 读到了数据，简单打印看看了事  
161.         System.out.println("第二次异步读到的数据：" + Bytes.toString(buf));  
162.     }  
163.   
164. }  

 

 

执行的就是创建一个/test节点，之后放入一个数据，读出打印出来，同时设置监视器。

当第二次放入数据时，监视器会被触发，之后异步读取新数据并打印出来：

Java代码  

1. 第一次读到的数据： 这是第一次放入的数据  
2. 第二次异步读到的数据：第二次放入的数据