zookeeper集群之java程序异步方式实现对数据节点的增，删，改，查及其权限管理（三）

本文链接：https://blog.youkuaiyun.com/dongyuancaizi/article/details/78669295

本文详细介绍使用Zookeeper原生API进行数据节点的增删改查及权限管理的异步操作方法，包括创建、删除节点、获取节点状态、更新节点数据、获取子节点列表和获取节点数据等。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

本文主要介绍通过zookeeper原生的api实现对数据节点的增，删，改，查，及其ACL权限管理。

package com.ilike.zk;

import java.io.IOException;

import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.Watcher.Event.KeeperState;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.ZooKeeper;

/**
* 通过zookeeper客户端异步创建数据节点
*
* @author 桑伟东
*
*
*/
public class CreateNodeASync implements Watcher {

// zookeeper客户端操作类
private static ZooKeeper zooKeeper;

public static void main(String[] args) throws IOException, InterruptedException {
    // 服务端的ip地址
    String serverIp = "192.168.111.129:2181";
    // 会话超时时间
    int sessionTimeout = 5000;
    // 实例化zookeeper客户端操作类，new CreateSession()为事件监听器对象
    zooKeeper = new ZooKeeper(serverIp, sessionTimeout, new CreateNodeASync());
    // 读取zookeeper的状态
    System.out.println(zooKeeper.getState());// CONNECTING
    // 为了让发送的异步请求等到服务器返回的响应后退出，这里让线程睡眠一会儿
    Thread.sleep(Integer.MAX_VALUE);
}

@Override
public void process(WatchedEvent event) {
    // TODO Auto-generated method stub
    // 输出监听到的事件
    System.out.println("接收到事件:" + event);
     接收到事件:WatchedEvent state:SyncConnected type:None path:null

    // 判断连接是否成功，如果成功，执行我们的业务逻辑
    if (event.getState() == KeeperState.SyncConnected) {
        doSomething();
    }

}

/**
 * 在该方法中执行节点的创建 节点的创建模式： PERSISTENT：持久节点
 * PERSISTENT_SEQUENTIAL：是一个持久节点，也是一个顺序节点 EPHEMERAL：是一个临时节点
 * EPHEMERAL_SEQUENTIAL：是一个临时节点，也是一个顺序节点
 * 
 */
private void doSomething() {

    // 第一个参数为节点路径
    // 第二个参数为节点数据
    // 第三个参数为ACL权限列表 Ids.OPEN_ACL_UNSAFE表示所有人可读
    // 第四个参数为创建模式 CreateMode.PERSISTENT表示这是一个持久节点
    // 第五个参数为异步调用的上下文
    zooKeeper.create("/node_3", "程序猿".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT, new IStringCallback(),
            "异步创建");
    // 异步调用，函数没有返回值
}

static class IStringCallback implements AsyncCallback.StringCallback {

    /**
     * 回调函数 rc：返回码，异步调用成功，返回0 path：需要创建节点的完整路径 ctx：异步调用的上下文
     * name：服务端返回的已经创建的节点的真实路径
     */
    @Override
    public void processResult(int rc, String path, Object ctx, String name) {
        // TODO Auto-generated method stub
        // 输出这几个参数
        StringBuilder sb = new StringBuilder();
        sb.append("rc=" + rc).append("\n");
        sb.append("path=" + path).append("\n");
        sb.append("ctx=" + ctx).append("\n");
        sb.append("rc=" + rc);
        System.out.println(sb.toString());
    }

}

}

package com.ilike.zk;

import java.io.IOException;
import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.Watcher.Event.EventType;
import org.apache.zookeeper.Watcher.Event.KeeperState;
import org.apache.zookeeper.ZooKeeper;
/**
* 通过zookeeper异步删除节点
* @author 桑伟东
*
*/
public class DeleteNodeASync implements Watcher{

//zookeeper对象
private static ZooKeeper zooKeeper;
public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
    //实例化zookeeper对象
    zooKeeper = new ZooKeeper("192.168.111.129:2181",5000,new DeleteNodeASync());
    System.out.println(zooKeeper.getState().toString());

    Thread.sleep(Integer.MAX_VALUE);

}

/**
 * 删除节点的方法
 * @param zooKeeper
 */
private void doSomething(WatchedEvent event){
    //第一个参数为需要删除的节点的完整路径
    //第二个参数为版本，-1表示不校验版本信息
    //第三个参数为回调函数类的对象
    //第四个参数为异步调用的上下文
    zooKeeper.delete("/node_5", -1, new IVoidCallback(),"异步删除节点");
}

