ZooKeeper API操作

最新推荐文章于 2024-07-23 16:30:52 发布
最新推荐文章于 2024-07-23 16:30:52 发布
阅读量1.1k 收藏
点赞数 1
分类专栏： Zookeeper Java Core 文章标签： zookeeper api
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/john_f_lau/article/details/50639560
版权

ZooKeeper集群中，客户端可以对ZooKeeper的命名空间写入数据，对数据进行各种操作。ZooKeeper API 接口如下表所示：

操作接口名称 描述
create 创建指定的ZooKeeper命名空间（PATH）数据。
delete 创建指定的ZooKeeper命名空间（PATH）数据。
exists 检测节点是否存在
getChildren 获取节点孩子列表
getData 获取指定节点数据
setData 设置指定节点的数据
getACL 获取节点的ACL
setACL 设置节点的ACL
sync 同步一个客户视图到ZooKeeper中

1.4.1 增删改查

给指定ZooKeeper命名空间创建节点，你可以扩展ZooKeeper类。你可以定义类ZooKeeperRetry，然后定义构造方法。

/**
 * @param connectString ZooKeeper‘s host and port 字符串表达 
 * @param sessionTimeout 连接超时时间
 * @param watcher    观察者对象
 * @throws IOException
 */
public ZooKeeperRetry(String connectString, int sessionTimeout,
        Watcher watcher) throws IOException {
    super(connectString, sessionTimeout, watcher);
    this.watcher = watcher;
}

复写ZooKeeper类的方法。对于添加操作API，复写对应的create方法，定义个性化地创建节点操作。

@Override
public String create(String path, byte[] data, List<ACL> acl,
        CreateMode createMode) throws KeeperException, InterruptedException {
    int count = 0;
    do {
        try {
            return super.create(path, data, acl, createMode);
        } catch (KeeperException.ConnectionLossException e) {
            LoggerFactory.getLogger().warn(
                    "ZooKeeper connection lost.  Trying to reconnect.");
            if (exists(path, false) != null) {
                return path;
            }
        } catch (KeeperException.NodeExistsException e) {
            return path;
        }
    } while (!closed && (limit == -1 || count++ < limit));
    return null;
}

对于修改操作，使用创建方法去完成更新，即存在的节点内容被新节点信息所覆盖。对于删除操作，直接复写ZooKeeper的delete方法，下面的代码实现了删除节点操作。如果操作失败，它会自动重复尝试3次，直到成功为止。

/**
 *
 * @param path
 *                the path of the node to be deleted.
 * @param version
 *                the expected node version.
 * @throws InterruptedException
 * @throws KeeperException
 */
@Override
public void delete(String path, int version) throws InterruptedException,
        KeeperException {
    int count = 0;
    do {
        try {
            super.delete(path, version);
        } catch (KeeperException.ConnectionLossException e) {
            LoggerFactory.getLogger().warn(
                    "ZooKeeper connection lost.  Trying to reconnect.");
            if (exists(path, false) == null) {
                return;
            }
        } catch (KeeperException.NoNodeException e) {
            break;
        }
    } while (!closed && (limit == -1 || count++ < limit));
}

为了加深理解，下面将给一个例子。
建立一个maven项目，添加下面的maven依赖配置。

<dependency>
  <groupId>org.apache.curator</groupId>
  <artifactId>curator-framework</artifactId>
  <version>2.9.1</version>
</dependency>
<dependency>
  <groupId>org.apache.curator</groupId>
  <artifactId>curator-recipes</artifactId>
  <version>2.9.1</version>
</dependency>
  <dependency>
      <groupId>org.apache.curator</groupId>
      <artifactId>curator-client</artifactId>
      <version>2.9.1</version>
  </dependency>

<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>3.8.1</version>
  <scope>test</scope>
</dependency>
<dependency>
  <groupId>log4j</groupId>
  <artifactId>log4j</artifactId>
  <version>1.2.15</version>
  <exclusions>
    <exclusion>
      <groupId>javax.mail</groupId>
      <artifactId>mail</artifactId>
    </exclusion>
    <exclusion>
      <groupId>javax.jms</groupId>
      <artifactId>jms</artifactId>
    </exclusion>
    <exclusion>
      <groupId>com.sun.jdmk</groupId>
      <artifactId>jmxtools</artifactId>
    </exclusion>
    <exclusion>
      <groupId>com.sun.jmx</groupId>
      <artifactId>jmxri</artifactId>
    </exclusion>
  </exclusions>
