Zookeeper 应用：Java 基本操作

   Zookeeper：分布式协调服务，数据存储在内存中（每个节点不超过 1M），采用分层存储结构，可以通过不同的路径访问到不同的节点

zkCli 命令操作

• 创建（create 路径 数据）
  • 持久节点：create /test abc
  • 持久子节点：create /test/aaa
  • 持久序数节点：create -s /test
  • 临时节点：create -e /test
  • 临时序数节点：create -e -s /test
• 查询
  • 节点：ls /test
  • 数据：get /test
  • 详细信息：get -s /test
• 删除
  • delete/deleteall /test
  • 乐观锁删除：delete -v 0 /test
    • 删除对应版本
• 权限
  • 注册当前会话账号和密码：addauth digest xxx:123
  • 创建节点并设置权限：create /test abc auth:xxx:123:cdwra

Java 操作

• 导入依赖

<dependencies>
    <dependency>
        <groupId>org.apache.curator</groupId>
        <artifactId>curator-recipes</artifactId>
        <version>2.13.0</version>
    </dependency>
</dependencies>

• 创建 Client

CuratorFramework client = CuratorFrameworkFactory.builder()
                .connectString("localhost:2181")
                .connectionTimeoutMs(60000)
                .sessionTimeoutMs(60000)
                .retryPolicy(new ExponentialBackoffRetry(1000, 3))
                .namespace("curator_test")
                .build();
client.start();

• Create

// 创建普通节点
client.create().forPath("/comm_msg_nd", "data".getBytes());
client.create().forPath("/comm_no_msg_nd");
// 创建临时节点
client.create().withMode(CreateMode.EPHEMERAL).forPath("/ephemeral_nd", "ff".getBytes());
// 自动创建父节点
client.create().creatingParentsIfNeeded().withMode(CreateMode.EPHEMERAL).forPath("/test/ephe_nd", "data".getBytes());
System.in.read();

• Delete

// 删除单独一个节点
client.delete().forPath("/comm_no_msg_nd");
// 删除多级节点
client.create().creatingParentsIfNeeded().forPath("/a/b/c");
client.delete().deletingChildrenIfNeeded().forPath("/a");
// 删除指定版本的节点
client.delete().withVersion(0).forPath("/comm_msg_nd");
// 保证删除，失败后继续执行
client.delete().guaranteed().forPath("/test/son");

• 查询

Stat stat = new Stat();
byte[] ctx = client.getData().storingStatIn(stat).forPath("/test");
// 获取节点内容为
log.info("Node data: {}", new String(ctx));
// 该节点 stat
log.info("Node stat: {}", stat);

• 更新

Stat stat = client.setData().forPath("/test", "test".getBytes());
log.info("Stat: {}", stat);

• 异步操作

ExecutorService es = Executors.newFixedThreadPool(2);
// 带线程的异步接口
client.create().inBackground(new BackgroundCallback() {
    @Override
    public void processResult(CuratorFramework curatorFramework, CuratorEvent curatorEvent) throws Exception {
        log.info("Create thread currentThread name: {}", Thread.currentThread().getName());
        log.info("Create event: {}", curatorEvent);
    }
}, es).forPath("/abc");
// 不带线程池的异步接口
client.delete().inBackground(new BackgroundCallback() {
    @Override
    public void processResult(CuratorFramework curatorFramework, CuratorEvent curatorEvent) throws Exception {
        log.info("Delete thread currentThread name: {}", Thread.currentThread().getName());
        log.info("Delete event: {}", curatorEvent);
    }
}).forPath("/abc");
Thread.sleep(Integer.MAX_VALUE);

• 节点监听 1

// 创建节点数据监听对象
final NodeCache nodeCache = new NodeCache(client, "/test");
/**
 * 开始缓存
 * start参数为true：可以直接获取监听的节点，System.out.println(nodeCache.getCurrentData());为ChildData{path='/aa', stat=607,765,1580205779732,1580973376268,2,1,0,0,5,1,608
 , data=[97, 98, 99, 100, 101]}
 * 参数为false：不可以获取监听的节点，System.out.println(nodeCache.getCurrentData());为null
 */
nodeCache.start(true);
log.info("NodeCache current data: {}", nodeCache.getCurrentData());
log.info("NodeCache now data: {}", new String(nodeCache.getCurrentData().getData()));
// 添加监听对象
nodeCache.getListenable().addListener(new NodeCacheListener() {
    @Override
    public void nodeChanged() throws Exception {
        log.info("Watcher current data: {}", nodeCache.getCurrentData());
        log.info("Watcher new data: {}", new String(nodeCache.getCurrentData().getData()));
    }
});
System.in.read();

• 节点监听 2

//监听指定节点的子节点变化情况包括 新增子节点 子节点数据变更 和子节点删除
//true表示用于配置是否把节点内容缓存起来，如果配置为true，客户端在接收到节点列表变更的同时，也能够获取到节点的数据内容（即：event.getData().getData()）ͺ如果为false 则无法取到数据内容（即：event.getData().getData()）
PathChildrenCache childrenCache = new PathChildrenCache(client,"/test/rw-lock",true);
/**
 * NORMAL:  普通启动方式, 在启动时缓存子节点数据
 * POST_INITIALIZED_EVENT：在启动时缓存子节点数据，提示初始化
 * BUILD_INITIAL_CACHE: 在启动时什么都不会输出
 *  在官方解释中说是因为这种模式会在start执行执行之前先执行rebuild的方法，而rebuild的方法不会发出任何事件通知。
 */
