Zookeeper节点操作-1

最新推荐文章于 2026-08-02 14:00:00 发布

原创最新推荐文章于 2026-08-02 14:00:00 发布 · 944 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

Zookeeper

本文介绍了如何使用Zookeeper的原生API进行节点的增删改查操作，包括节点的创建、监听、数据更新和删除。通过示例展示了事件触发后如何处理，并给出了一步步的操作结果。

Zookeeper客户端api有三种方式：
1、原生api

2、客户端client

3、第三方curator

原生api使用起来麻烦点，首先事件注册在事件触发后就失效，又必须重新注册，汽车删除节点没有原生迭代删除api。

这里用原生api写的增删该查的简单例子。

package enjoy.zook;

import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;
import java.io.IOException;
import java.util.concurrent.CountDownLatch;

public class TestZook01 implements Watcher {
    //使用逗号，不适用分号，分号直接报错了
    public static String CONNECTION_URL = "192.168.249.138:2181,192.168.249.139:2181,192.168.249.140:2181";
    public static int SESSION_TIME_OUT = 5000;
    private  CountDownLatch connectedSemaphore =  new CountDownLatch(1);
    public ZooKeeper zooKeeper = null;

    public static void main(String[] args) throws InterruptedException {
        TestZook01 zook = new TestZook01();
        String root = "/root";
        String path ="/root/water";
        zook.createConnection();

        if(zook.exsits(root,true) == null){
            zook.createPersistNode(root,"节点初始化");//创建持久节点
        }

        if(zook.exsits(path,true) == null){
            zook.createEphemeralNode(path,"节点初始化");//创建临时节点
        }else{
            zook.deleteNode(path);//删除节点
        }

        //修改数据
        if(zook.exsits(path,true) != null){
            zook.writeData(path,"hello World".getBytes());
        }

        //获取数据
        zook.readData(path);

        //删除节点
        if(zook.exsits(path,true) != null){
            zook.deleteNode(path);//删除节点
        }

        //删除节点
        if(zook.exsits(root,true) != null){
            zook.deleteNode(root);//删除节点
        }
    }

    /**
     * 连接到服务器
     */
    public void createConnection(){
        this.releaseConnection();
        if(this.zooKeeper == null) {
            try {
                this.zooKeeper = new ZooKeeper(CONNECTION_URL, SESSION_TIME_OUT, this);
                this.connectedSemaphore.await();
            } catch (InterruptedException e) {
                System.out.println("连接创建失败，发生InterruptedException");
                e.printStackTrace();
            }catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 释放连接
     */
    public void releaseConnection(){
        if(this.zooKeeper != null){
            try {
                this.zooKeeper.close();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 创建持久节点
     * @param path
     * @param data
     */
    public  void createPersistNode(String path,String data){
        try {
            System.out.println("节点创建成功，path："
                    +this.zooKeeper.create(path//节点路径
                    ,data.getBytes()//节点数据
                    , ZooDefs.Ids.OPEN_ACL_UNSAFE//节点权限
                    , CreateMode.PERSISTENT));//节点类型
        } catch (KeeperException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 创建临时节点
     * @param path
     * @param data
     */
    public void createEphemeralNode(String path,String data){
        try {
            System.out.println("节点创建成功，path："
                    +this.zooKeeper.create(path//节点路径
                    ,data.getBytes()//节点数据
                    , ZooDefs.Ids.OPEN_ACL_UNSAFE//节点权限
                    , CreateMode.EPHEMERAL));//节点类型
        } catch (KeeperException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 读取节点数据
     * @param path
     * @return
     */
    public  String readData(String path){
        try {
            System.out.println("获取数据成功，path：" + path);
            return new String(zooKeeper.getData(path,this,null));
        } catch (KeeperException e) {
            System.out.println("读取数据失败，发生KeeperException，path: " + path);
            e.printStackTrace();
            return "";
        } catch (InterruptedException e) {
            System.out.println("读取数据失败，发生 InterruptedException，path: " + path);
            e.printStackTrace();
            return "";
        }
    }
    /**
     * 更新节点数据内容
     * @param path
     * @param bytes
     */
    public void writeData(String path,byte[] bytes){
        try {
            System.out.println("更新数据成功，path：" + path + ", stat: " +
                    this.zooKeeper.setData(path, bytes, -1));
        } catch (KeeperException e) {
            System.out.println("更新数据失败，发生KeeperException，path: " + path);
            e.printStackTrace();
        } catch (InterruptedException e) {
            System.out.println("更新数据失败，发生KeeperException，path: " + path);
            e.printStackTrace();
        }
    }

    /**
     * 删除节点
     * @param path
     */
    public void deleteNode(String path){
        try {
            zooKeeper.delete(path,-1);
            System.out.println("删除节点成功，path：" + path);
        } catch (KeeperException e) {
            e.printStackTrace();
            System.out.println("删除节点失败，发生KeeperException，path: " + path);
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("删除节点失败，InterruptedException，path: " + path);
        }
    }

    /**
     * 节点是否存在
     * @param path
     */
    public Stat exsits(String path,boolean watch){
        Stat stat = null;
        try {
            stat = zooKeeper.exists(path,watch);
           System.out.println("节点是否存在，path:"+path+","+"Stat:"+stat);
        } catch (KeeperException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return stat;
    }

    public void process(WatchedEvent event) {
        System.out.print("event:"+event+">>>");
        if(Event.EventType.None.equals(event.getType())
            && event.getState() == Event.KeeperState.SyncConnected){
            System.out.println("连接到服务器...");
            this.connectedSemaphore.countDown();
        }else if(Event.EventType.NodeCreated.equals(event.getType())){
            System.out.println("监听到节点创建...");
        }else if(Event.EventType.NodeDeleted.equals(event.getType())){
            System.out.println("监听到节点删除...");
        }else if(Event.EventType.NodeDataChanged.equals(event.getType())){
            System.out.println("监听到节点更新...");
        }else if(Event.EventType.NodeChildrenChanged.equals(event.getType())){
            System.out.println("监听到子节点删除...");
        }
    }
}

运行结果：

event:WatchedEvent state:SyncConnected type:None path:null>>>连接到服务器...
节点是否存在，path:/root,Stat:null
event:WatchedEvent state:SyncConnected type:NodeCreated path:/root>>>监听到节点创建...
节点创建成功，path：/root
节点是否存在，path:/root/water,Stat:null
event:WatchedEvent state:SyncConnected type:NodeCreated path:/root/water>>>监听到节点创建...
节点创建成功，path：/root/water
节点是否存在，path:/root/water,Stat:47244640282,47244640282,1566111376602,1566111376602,0,0,0,216176252308881408,15,0,47244640282

event:WatchedEvent state:SyncConnected type:NodeDataChanged path:/root/water>>>监听到节点更新...
更新数据成功，path：/root/water, stat: 47244640282,47244640283,1566111376602,1566111376618,1,0,0,216176252308881408,11,0,47244640282

获取数据成功，path：/root/water
节点是否存在，path:/root/water,Stat:47244640282,47244640283,1566111376602,1566111376618,1,0,0,216176252308881408,11,0,47244640282

event:WatchedEvent state:SyncConnected type:NodeDeleted path:/root/water>>>监听到节点删除...
删除节点成功，path：/root/water
节点是否存在，path:/root,Stat:47244640281,47244640281,1566111376564,1566111376564,0,2,0,0,15,0,47244640284

event:WatchedEvent state:SyncConnected type:NodeDeleted path:/root>>>监听到节点删除...
删除节点成功，path：/root

标签

#zookeeper #zook #原生api