</dependency>
<dependency>
  <groupId>org.apache.zookeeper</groupId>
  <artifactId>zookeeper</artifactId>
  <version>3.4.6</version>
  <exclusions>
    <exclusion>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
    </exclusion>
  </exclusions>
</dependency>
<dependency>
  <groupId>org.testng</groupId>
  <artifactId>testng</artifactId>
  <version>6.9.6</version>
</dependency>

定义ZooKeeper的扩展类ZooKeeperRobot类，文件代码如下所示：

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.ACL;
import org.apache.zookeeper.data.Stat;
import org.apache.zookeeper.inspector.logger.LoggerFactory;

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

/**
 * A Class which extends {@link ZooKeeper} and will automatically retry calls to
 * zookeeper if a {@link KeeperException.ConnectionLossException} occurs
 */
public class ZooKeeperRobot extends ZooKeeper {

    private boolean closed = false;
    private final Watcher watcher;
    private int limit = -1;

    /**
     * @param connectString ZooKeeper‘s host and port 字符串表达
     * @param sessionTimeout 连接超时时间
     * @param watcher    观察者对象
     * @throws IOException
     */
    public ZooKeeperRobot(String connectString, int sessionTimeout,
                          Watcher watcher) throws IOException {
        super(connectString, sessionTimeout, watcher);
        this.watcher = watcher;
    }

    /**
     * @param connectString
     * @param sessionTimeout
     * @param watcher
     * @param sessionId
     * @param sessionPasswd
     * @throws IOException
     */
    public ZooKeeperRobot(String connectString, int sessionTimeout,
                          Watcher watcher, long sessionId, byte[] sessionPasswd)
            throws IOException {
        super(connectString, sessionTimeout, watcher, sessionId, sessionPasswd);
        this.watcher = watcher;
    }

    @Override
    public synchronized void close() throws InterruptedException {
        this.closed = true;
        super.close();
    }

    /**
     *      * @param path
     *                the path for the node
     * @param data
     *                the initial data for the node
     * @param acl
     *                the acl for the node
     * @param createMode
     *                specifying whether the node to be created is ephemeral
     *                and/or sequential
     * @return the actual path of the created node
     * @throws KeeperException
     * @throws InterruptedException
     */
    @Override
    public String create(String path, byte[] data, List<ACL> acl,
            CreateMode createMode) throws KeeperException, InterruptedException {
        int count = 0;
        do {
            try {
                return super.create(path, data, acl, createMode);
            } catch (KeeperException.ConnectionLossException e) {
                LoggerFactory.getLogger().warn(
                        "ZooKeeper connection lost.  Trying to reconnect."+e.getMessage());
                if (exists(path, false) != null) {
                    return path;
                }
            } catch (KeeperException.NodeExistsException e) {
                LoggerFactory.getLogger().warn(
                        "NodeExistsException:."+e.getMessage());
                return path;
            }catch(KeeperException.NoNodeException e){
                LoggerFactory.getLogger().warn(
                        "NoNodeException:."+e.getMessage());
                return path;
            }
        } while (!closed && (limit == -1 || count++ < limit));
        return null;
    }


