Zookeeper Java API操作流程
首先需要配置一台Zookeeper服务器
pom文件
<dependencies>
<!-- https://mvnrepository.com/artifact/org.apache.zookeeper/zookeeper -->
<dependency>
<groupId>org.apache.zookeeper</groupId>
<artifactId>zookeeper</artifactId>
<version>3.6.3</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.apache.curator/curator-framework -->
<!--Zookeeper客户端基础包-->
<dependency>
<groupId>org.apache.curator</groupId>
<artifactId>curator-framework</artifactId>
<version>4.0.1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.apache.curator/curator-recipes -->
<!--Zookeeper客户端曾强包-->
<dependency>
<groupId>org.apache.curator</groupId>
<artifactId>curator-recipes</artifactId>
<version>4.0.1</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
</dependencies>
实现节点的增删改查
/**
* 实现节点的增删改查
* 方式1：创建一个空永久节点(只能创建一个节点)
* 方式2：创建一个有内容永久的空节点(只能创建一层节点)
* 方式3：创建多层节点
* 是否需要创建父节点creatingParentsIfNeeded()
* 节点的创建模式 withMode(模式) 方法
* 参数CreateMode.PERSISTENT 创建持久性节点
* 参数CreateMode.PERSISTENT_SEQUENTIAL 创建带有序号的持久性节点
* 参数CreateMode.EPHEMERAL 创建临时性节点(客户端关闭,节点消失)
* 参数CreateMode.EPHEMERAL_SEQUENTIAL 创建带有序号的临时节点(客户端关闭,节点消失)
*/
public class zkDemo {
private CuratorFramework client = null;
/**
* 创建客户端
* 步骤：
* 1、创建连接失败重试策略对象
* 2、创建连接客户端
*/
@Before
public void createClient() {
//1.创建连接失败重试策略对象
//RetryPolIcy接口 失败重试策略的公共接口；ExponentialBackoffRetry实现类，是失败重试策略的接口实现类
//参数1：两次重试之间等待的初始化时间(单位毫秒)
//参数2：最大重试次数
RetryPolicy retryPolicy = new ExponentialBackoffRetry(3000, 3);
//2.创建客户端对象
//参数1：连接Zookeeper服务的IP地址和端口号
//参数2：会话超时时间(单位毫秒)
//参数3：连接超时时间(单位毫秒)
//参数4：失败重试策略对象
client = CuratorFrameworkFactory.newClient("节点的IP地址:2181", 1000, 1000, retryPolicy);
}
/**
* 创建节点(创建一个空节点)
* 1、开启客户端(会阻塞到会话连接成功为止)
* 2、创建节点
* 3、关闭客户端
*
* @throws Exception 异常行为
*/
@Test
public void createNode01() throws Exception {
//创建一个空节点
client.create().forPath("/app1");
}
/**
* 创建节点(创建一个有内容的空节点)
* 1、开启客户端(会阻塞到会话连接成功为止)
* 2、创建节点
* 3、关闭客户端
*
* @throws Exception 异常行为
*/
@Test
public void createNode02() throws Exception {
//创建一个有内容的空节点
client.create().forPath("/app2", "App2 Node".getBytes());
}
/**
* 创建节点(创建多层节点)
* 1、开启客户端(会阻塞到会话连接成功为止)
* 2、创建节点
* 3、关闭客户端
*
* @throws Exception 异常行为
*/
@Test
public void createNode03() throws Exception {
//创建多层节点
client.create().creatingParentsIfNeeded().forPath("/app4/data", "App4 Node".getBytes());
}
/**
* 创建节点(创建临时性节点)
* 1、开启客户端(会阻塞到会话连接成功为止)
* 2、创建节点
* 3、关闭客户端
*
* @throws Exception 异常行为
*/
@Test
public void createNode04() throws Exception {
//创建临时性节点
client.create().withMode(CreateMode.EPHEMERAL)
.forPath("/app5", "App5 Node".getBytes());
}
/**
* 创建节点(创建带序号的永久节点)
* 1、开启客户端(会阻塞到会话连接成功为止)
* 2、创建节点
* 3、关闭客户端
*
* @throws Exception 异常行为
*/
@Test
public void createNode05() throws Exception {
client.create().withMode(CreateMode.CONTAINER)
.forPath("/app6", "App6 Node".getBytes());
}
/**
* 修改节点数据
* 步骤：
* 1、启动客户端
* 2、修改节点
* 3、关闭客户端
*/
@Test
public void modifyNode() throws Exception {
//启动客户端
client.start();
//修改节点数据
client.setData().forPath("/app1", "app1 Node".getBytes());
//关闭客户端
client.close();
}
/**
* 获取节点数据
* 步骤：
* 1、启动客户端
* 2、获取节点数据
* 3、关闭客户端
*/
@Test
public void findNodeData() throws Exception {
//启动客户端
client.start();
//获取节点数据(返回字节数组)
byte[] bytes = client.getData().forPath("/app2");
System.out.println("App2节点数据=" + new String(bytes));
//关闭客户端
client.close();
}
/**
* 节点的删除(正常删除一个子节点)
* 步骤：
* 1、启动客户端
* 2、删除节点
* 3、关闭客户端
*/
@Test
public void deleteNode01() throws Exception {
//启动客户端
client.start();
//正常删除一个子节点
client.delete().forPath("/app1");
//关闭客户端
client.close();
}
/**
* 节点的删除(递归删除一个子节点)
* 步骤：
* 1、启动客户端
* 2、删除节点
* 3、关闭客户端
*/
@Test
public void deleteNode02() throws Exception {
//启动客户端
client.start();
//递归删除一个子节点
client.delete().deletingChildrenIfNeeded().forPath("/app4");
//关闭客户端
client.close();
}
/**
* 节点的删除(强制保证删除一个节点)
* 比如遇到一些网络异常的情况，此guaranteed的强制删除会很有效果
* 步骤：
* 1、启动客户端
* 2、删除节点
* 3、关闭客户端
*/
@Test
public void deleteNode03() throws Exception{
//启动客户端
client.start();
//保证强制删除一个节点
client.delete().guaranteed().forPath("/app5");
//关闭客户端
client.close();
}
}
Zookeeper的监听机制
/**
* Zookeeper的监听机制
*/
public class ZkWatch {
/**
* NodeCache是用来监听节点数据变化的，当监听的节点的数据发生变化时就会回调对应的函数
* 步骤：
* 1、创建重试策略
* 2、创建客户端使用重试策略
* 3、开启客户端
* 4、创建节点数据监听对象
* 5、开始缓存(true:可以直接获取监听节点。false:不可以获取监听的节点)
* 6、添加监听对象(如果节点数据有变化,会回调该方法)
*
* @throws Exception 失败异常
*/
@Test
public void nodeCacheTest() throws Exception {
//1.创建重试策略
RetryPolicy retryPolicy = new ExponentialBackoffRetry(3000, 3);
//2.创建客户端
CuratorFramework client = CuratorFrameworkFactory
.newClient("192.168.10.101:2181", 1000, 1000, retryPolicy);
//3.开启客户端
client.start();
System.out.println("连接Zookeeper服务成功");
//4.创建节点监听对象 NodeCache(参数1：哪个客户端,参数2：监听那个节点)
final NodeCache nodeCache = new NodeCache(client, "/hello");
//5.开始缓存(true:可以直接获取监听节点。false:不可以获取监听的节点)
nodeCache.start(true);
//6.添加监听对象(如果节点数据有变化,会回调该方法)
nodeCache.getListenable().addListener(new NodeCacheListener() {
public void nodeChanged() throws Exception {
//如果回调方法被调用，获取节点中最新的数据
ChildData data = nodeCache.getCurrentData();
//打印最新节点数据
System.out.println("节点数据: path ==> " + data.getPath() + " 数据内容: ==> " + new String(data.getData()));
}
});
//阻塞程序的执行，让程序一直执行
System.in.read();
}
/**
* PathChildrenCache是用来监听指定节点的子节点变化情况
* 步骤：
* 1、创建重试策略
* 2、创建客户端，使用重试策略
* 3、开启客户端
* 4、创建节点的数据监控对象
* 5、开始缓存(设置启动模式)
* 6、添加监听对象(如果节点有变化，会回调该方法)
*
* @throws Exception 失败异常
*/
@Test
public void nodePathChildrenCache() throws Exception {
//1.创建重试策略
RetryPolicy retryPolicy = new ExponentialBackoffRetry(3000, 3);
//2.创建客户端，使用重试策略
CuratorFramework client = CuratorFrameworkFactory
.newClient("192.168.10.101:2181", 1000, 1000, retryPolicy);
//3.开启客户端
client.start();
//4.创建节点的数据监控对象(参数1:连接对象,参数2:节点名称,参数3:[如果为false则无法读取到数据内容,如果为true则客户端在接收到节点列表改变的同时，也能够获取到节点数据内容])
final PathChildrenCache pathChildrenCache = new PathChildrenCache(client, "/hello", true);
//5.开始缓存(设置启动模式)
//三种启动模式:
// 1、NORMAL:普通启动模式，在启动时缓存子节点数据
// 2、POST_INITIALIZED_EVENT:在启动时缓存节点数据，提示初始化
// 3、BUILD_INITIAL_CACHE:在启动时什么都不会输出
pathChildrenCache.start(PathChildrenCache.StartMode.POST_INITIALIZED_EVENT);
//6.添加监听对象(如果节点有变化，会回调该方法)
pathChildrenCache.getListenable().addListener(new PathChildrenCacheListener() {
/**
* 一共有7种事件类型
* 1.PathChildrenEvent.CHILD_ADDED 子节点添加,
* 2.PathChildrenEvent.CHILD_UPDATED 子节点修改,
* 3.PathChildrenEvent.CHILD_REMOVED 子节点删除,
* 4.PathChildrenEvent.CONNECTION_SUSPENDED 连接超时,
* 5.PathChildrenEvent.CONNECTION_RECONNECTED, 重新连接
* 6.PathChildrenEvent.CONNECTION_LOST, 连接超时一段时间
* 7.PathChildrenEvent.INITIALIZED 初始化完成;
* @param curatorFramework 客户端对象
* @param Event 当前监听的节点事件对象
* @throws Exception 异常
*/
public void childEvent(CuratorFramework curatorFramework, PathChildrenCacheEvent Event) throws Exception {
//回调方法
//子节点添加
if (Event.getType() == PathChildrenCacheEvent.Type.CHILD_ADDED) {
System.out.println("添加了一个子节点; 节点路径==>" + Event.getData().getPath() + " 节点数据==>" + new String(Event.getData().getData()));
} else if (Event.getType() == PathChildrenCacheEvent.Type.CHILD_UPDATED) {
System.out.println("修改了一个子节点; 节点路径==>" + Event.getData().getPath() + " 节点数据==>" + new String(Event.getData().getData()));
} else if (Event.getType() == PathChildrenCacheEvent.Type.CHILD_REMOVED) {
System.out.println("删除了一个子节点; 节点路径==>" + Event.getData().getPath() + " 节点数据==>" + new String(Event.getData().getData()));
} else if (Event.getType() == PathChildrenCacheEvent.Type.CONNECTION_SUSPENDED) {
System.out.println("连接超时");
} else if (Event.getType() == PathChildrenCacheEvent.Type.CONNECTION_RECONNECTED) {
System.out.println("重新连接");
} else if (Event.getType() == PathChildrenCacheEvent.Type.CONNECTION_LOST) {
System.out.println("连接超时一段时间");
} else if (Event.getType() == PathChildrenCacheEvent.Type.INITIALIZED) {
System.out.println("初始化完成");
}
}
});
//阻塞程序的执行，让程序一直执行
System.in.read();
}
/***
* TreeCache既能够监听自节点的变化，也能够监听子节点的变化【重要，需牢记】
* 步骤：
* 1、创建连接重试策略
* 2、创建客户端，使用重试策略
* 3、开启客户端
* 4、创建节点的数据监听对象
* 5、开始缓存
* 6、添加监听对象(如果节点数据有变化，会回调该方法)
* @throws Exception 异常
*/
@Test
public void nodeTreeCache() throws Exception {
//1.创建重试策略
RetryPolicy retryPolicy = new ExponentialBackoffRetry(3000, 3);
//2.创建客户端，使用重试策略
CuratorFramework client = CuratorFrameworkFactory
.newClient("192.168.10.101:2181", 1000, 1000, retryPolicy);
//3.开启客户端
client.start();
//4.创建节点的数据监听对象
//参数1:连接对象
//参数2:节点名称
TreeCache treeCache = new TreeCache(client, "/hello");
//5.开始缓存
treeCache.start();
//6.添加监听对象(如果节点数据有变化，会回调该方法)
//TreeCacheEvent.Type.NODE_ADDED, 子节点添加
//TreeCacheEvent.Type.NODE_UPDATED, 子节点更新
//TreeCacheEvent.Type.NODE_REMOVED, 子节点删除
//TreeCacheEvent.Type.CONNECTION_SUSPENDED, 待定
//TreeCacheEvent.Type.CONNECTION_RECONNECTED, 重新连接
//TreeCacheEvent.Type.CONNECTION_LOST, 连接超时一段时间
//TreeCacheEvent.Type.INITIALIZED, 初始化完成
treeCache.getListenable().addListener(new TreeCacheListener() {
public void childEvent(CuratorFramework client, TreeCacheEvent Event) throws Exception {
if (Event.getType() == TreeCacheEvent.Type.NODE_ADDED) {
System.out.println("添加了一个子节点; 节点路径==>" + Event.getData().getPath() + " 节点数据==>" + new String(Event.getData().getData()));
} else if (Event.getType() == TreeCacheEvent.Type.NODE_UPDATED) {
System.out.println("更新了一个子节点; 节点路径==>" + Event.getData().getPath() + " 节点数据==>" + new String(Event.getData().getData()));
} else if (Event.getType() == TreeCacheEvent.Type.NODE_REMOVED) {
System.out.println("删除了一个子节点; 节点路径==>" + Event.getData().getPath() + " 节点数据==>" + new String(Event.getData().getData()));
} else if (Event.getType() == TreeCacheEvent.Type.CONNECTION_SUSPENDED) {
System.out.println("暂停了一个子节点; 节点路径==>" + Event.getData().getPath() + " 节点数据==>" + new String(Event.getData().getData()));
} else if (Event.getType() == TreeCacheEvent.Type.CONNECTION_RECONNECTED) {
System.out.println("重新连接了");
} else if (Event.getType() == TreeCacheEvent.Type.CONNECTION_LOST) {
System.out.println("连接超时了一段时间");
} else if (Event.getType() == TreeCacheEvent.Type.INITIALIZED) {
System.out.println("初始化完成");
}
}
});
//阻塞程序的执行，让程序一直执行
System.in.read();
}
}
