zookeeper实践之使用JavaAPI 一

最新推荐文章于 2022-06-16 17:12:06 发布

耐得住寂寞、守得住繁华

最新推荐文章于 2022-06-16 17:12:06 发布

阅读量130

点赞数

分类专栏： zookeeper

本文链接：https://blog.csdn.net/weixin_42077253/article/details/109221998

版权

zookeeper 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

zookeeper使用javaAPI

一、创建一个mawen项目
- - - 1、添加依赖
二、连接zookeeper
三、新增节点
四、更新节点
五、删除节点
六、查看节点
七、查看子节点
八、检查节点是否存在
九、注册watcher的方法
- 客户端与服务器的连接状态
- 检查节点是否存在

一、创建一个mawen项目

1、添加依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.csii.wyw</groupId>
    <artifactId>zookeeperJavaAPI</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
        </dependency>

        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.5.8</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.25</version>
        </dependency>
    </dependencies>

</project>

二、连接zookeeper

1、创建ZookeeperConnection类

import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;

import java.util.concurrent.CountDownLatch;

public class ZookeeperConnection {
    public static void main(String[] args) {
        try {

            //计数器对象
            final CountDownLatch countDownLatch = new CountDownLatch(1);
            /**
             * arg1:服务器的ip和端口
             * arg2：客户端与服务器之间的会话超时时间 以毫秒为单位
             * arg3：监视器对象
             */
            ZooKeeper zooKeeper = new ZooKeeper("192.168.191.128:2181", 5000, new Watcher() {
                public void process(WatchedEvent watchedEvent) {
                    if (watchedEvent.getState() == Event.KeeperState.SyncConnected){
                        System.out.println("连接成功");
                        countDownLatch.countDown();
                    }
                }
            });
            //主线程阻塞等待连接对象的创建成功
            countDownLatch.await();
            //会话编号
            System.out.println(zooKeeper.getSessionId());
            zooKeeper.close();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

2、运行出现了异常：

异常信息

3、解决办法

百度了一下，原因是Linux防火墙没关闭
关闭防火墙

查看已开启的端口

firewall-cmd --list-ports

查看防火墙状态

firewall-cmd --state

开启状态：running 
关闭状态：not running 

2.关闭防火墙：
systemctl stop firewalld.service 

3.开机不启动防火墙：
systemctl disable firewalld.service

开启防火墙

systemctl start firewalld

开启端口

firewall-cmd --zone=public --add-port=6379/tcp --permanent

重启防火墙

firewall-cmd --reload

关闭防火墙后就能连接上了

运行成功示例图

三、新增节点

1、同步方式
create(String path,byte[] data,List acl,CreateMode createMode)
2、异步方式
create(String path,byte[] data,List acl,CreateMode createMode,AsyncCallback.StringCallback callBack,Object ctx)

path -znode路径。例如， /create/node1
data -要存储在指定znode路径中的数据
acl -要创建的节点的访问控制列表。zookeeper API提供了一个静态接口ZooDefs.Ids来获取一些基本的acl列表。例如，ZooDefs.Ids.OPEN_ACL_UNSAFE返回打开znode的acl列表。
createMode-节点的类型，这是一个枚举。
callBack-异步回调接口
ctx-传递上下文参数

案例：

package com.csii.javaapi;

import org.apache.zookeeper.*;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.util.concurrent.CountDownLatch;

public class ZKCreate {
    String IP = "192.168.191.128:2181";
    ZooKeeper zooKeeper;

    @Before
    public void before() throws Exception {
        System.out.println("before");
        //计数器对象
        final CountDownLatch countDownLatch = new CountDownLatch(1);
        /**
         * arg1:服务器的ip和端口
         * arg2：客户端与服务器之间的会话超时时间 以毫秒为单位
         * arg3：监视器对象
         */
        zooKeeper = new ZooKeeper(IP, 5000, new Watcher() {
            @Override
            public void process(WatchedEvent watchedEvent) {
                if (watchedEvent.getState() == Event.KeeperState.SyncConnected) {
                    System.out.println("连接成功");
                    countDownLatch.countDown();
                }
            }
        });
        //主线程阻塞等待连接对象的创建成功
        countDownLatch.await();
    }
    
    @After
    public void after() throws Exception {
    zooKeeper.close();
    }
    
    @Test
    public void create1() throws Exception {

        /**
         * arg1:节点的路径
         * arg2:节点的数据
         * arg3:权限列表 world:anyone:cdrwa
         * arg4:节点类型 持久化节点
         */
        zooKeeper.create("/create/node1","node1".getBytes(),ZooDefs.Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT);

    }

@Test
    public void create2() throws Exception {
        // READ_ACL_UNSAFE world:anyone:r
        zooKeeper.create("/create/node2", "node2".getBytes(), ZooDefs.Ids.READ_ACL_UNSAFE, CreateMode.PERSISTENT);

    }

    @Test
    public void create3() throws Exception {

        // world授权模式
        // 权限列表
        List<ACL> acls = new ArrayList<>();
        //授权模式和授权对象
        Id id = new Id("world", "anyone");
        //权限设置
        acls.add(new ACL(ZooDefs.Perms.READ, id));
        acls.add(new ACL(ZooDefs.Perms.WRITE, id));
        zooKeeper.create("/create/node3", "node3".getBytes(), acls, CreateMode.PERSISTENT);

    }

    @Test
    public void create4() throws Exception {

        // ip授权模式
        // 权限列表
        List<ACL> acls = new ArrayList<>();
        //授权模式和授权对象
        Id id = new Id("ip", "192.168.191.128");
        //权限设置
        acls.add(new ACL(ZooDefs.Perms.ALL, id));
        zooKeeper.create("/create/node4", "node4".getBytes(), acls, CreateMode.PERSISTENT);

    }

    @Test
    public void create5() throws Exception {

        // auth授权模式
        // 添加授权用户
        zooKeeper.addAuthInfo("digest","itcast:123456".getBytes());
        //权限设置
        zooKeeper.create("/create/node5", "node5".getBytes(), ZooDefs.Ids.CREATOR_ALL_ACL, CreateMode.PERSISTENT);

    }

    /**
     * [zk: localhost:2181(CONNECTED) 8] get /create/node5
     * org.apache.zookeeper.KeeperException$NoAuthException: KeeperErrorCode = NoAuth for /create/node5
     * [zk: localhost:2181(CONNECTED) 9] addauth digest itcast:123456
     * [zk: localhost:2181(CONNECTED) 10] get /create/node5
     * node5
     * [zk: localhost:2181(CONNECTED) 11] getAcl /create/node5
     * 'digest,'itcast:673OfZhUE8JEFMcu0l64qI8e5ek=
     * : cdrwa
     * [zk: localhost:2181(CONNECTED) 12]
     */

    @Test
    public void create6() throws Exception {

        // auth授权模式
        // 添加授权用户
        zooKeeper.addAuthInfo("digest","itcast:123456".getBytes());
        //权限列表
        List<ACL> acls = new ArrayList<>();
        //授权模式和授权对象
        Id id = new Id("auth","itcast");
        //权限设置
        acls.add(new ACL(ZooDefs.Perms.READ,id));
        zooKeeper.create("/create/node6", "node6".getBytes(),acls, CreateMode.PERSISTENT);

    }

    @Test
    public void create7() throws Exception {

        // digest授权模式
        //权限列表
        List<ACL> acls = new ArrayList<>();
        //授权模式和授权对象
        Id id = new Id("digest","itcast:673OfZhUE8JEFMcu0l64qI8e5ek=");
        //权限设置
        acls.add(new ACL(ZooDefs.Perms.ALL,id));
        zooKeeper.create("/create/node7", "node7".getBytes(),acls, CreateMode.PERSISTENT);

    }

    @Test
    public void create8() throws Exception {

        // 持久化顺序节点
        // OPEN_ACL_UNSAFE world:anyone:cdrwa
        String result = zooKeeper.create("/create/node8", "node8".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT_SEQUENTIAL);
        System.out.println(result);

    }
    
    @Test
    public void create9() throws Exception {
/**
 * EPHEMERAL 临时节点
 * 换成EPHEMERAL_SEQUENTIAL 则是 临时顺序节点
 */
        // 临时节点
        // OPEN_ACL_UNSAFE world:anyone:cdrwa
        String result = zooKeeper.create("/create/node9", "node9".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
        System.out.println(result);

    }
 @Test
    public void create10() throws Exception {
/**
 *  异步方式创建节点
 */
        zooKeeper.create("/create/node10", "node10".getBytes(),
                ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT, new AsyncCallback.StringCallback() {
                    @Override
                    public void processResult(int rc, String path, Object ctx, String name) {
                        // 0代表创建成功
                        System.out.println(rc);
                        //节点的路径
                        System.out.println(path);
                        //节点的名称
                        System.out.println(name);
                        //上下文参数
                        System.out.println(ctx);
                    }
                }, "I am context");
        Thread.sleep(10000);
        System.out.println("结束");
    }

}

四、更新节点

同步方式
setData(String path,byte[] data,int version)
异步方式
setData(String path,byte[] data,int version,AsyncCallback.StatCallack callBack,Object ctx)

path -znode路径
data-要存储在指定znode路径中的数据
version -znode的当前版本。每当数据更新时， Zookeeper会更新znode的版本号
callBack-异步回调接口
ctx-传递上下文参数

package com.csii.javaapi;

import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.util.concurrent.CountDownLatch;

public class ZKSet {
    String IP = "192.168.191.128:2181";
    ZooKeeper zooKeeper;

    @Before
    public void before() throws Exception {
        System.out.println("before");
        //计数器对象
        final CountDownLatch countDownLatch = new CountDownLatch(1);
        /**
         * arg1:服务器的ip和端口
         * arg2：客户端与服务器之间的会话超时时间 以毫秒为单位
         * arg3：监视器对象
         */
        zooKeeper = new ZooKeeper(IP, 5000, new Watcher() {
            @Override
            public void process(WatchedEvent watchedEvent) {
                if (watchedEvent.getState() == Event.KeeperState.SyncConnected) {
                    System.out.println("连接成功");
                    countDownLatch.countDown();
                }
            }
        });
        //主线程阻塞等待连接对象的创建成功
        countDownLatch.await();
    }

    @After
    public void after() throws Exception {
        zooKeeper.close();
    }


    @Test
    public void set1() throws Exception {
        //arg1:节点的路径
        //arg2：修改的数据
        //arg3：数据版本号 -1代表版本号不参与更新
        //zooKeeper.setData("/set/node1","node11".getBytes(),-1);

        //使用Stat可以获取节点的详细信息
        Stat stat = zooKeeper.setData("/set/node1", "node12".getBytes(), -1);
        System.out.println(stat.getVersion());
    }

    @Test
    public void set2() throws Exception {
        zooKeeper.setData("/set/node1", "node13".getBytes(), -1, new AsyncCallback.StatCallback() {
            @Override
            public void processResult(int rc, String path, Object ctx, Stat stat) {
                //0代表成功
                System.out.println(rc);
                //节点的路径
                System.out.println(path);
                //上下文描述的对象
                System.out.println(ctx);
                //属性描述对象
                System.out.println(stat.getVersion());
            }
        },"I am contex");

        Thread.sleep(10000);
        System.out.println("结束");
    }
    
}

五、删除节点

同步方式
delete(String path,int version)

异步方式
delete(String path,int version,AsyncCallback.VoidCallbck callBack,Object ctx)

path -znode路径
version -znode的当前版本
callBack - 异步回调接口
ctx -传递上下文参数

package com.csii.javaapi;

import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.util.concurrent.CountDownLatch;

public class ZKDelete {
    String IP = "192.168.191.128:2181";
    ZooKeeper zooKeeper;

    @Before
    public void before() throws Exception {
        System.out.println("before");
        //计数器对象
        final CountDownLatch countDownLatch = new CountDownLatch(1);
        /**
         * arg1:服务器的ip和端口
         * arg2：客户端与服务器之间的会话超时时间 以毫秒为单位
         * arg3：监视器对象
         */
        zooKeeper = new ZooKeeper(IP, 5000, new Watcher() {
            @Override
            public void process(WatchedEvent watchedEvent) {
                if (watchedEvent.getState() == Event.KeeperState.SyncConnected) {
                    System.out.println("连接成功");
                    countDownLatch.countDown();
                }
            }
        });
        //主线程阻塞等待连接对象的创建成功
        countDownLatch.await();
    }

    @After
    public void after() throws Exception {
        zooKeeper.close();
    }

    @Test
    public void delete1() throws Exception {

        //arg1 删除节点的节点路径
        //arg2 要数据版本信息，-1代表删除节点时不考虑版本信息
        zooKeeper.delete("/delete/node1",-1);
    }

    @Test
    public void delete2() throws Exception {

        zooKeeper.delete("/delete/node2", -1, new AsyncCallback.VoidCallback() {
            @Override
            public void processResult(int rc, String path, Object ctx) {
                //0代表成功
                System.out.println(rc);
                //节点的路径
                System.out.println(path);
                //上下文描述的对象
                System.out.println(ctx);
            }
        },"I am context");
        Thread.sleep(10000);
        System.out.println("结束");
    }
}

六、查看节点

同步方式

getData(String path,boolean b,Stat stat);

异步方式

getData(String path,boolean b,AsyncCallback.DataCallback callBack,Object ctx);

path -znode路径
b -是否使用连接对象中注册的监视器
stat - 返回znode的元数据
callBack -异步回调接口
ctx -传递上下文参数

package com.csii.javaapi;

import java.lang.String;
import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.util.concurrent.CountDownLatch;

public class ZKGet {

    String IP = "192.168.191.128:2181";
    ZooKeeper zooKeeper;

    @Before
    public void before() throws Exception {
        System.out.println("before");
        //计数器对象
        final CountDownLatch countDownLatch = new CountDownLatch(1);
        /**
         * arg1:服务器的ip和端口
         * arg2：客户端与服务器之间的会话超时时间 以毫秒为单位
         * arg3：监视器对象
         */
        zooKeeper = new ZooKeeper(IP, 5000, new Watcher() {
            @Override
            public void process(WatchedEvent watchedEvent) {
                if (watchedEvent.getState() == Event.KeeperState.SyncConnected) {
                    System.out.println("连接成功");
                    countDownLatch.countDown();
                }
            }
        });
        //主线程阻塞等待连接对象的创建成功
        countDownLatch.await();
    }

    @After
    public void after() throws Exception {
        zooKeeper.close();
    }

    @Test
    public void get1() throws Exception {

        //arg1：节点的路径
        //arg3: 读取节点属性的对象
        Stat stat = new Stat();
        byte[] bys =  zooKeeper.getData("/get/node1",false,stat);
        //打印数据
        System.out.println(new String (bys));
        //版本信息
        System.out.println(stat.getVersion());
    }

    @Test
    public void get2() throws Exception {
        //异步方式
        zooKeeper.getData("/get/node1", false, new AsyncCallback.DataCallback() {
            @Override
            public void processResult(int rc, String path, Object ctx, byte[] data, Stat stat) {
                //0代表成功
                System.out.println(rc);
                //节点的路径
                System.out.println(path);
                //上下文描述的对象
                System.out.println(ctx);
                //数据
                System.out.println(new String(data));
                //属性对象
                System.out.println(stat.getVersion());
            }
        },"I am contex");
    }

}

七、查看子节点

同步方式

getChildren(String path,boolean b);

异步方式

getData(String path,boolean b,AsyncCallback.ChildrenCallback callBack,Object ctx);

path -znode路径
b -是否使用连接对象中注册的监视器
callBack -异步回调接口
ctx -传递上下文参数

package com.csii.javaapi;

import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.util.List;
import java.util.concurrent.CountDownLatch;

public class ZKGetChild {
    String IP = "192.168.191.128:2181";
    ZooKeeper zooKeeper;

    @Before
    public void before() throws Exception {
        System.out.println("before");
        //计数器对象
        final CountDownLatch countDownLatch = new CountDownLatch(1);
        /**
         * arg1:服务器的ip和端口
         * arg2：客户端与服务器之间的会话超时时间 以毫秒为单位
         * arg3：监视器对象
         */
        zooKeeper = new ZooKeeper(IP, 5000, new Watcher() {
            @Override
            public void process(WatchedEvent watchedEvent) {
                if (watchedEvent.getState() == Event.KeeperState.SyncConnected) {
                    System.out.println("连接成功");
                    countDownLatch.countDown();
                }
            }
        });
        //主线程阻塞等待连接对象的创建成功
        countDownLatch.await();
    }

    @After
    public void after() throws Exception {
        zooKeeper.close();
    }

    @Test
    public void get1() throws Exception {
        //arg1:节点的路径
        List<String> list = zooKeeper.getChildren("/get",false);
        for (String str:list
             ) {
            System.out.println(str);

        }
    }

    @Test
    public void get2() throws Exception {
    //异步用法
        zooKeeper.getChildren("/get", false, new AsyncCallback.ChildrenCallback() {
            @Override
            public void processResult(int rc, String path, Object ctx, List<String> list) {
                //0代表成功
                System.out.println(rc);
                //节点的路径
                System.out.println(path);
                //上下文描述的对象
                System.out.println(ctx);
                //数据
                for (String str:list
                        ) {
                    System.out.println(str);

                }
            }
        },"I am Context");
        Thread.sleep(10000);
        System.out.println("结束");
    }

}

八、检查节点是否存在

同步方式

exists(String path,boolean b);

异步方式

exists(String path,boolean b,AsyncCallback.StatCallback callBack,Object ctx);

path -znode路径
b -是否使用连接对象中注册的监视器
callBack -异步回调接口
ctx -传递上下文参数

案例：

package com.csii.javaapi;

import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.util.concurrent.CountDownLatch;

public class ZKExists {
    String IP = "192.168.191.128:2181";
    ZooKeeper zooKeeper;

    @Before
    public void before() throws Exception {
        System.out.println("before");
        //计数器对象
        final CountDownLatch countDownLatch = new CountDownLatch(1);
        /**
         * arg1:服务器的ip和端口
         * arg2：客户端与服务器之间的会话超时时间 以毫秒为单位
         * arg3：监视器对象
         */
        zooKeeper = new ZooKeeper(IP, 5000, new Watcher() {
            @Override
            public void process(WatchedEvent watchedEvent) {
                if (watchedEvent.getState() == Event.KeeperState.SyncConnected) {
                    System.out.println("连接成功");
                    countDownLatch.countDown();
                }
            }
        });
        //主线程阻塞等待连接对象的创建成功
        countDownLatch.await();
    }

    @After
    public void after() throws Exception {
        zooKeeper.close();
    }

    @Test
    public void exists1() throws Exception {
        //arg1:节点的路径
        Stat stat = zooKeeper.exists("/exists",false);
        System.out.println(stat.getVersion());
    }

    @Test
    public void exists2() throws Exception {
        //arg1:节点的路径
       zooKeeper.exists("/exists", false, new AsyncCallback.StatCallback() {
           @Override
           public void processResult(int rc, String path, Object ctx, Stat stat) {
               //0代表成功
               System.out.println(rc);
               //节点的路径
               System.out.println(path);
               //上下文参数
               System.out.println(ctx);
               //节点的版本信息
               System.out.println(stat.getVersion());
           }
       },"I am Context");
        Thread.sleep(10000);
        System.out.println("结束");
    }
}

九、注册watcher的方法

客户端与服务器的连接状态

keeperState 通知状态
SyncConnected:客户端与服务器正常连接时
Disconnected:客户端与服务器断开连接时
Expired：会话session失效时
Authfailed：身份认证失败时

事件类型为：None

package com.csii.javaapi.watcher;

import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;

import java.util.concurrent.CountDownLatch;
public class ZKConnectionWatcher implements Watcher {

    /**
     * 计数器对象
     */
    static CountDownLatch countDownLatch = new CountDownLatch(1);
    /**
     * 连接对象
     */
    static ZooKeeper zooKeeper;

    @Override
    public void process(WatchedEvent event) {
        try {
            //事件类型
            if (event.getType() == Event.EventType.None) {
                if (event.getState() == Event.KeeperState.SyncConnected) {
                    System.out.println("连接创建成功");
                    countDownLatch.countDown();
                } else if (event.getState() == Event.KeeperState.Disconnected) {
                    System.out.println("断开连接");
                } else if (event.getState() == Event.KeeperState.Expired) {
                    System.out.println("会话超时！");
                    zooKeeper = new ZooKeeper("192.168.191.128:2181", 5000, new ZKConnectionWatcher());
                } else if (event.getState() == Event.KeeperState.AuthFailed) {
                    System.out.println("认证失败！");
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        try {
            zooKeeper = new ZooKeeper("192.168.191.128:2181", 5000, new ZKConnectionWatcher());
            //阻塞线程等待连接的创建
            countDownLatch.await();
            //会话id
            System.out.println(zooKeeper.getSessionId());
            //添加授权用户
            zooKeeper.addAuthInfo("digest", "itcast:123456".getBytes());
            byte[] bys = zooKeeper.getData("/node1", false, null);
            System.out.println(new String(bys));
            Thread.sleep(50000);
            zooKeeper.close();
            System.out.println("结束");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

检查节点是否存在

使用连接对象的监视器
exists(String path,boolean b)
自定义监视器
exists(String path,Watcher w)

//NodeCreated:节点创建
//NodeDeleted:节点删除
//NodeDataChanged:节点内容发上变化

path -znode路径

b -是否使用连接对象中注册的监视器
w -监视器对象

案例：

package com.csii.javaapi.watcher;

import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.util.concurrent.CountDownLatch;

public class ZKWatcherExists {
    String IP = "192.168.191.128:2181";
    ZooKeeper zooKeeper;

    @Before
    public void before() throws Exception {
        System.out.println("before");
        //计数器对象
        final CountDownLatch countDownLatch = new CountDownLatch(1);
        /**
         * arg1:服务器的ip和端口
         * arg2：客户端与服务器之间的会话超时时间 以毫秒为单位
         * arg3：监视器对象
         */
        zooKeeper = new ZooKeeper(IP, 5000, new Watcher() {
            @Override
            public void process(WatchedEvent watchedEvent) {
                System.out.println("连接对象的参数");
                if (watchedEvent.getState() == Event.KeeperState.SyncConnected) {
                    System.out.println("连接成功");
                    countDownLatch.countDown();
                }
                System.out.println("path=" + watchedEvent.getPath());
                System.out.println("evenType=" + watchedEvent.getType());
            }
        });
        //主线程阻塞等待连接对象的创建成功
        countDownLatch.await();
    }

    @After
    public void after() throws Exception {
        zooKeeper.close();
    }

    @Test
    public void watcherExists1() throws Exception {
        //arg1:节点的路径
        //arg2：使用连接对象中的watcher
        zooKeeper.exists("/watcher1", true);
        Thread.sleep(50000);
        System.out.println("结束");
    }

    @Test
    public void watcherExists2() throws Exception {
        //arg1：节点的路径
        //arg2：自定义watcher对象
        zooKeeper.exists("/watcher1", new Watcher() {
            @Override
            public void process(WatchedEvent watchedEvent) {
                System.out.println("自定义watcher");
                System.out.println("path=" + watchedEvent.getPath());
                System.out.println("evenType=" + watchedEvent.getType());
            }
        });
        Thread.sleep(50000);
        System.out.println("结束");
    }

    @Test
    public void watcherExists3() throws Exception {
        //watcher是一次性的
        Watcher watcher = new Watcher() {
            @Override
            public void process(WatchedEvent watchedEvent) {
                try {
                    System.out.println("自定义watcher");
                    System.out.println("path=" + watchedEvent.getPath());
                    System.out.println("evenType=" + watchedEvent.getType());
                    //可以通过在process方法中加入zooKeeper对象实现多次监听
                    zooKeeper.exists("/watcher1",this);
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        };
        zooKeeper.exists("/watcher1",watcher);
        Thread.sleep(80000);
        System.out.println("结束");
    }

    @Test
    public void watcherExists4() throws Exception {
        //注册多个监听器对象
        zooKeeper.exists("/watcher1", new Watcher() {
            @Override
            public void process(WatchedEvent watchedEvent) {
                System.out.println("自定义watcher1");
                System.out.println("path=" + watchedEvent.getPath());
                System.out.println("evenType=" + watchedEvent.getType());
            }
        });

        zooKeeper.exists("/watcher1", new Watcher() {
            @Override
            public void process(WatchedEvent watchedEvent) {
                System.out.println("自定义watcher2");
                System.out.println("path=" + watchedEvent.getPath());
                System.out.println("evenType=" + watchedEvent.getType());
            }
        });
        Thread.sleep(80000);
        System.out.println("结束");
    }
}

耐得住寂寞、守得住繁华

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
zookeeper实践之使用JavaAPI 一

zookeeper使用javaAPI一、创建一个mawen项目1、添加依赖二、连接zookeeper1、创建ZookeeperConnection类2、运行出现了异常：3、解决办法三、新增节点一、创建一个mawen项目1、添加依赖<?xml version="1.0" encoding="UTF-8"?><project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org
复制链接

扫一扫