    /**
     *      * @param path
     *                the path for the node
     * @param data
     *                the initial data for the node
     * @param acl
     *                the acl for the node
     * @param createMode
     *                specifying whether the node to be created is ephemeral
     *                and/or sequential
     * @return the actual path of the created node
     * @throws KeeperException
     * @throws InterruptedException
     */
    public String createPersistent(String path, byte[] data, List<ACL> acl,
                         CreateMode createMode) throws KeeperException, InterruptedException {
        int count = 0;
        String[] partsPath = path.split("/");
        int checkSize = partsPath.length - 1;
        for(int i = 0; i< checkSize; i++){
            String prefixMark = "";
            for(int j = 0; j <= i; j++){
                prefixMark += partsPath[j] + "/";
            }
            if(prefixMark.length() != 1){
                prefixMark = prefixMark.substring(0, prefixMark.length()-1);
                if(exists(prefixMark, false) == null){
                    LoggerFactory.getLogger().warn("create namespace: " + super.create(prefixMark, "".getBytes(), acl, createMode));
                }
            }
        }
        do {
            try {
                return super.create(path, data, acl, createMode);
            } catch (KeeperException.ConnectionLossException e) {
                LoggerFactory.getLogger().warn(
                        "ZooKeeper connection lost.  Trying to reconnect."+e.getMessage());
                if (exists(path, false) != null) {
                    return path;
                }
            } catch (KeeperException.NodeExistsException e) {
                LoggerFactory.getLogger().warn(
                        "NodeExistsException:."+e.getMessage());
                return path;
            }catch(KeeperException.NoNodeException e){
                LoggerFactory.getLogger().warn(
                        "NoNodeException:."+e.getMessage());
            }
        } while (!closed && (limit == -1 || count++ < limit));
        return null;
    }
    /**
     *
     * @param path
     *                the path of the node to be deleted.
     * @param version
     *                the expected node version.
     * @throws InterruptedException
     * @throws KeeperException
     */
    @Override
    public void delete(String path, int version) throws InterruptedException,
            KeeperException {
        int count = 0;
        do {
            try {
                super.delete(path, version);
            } catch (KeeperException.ConnectionLossException e) {
                LoggerFactory.getLogger().warn(
                        "ZooKeeper connection lost.  Trying to reconnect.");
                if (exists(path, false) == null) {
                    return;
                }
            } catch (KeeperException.NoNodeException e) {
                break;
            }
        } while (!closed && (limit == -1 || count++ < limit));
    }

    @Override
    public Stat exists(String path, boolean watch) throws KeeperException,
            InterruptedException {
        int count = 0;
        do {
            try {
                return super.exists(path, watch ? watcher : null);
            } catch (KeeperException.ConnectionLossException e) {
                LoggerFactory.getLogger().warn(
                        "ZooKeeper connection lost.  Trying to reconnect.");
            }
        } while (!closed && (limit == -1 || count++ < limit));
        return null;
    }

    @Override
    public Stat exists(String path, Watcher watcher) throws KeeperException,
            InterruptedException {
        int count = 0;
        do {
            try {
                return super.exists(path, watcher);
            } catch (KeeperException.ConnectionLossException e) {
                LoggerFactory.getLogger().warn(
                        "ZooKeeper connection lost.  Trying to reconnect.");
            }
        } while (!closed && (limit == -1 || count++ < limit));
        return null;
    }

    @Override
    public List<ACL> getACL(String path, Stat stat) throws KeeperException,
            InterruptedException {
        int count = 0;
        do {
            try {
                return super.getACL(path, stat);
            } catch (KeeperException.ConnectionLossException e) {
                LoggerFactory.getLogger().warn(
                        "ZooKeeper connection lost.  Trying to reconnect.");
            }
        } while (!closed && (limit == -1 || count++ < limit));
        return null;
    }

    @Override
    public List<String> getChildren(String path, boolean watch)
            throws KeeperException, InterruptedException {
        int count = 0;
        do {
            try {
                return super.getChildren(path, watch ? watcher : null);
            } catch (KeeperException.ConnectionLossException e) {
                LoggerFactory.getLogger().warn(
                        "ZooKeeper connection lost.  Trying to reconnect.");
            }
        } while (!closed && (limit == -1 || count++ < limit));
        return new ArrayList<String>();
    }

    @Override
    public List<String> getChildren(String path, Watcher watcher)
            throws KeeperException, InterruptedException {
        int count = 0;
        do {
            try {
                return super.getChildren(path, watcher);
            } catch (KeeperException.ConnectionLossException e) {
                LoggerFactory.getLogger().warn(
                        "ZooKeeper connection lost.  Trying to reconnect.");
            }
        } while (!closed && (limit == -1 || count++ < limit));
        return new ArrayList<String>();
    }

    @Override
    public byte[] getData(String path, boolean watch, Stat stat)
            throws KeeperException, InterruptedException {
        int count = 0;
        do {
            try {
                return super.getData(path, watch ? watcher : null, stat);
            } catch (KeeperException.ConnectionLossException e) {
                LoggerFactory.getLogger().warn(
                        "ZooKeeper connection lost.  Trying to reconnect.");
            }
        } while (!closed && (limit == -1 || count++ < limit));
        return null;
    }