@Override
public void process(WatchedEvent event) {
    // TODO Auto-generated method stub

    if (event.getState()==KeeperState.SyncConnected){
        if (event.getType()==EventType.None && null==event.getPath()){
            doSomething(event);
        }
    }
}

static class IVoidCallback implements AsyncCallback.VoidCallback{

    @Override
    public void processResult(int rc, String path, Object ctx) {
        StringBuilder sb = new StringBuilder();
        sb.append("rc="+rc).append("\n");
        sb.append("path="+path).append("\n");
        sb.append("ctx="+ctx).append("\n");
        System.out.println(sb.toString());

    }       

}

}
package com.ilike.zk;

import java.io.IOException;
import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.Watcher.Event.EventType;
import org.apache.zookeeper.Watcher.Event.KeeperState;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;
/**
* 通过zookeeper异步调用判断节点是否存在
*/

public class NodeExistsASync implements Watcher{

//zookeeper对象
private static ZooKeeper zooKeeper;

public static void main(String[] args) throws IOException, InterruptedException, KeeperException {

    //实例化zookeeper对象
    zooKeeper = new ZooKeeper("192.168.111.129:2181",5000,new NodeExistsASync());
    System.out.println(zooKeeper.getState().toString());        

    Thread.sleep(Integer.MAX_VALUE);


}
/**
 * 判断节点是否存在的方法
 * @param zooKeeper
 */ 
private void doSomething(ZooKeeper zookeeper){

    //第一个参数为要判断的节点的路径
    //第二个参数为是否关注节点变化
    //第三个参数为回调函数的类的对象
    //第四个参数为异步调用的上下文

    zooKeeper.exists("/node_1", true, new IStateCallback(), "异步判断节点是否存在");

}

@Override
public void process(WatchedEvent event) {
    // TODO Auto-generated method stub

    if (event.getState()==KeeperState.SyncConnected){
        if (event.getType()==EventType.None && null==event.getPath()){
            doSomething(zooKeeper);
        }else{
            try {
                if (event.getType()==EventType.NodeCreated){
                    System.out.println(event.getPath()+" created");
                    zooKeeper.exists(event.getPath(), true, new IStateCallback(), null);
                }
                else if (event.getType()==EventType.NodeDataChanged){
                    System.out.println(event.getPath()+" updated");
                    zooKeeper.exists(event.getPath(), true, new IStateCallback(), null);
                }
                else if (event.getType()==EventType.NodeDeleted){
                    System.out.println(event.getPath()+" deleted");
                    zooKeeper.exists(event.getPath(), true, new IStateCallback(), null);
                }

            } catch (Exception e) {
                // TODO: handle exception
            }

        }

    }
}


static class  IStateCallback implements AsyncCallback.StatCallback{

    @Override
    public void processResult(int rc, String path, Object ctx, Stat stat) {
        System.out.println("rc:"+rc); 

    }

}

}
package com.ilike.zk;
import java.io.IOException;
import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.Watcher.Event.EventType;
import org.apache.zookeeper.Watcher.Event.KeeperState;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;
/**
* 通过zookeeper异步修改节点数据
* @author 桑伟东
*
*/
public class UpdateNodeASync implements Watcher{

//zookeeper对象
private static ZooKeeper zooKeeper;
public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
    //实例化zookeeper对象
    zooKeeper = new ZooKeeper("192.168.111.129:2181",5000,new UpdateNodeASync());
    System.out.println(zooKeeper.getState().toString());


    Thread.sleep(Integer.MAX_VALUE);


}
/**
 * 修改节点数据的方法
 * @param event
 */
private void doSomething(WatchedEvent event){

    zooKeeper.setData("/node_6", "234".getBytes(), -1, new IStatCallback(),null);

}

@Override
public void process(WatchedEvent event) {
    // TODO Auto-generated method stub

    if (event.getState()==KeeperState.SyncConnected){
        if (event.getType()==EventType.None && null==event.getPath()){
            doSomething(event);
        }
    }
}

static class IStatCallback implements AsyncCallback.StatCallback{

    @Override
    public void processResult(int rc, String path, Object ctx, Stat stat) {
        StringBuilder sb = new StringBuilder();
        sb.append("rc="+rc).append("\n");
        sb.append("path"+path).append("\n");
        sb.append("ctx="+ctx).append("\n");
        sb.append("Stat="+stat).append("\n");
        System.out.println(sb.toString());
    }       

}

}
package com.ilike.zk;

