zookeeper学习笔记（四）使用Java连接zk，操作zk

本文链接：https://blog.csdn.net/liutao43/article/details/115460777

创建maven工程

<dependency>
      <groupId>org.apache.zookeeper</groupId>
      <artifactId>zookeeper</artifactId>
      <version>3.4.6</version>
</dependency>

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

在配置文件log4j.properties（文件名必须这个，放在resources目录）全选粘贴如下代码：

# Global logging configuration 开发时候建议使用 debug
log4j.rootLogger=DEBUG, stdout
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

在这里插入图片描述

API链接zk集群

zk的链接API，因为调用ZooKeeper构造函数和Watcher接口中的process方法被执行是在两个线程中，需要利用信号量来同步两个操作，使用CountDownLatch

connectionString - ZooKeeper集合主机。
sessionTimeout - 会话超时（以毫秒为单位）。
watcher - 实现“监视器”界面的对象。ZooKeeper集合通过监视器对象返回连接状态。


ZooKeeper(String connectionString, int sessionTimeout, Watcher watcher)

CountDownLatch类只提供了一个构造器：

public CountDownLatch(int count) {  };  //参数count为计数值

然后下面这3个方法是CountDownLatch类中最重要的方法：

public void await() throws InterruptedException { };   //调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行
public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };  //和await()类似，只不过等待一定的时间后count值还没为0的话就会继续执行
public void countDown() { };  //将count值减1

代码

链接zk不是同步，而是异步，可能有多个请求链接zk，所以创建完连接并不代表一定会连接成功，而是要等待，等待给监控器一个连接状态，才算连接完毕。

因为调用ZooKeeper构造函数和Watcher接口中的process方法被执行是在两个线程中，需要利用信号量来同步两个操作，使用CountDownLatch

package org.example;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import java.util.concurrent.CountDownLatch;