    @Override
    public byte[] getData(String path, Watcher watcher, Stat stat)
            throws KeeperException, InterruptedException {
        int count = 0;
        do {
            try {
                return super.getData(path, watcher, stat);
            } catch (KeeperException.ConnectionLossException e) {
                LoggerFactory.getLogger().warn(
                        "ZooKeeper connection lost.  Trying to reconnect.");
            }
        } while (!closed && (limit == -1 || count++ < limit));
        return null;
    }

    @Override
    public Stat setACL(String path, List<ACL> acl, int version)
            throws KeeperException, InterruptedException {
        int count = 0;
        do {
            try {
                return super.setACL(path, acl, version);
            } catch (KeeperException.ConnectionLossException e) {
                LoggerFactory.getLogger().warn(
                        "ZooKeeper connection lost.  Trying to reconnect.");
                Stat s = exists(path, false);
                if (s != null) {
                    if (getACL(path, s).equals(acl)) {
                        return s;
                    }
                } else {
                    return null;
                }
            }
        } while (!closed && (limit == -1 || count++ < limit));
        return null;
    }

    @Override
    public Stat setData(String path, byte[] data, int version)
            throws KeeperException, InterruptedException {
        int count = 0;
        do {
            try {
                return super.setData(path, data, version);
            } catch (KeeperException.ConnectionLossException e) {
                LoggerFactory.getLogger().warn(
                        "ZooKeeper connection lost.  Trying to reconnect.");
                Stat s = exists(path, false);
                if (s != null) {
                    if (getData(path, false, s) == data) {
                        return s;
                    }
                } else {
                    return null;
                }
            }
        } while (!closed && (limit == -1 || count++ < limit));
        return null;
    }

    /**
     * @param limit
     */
    public void setRetryLimit(int limit) {
        this.limit = limit;
    }

    /**
     * @return true if successfully connected to zookeeper
     */
    public boolean testConnection() {
        int count = 0;
        do {
            try {
                return super.exists("/", null) != null;
            } catch (Exception e) {
                LoggerFactory.getLogger().warn(
                        "ZooKeeper connection lost.  Trying to reconnect.");
            }
        } while (count++ < 3);
        return false;
    }

}

对于的测试类ZooKeeperRobotTest。


import org.apache.zookeeper.*;
import org.apache.zookeeper.data.ACL;
import org.apache.zookeeper.data.Stat;
import org.testng.Assert;
import org.testng.annotations.Test;

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


/**
 * @author elite_jigang@163.com
 */
public class ZooKeeperRobotTest {

    private final static String ZOO_KEEPER_ADDRESS = "192.168.115.15:2222,192.168.115.2:2222,192.168.115.20:2222";
    private boolean connected = true;

    private ZooKeeper zooKeeper;