import java.io.IOException;
import java.util.List;
import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.Watcher.Event.EventType;
import org.apache.zookeeper.Watcher.Event.KeeperState;
import org.apache.zookeeper.data.Stat;
import org.apache.zookeeper.ZooKeeper;
/**
* 通过zookeeper客户端异步获取子节点列表
* @author 桑伟东
*
*/

public class GetChildrenASync implements Watcher{

//zookeeper客户端
private static ZooKeeper zooKeeper;

public static void main(String[] args) throws IOException, InterruptedException, KeeperException {

    //实例化zookeeper客户端
    zooKeeper = new ZooKeeper("192.168.111.129:2181",5000,new GetChildrenASync());
    System.out.println(zooKeeper.getState().toString());

    Thread.sleep(Integer.MAX_VALUE);


}
/**
 * 异步调用获取子节点列表的方法
 * @param zookeeper
 */
private void doSomething(ZooKeeper zookeeper){

    try {
        //第一个参数要获取子节点列表的节点路径
        //第二个参数为是否关注子节点的变化
        //第三个参数为回调函数类的对象
        //第四个参数为异步调用的上下文
       zooKeeper.getChildren("/", true, new IChildren2Callback(), "异步获取子节点列表");     
    } catch (Exception e) {
        // TODO: handle exception
    }


}

@Override
public void process(WatchedEvent event) {
    // TODO Auto-generated method stub
    //判断连接是否成功
    if (event.getState()==KeeperState.SyncConnected){
        if (event.getType()==EventType.None && null==event.getPath()){
            doSomething(zooKeeper);
        }else{  
            //判断事件的类型是不是子节点改变的事件
            if (event.getType()==EventType.NodeChildrenChanged){
                zooKeeper.getChildren(event.getPath(), true, new IChildren2Callback(), "异步获取子节点列表");
            }           
        }
    }
}

static class IChildren2Callback implements AsyncCallback.Children2Callback{

    /**
     * 回调函数
     * rc：返回码，异步调用成功，返回0
     * path：需要创建节点的完整路径
     * ctx：异步调用的上下文
     * children：服务端返回的已经子节点的列表
     * stat:节点的状态
     */

    @Override
    public void processResult(int rc, String path, Object ctx,
            List<String> children, Stat stat) {

        StringBuilder sb = new StringBuilder();
        sb.append("rc="+rc).append("\n");
        sb.append("path="+path).append("\n");
        sb.append("ctx="+ctx).append("\n");
        sb.append("children="+children).append("\n");
        sb.append("stat="+stat).append("\n");
        System.out.println(sb.toString());

    }


}

}
package com.ilike.zk;

import java.io.IOException;
import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.Watcher.Event.EventType;
import org.apache.zookeeper.Watcher.Event.KeeperState;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;
/**
* 通过zookeeper对象异步获取节点数据
* @author 桑伟东
*
*/

public class GetDataASync implements Watcher{

//zookeeper对象
private static ZooKeeper zooKeeper;


public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
    //实例化zookeeper对象
    zooKeeper = new ZooKeeper("192.168.111.129:2181",5000,new GetDataASync());
    System.out.println(zooKeeper.getState().toString());    

    Thread.sleep(Integer.MAX_VALUE);




}
/**
 * 获取节点数据的方法
 * @param zookeeper
 */
private void doSomething(ZooKeeper zookeeper){
    //第一个参数为你需要获取数据的节点
    //第二个参数为是否关注数据变化
    //第三个参数为zookeeper的状态实例，zookeeper会将返回的数据信息封装在这个事例中
    //第四个参数为异步调用的上下文
    zooKeeper.getData("/node_1", true, new IDataCallback(), "异步获取节点数据");    
}

@Override
public void process(WatchedEvent event) {
    // TODO Auto-generated method stub

    if (event.getState()==KeeperState.SyncConnected){
        if (event.getType()==EventType.None && null==event.getPath()){
            doSomething(zooKeeper);
        }else{
            if (event.getType()==EventType.NodeDataChanged){
                try {
                    zooKeeper.getData(event.getPath(), true, new IDataCallback(), null);
                } catch (Exception e) {
                    e.printStackTrace();
                } 
            }
        }

    }
}

static class IDataCallback implements AsyncCallback.DataCallback{

    @Override
    public void processResult(int rc, String path, Object ctx, byte[] data,
            Stat stat) {
        try {
            System.out.println(new String(zooKeeper.getData(path, true, stat)));
            System.out.println("stat:"+stat);
        } catch (KeeperException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


    }

}

}