childrenCache.start(PathChildrenCache.StartMode.POST_INITIALIZED_EVENT);
log.info("Children cache current data: {}", childrenCache.getCurrentData());
childrenCache.getListenable().addListener(new PathChildrenCacheListener() {
    @Override
    public void childEvent(CuratorFramework client, PathChildrenCacheEvent event) throws Exception {
        if (event.getType() == PathChildrenCacheEvent.Type.CHILD_UPDATED) {
            log.info("Children update");
            log.info("Children node: {}", event.getData().getPath());
            log.info("Children data: {}", new String(event.getData().getData()));
        } else if (event.getType() == PathChildrenCacheEvent.Type.INITIALIZED) {
            log.info("Init option");
        } else if (event.getType() == PathChildrenCacheEvent.Type.CHILD_REMOVED) {
            log.info("Children delete");
            log.info("Children node: {}", event.getData().getPath());
            log.info("Children data: {}", new String(event.getData().getData()));
        } else if (event.getType() == PathChildrenCacheEvent.Type.CHILD_ADDED) {
            log.info("Children add");
            log.info("Children node: {}", event.getData().getPath());
            log.info("Children data: {}", new String(event.getData().getData()));
        } else if (event.getType() == PathChildrenCacheEvent.Type.CONNECTION_SUSPENDED) {
            log.info("Children connection suspended");
        } else if (event.getType() == PathChildrenCacheEvent.Type.CONNECTION_RECONNECTED) {
            log.info("Children reconnected");
        } else if (event.getType() == PathChildrenCacheEvent.Type.CONNECTION_LOST) {
            log.info("Children connection lost");
        }
    }
});
System.in.read();

• 节点监听 3

// 监听和缓存根节点变化和子节点变化
TreeCache treeCache = new TreeCache(client, "/");
treeCache.start();
log.info("TreeCache current data: {}", treeCache.getCurrentData("/"));
treeCache.getListenable().addListener(new TreeCacheListener() {
    @Override
    public void childEvent(CuratorFramework client, TreeCacheEvent event) throws Exception {
        if(event.getType() == TreeCacheEvent.Type.NODE_ADDED){
            System.out.println(event.getData().getPath() + "节点添加");
        }else if (event.getType() == TreeCacheEvent.Type.NODE_REMOVED){
            System.out.println(event.getData().getPath() + "节点移除");
        }else if(event.getType() == TreeCacheEvent.Type.NODE_UPDATED){
            System.out.println(event.getData().getPath() + "节点修改");
        }else if(event.getType() == TreeCacheEvent.Type.INITIALIZED){
            System.out.println("初始化完成");
        }else if(event.getType() ==TreeCacheEvent.Type.CONNECTION_SUSPENDED){
            System.out.println("连接过时");
        }else if(event.getType() ==TreeCacheEvent.Type.CONNECTION_RECONNECTED){
            System.out.println("重新连接");
        }else if(event.getType() ==TreeCacheEvent.Type.CONNECTION_LOST){
            System.out.println("连接过时一段时间");
        }
    }
});
System.in.read();

• 节点监听 4

LeaderSelector selector = new LeaderSelector(client, "/leader", new LeaderSelectorListener() {
    @Override
    public void takeLeadership(CuratorFramework curatorFramework) throws Exception {
        log.info("Do leader work");
        Thread.sleep(5000);
        log.info("End work");
    }
    @Override
    public void stateChanged(CuratorFramework curatorFramework, ConnectionState connectionState) {
        log.info("StateChanged: {}", connectionState);
    }
});
selector.autoRequeue();
selector.start();
Thread.sleep(Integer.MAX_VALUE);

• 分布式锁

// 分布式锁
String lockPath = "/test/lock";
InterProcessMutex lock = new InterProcessMutex(client, lockPath);
lock.acquire();
log.info("Do anything");
Thread.sleep(10000);
lock.release();

• 分布式计算器

// 分布式计数器
DistributedAtomicInteger atomicInteger = new DistributedAtomicInteger(client, "/test/distributed_atomic_counter", new ExponentialBackoffRetry(1000, 3));
AtomicValue<Integer> av = atomicInteger.add(10);
log.info("AtomicValue succeeded: {}", av.succeeded());
log.info("AtomicValue pre value: {}", av.preValue());
log.info("AtomicValue post value: {}", av.postValue());

• 读写锁

// 读写锁
InterProcessReadWriteLock interProcessReadWriteLock = new InterProcessReadWriteLock(client, "/test/rw-lock");
// 获取读锁对象
InterProcessMutex interProcessMutex = interProcessReadWriteLock.readLock();
log.info("Wait get read lock object");
// 获取锁
interProcessMutex.acquire();
for (int i = 0; i < 10; i++) {
    Thread.sleep(3000);
    log.info("Thread sleep: {}", i);
}
// 释放锁
interProcessMutex.release();
log.info("Release lock");

// 读写锁
InterProcessReadWriteLock interProcessReadWriteLock = new InterProcessReadWriteLock(client, "/test/rw-lock");
// 获取读锁对象
InterProcessMutex interProcessMutex = interProcessReadWriteLock.readLock();
log.info("Wait get read lock object");
// 获取锁
interProcessMutex.acquire();
for (int i = 0; i < 10; i++) {
    Thread.sleep(3000);
    log.info("(Tmp)Thread sleep: {}", i);
}
// 释放锁
interProcessMutex.release();
log.info("Release lock");

• 获取写锁

InterProcessReadWriteLock interProcessReadWriteLock = new InterProcessReadWriteLock(client, "/test/rw-lock");
InterProcessMutex interProcessMutex = interProcessReadWriteLock.writeLock();
log.info("Wait get write lock object");
interProcessMutex.acquire();
for (int i = 0; i < 10; i++) {
    Thread.sleep(3000);
    log.info("Thread sleep: {}", i);
}
interProcessMutex.release();
log.info("Release lock");