    @Test
    public void testCreatePersistent() throws IOException, KeeperException, InterruptedException {
        zooKeeper= new ZooKeeperRobot(ZOO_KEEPER_ADDRESS, 3000, new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                if (event.getState() == Event.KeeperState.Expired) {
                    connected = false;
                }
            }
        });
        ((ZooKeeperRobot)zooKeeper).setRetryLimit(3);
        System.out.println("connect to ZooKeeper servers : " + ((ZooKeeperRobot) zooKeeper).testConnection());
        String data = "HBase, SolrCloud,Kafka";
        String nodePath1  = "/root2/node_b";

        String[] partsPath = nodePath1.split("/");
        int checkSize = partsPath.length - 1;
        for(int i = 0; i< checkSize; i++){
            String prefixMark = "";
            for(int j = 0; j <= i; j++){
                prefixMark += partsPath[j] + "/";
            }
            if(prefixMark.length() != 1){
                prefixMark = prefixMark.substring(0, prefixMark.length()-1);
                Stat stat = ((ZooKeeperRobot)zooKeeper).exists(prefixMark, false);
                if(stat == null){
                    ((ZooKeeperRobot)zooKeeper).create(prefixMark, "12333333".getBytes(),
                            ZooDefs.Ids.OPEN_ACL_UNSAFE,
                            CreateMode.PERSISTENT);
                }
            }
        }
        Stat stat = ((ZooKeeperRobot)zooKeeper).exists(nodePath1, null);
        if(stat == null){
            String result1 = ((ZooKeeperRobot)zooKeeper).createPersistent(nodePath1,
                    data.getBytes(),
                    ZooDefs.Ids.OPEN_ACL_UNSAFE,
                    CreateMode.PERSISTENT);
            System.out.println("-------" + result1);
            Assert.assertEquals(result1, nodePath1);
        }
        System.out.println("-------");

        ((ZooKeeperRobot)zooKeeper).close();
    }
    @org.testng.annotations.Test
    public void testCreatePersistentNode1() throws Exception {
        ZooKeeper zooKeeper= new ZooKeeperRobot(
                                      ZOO_KEEPER_ADDRESS, 3000, new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                if (event.getState() == Event.KeeperState.Expired) {
                    connected = false;
                }
            }
        });
        ((ZooKeeperRobot)zooKeeper).setRetryLimit(3);
        System.out.println("connect to ZooKeeper servers : " + ((ZooKeeperRobot) zooKeeper).testConnection());
        String data = "HBase, SolrCloud,Kafka";
        String nodePath1  = "/root/node_b";
        String firstPath2 = "/root";
        String result1 = ((ZooKeeperRobot)zooKeeper).create(firstPath2,
                "123".getBytes(),
                ZooDefs.Ids.OPEN_ACL_UNSAFE,
                CreateMode.PERSISTENT);
        System.out.println("-------" + result1);
        Assert.assertEquals(result1, firstPath2);

        Stat stat = ((ZooKeeperRobot)zooKeeper).exists(nodePath1, null);
        if(stat == null){
            result1 = ((ZooKeeperRobot)zooKeeper).create(firstPath2,
                    data.getBytes(),
                    ZooDefs.Ids.OPEN_ACL_UNSAFE,
                    CreateMode.PERSISTENT);
            System.out.println("-------" + result1);
            Assert.assertEquals(result1, nodePath1);
        }
        System.out.println("-------");

        ((ZooKeeperRobot)zooKeeper).close();
    }

    @org.testng.annotations.Test
    public void testDelete() throws Exception {

        zooKeeper= new ZooKeeperRobot(ZOO_KEEPER_ADDRESS, 3000, new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                if (event.getState() == Event.KeeperState.Expired) {
                    connected = false;
                }
            }
        });
        ((ZooKeeperRobot)zooKeeper).setRetryLimit(3);
        System.out.println("connect to ZooKeeper servers : " + ((ZooKeeperRobot) zooKeeper).testConnection());
        String nodePath1  = "/root/node_b";
        String nodePath2  = "/root2/node_b";
        String nodePath3  = "/root";
        String nodePath4  = "/root2";

        ((ZooKeeperRobot)zooKeeper).delete(nodePath1, -1);
        ((ZooKeeperRobot)zooKeeper).delete(nodePath2, -1);
        ((ZooKeeperRobot)zooKeeper).delete(nodePath3, -1);
        ((ZooKeeperRobot)zooKeeper).delete(nodePath4, -1);
    }


    @org.testng.annotations.Test
    public void testGetACL() throws Exception {
        zooKeeper= new ZooKeeperRobot(ZOO_KEEPER_ADDRESS, 3000, new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                if (event.getState() == Event.KeeperState.Expired) {
                    connected = false;
                }
            }
        });
        ((ZooKeeperRobot)zooKeeper).setRetryLimit(3);
        System.out.println("connect to ZooKeeper servers : " + ((ZooKeeperRobot) zooKeeper).testConnection());
        String nodePath1  = "/root1/node_b";

        List<ACL> list = ((ZooKeeperRobot)zooKeeper).getACL(nodePath1, new Stat());
        for(ACL acl: list){
            System.out.println(" acl:"+ acl);
        }
    }

    @org.testng.annotations.Test
    public void testGetChildren() throws Exception {
        ZooKeeper zooKeeper = null;
        try {
            zooKeeper =
                    new ZooKeeperRobot(ZOO_KEEPER_ADDRESS,
                            3000,  // millisecond
                            new Watcher() {

                                @Override
                                public void process(WatchedEvent event) {
                                    if (event.getState() == Event.KeeperState.Expired) {
                                        connected = false;
                                    }
                                }
                            });
            ((ZooKeeperRobot) zooKeeper).setRetryLimit(3);
            connected  = ((ZooKeeperRobot)zooKeeper).testConnection();
            System.out.println(" connect to zookeeper : "+ connected);

            Stat stat = new Stat();
            String path = "/test";
            try {
                List<String> childs = zooKeeper.getChildren(path, false, stat);
                for(String node: childs){
                    System.out.println("\t"+ node);
                }
            } catch (KeeperException e) {
                e.printStackTrace();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @org.testng.annotations.Test
    public void testGetData() throws Exception {
        zooKeeper= new ZooKeeperRobot(ZOO_KEEPER_ADDRESS, 3000, new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                if (event.getState() == Event.KeeperState.Expired) {
                    connected = false;
                }
            }
        });
        ((ZooKeeperRobot)zooKeeper).setRetryLimit(3);
        System.out.println("connect to ZooKeeper servers : " + ((ZooKeeperRobot) zooKeeper).testConnection());
        String nodePath1  = "/root1/node_b";

        System.out.println("----"+ new String(((ZooKeeperRobot) zooKeeper).getData(nodePath1, false, new Stat())));
    }


    @org.testng.annotations.Test
    public void testSetACL() throws Exception {

    }

    @org.testng.annotations.Test
    public void testSetData() throws Exception {
        zooKeeper= new ZooKeeperRobot(ZOO_KEEPER_ADDRESS, 3000, new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                if (event.getState() == Event.KeeperState.Expired) {
                    connected = false;
                }
            }
        });
        ((ZooKeeperRobot)zooKeeper).setRetryLimit(3);
        System.out.println("connect to ZooKeeper servers : " + ((ZooKeeperRobot) zooKeeper).testConnection());
        String nodePath1  = "/root1/node_b";

        System.out.println("----"+ ((ZooKeeperRobot) zooKeeper).setData(nodePath1, "2222222".getBytes(), -1));
        System.out.println("*****" + new String(((ZooKeeperRobot) zooKeeper).getData(nodePath1, false, new Stat())));
    }

}

