一、基于java API初探zookeeper的使用
（1）建立连接
public static void main(String[] args) {
//NOT_CONNECTED-->CONNECTING-->CONNECTED-->CLOSE 连接的状态
try {
final CountDownLatch countDownLatch = new CountDownLatch(1);
ZooKeeper zooKeeper = new ZooKeeper("192.168.25.129:2181,192.168.25.130:2181,192.168.25.131:2181", 4000, new Watcher() {
@Override
public void process(WatchedEvent event) {
// TODO Auto-generated method stub
if(Event.KeeperState.SyncConnected == event.getState()){
//如果接收到服务端响应事件，连接成功
countDownLatch.countDown();
}
}
});
countDownLatch.await();
System.out.println(zooKeeper.getState());//CONNECTING
//Thread.sleep(1000);
//System.out.println(zooKeeper.getState());//CONNECTED
zooKeeper.close();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
（2）节点数据的增删改查
public static void main(String[] args) {
//NOT_CONNECTED-->CONNECTING-->CONNECTED-->CLOSE 连接的状态
try {
final CountDownLatch countDownLatch = new CountDownLatch(1);
ZooKeeper zooKeeper = new ZooKeeper("192.168.25.129:2181,192.168.25.130:2181,192.168.25.131:2181", 4000, new Watcher() {
@Override
public void process(WatchedEvent event) {
// TODO Auto-generated method stub
if(Event.KeeperState.SyncConnected == event.getState()){
//如果接收到服务端响应事件，连接成功
countDownLatch.countDown();
}
}
});
countDownLatch.await();
System.out.println(zooKeeper.getState());//CONNECTING
//Thread.sleep(1000);
//System.out.println(zooKeeper.getState());//CONNECTED
//添加节点
zooKeeper.create("/lf00","123".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
Thread.sleep(1000);
Stat stat = new Stat();
//得到当前节点的值
byte[] data = zooKeeper.getData("/lf00", null, stat);
System.out.println(data.toString()+"---"+stat.getVersion());
//修改当前节点的值
zooKeeper.setData("/lf00", "124".getBytes(), stat.getVersion());
//得到当前节点的值
byte[] data2 = zooKeeper.getData("/lf00", null, stat);
System.out.println(data2.toString()+"---"+stat.getVersion());
//删除节点
zooKeeper.delete("/lf00", stat.getVersion());
zooKeeper.close();
System.in.read();//阻塞进程
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
（3）事件特性
Watcher特性：当数据发生变化的时候，zookeeper会产生一个watcher事件，并且会发送到客户端。但是客户端是会收到一次通知。如果后续这个节点再次发生变化，那么之前设置watcher的客户端不会再次收到通知（watcher是一次性的操作），可以通过循环监听达到永久监听的效果。
如何注册事件机制：getDate、Exists、getChildren
public static void main(String[] args) {
try {
final CountDownLatch countDownLatch = new CountDownLatch(1);
ZooKeeper zooKeeper = new ZooKeeper("192.168.25.129:2181,192.168.25.130:2181,192.168.25.131:2181", 4000, new Watcher() {
@Override
public void process(WatchedEvent event) {
System.out.println("全局默认事件："+event.getType()+"->"+event.getPath());
// TODO Auto-generated method stub
if(Event.KeeperState.SyncConnected == event.getState()){
//如果接收到服务端响应事件，连接成功
countDownLatch.countDown();
}
}
});
countDownLatch.await();
System.out.println(zooKeeper.getState());//CONNECTING
zooKeeper.create("/lf", "111".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
//通过Exists、getData、getChildren绑定watcher事件
//Stat stat = zooKeeper.exists("/lf", true);
Stat stat = zooKeeper.exists("/lf", new Watcher() {
@Override
public void process(WatchedEvent event) {
// TODO Auto-generated method stub
System.out.println(event.getType()+"->"+event.getPath());
}
});
//通过修改事务操作来触发监听
stat = zooKeeper.setData("/lf", "222".getBytes(), stat.getVersion());
Thread.sleep(1000);
zooKeeper.delete("/lf", stat.getVersion());
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
}
运行结果：
全局默认事件：None
CONNECTED
NodeDataChanged->/lf 只会有一次事务监听，删除节点的事务监听没通知
循环监听：
public static void main(String[] args) {
try {
final CountDownLatch countDownLatch = new CountDownLatch(1);
ZooKeeper zooKeeper = new ZooKeeper("192.168.25.129:2181,192.168.25.130:2181,192.168.25.131:2181", 4000, new Watcher() {
@Override
public void process(WatchedEvent event) {
System.out.println("全局默认事件："+event.getType()+"->"+event.getPath());
// TODO Auto-generated method stub
if(Event.KeeperState.SyncConnected == event.getState()){
//如果接收到服务端响应事件，连接成功
countDownLatch.countDown();
}
}
});
countDownLatch.await();
System.out.println(zooKeeper.getState());//CONNECTING
zooKeeper.create("/lf", "111".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
//通过Exists、getData、getChildren绑定watcher事件
//Stat stat = zooKeeper.exists("/lf", true);
Stat stat = zooKeeper.exists("/lf", new Watcher() {
@Override
public void process(WatchedEvent event) {
// TODO Auto-generated method stub
System.out.println(event.getType()+"->"+event.getPath());
try {
//zooKeeper.exists("/lf", true);
zooKeeper.exists("/lf", new Watcher() {
@Override
public void process(WatchedEvent event) {
// TODO Auto-generated method stub
System.out.println(event.getType()+"->"+event.getPath());
}
});
} catch (Exception e) {
e.printStackTrace();
}
}
});
//通过修改事务操作来触发监听
stat = zooKeeper.setData("/lf", "222".getBytes(), stat.getVersion());
//再通过修改事务操作来触发监听，发现还是两次，还得添加在上面嵌套//zooKeeper.exists("/lf", true);监听
//stat = zooKeeper.setData("/lf", "322".getBytes(), stat.getVersion());
Thread.sleep(1000);
zooKeeper.delete("/lf", stat.getVersion());
System.in.read();
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
}
结果;
全局默认事件：None->null
CONNECTED
NodeDataChanged->/lf
NodeDeleted->/lf
放开标记绿色部分，运行结果：
全局默认事件：None->null
CONNECTED
NodeDataChanged->/lf
NodeDataChanged->/lf 再通过修改事务操作来触发监听，发现还是两次，还得添加在上面嵌套//zooKeeper.exists("/lf", true);监听
Watcher事件类型：
None (-1), // 客户端连接状态发生变化的时候 会受到none事件
NodeCreated (1), // 节点创建事件
NodeDeleted (2), // 节点删除事件
NodeDataChanged (3), // 节点数据变化
NodeChildrenChanged (4); // 子节点被创建 删除触发该事件
什么样的操作会产生什么样的事件的？
Watcher事件机制原理：
client 端连接后会注册一个事件，然后客户端会保存这个事件，通过zkWatcherManager 保存客户端的事件注册，通知服务端 Watcher 为 true，然后服务端会通过WahcerManager 会绑定path对应的事件。如下图：
Curator的使用
public static void main(String[] args) throws Exception {
CuratorFramework curatorFramework = CuratorFrameworkFactory.builder()
.connectString("192.168.25.129:2181," + "192.168.25.130:2181," + "192.168.25.131:2181")
.sessionTimeoutMs(4000).retryPolicy(new ExponentialBackoffRetry(1000, 3)).namespace("curator").build();
curatorFramework.start();
//创建节点
curatorFramework.create().creatingParentsIfNeeded().withMode(CreateMode.PERSISTENT).forPath("/lf001/node002",
"111".getBytes());
Stat stat = new Stat();
byte[] path = curatorFramework.getData().storingStatIn(stat).forPath("/lf001/node002");
String value = new String(path);
System.out.println("创建节点"+value);
stat = curatorFramework.setData().withVersion(stat.getVersion()).forPath("/lf001/node002", "222".getBytes());
byte[] path2 = curatorFramework.getData().storingStatIn(stat).forPath("/lf001/node002");
String value2 = new String(path2);
System.out.println("创建节点"+value2);
curatorFramework.delete().deletingChildrenIfNeeded().forPath("/curator");
System.out.println("执行结束！");
curatorFramework.close();
}
Curator的Watcher机制
package com.lf.zookeeper;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.cache.NodeCache;
import org.apache.curator.framework.recipes.cache.NodeCacheListener;
import org.apache.curator.framework.recipes.cache.PathChildrenCache;
import org.apache.curator.framework.recipes.cache.PathChildrenCacheEvent;
import org.apache.curator.framework.recipes.cache.PathChildrenCacheListener;
import org.apache.curator.framework.recipes.cache.TreeCache;
import org.apache.curator.framework.recipes.cache.TreeCacheEvent;
import org.apache.curator.framework.recipes.cache.TreeCacheListener;
import org.apache.curator.retry.ExponentialBackoffRetry;
public class CuratorWatcherDemo {
public static void main(String[] args) throws Exception {
CuratorFramework curatorFramework = CuratorFrameworkFactory.builder()
.connectString("192.168.25.129:2181," + "192.168.25.130:2181," + "192.168.25.131:2181")
.sessionTimeoutMs(4000).retryPolicy(new ExponentialBackoffRetry(1000, 3)).namespace("curator").build();
curatorFramework.start();
//当前节点的创建和删除事件监听 ---永久的
// addListenerWithNodeCache(curatorFramework,"/lf");
//子节点的增加、修改、删除的事件监听
addListenerWithPathChildCache(curatorFramework,"/lf");
//综合节点监听事件
// addListenerWithTreeCache(curatorFramework,"/lf");
System.in.read();
}
public static void addListenerWithTreeCache(CuratorFramework curatorFramework,String path) throws Exception {
TreeCache treeCache=new TreeCache(curatorFramework,path);
TreeCacheListener treeCacheListener=new TreeCacheListener() {
@Override
public void childEvent(CuratorFramework client, TreeCacheEvent event) throws Exception {
System.out.println(event.getType()+"->"+event.getData().getPath());
}
};
treeCache.getListenable().addListener(treeCacheListener);
treeCache.start();
}
/**
* PathChildrenCache 监听一个节点下子节点的创建、删除、更新
* NodeCache 监听一个节点的更新和创建事件
* TreeCache 综合PathChildrenCache和NodeCache的特性
*/
public static void addListenerWithPathChildCache(CuratorFramework curatorFramework,String path) throws Exception {
PathChildrenCache pathChildrenCache=new PathChildrenCache(curatorFramework,path,true);
PathChildrenCacheListener pathChildrenCacheListener=new PathChildrenCacheListener() {
@Override
public void childEvent(CuratorFramework client, PathChildrenCacheEvent event) throws Exception {
System.out.println("Receive Event2:"+event.getType());
}
};
pathChildrenCache.getListenable().addListener(pathChildrenCacheListener);
pathChildrenCache.start(PathChildrenCache.StartMode.NORMAL);
}
// 监听一个节点的更新，创建/lf节点事件
public static void addListenerWithNodeCache(CuratorFramework curatorFramework,String path) throws Exception {
final NodeCache nodeCache=new NodeCache(curatorFramework,path,false);
NodeCacheListener nodeCacheListener=new NodeCacheListener() {
@Override
public void nodeChanged() throws Exception {
System.out.println("Receive Event1:"+nodeCache.getCurrentData().getPath());
}
};
nodeCache.getListenable().addListener(nodeCacheListener);
}
}
