zookeeper 原生 api 增删改查 权限 操作原码参考

maven dependency:

<!-- zookeeper jdk https://mvnrepository.com/artifact/org.apache.zookeeper/zookeeper -->
<dependency>
    <groupId>org.apache.zookeeper</groupId>
    <artifactId>zookeeper</artifactId>
    <version>3.4.10</version>
    <!--<type>pom</type>-->
</dependency>

第一个类: main 函数在里面

package com.xlj.zookeeper.jdk;

import org.apache.zookeeper.*;
import org.apache.zookeeper.data.ACL;
import org.apache.zookeeper.data.Id;
import org.apache.zookeeper.data.Stat;
import org.apache.zookeeper.server.auth.DigestAuthenticationProvider;

import java.io.IOException;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

import static org.apache.zookeeper.Watcher.Event.EventType.NodeDeleted;

public class Start {

    static ZookeeperUtils zookeeperUtils;
    static ZookeeperUtils zookeeperUtils2;


    static CountDownLatch countDownLatch;
    static String basePath = "/xlj";
    static Watcher watcher =new Watcher() {
        @Override
        public void process(WatchedEvent watchedEvent) {

            //
            System.out.println("state: "  + watchedEvent.getState());
            System.out.println("type: "  + watchedEvent.getType());
            System.out.println("path: "  + watchedEvent.getPath());

            Event.KeeperState state =  watchedEvent.getState();
            Event.EventType eventType = watchedEvent.getType();
            String path = watchedEvent.getPath();

            try {

                //异步链接状态
                if(state == Event.KeeperState.SyncConnected) {

                    //路径不为 null
                    if(path != null) {
                        //继续监听修改事件
//                      zookeeperUtils.getZooKeeper().getData("/", watcher, new Stat());

                        //读取节点数据
                        String data = "";
                        byte[] dataBytes;
                        char[] dataChars;

                        switch (eventType) {


                            case NodeCreated: //创建节点之前必须监听否则无效,如: zookeeper.exist("/test", true)
                                dataBytes = zookeeperUtils.setPath(watchedEvent.getPath()).getData();
                                dataChars = new char[dataBytes.length];
                                for (int i = 0; i < dataBytes.length; i++) {
                                    dataChars[i] = (char) dataBytes[i];
                                }
                                data = String.valueOf(dataChars);
                                System.out.println("创建节点: path=" + watchedEvent.getPath() + " data:" + data);
                                break;

                            case NodeDataChanged: //修改当前节点数据激发
                                dataBytes = zookeeperUtils.setPath(watchedEvent.getPath()).getData();
                                dataChars = new char[dataBytes.length];
                                for (int i = 0; i < dataBytes.length; i++) {
                                    dataChars[i] = (char) dataBytes[i];
                                }
                                data = String.valueOf(dataChars);
                                System.out.println("修改节点数据: path=" + watchedEvent.getPath() + " data:" + data);
                                break;


                            case NodeChildrenChanged: //删除子节点的时候会激发,修改子节点数据不激发
                                System.out.println("子节点修改: path=" + watchedEvent.getPath() + " data:" + data);
                                break;

                            case NodeDeleted: //删除的时候应该取消监听否则看能导致重复监听
                                System.out.println("删除节点: path=" + watchedEvent.getPath());
                                break;

                            default:
                                break;
                        }

                        if(eventType.equals(NodeDeleted))
                        {
                            zookeeperUtils.getZooKeeper().exists(path, false);
                        }
                        else {
                            zookeeperUtils.getZooKeeper().exists(path, true);
                        }
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            finally {
//                countDownLatch.countDown();
            }

            System.out.println("---------------------------------------------");
            System.out.println("");
        }
    };




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

        //设置林权限创建节点 修改数据
        testAuthCreateSetData();

        //没有权限修改数据 会报异常
//        testNotAuthGetData();

        TimeUnit.SECONDS.sleep(120);
    }

    /**
     * 测试用权限 创建和修改数据
     * @throws KeeperException
     * @throws InterruptedException
     * @throws IOException
     */
    private static void testAuthCreateSetData() throws KeeperException, InterruptedException, IOException, NoSuchAlgorithmException {

        System.out.println("1. init");
        zookeeperUtils = initZookeeperUtils();

        //设置权限(创建的时候使用的权限)
        List<ACL> acls = new ArrayList<ACL>();
        ACL aclAll = new ACL(ZooDefs.Perms.ALL, new Id("digest", DigestAuthenticationProvider.generateDigest("xlj:20060619Csj")));
        acls.add(aclAll);
        zookeeperUtils.setAcls(acls);

        //初始化的时候使用的权限
        List<Id> ids = new ArrayList<Id>();
        Id idAll = new Id("digest", "xlj:20060619Csj");
        ids.add(idAll);
        zookeeperUtils.setIds(ids);

        zookeeperUtils.doInitZookeeper();
        Thread.sleep(2 * 1000);


        try {
            System.out.println("2. deleteall");
            //删除所有数据
            deleteAll(zookeeperUtils.getZooKeeper(), basePath);
            Thread.sleep(5 * 1000);
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
        finally {
            initZookeeperUtils();
        }


        //添加一个根节点(根节点不能是 /root, 会有异常 应该是保留关键字)
        //修改根节点的数据
        try{
            zookeeperUtils.setPath(basePath).setData("xlj".getBytes());

            System.out.println("3. exists: " + basePath);
            zookeeperUtils.doAddListener();
            Thread.sleep(5 * 1000);

            System.out.println("4. add persistent: " + basePath);
            zookeeperUtils.doCreatePERSISTENT(false);
            Thread.sleep(5 * 1000);

            System.out.println("4.1. change data persistent: 123 " + basePath);
            zookeeperUtils.setData("123".getBytes());
            zookeeperUtils.doChangeData();
            Thread.sleep(5 * 1000);
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
        finally {
            initZookeeperUtils();
        }


        //创建一个永久节点
        //修改永久节点的数据
        try {
            System.out.println("5. add persistent: " + basePath + "/xlj_PERSISTENT");
            zookeeperUtils.setPath(basePath + "/xlj_PERSISTENT").setData("xlj_PERSISTENT".getBytes()).doCreatePERSISTENT(true);
            Thread.sleep(5 * 1000);

            System.out.println("5.1. change data persistent: 234 " + basePath);
            zookeeperUtils.setData("234".getBytes());
            zookeeperUtils.doChangeData();
            Thread.sleep(5 * 1000);

            System.out.println("5.2. change data persistent: 345 " + basePath);
            zookeeperUtils.setData("345".getBytes());
            zookeeperUtils.doChangeData();
            Thread.sleep(5 * 1000);

        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
        finally {
            initZookeeperUtils();
        }


        //创建一个永久有序节点
        try {
            System.out.println("6. add persistent sequential: " + basePath+ "/xlj_PERSISTENTSEQUENTIAL");
            zookeeperUtils.setPath(basePath + "/xlj_PERSISTENTSEQUENTIAL").setData("xlj_PERSISTENTSEQUENTIAL".getBytes()).doCreatePERSISTENTSEQUENTIAL(true);
            Thread.sleep(5 * 1000);
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
        finally {
            initZookeeperUtils();
        }


        //创建一个临时节点
        try
        {
            System.out.println("7. add ephemeral: " + basePath + "/xlj_EPHEMERAL");
            zookeeperUtils.setPath(basePath + "/xlj_EPHEMERAL").setData("xlj_EPHEMERAL".getBytes()).doCreateEPHEMERAL(true);
            Thread.sleep(5 * 1000);
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
        finally {
            initZookeeperUtils();
        }


        //创建一个临时有序节点
        try
        {
            System.out.println("8. add ephemeral sequential: " + basePath + "/xlj_EPHEMERALSEQUENTIAL");
            zookeeperUtils.setPath(basePath + "/xlj_EPHEMERALSEQUENTIAL").setData("xlj_EPHEMERALSEQUENTIAL".getBytes()).doCreateEPHEMERALSEQUENTIAL(true);
            Thread.sleep(5 * 1000);
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
        finally {
            initZookeeperUtils();
        }
    }

    /**
     * 测试无权限操作
     */
    private static void testNotAuthGetData() throws IOException, KeeperException, InterruptedException {

        System.out.println("1. init");
        zookeeperUtils2 = initZookeeperUtils();
        zookeeperUtils2.doInitZookeeper();
        Thread.sleep(2 * 1000);

        System.out.println("2. get data: ");
        System.out.println(zookeeperUtils2.setPath(basePath).getData().toString());

    }

    /**
     * 初始化
     * @throws IOException
     */
    public static ZookeeperUtils initZookeeperUtils() throws IOException {
         return ZookeeperUtils.getZookeeperUtils().setConnectionString("127.0.0.1:2181").setWatcher(watcher);
    }

    /**
     * 删除所有节点(递归删除)
     * @param zooKeeper
     * @param path
     * @throws KeeperException
     * @throws InterruptedException
     */
    public static void deleteAll(ZooKeeper zooKeeper, String path) throws KeeperException, InterruptedException {
        //判断节点是否存在
        Stat stat = zooKeeper.exists(path, true);

        //zookeeper 默认配置的节点不删除
        if(path == "/zookeeper" || stat == null)
        {
            return;
        }

        List<String> childrens = zooKeeper.getChildren(path, true);

        for(String child : childrens) {
            deleteAll(zooKeeper, path + "/" + child);
        }

        zooKeeper.delete(path, -1);
    }

}

第二个类:

package com.xlj.zookeeper.jdk;

import org.apache.zookeeper.*;
import org.apache.zookeeper.data.ACL;
import org.apache.zookeeper.data.Id;
import org.apache.zookeeper.data.Stat;

import java.io.IOException;
import java.util.List;

public class ZookeeperUtils {

    //链接字符串(192.168.0.1:2181,192.168.0.2:2181)
    private String connectionString = "";

    //当前操作的路径
    private String path = "";

    //创建时候写入的内容
    private byte[] data = null;

    //事件监听器
    private Watcher watcher = null;

    //当前 zookeeper
    private ZooKeeper zooKeeper = null;

    //链接超时时间
    private int timeOut = 60 * 1000;

    //权限(创建的需要该参数 该参数的 每一个对象中的 id 对象的 id值都需要经过 DigestAuthenticationProvider.generateDigest("user:pwd") 传入)
    private List<ACL> acls = null;

    //初始化 zookeeper 之后设置权限的时候使用
    private List<Id> ids = null;

    public List<ACL> getAcls() {
        return acls;
    }

    public ZookeeperUtils setAcls(List<ACL> acls) {
        this.acls = acls;
        return  this;
    }

    public static ZookeeperUtils getZookeeperUtils()
    {
        return new ZookeeperUtils();
    }

    public ZookeeperUtils setConnectionString(String connectionString) {
        this.connectionString = connectionString;
        return this;
    }

    public ZookeeperUtils setPath(String path) {
        this.path = path;
        return this;
    }

    public ZookeeperUtils setData(byte[] data) {
        this.data = data;
        return this;
    }

    public ZookeeperUtils setWatcher(Watcher watcher) {
        this.watcher = watcher;
        return this;
    }

    public List<Id> getIds() {
        return ids;
    }

    public ZookeeperUtils setIds(List<Id> ids) {
        this.ids = ids;
        return  this;
    }

    public ZookeeperUtils doInitZookeeper() throws IOException {
        this.zooKeeper = new ZooKeeper(this.connectionString, this.timeOut, this.watcher);
        if(this.acls != null) {
            for (Id id : this.ids) {
                this.zooKeeper.addAuthInfo(
                        id.getScheme(),

                        id.getId().getBytes());
            }
        }
        return this;
    }

    /**
     * 获取数据
     * @return
     * @throws KeeperException
     * @throws InterruptedException
     */
    public byte[] getData() throws KeeperException, InterruptedException {
        return this.zooKeeper.getData(this.path, this.watcher, new Stat());
    }

    /**
     * 添加监控
     * 如果节点不存在则会激发 watcher 的 process, 且生效监听
     * state: SyncConnected
     * type: None
     * path: null
     *
     * 如果节点存在则不会激发 watcher 的 process
     */
    public ZookeeperUtils doAddListener() throws KeeperException, InterruptedException {
        this.zooKeeper.exists(this.path, true);
        return this;
    }

    /**
     * 创建临时
     * @return 创建出来的节点
     */
    public String doCreateEPHEMERAL(boolean addListener) throws KeeperException, InterruptedException, IOException {

        if(addListener)
        {
            this.doAddListener();
        }

        String path = this.zooKeeper.create(this.path, this.data,
                (this.acls == null || this.acls.size() == 0)? (List<ACL>) ZooDefs.Ids.ANYONE_ID_UNSAFE : this.acls,
                CreateMode.EPHEMERAL);
        this.zooKeeper.getData(this.path, true, new Stat());
        return path;
    }

    /**
     * 创建永久
     * @return 创建出来的节点
     */
    public String doCreatePERSISTENT(boolean addListener) throws KeeperException, InterruptedException, IOException {

        if(addListener)
        {
            this.doAddListener();
        }

        String path = this.zooKeeper.create(this.path, this.data,
                (this.acls == null || this.acls.size() == 0)? (List<ACL>) ZooDefs.Ids.ANYONE_ID_UNSAFE : this.acls,
                CreateMode.PERSISTENT);
        return path;
    }

    /**
     * 临时有序
     * 不会揭发 watcher 的 process
     * @return 创建出来的节点
     */
    public String doCreateEPHEMERALSEQUENTIAL(boolean addListener) throws KeeperException, InterruptedException, IOException {

        if(addListener)
        {
            this.doAddListener();
        }

        String path = this.zooKeeper.create(this.path, this.data,
                (this.acls == null || this.acls.size() == 0)? (List<ACL>) ZooDefs.Ids.ANYONE_ID_UNSAFE : this.acls,
                CreateMode.EPHEMERAL_SEQUENTIAL);
        return path;
    }

    /**
     * 永久有序
     * 不会揭发 watcher 的 process
     * @return 创建出来的节点
     */
    public String doCreatePERSISTENTSEQUENTIAL(boolean addListener) throws KeeperException, InterruptedException, IOException {

        if(addListener)
        {
            this.doAddListener();
        }

        String path = this.zooKeeper.create(this.path, this.data,
                (this.acls == null || this.acls.size() == 0)? (List<ACL>) ZooDefs.Ids.ANYONE_ID_UNSAFE : this.acls,
                CreateMode.PERSISTENT_SEQUENTIAL);

        return path;
    }

    /**
     * 提交数据修改
     * @throws KeeperException
     * @throws InterruptedException
     */
    public void doChangeData() throws KeeperException, InterruptedException {
        this.zooKeeper.setData(this.path, this.data, -1);
    }

    /**
     * 删除当前路径
     * @throws KeeperException
     * @throws InterruptedException
     */
    public void doDelete() throws KeeperException, InterruptedException {
        this.zooKeeper.delete(this.path, -1);
    }

    public ZooKeeper getZooKeeper() {
        return zooKeeper;
    }

}