欢迎关注我的微信公众号
weixing

钛合金编程
关注
专栏目录
zookeeper API基本操作及简单案例
窃格拉瓦
08-20 483
一、基本操作 1、IDEA 环境搭建 maven： 创建maven项目，添加maven依赖： &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSc...
zookeeper API操作，基本命令及报错
Hello World
07-20 2062
API ZooKeeper API 中，有两个包是我们经常打交道的，分别是 org.apache.zookeeper， org.apache.zookeeper.data 。前一个包提供了一些API操作zk，例如对节点node增删改查，后一个包定义了一些实体类，例如对zk 节点进行权限控制的ACL类、Id类等。zk常用的API如下。 创建会话 ZooKeeper(String conn...
Zookeeper的API操作
weixin_45316851的博客
07-01 391
Java API操作 6.1 原生 API 1）Maven依赖 <!-- https://mvnrepository.com/artifact/org.apache.zookeeper/zookeeper --> <dependency> <groupId>org.apache.zookeeper</groupId> <artifactId>zookeeper</artifac
【zookeeper】zookeeper的 ACL权限学习
最新发布
Mrerlou的博客
07-23 292
ZooKeeper使用ACL来控制对其znodeZooKeeper数据树的数据节点）的访问。ACL实现与UNIX文件访问权限非常相似：它使用权限位来允许/禁止针对节点及其所应用范围的各种操作。与标准UNIX权限不同，ZooKeeper节点不受用户（文件所有者）、组和环境（其他）的三个标准范围的限制。ZooKeeper没有znode所有者的概念。而是，ACL指定一组ID和与这些ID关联的权限。还请注意，ACL仅与特定的znode有关。特别是它不适用于子节点。例如，如果/app仅可被读取，并且。
【ZooKeeper Notes 3】ZooKeeper Java API 使用样例
weixin_33901926的博客
03-03 81
查看PDF版本 转载请注明：@ni掌柜 nileader@gmail.com ZooKeeper是一个分布式的，开放源码的分布式应用程序协调服务框架，包含一组简单的原语集合。通过这些原语言的组合使用，能够帮助我们解决更高层次的分布式问题，关于ZooKeeper的典型使用场景，请查看这个文章《ZooKeeper典型使用场景一览》 本文主要针对ZooKeeper提供的Java API，通过实际代...
Zookeeper的api使用
凉茶铺的博客
08-10 919
Zookeeper作为⼀个分布式框架，主要用来解决分布式⼀致性问题，它提供了简单的分布式原语，并且对多种编程语⾔提供了。服务端会向会话对应的客户端发送⼀个事件通知，以告知客户端，客户端只有在获取这个通知之后，才算真正建立了会话。理完客户端初始化工作后立即返回，在⼤多数情况下，此时并没有真正建立好⼀个可用的会话，在会话。Zookeeper类，他是我们编程时最常⽤的类文件。客户端和服务端会话的建立是⼀个异步的过程，也就是说在程序中，构造⽅法会在处。值，并且客户端将会周期性的向服务器端发送心跳来维持会话连接。..
ZookeeperAPI操作
互联网知识分享
07-19 239
在这段代码中，我们首先创建了一个新的多操作。然后，我们添加了几个操作到这个多操作中，包括检查一个节点的版本、创建一个新的节点，和设置一个节点的数据。这个装饰器接受一个节点的路径作为参数，然后返回一个新的装饰器，我们可以使用这个装饰器来装饰我们的回调函数。每当节点的数据发生变化时，Zookeeper就会调用我们的回调函数，并传入新的数据和节点的状态。需要注意的是，Zookeeper的所有操作都是原子的，如果操作失败，那么不会有部分效果。在这段代码中，我们调用了set()方法，并传入了节点的路径和新的值。
ZooKeeper API 异步操作教学
06-20
ZooKeeper API 是 Apache ZooKeeper 的一套应用程序接口，它允许开发者在其应用程序中使用 ZooKeeper 集群提供的服务。ZooKeeper 是一个开源的分布式协调服务，常用于分布式应用程序中，用于解决共识、同步、组管理...
zookeeper C API中文文档
12-19
Zookeeper C API 中文文档 Zookeeper C API 是 Zookeeper 的一个 C 语言实现，提供了一个简洁的 API，让开发者可以轻松地使用 Zookeeper 的功能。本文档将详细介绍 Zookeeper C API 的使用方法和相关知识点。 ...
Zookeeper 原生api zkClient Curator操作
09-30
在Java开发中，我们通常使用三种方式来操作Zookeeper：原生API、zkClient和Curator。接下来，我们将详细探讨这三种方式。 **一、Zookeeper原生API** Zookeeper提供了Java API，可以直接与Zookeeper服务器进行交互...
Zookeeper Api(java)入门与应用
06-21
zookeeper-api基础 ...通过监控这些数据状态的变化，从而可以达到基于数据的集群管理，后面将会详细介绍 Zookeeper 能够解决的一些典型问题，这里先介绍一下，Zookeeper 的操作接口和简单使用示例。
Zookeeper API操作
思变的博客
12-04 1345
pom引入： <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>RELEASE</version> </dependency> <depen
Zookeeper客户端API操作
weixin_47260194的博客
04-11 720
前提：保证 hadoop102、hadoop103、hadoop104 服务器上 Zookeeper 集群服务端启动。（对于自己的虚拟机服务器） IDEA环境搭建 1）创建一个工程：zookeeper 2）添加pom文件 <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>RELEA
Zookeeper 客户端 API 操作
weixin_45417821的博客
07-03 245
文章目录IDEA 环境搭建创建 ZooKeeper 客户端创建子节点获取子节点并监听节点变化判断 Znode 是否存在 前提：保证 Bigdata04、Bigdata05、Bigdata06服务器上 Zookeeper 集群服务端启动。 IDEA 环境搭建 1）创建一个工程：zookeeper 2）添加pom文件 <dependencies> <dependency> <groupId>junit</groupId> &
大数据之Zookeeper：API应用
weixin_43597208的博客
06-13 142
目录1.Eclipse环境搭建2.创建ZooKeeper客户端3.创建子节点4.获取子节点并监听节点变化5.判断Znode是否存在 1.Eclipse环境搭建 1．创建一个Maven工程 2．添加pom文件 <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>RELEAS
Zookeeper_客户端 API 操作
weixin_43955488的博客
02-01 1615
zookeeper客户端api操作
Donny的专栏
09-21 426
这里记录zookeeper java客户端api的使用。 客户端创建Zookeeper实例，然后调用这个类提供的方法与zookeeper服务器进行交互。 Zookeeper的构造函数有如下4种： ZooKeeper(connectString, sessionTimeout, watcher); ZooKeeper(connectString, sessionTimeout, watcher,ca...
Zookeeper（案例）的API操作—编程思维训练
potter
03-22 270
编程思维训练：package zookeeper1; import java.util.HashMap; import java.util.List; import java.util.Map; import org.apache.zookeeper.CreateMode; import org.apache.zookeeper.ZooDefs.Ids; import org.apache.zo...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值