Java客户端_原生api操作Zookeeper

利用Zookeeper官方的原生java api进行连接，然后演示一些创建、删除、修改、查询节点的操作。

引入依赖

<dependencies>
  <dependency>
    <groupId>org.apache.zookeeper</groupId>
    <artifactId>zookeeper</artifactId>
    <version>3.4.8</version>
  </dependency>
</dependencies>

创建会话

 /**
     * 创建一个 Zookeeper 的实例
     * 此处为一个集群，Zookeeper 的 ip 之间用逗号隔开
     *
     * 参数解释：
     * param 1 - Zookeeper 的实例 ip ，此处是一个集群，所以配置了多个 ip，用逗号隔开
     * param 2 - session 过期时间，单位秒 (1000)
     * param 3 - 监视者，用于获取监听事件 (MyWatch)
     */
ZooKeeper zooKeeper = new ZooKeeper("192.168.1.108:2181", 5000, watcher);

创建节点

java 复制代码

private void createNodeSync() throws KeeperException, InterruptedException {
  String path = "/poype_node";
  /*
  *znode名称
  *节点数据
  *设置权限
  *znode类型
  *
  */
  String nodePath = zooKeeper.create(path, "123".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
  System.out.println(nodePath);
}

znode 类型有四种

PERSISTENT - 持久化目录节点，客户端与zookeeper断开连接后，该节点依旧存在

PERSISTENT_SEQUENTIAL - 持久化，并带有序列号

EPHEMERAL - 临时目录节点，客户端与zookeeper断开连接后，该节点被删除

EPHEMERAL_SEQUENTIAL - 临时，并带有序列号

删除节点

同步方式删除一个节点：

java 复制代码

private void deleteSync() throws KeeperException, InterruptedException {
   zooKeeper.delete("/node_1", 12);
}

读取数据

java 复制代码

private void getDataSync() throws KeeperException, InterruptedException {
   Stat stat = new Stat();
   // getData的返回值是该节点的数据值，节点的状态信息会赋值给stat对象
   byte[] data = zooKeeper.getData("/node_1",true, stat);
   System.out.println(new String(data));
   System.out.println(stat);
}

参数：

znode 名称 (/zoo)

监视者，用于获取监控事件 (MyWatch)

Zookeeper 实例信息和数据信息 (stat)

更新数据

java 复制代码

Stat stat = zooKeeper.setData("/poype_node2", "poype5211314".getBytes(), 1);

参数:

param1：znode名称

param2：节点数据

param3：该节点的版本

检测节点是否存在

java 复制代码

private void existSync() throws KeeperException, InterruptedException {
   Stat stat = zooKeeper.exists("/poype_node2", true);
   System.out.println(stat);
}

参数：

param1：znode 名称 (/zoo)

param2：监视者，用于获取监控事件 (MyWatch)

注册监听getChilren

通过zkCli.getchildren("/",new watch()){}来注册监听，监听的是整个根节点,但是这个监听只能监听一次。线程休眠是为了让监听等待事件发生，不然会随着程序直接运行完。

java 复制代码

public class WatchDemo1 {
    
    static List<String> children = null;
    public static void main(String[] args) throws IOException, KeeperException, InterruptedException {
        


        ZooKeeper zkCli = new ZooKeeper("192.168.50.183:2181,192.168.50.184:2181,192.168.50.185:2181", 3000, new Watcher() {
                
                //监听回调
                @Override
                public void process(WatchedEvent event) {
                    System.out.println("正在监听中.....");
                }
            });
        
            //监听目录
            children = zkCli.getChildren("/", new Watcher() {
            
            @Override
            public void process(WatchedEvent event) {
                
                System.out.println("监听路径为：" + event.getPath());
                System.out.println("监听的类型为：" + event.getType());
                System.out.println("数据被2货修改了！！！");
                
                for(String c:children) {
                    System.out.println(c);
                }
            }
        }); 
            Thread.sleep(Long.MAX_VALUE);
    }   
}

注册监听getData

getData监听的为一个节点,同样只监听一次，返回的是该节点的内容。

java 复制代码

public class WatchDemo {
    public static void main(String[] args) throws IOException, KeeperException, InterruptedException {
        ZooKeeper zkCli = new ZooKeeper("192.168.50.183:2181,192.168.50.184:2181,192.168.50.185:2181", 3000, new Watcher() {
            
            //监听回调
            @Override
            public void process(WatchedEvent event) {
                
            }
        });
        
        byte[] data = zkCli.getData("/hunter", new Watcher() {
            //监听的具体内容
            @Override
            public void process(WatchedEvent event) {
                System.out.println("监听路径为：" + event.getPath());
                System.out.println("监听的类型为：" + event.getType());
                System.out.println("数据被2货修改了！！！");
            }
        }, null);
        System.out.println(new String(data));
        Thread.sleep(Long.MAX_VALUE);
    }
}