public class ZookeeperConnect {
    public static void main(String[] args) {
        try {
            // 计数器对象
            final CountDownLatch countDownLatch=new CountDownLatch(1);
            // arg1:服务器的ip和端口
            // arg2:客户端与服务器之间的会话超时时间,以毫秒为单位
            // arg3:监视器对象，捕获客户端，因为调用ZooKeeper构造函数和process方法被执行是在两个线程中，需要利用信号量来同步两个操作。
            ZooKeeper zooKeeper=new ZooKeeper("ip:端口",
                    5000, new Watcher() {
                @Override
                public void process(WatchedEvent event) {
                    if(event.getState()==Event.KeeperState.SyncConnected)
                    {
                        System.out.println("连接创建成功!");
                        countDownLatch.countDown();
                    }
                }
            });
            // 主线程阻塞等待连接对象的创建成功
            countDownLatch.await();
            // 会话编号
            System.out.println(zooKeeper.getSessionId());
            zooKeeper.close();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

输出：

INFO [main] - Client environment:zookeeper.version=3.4.6-1569965, built on 02/20/2014 09:09 GMT
 INFO [main] - Client environment:host.name=liutao-GE5S
 INFO [main] - Client environment:java.version=1.8.0_281
 INFO [main] - Client environment:java.vendor=Oracle Corporation
 INFO [main] - Client environment:java.home=/usr/local/jdk8/jre
 INFO [main] - Client environment:java.class.path=/usr/local/jdk8/jre/lib/charsets.jar:/usr/local/jdk8/jre/lib/deploy.jar:/usr/local/jdk8/jre/lib/ext/cldrdata.jar:/usr/local/jdk8/jre/lib/ext/dnsns.jar:/usr/local/jdk8/jre/lib/ext/jaccess.jar:/usr/local/jdk8/jre/lib/ext/jfxrt.jar:/usr/local/jdk8/jre/lib/ext/localedata.jar:/usr/local/jdk8/jre/lib/ext/nashorn.jar:/usr/local/jdk8/jre/lib/ext/sunec.jar:/usr/local/jdk8/jre/lib/ext/sunjce_provider.jar:/usr/local/jdk8/jre/lib/ext/sunpkcs11.jar:/usr/local/jdk8/jre/lib/ext/zipfs.jar:/usr/local/jdk8/jre/lib/javaws.jar:/usr/local/jdk8/jre/lib/jce.jar:/usr/local/jdk8/jre/lib/jfr.jar:/usr/local/jdk8/jre/lib/jfxswt.jar:/usr/local/jdk8/jre/lib/jsse.jar:/usr/local/jdk8/jre/lib/management-agent.jar:/usr/local/jdk8/jre/lib/plugin.jar:/usr/local/jdk8/jre/lib/resources.jar:/usr/local/jdk8/jre/lib/rt.jar:/home/liutao/IdeaProject/zookeeperapi/target/classes:/home/liutao/.m2/repository/org/apache/zookeeper/zookeeper/3.4.6/zookeeper-3.4.6.jar:/home/liutao/.m2/repository/org/slf4j/slf4j-api/1.6.1/slf4j-api-1.6.1.jar:/home/liutao/.m2/repository/org/slf4j/slf4j-log4j12/1.6.1/slf4j-log4j12-1.6.1.jar:/home/liutao/.m2/repository/log4j/log4j/1.2.16/log4j-1.2.16.jar:/home/liutao/.m2/repository/jline/jline/0.9.94/jline-0.9.94.jar:/home/liutao/.m2/repository/io/netty/netty/3.7.0.Final/netty-3.7.0.Final.jar:/opt/idea-IU-203.7148.57/lib/idea_rt.jar
 INFO [main] - Client environment:java.library.path=/usr/java/packages/lib/amd64:/usr/lib64:/lib64:/lib:/usr/lib
 INFO [main] - Client environment:java.io.tmpdir=/tmp
 INFO [main] - Client environment:java.compiler=<NA>
 INFO [main] - Client environment:os.name=Linux
 INFO [main] - Client environment:os.arch=amd64
 INFO [main] - Client environment:os.version=5.8.0-48-generic
 INFO [main] - Client environment:user.name=liutao
 INFO [main] - Client environment:user.home=/home/liutao
 INFO [main] - Client environment:user.dir=/home/liutao/IdeaProject
 INFO [main] - Initiating client connection, connectString=10.10.108.71:2181 sessionTimeout=6000 watcher=org.example.ZookeeperConnect$1@37f8bb67
DEBUG [main] - zookeeper.disableAutoWatchReset is false
 INFO [main-SendThread(10.10.108.71:2181)] - Opening socket connection to server 10.10.108.71/10.10.108.71:2181. Will not attempt to authenticate using SASL (unknown error)
 INFO [main-SendThread(10.10.108.71:2181)] - Socket connection established to 10.10.108.71/10.10.108.71:2181, initiating session
DEBUG [main-SendThread(10.10.108.71:2181)] - Session establishment request sent on 10.10.108.71/10.10.108.71:2181
 INFO [main-SendThread(10.10.108.71:2181)] - Session establishment complete on server 10.10.108.71/10.10.108.71:2181, sessionid = 0x178a5cabcf60002, negotiated timeout = 6000
连接创建成功!
106016881415421954
DEBUG [main] - Closing session: 0x178a5cabcf60002
DEBUG [main] - Closing client for session: 0x178a5cabcf60002
DEBUG [main-SendThread(10.10.108.71:2181)] - Reading reply sessionid:0x178a5cabcf60002, packet:: clientPath:null serverPath:null finished:false header:: 1,-11  replyHeader:: 1,12884901912,0  request:: null response:: null
DEBUG [main] - Disconnecting client for session: 0x178a5cabcf60002
 INFO [main] - Session: 0x178a5cabcf60002 closed
 INFO [main-EventThread] - EventThread shut down

Process finished with exit code

创建结点

// 同步方式
create(String path, byte[] data, List<ACL> acl, CreateMode createMode)
// 异步方式
create(String path, byte[] data, List<ACL> acl, CreateMode createMode, AsyncCallback.StringCallback callBack,Object ctx)

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

需要执行的情况太多，需要用到junit

以下是JUnit4常用的几个annotation：

@Before：初始化方法对于每一个测试方法都要执行一次（注意与BeforeClass区别，后者是对于所有方法执行一次）
@After：释放资源对于每一个测试方法都要执行一次（注意与AfterClass区别，后者是对于所有方法执行一次）
@Test：测试方法，在这里可以测试期望异常和超时时间
@Test(expected=ArithmeticException.class)检查被测方法是否抛出ArithmeticException异常
@Ignore：忽略的测试方法 @BeforeClass：针对所有测试，只执行一次，且必须为static void
@AfterClass：针对所有测试，只执行一次，且必须为static void 一个JUnit4的单元测试用例执行顺序为：
@BeforeClass -> @Before -> @Test -> @After -> @AfterClass;
每一个测试方法的调用顺序为： @Before -> @Test -> @After;

代码

package org.example;

import org.apache.zookeeper.*;
import org.apache.zookeeper.data.ACL;
import org.apache.zookeeper.data.Id;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
public class ZKCreate {
    String IP="10.10.108.72:2181";
    ZooKeeper zooKeeper;
    @Before
    public void before()throws Exception{
        // 计数器对象
        final CountDownLatch countDownLatch=new CountDownLatch(1);
        // arg1:服务器的ip和端口
        // arg2:客户端与服务器之间的会话超时时 ,以毫秒为单位的
        // arg3:监视器对象
                zooKeeper=new ZooKeeper(IP, 5000, new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                if(event.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 {
        // Ids.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<ACL>();
        // 授权模式和授权对象
        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<ACL>();
        // 授权模式和授权对象
        Id id = new Id("ip", "192.168.60.130");
        // 权限设置
        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);
    }
    @Test
    public void create6() throws Exception {
        // auth授权模式
        // 添加授权用户
        zooKeeper.addAuthInfo("digest", "itcast:123456".getBytes());
        // 权限列表
        List<ACL> acls = new ArrayList<ACL>();
        // 授权模式和授权对象
        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<ACL>();
        // 授权模式和授权对象
        Id id = new Id("digest", "itheima:qlzQzCLKhBROghkooLvb+Mlwv4A=");
        // 权限设置
        acls.add(new ACL(ZooDefs.Perms.ALL, id));
        zooKeeper.create("/create/node7", "node7".getBytes(), acls,
                CreateMode.PERSISTENT);
    }

    @Test
    public void create8() throws Exception {
        // 持久化顺序节点
        // Ids.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 {
        // 临时节点
        // Ids.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 {
        // 临时顺序节点
        // Ids.OPEN_ACL_UNSAFE world:anyone:cdrwa
        String result = zooKeeper.create("/create/node10",
                "node10".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE,
                CreateMode.EPHEMERAL_SEQUENTIAL);
        System.out.println(result);
    }

    @Test
    public void create11() throws Exception {
        // 异步方式创建节点
        zooKeeper.create("/create/node11", "node11".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.StatCallback callBack, Object ctx)

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

代码

package org.example;
import org.apache.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 = "10.10.108.71:2181";
    ZooKeeper zookeeper;
    @Before
    public void before() throws Exception {
        final CountDownLatch countDownLatch = new CountDownLatch(1);
        // arg1:zookeeper服务器的ip地址和端口号
        // arg2:连接的超时时间,以毫秒为单位
        // arg3:监听器对象
                zookeeper = new ZooKeeper(IP, 5000, new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                if (event.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，则表示更新操作针对任何版本均可。当更新版本不为-1，且不等于节点的目前版本，则更新失败。
        Stat stat=zookeeper.setData("/set/node1","node13".getBytes(),-1);
    // 节点的版本号
        System.out.println(stat.getVersion());
    // 节点的创建时间
        System.out.println(stat.getCtime());
    }

    @Test
    public void set2() throws Exception {
    // 异步方式修改节点
        zookeeper.setData("/set/node2", "node21".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 Context");
        Thread.sleep(50000);
        System.out.println("结束");
    }
}

删除结点

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

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

代码

package org.example;
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 ZKDelete {
    String IP = "10.10.108.71:2181";
    ZooKeeper zooKeeper;
    @Before
    public void before() throws Exception {
        final CountDownLatch countDownLatch = new CountDownLatch(1);
    // arg1:zookeeper服务器的ip地址和端口号
    // arg2:连接的超时时间 以毫秒为单位
    // arg3:监听器对象
                zooKeeper = new ZooKeeper(IP, 5000, new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                if (event.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 org.example;

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 = "10.10.108.71:2181";
    ZooKeeper zooKeeper;
    @Before
    public void before() throws Exception {
        final CountDownLatch countDownLatch = new CountDownLatch(1);
    // arg1:zookeeper服务器的ip地址和端口号
    // arg2:连接的超时时间,以毫秒为单位
    // arg3:监听器对象
                zooKeeper = new ZooKeeper(IP, 5000, new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                if (event.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 Context");
        Thread.sleep(10000);
        System.out.println("结束");
    }
}

查看子结点

// 同步方式
getChildren(String path, boolean b)
// 异步方式
getChildren(String path, boolean b,AsyncCallback.ChildrenCallback callBack,Object ctx)

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

代码

package org.example;
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.List;
import java.util.concurrent.CountDownLatch;
public class ZKGetChid {
    String IP = "10.10.108.71:2181";
    ZooKeeper zooKeeper;
    @Before
    public void before() throws Exception {
        final CountDownLatch countDownLatch = new CountDownLatch(1);
        // arg1:zookeeper服务器的ip地址和端口号
        // arg2:连接的超时时间,以毫秒为单位
        // arg3:监听器对象
                zooKeeper = new ZooKeeper(IP, 5000, new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                if (event.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> children) {
                            // 0代表读取成功
                        System.out.println(rc);
                            // 节点的路径
                        System.out.println(path);
                            // 上下文参数对象
                        System.out.println(ctx);
                            // 子节点信息
                        for (String str : children) {
                            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 org.example;

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 = "10.10.108.72:2181";
    ZooKeeper zookeeper;
    @Before
    public void before() throws Exception {
        final CountDownLatch countDownLatch = new CountDownLatch(1);
            // arg1:zookeeper服务器的ip地址和端口号
            // arg2:连接的超时时间,以毫秒为单位
            // arg3:监听器对象
                zookeeper = new ZooKeeper(IP, 5000, new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                if (event.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("/exists1", false);
        System.out.println(stat.getVersion());
    }

    @Test
    public void exists2() throws Exception {
        // 异步使用方式
        zookeeper.exists("/exists1", false, new
                AsyncCallback.StatCallback() {
                    @Override
                    public void processResult(int rc, String path, Object ctx, Stat stat) {
                        // 判断成功
                        System.out.println(rc);
                        // 路径
                        System.out.println(path);
                        // 上下文参数
                        System.out.println(ctx);
                        // null 节点不存在
                        System.out.println(stat.getVersion());
                    }
                }, "I am Context");
        Thread.sleep(5000);
        System.out.println("结束");
    }
}