5.zookeeper javaAPI

最新推荐文章于 2024-07-18 19:34:58 发布
最新推荐文章于 2024-07-18 19:34:58 发布
阅读量115 收藏
点赞数
分类专栏： zookeeper 文章标签： zookeeper java 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guachiqi2340/article/details/117049484
版权

znode是zooKeeper集合的核心组件，zookeeper API提供了一小组方法使用 zookeeper集合来操纵znode的所有细节。

客户端应该遵循以步骤，与zookeeper服务器进行清晰和干净的交互。

  • 连接到zookeeper服务器，zookeeper服务器为客户端分配会话ID（sessionId）。
  • 定期向服务器发送心跳。否则，zookeeper服务器将过期会话ID，客户端需要重新连接。
  • 只要会话ID处于活动状态，就可以获取/设置znode。
  • 所有任务完成后，断开与zookeeper服务器的连接。如果客户端长时间不活动，则zookeeper服务器将自动断开客户端。

maven依赖

<dependencies>
        <!--zookeeper核心依赖-->
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.6.2</version>
        </dependency>

        <!--junit测试工具依赖-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.1</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

zookeeper API

  1. ZooKeeper构造函数
public ZooKeeper(String connectString, int sessionTimeout, Watcher watcher);
  • connectString：连接到zookeeper主机，格式：ip + port。
  • sessionTimeout：会话超时时长，单位毫秒。
  • watcher：监视器对象。由于zookeeper API连接zookeeper服务是异步连接的，所以通过监控器来监听连接服务状态。
package com.huazai.zookeeper.zkexample.config;

import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;

import java.util.concurrent.CountDownLatch;

/**
 * @author pyh
 * @date 2021/5/19 0:20
 */
public class ZookeeperConnection {
    public static void main(String[] args) {
        connect();
    }

    public static ZooKeeper zooKeeper;

    public static ZooKeeper connect() {
        try {
            // 由于连接zookeeper服务器是异步连接，需要CountDownLatch阻塞主线程，等待子线程连接结果后反馈给主线程
            CountDownLatch countDownLatch = new CountDownLatch(1);
            /*
                connectString:服务器的ip和端口
                sessionTimeout:客户端与服务器之间的会话超时时间，以毫秒为单位的
                watcher：监视器对象
            */
            zooKeeper = new ZooKeeper("192.168.64.129:2181", 5000, new Watcher() {
                @Override
                public void process(WatchedEvent watchedEvent) {
                    if (watchedEvent.getState() == Event.KeeperState.SyncConnected) {
                        System.out.println("zookeeper异步连接成功");
                    } else if (watchedEvent.getState() == Event.KeeperState.Disconnected) {
                        System.out.println("断开连接");
                    } else if (watchedEvent.getState() == Event.KeeperState.Expired) {
                        System.out.println("会话超时");
                    } else if (watchedEvent.getState() == Event.KeeperState.AuthFailed) {
                        System.out.println("认证失败");
                    } else if (watchedEvent.getState() == Event.KeeperState.Closed) {
                        System.out.println("连接关闭");
                    }
                    countDownLatch.countDown();
                }
            });
            // 主线程阻塞等待连接对象的创建成功
            countDownLatch.await();
            // 会话编号
            System.out.println("客户端sessionId：" + zooKeeper.getSessionId());
            return zooKeeper;
        } catch (Exception e) {
            System.out.println("zookeeper连接异常");
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 关闭zookeeper会话
     */
    public static void close() {
        if (zooKeeper != null) {
            try {
                zooKeeper.close();
                System.out.println("zookeeper关闭成功");
            } catch (InterruptedException e) {
                System.out.println("zookeeper关闭失败");
                e.printStackTrace();
            }
        }
    }
}
  1. create新增节点方法
// 同步方法
public String create(final String path, byte[] data, List<ACL> acl, CreateMode createMode);

// 异步方法
public void create(final String path, byte[] data, List<ACL> acl, CreateMode createMode, StringCallback cb, Object ctx);
  • path：znode路径。例如，/node1 /node11/node111。
  • data：要存储在指定znode路径中的数据。
  • acl：要创建的节点的访问控制列表。zookeeper API提供了一个静态接口 ZooDefs.Ids 来获取一些基本的acl列表。例如，ZooDefs.Ids.OPEN_ACL_UNSAFE 返回开放的znode的acl列表。
  • createMode：节点的类型,这是一个枚举。
  • callBack：异步回调接口。
  • ctx：传递上下文参数。
    一共有create六个重载方法，其中带StringCallback形参的为异步新增节点方法，不带的为同步新增节点方法，其中三个为同步方法，三个异步方法。同步新增节点的重载方法返回值为成功创建节点后的路径。
package com.huazai.zookeeper.zkexample;

import com.huazai.zookeeper.zkexample.config.ZookeeperConnection;
import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.ACL;
import org.apache.zookeeper.data.Id;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

/**
 * @author pyh
 * @date 2021/5/19 0:53
 */
public class ZKCreate {
    private ZooKeeper zooKeeper;

    @Before
    public void before() {
        zooKeeper = ZookeeperConnection.connect();
    }

    /**
     * 测试同步新增节点方法
     *
     * @throws Exception
     */
    @Test
    public void createSync() throws Exception {
        /*
            path:节点的路径
            data:节点的数据
            acl:权限列表 world:anyone:cdrwa
            createMode:节点类型，持久化节点
         */
        String nodePath = zooKeeper.create("/createSync", "createSync".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        System.out.println(nodePath);   // /createSync
    }

    /**
     * 测试新增节点的自定义world授权模式权限列表
     *
     * @throws Exception
     */
    @Test
    public void createCustomAclForWorld() throws Exception {
        // 权限列表集合
        List<ACL> acls = new ArrayList<>();
        // 入参分别为授权模式和授权对象
        Id id = new Id("world", "anyone");

        // 权限列表
        acls.add(new ACL(ZooDefs.Perms.READ, id));  // world:anyone:r
        acls.add(new ACL(ZooDefs.Perms.WRITE, id)); // world:anyone:w
        String nodePath = zooKeeper.create("/createCustomAclForWorld", "createCustomAclForWorld".getBytes(), acls, CreateMode.PERSISTENT);
        System.out.println(nodePath);   // /createCustomAclForWorld
    }

    /**
     * 测试新增节点的自定义ip授权模式权限列表
     *
     * @throws Exception
     */
    @Test
    public void createCustomAclForIp() throws Exception {
        // 权限列表集合
        List<ACL> acls = new ArrayList<>();
        // 入参分别为授权模式和授权对象
        Id id = new Id("ip", "192.168.64.129");

        // 权限列表
        acls.add(new ACL(ZooDefs.Perms.ALL, id));  // ip:192.168.64.129:crdwa
        acls.add(new ACL(ZooDefs.Perms.WRITE, id)); // ip:192.168.64.129:w
        String nodePath = zooKeeper.create("/createCustomAclForId", "createCustomAclForId".getBytes(), acls, CreateMode.PERSISTENT);
        System.out.println(nodePath);   // /createCustomAclForWorld
    }

    /**
     * 测试新增节点的auth授权模式权限列表
     *
     * @throws Exception
     */
    @Test
    public void createAuth() throws Exception {
        // 添加授权用户
        zooKeeper.addAuthInfo("digest", "huazai:123456".getBytes());    // addauth digest huazai:123456
        /*
            若应用auth授权模式，必须使用CREATOR_ALL_ACL常量，不能使用OPEN_ACL_UNSAFE，
            因为CREATOR_ALL_ACL指定的是授权为auth，OPEN_ACL_UNSAFE指向的授权模式是world，底层源码中可以看到
         */
        String nodePath = zooKeeper.create("/createAuth", "createAuth".getBytes(),
                ZooDefs.Ids.CREATOR_ALL_ACL, CreateMode.PERSISTENT);
        System.out.println(nodePath);
    }

    /**
     * 测试新增节点的自定义auth授权模式权限列表
     *
     * @throws Exception
     */
    @Test
    public void createCustomAclForAuth() throws Exception {
        // 添加授权用户
        zooKeeper.addAuthInfo("digest", "huazai:123456".getBytes());    // addauth digest huazai:123456
        // 权限列表
        List<ACL> acls = new ArrayList<ACL>();
        // 授权模式和授权对象
        Id id = new Id("auth", "huazai");
        // 权限设置
        acls.add(new ACL(ZooDefs.Perms.READ, id));  // auth:huazai:r
        String nodePath = zooKeeper.create("/createCustomAclForAuth", "createCustomAclForAuth".getBytes(), acls, CreateMode.PERSISTENT);
        System.out.println(nodePath);
    }

    /**
     * 测试新增节点的自定义digest授权模式权限列表
     *
     * @throws Exception
     */
    @Test
    public void createCustomAclForDigest() throws Exception {
        // 权限列表
        List<ACL> acls = new ArrayList<ACL>();
        // 授权模式和授权对象
        // 密文生成格式：echo -n <user>:<password> | openssl dgst -binary -sha1 | openssl base64
        Id id = new Id("digest", "huazai:gb3+BhkHKjQhm0YiyONAAoQUKpc=");
        // 权限设置
        acls.add(new ACL(ZooDefs.Perms.ALL, id));   // digest:huazai:123456:crdwa
        String nodePath = zooKeeper.create("/createCustomAclForDigest", "createCustomAclForDigest".getBytes(), acls, CreateMode.PERSISTENT);
        System.out.println(nodePath);
    }

    /**
     * 测试新增持久化有序节点
     *
     * @throws Exception
     */
    @Test
    public void createPersistenSequential() throws Exception {
        // 创建节点同时指定权限，
        // 等价于：create -s /createPersistenSequential "createPersistenSequential" "world:anyone:crdwa"
        String nodePath = zooKeeper.create("/createPersistenSequential", "createPersistenSequential".getBytes(),
                ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT_SEQUENTIAL);
        // 成功创建后节点路径为带序号的节点路径，而不是自己指定的路径
        System.out.println(nodePath);
    }

    /**
     * 测试新增临时节点
     *
     * @throws Exception
     */
    @Test
    public void createEphemeral() throws Exception {
        // 创建节点同时指定权限，
        // 等价于：create -e /createEphemeral "createEphemeral" "world:anyone:crdwa"
        String nodePath = zooKeeper.create("/createEphemeral", "createEphemeral".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
        // 由于创建的是临时节点，只在当前会话有效，所以创建之后自己到虚拟机是查询不到该节点数据
        System.out.println(nodePath);
    }

    /**
     * 测试新增临时有序节点
     *
     * @throws Exception
     */
    @Test
    public void createEphemeralSequential() throws Exception {
        // 创建节点同时指定权限，
        // 等价于：create -e -s /createEphemeral "createEphemeral" "world:anyone:crdwa"
        String nodePath = zooKeeper.create("/createEphemeralSequential", "createEphemeralSequential".getBytes(),
                ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
        // 由于创建的是临时节点，只在当前会话有效，所以创建之后自己到虚拟机是查询不到该节点数据
        System.out.println(nodePath);
    }

    /**
     * 测试异步新增节点
     *
     * @throws Exception
     */
    @Test
    public void createAsync() throws Exception {
        zooKeeper.create("/createAsync", "createAsync".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT,
                new AsyncCallback.StringCallback() {
                    @Override
                    public void processResult(int rc, String path, Object ctx, String name) {
                        // 0 代表创建成功，状态码参考：org.apache.zookeeper.KeeperException.CodeDeprecated
                        System.out.println(rc);     // 0
                        // 节点的路径
                        System.out.println(path);   // /createAsync
                        // 节点路径
                        System.out.println(name);   // /createAsync
                        // 上下文对象
                        System.out.println(ctx);    // 我是上下文对象，在processResult回调方法中的ctx参数可以获取到我

                    }
                }, "我是上下文对象，在processResult回调方法中的ctx参数可以获取到我");

    }


    @After
    public void after() {
        ZookeeperConnection.close();
    }
}
  1. set设置节点数据
// 同步设置数据方法
public Stat setData(final String path, byte[] data, int version);

// 异步设置数据方法
public void setData(final String path, byte[] data, int version, StatCallback cb, Object ctx)
  • path：znode路径。
  • data：要存储在指定znode路径中的数据。
  • version：znode的当前版本，-1代表删除节点时不考虑版本信息。
  • cb：异步回调接口。
  • ctx：传递上下文参数。
package com.huazai.zookeeper.zkexample;

import com.huazai.zookeeper.zkexample.config.ZookeeperConnection;
import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

/**
 * @author pyh
 * @date 2021/5/21 0:18
 */
public class ZKSet {
    private ZooKeeper zooKeeper;

    @Before
    public void before() {
        zooKeeper = ZookeeperConnection.connect();
    }

    /**
     * 测试同步设置节点数据，如果乐观锁版本不匹配，则修改失败，抛出异常
     */
    @Test
    public void setSync() throws Exception {
        // path：节点的路径
        // data：节点数据
        // version：乐观锁版本，-1代表版本号不作为修改条件
        // set /setSync "test" -v 1
        Stat stat = zooKeeper.setData("/setSync", "test".getBytes(), 1);
        // 返回值数据等价于：stat /setSync
        System.out.println(stat);
    }

    /**
     * 测试异步设置节点数据，如果乐观锁版本不匹配，则修改失败，抛出异常
     *
     * @throws Exception
     */
    @Test
    public void setASync() throws Exception {
        // set /setASync "test" -v 1
        zooKeeper.setData("/setASync", "test".getBytes(), 0,
                new AsyncCallback.StatCallback() {
                    @Override
                    public void processResult(int rc, String path, Object ctx, Stat stat) {
                        // 0 代表创建成功，状态码参考：org.apache.zookeeper.KeeperException.CodeDeprecated
                        System.out.println(rc);     // 0
                        // 节点的路径
                        System.out.println(path);   // /setASync
                        // 上下文对象
                        System.out.println(ctx);    // 我是上下文对象，在processResult回调方法中的ctx参数可以获取到我
                        System.out.println(stat);    // stat /setASync
                    }
                }, "我是上下文对象，在processResult回调方法中的ctx参数可以获取到我");
    }

    @After
    public void after() {
        ZookeeperConnection.close();
    }
}
  1. delete删除节点
// 同步删除节点方法
public void delete(final String path, int version);

// 异步删除节点方法
public void delete(final String path, int version, VoidCallback cb, Object ctx);
  • path：znode路径。
  • version：znode的当前版本，-1代表删除节点时不考虑版本信息。
  • cb：异步回调接口。
  • ctx：传递上下文参数。
package com.huazai.zookeeper.zkexample;

import com.huazai.zookeeper.zkexample.config.ZookeeperConnection;
import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.ZooKeeper;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

/**
 * @author pyh
 * @date 2021/5/24 23:50
 */
public class ZKDelete {
    private ZooKeeper zooKeeper;

    @Before
    public void before() {
        zooKeeper = ZookeeperConnection.connect();
    }

    /**
     * 测试同步删除节点方法
     *
     * @throws Exception
     */
    @Test
    public void deleteSync() throws Exception {
        zooKeeper.delete("/hello", 0);
    }

    /**
     * 测试异步删除节点方法
     *
     * @throws Exception
     */
    @Test
    public void deleteAsync() throws Exception {
        zooKeeper.delete("/zk", 0, new AsyncCallback.VoidCallback() {
            @Override
            public void processResult(int rc, String path, Object ctx) {
                // 0 代表创建成功，状态码参考：org.apache.zookeeper.KeeperException.CodeDeprecated
                System.out.println(rc);     // 0
                // 节点的路径
                System.out.println(path);   // /hello
                // 上下文对象
                System.out.println(ctx);    // 我是上下文对象，在processResult回调方法中的ctx参数可以获取到我
            }
        }, "我是上下文对象，在processResult回调方法中的ctx参数可以获取到我");
    }

    @After
    public void after() {
        ZookeeperConnection.close();
    }
}
  1. get获取节点数据
// 同步获取节点数据方法
public byte[] getData(String path, boolean watch, Stat stat);
public byte[] getData(final String path, Watcher watcher, Stat stat);

// 异步获取节点数据方法
public void getData(String path, boolean watch, DataCallback cb, Object ctx);
public void getData(final String path, Watcher watcher, DataCallback cb, Object ctx);
  • path：znode路径。
  • watch：是否使用连接对象中注册的监视器。
  • watcher：监视器对象。
  • stat：返回znode的元数据。
  • cb：异步回调接口。
  • ctx：传递上下文参数。

zookeeper无论同步或者异步方法都提供能拿到监视器对象的重载方法。

package com.huazai.zookeeper.zkexample;

import com.huazai.zookeeper.zkexample.config.ZookeeperConnection;
import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

/**
 * @author pyh
 * @date 2021/5/25 0:06
 */
public class ZKGet {
    private ZooKeeper zooKeeper;

    @Before
    public void before() {
        zooKeeper = ZookeeperConnection.connect();
    }

    /**
     * 测试同步获取节点数据方法
     *
     * @throws Exception
     */
    @Test
    public void getSync() throws Exception {
        // 获取的节点属性保存在这里
        Stat stat = new Stat();
        // 获取节点数据
        byte[] data = zooKeeper.getData("/hadoop", false, stat);
        System.out.println(new String(data));
        System.out.println(stat);
    }

    /**
     * 测试异步获取数据方法
     *
     * @throws Exception
     */
    @Test
    public void getAsync() throws Exception {
        zooKeeper.getData("/hadoop", false, new AsyncCallback.DataCallback() {
            @Override
            public void processResult(int rc, String path, Object ctx, byte[] data, Stat stat) {
                if (rc == 0) {
                    // 成功获取节点/hadoop数据：hadoop
                    System.out.println("成功获取节点" + path + "数据：" + new String(data));
                }
                System.out.println(ctx);
                System.out.println(stat);
            }
        }, "我是上下文对象，在processResult回调方法中的ctx参数可以获取到我");
    }

    @After
    public void after() {
        ZookeeperConnection.close();
    }
}
  1. getChildren查询子节点数据方法
// 获取子节点同步方法，返回值是子节点路径列表
public List<String> getChildren(String path, boolean watch);

// 获取子节点异步方法
public void getChildren(String path, boolean watch, ChildrenCallback cb, Object ctx);
  • path：znode父节点路径。
  • watch：是否使用连接对象中注册的监视器。
  • cb：异步回调接口。
  • ctx：传递上下文参数。
package com.huazai.zookeeper.zkexample;

import com.huazai.zookeeper.zkexample.config.ZookeeperConnection;
import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.ZooKeeper;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.util.List;

/**
 * @author pyh
 * @date 2021/5/25 0:31
 */
public class getChildren {
    private ZooKeeper zooKeeper;

    @Before
    public void before() {
        zooKeeper = ZookeeperConnection.connect();
    }

    /**
     * 测试获取子节点同步方法
     *
     * @throws Exception
     */
    @Test
    public void getChildrenSync() throws Exception {
        // 子节点路径
        List<String> list = zooKeeper.getChildren("/hadoop", false);
        for (String str : list) {
            System.out.println(str);
        }
    }

    /**
     * 测试获取子节点异步方法
     *
     * @throws Exception
     */
    @Test
    public void getChildrenAsync() throws Exception {
        zooKeeper.getChildren("/hadoop", false, new AsyncCallback.ChildrenCallback() {
            @Override
            public void processResult(int rc, String path, Object ctx, List<String> children) {
                if (rc == 0) {
                    // 成功获取节点/hadoop子节点，子节点数量：1
                    System.out.println("成功获取节点" + path + "子节点，子节点数量：" + children.size());
                }
                System.out.println(ctx);
            }
        }, "在processResult回调方法中的ctx参数可以获取到我");
    }

    @After
    public void after() {
        ZookeeperConnection.close();
    }

}
  1. exists判断节点是否存在方法
// 同步判断方法
public Stat exists(String path, boolean watch);

// 异步判断方法
public void exists(String path, boolean watch, StatCallback cb, Object ctx);
  • path：znode路径。
  • watch：是否使用连接对象中注册的监视器。
  • cb：异步回调接口。
  • ctx：传递上下文参数。
package com.huazai.zookeeper.zkexample;

import com.huazai.zookeeper.zkexample.config.ZookeeperConnection;
import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

/**
 * @author pyh
 * @date 2021/5/25 0:28
 */
public class ZKExists {
    private ZooKeeper zooKeeper;

    @Before
    public void before() {
        zooKeeper = ZookeeperConnection.connect();
    }

    /**
     * 测试检测节点是否存在同步方法
     *
     * @throws Exception
     */
    @Test
    public void existsSync() throws Exception {
        Stat stat = zooKeeper.exists("/hadoop", false);
        System.out.println(stat);
    }

    /**
     * 测试检测节点是否存在异步方法
     *
     * @throws Exception
     */
    @Test
    public void existsAsync() throws Exception {
        zooKeeper.exists("/hadoop", false, new AsyncCallback.StatCallback() {
            @Override
            public void processResult(int rc, String path, Object ctx, Stat stat) {
                System.out.println(rc);
                // /hadoop
                System.out.println(path);
                // 我是上下文对象，在processResult回调方法中的ctx参数可以获取到我
                System.out.println(ctx);
                System.out.println(stat);
            }
        }, "我是上下文对象，在processResult回调方法中的ctx参数可以获取到我");
    }


    @After
    public void after() {
        ZookeeperConnection.close();
    }
}
NPException.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
大数据讲课笔记6.6 ZooKeeper的Java API操作
howard2005的专栏
10-10 871
1. 了解ZooKeeper Java API； 2. 能利用Java API操作ZooKeeper
10. Zookeeper JavaAPI-Watcher监听节点变化
Java 程序源
08-27 5255
Zookeeper JavaAPI-Watcher监听节点变化
zookeeper之java API使用
m0_69526738的博客
04-23 1116
public static void main(String[] args) { try { zooKeeper = new ZooKeeper(“192.168.40.135:2181”, 5000, new Watcher() { public void process(WatchedEvent watchedEvent) { if (watchedEvent.getState() == Event.KeeperState.SyncConnected) { doSomeThing(); } } });
zookeeper JavaAPI操作
weixin_45794641的博客
06-17 672
使用java对zookeeper进行操作，使用curator框架而不是原生的java API
11. Zookeeper JavaAPI-异步调用
Java 程序源
08-27 3104
Zookeeper JavaAPI-异步调用
ZooKeeper JavaAPI 操作
于小浩的博客
05-27 1114
ZooKeeper JavaAPI 操作
ZooKeeper的Java API客户端异常：org.apache.zookeeper.KeeperException$ConnectionLossException: KeeperErrorCod
热门推荐
DraGon_HooRay的博客
01-04 1万+
ZooKeeper的Java API客户端异常：org.apache.zookeeper.KeeperException$ConnectionLossException: KeeperErrorCode = ConnectionLoss for /sanguo/wuguo org.apache.zookeeper.KeeperException$ConnectionLossException: K...
08. Zookeeper JavaAPI-环境搭建
Java 程序源
08-27 3248
Zookeeper JavaAPI-环境搭建
Zookeeper的API客户端异常org.apache.zookeeper.KeeperException$ConnectionLossException: KeeperErrorCode
派大星的博客
03-10 2539
Zookeeper的API客户端异常org.apache.zookeeper.KeeperException$ConnectionLossException: KeeperErrorCode = ConnectionLoss for /atguigu 网上常见的解决方法是：关闭防火墙 但是防火墙就是处于关闭状态，所以此方法不可用。 经过调试发现 private static final int sessionTimeout = 10000 中设置的sessionTimeout值太小，应增大此值，问题解决。
09. Zookeeper JavaAPI-常用操作
Java 程序源
08-27 3278
Zookeeper JavaAPI-常用操作
zookeeper+kafka消息队列群集部署
m0_73868794的博客
07-15 974
许多消息队列所采用的"插入-获取-删除"范式中，在把一个消息从队列中删除之前，需要你的处理系统明确的指出该消息已经被处理完毕，从而确保你的数据被安全的保存直到你使用完毕。例如，在电商系统中，用户下单后，订单处理的消息可以先放入消息队列，后续的库存更新、物流通知等操作可以异步进行，而不必等待每个环节依次完成，从而提高系统的响应速度和整体性能。想向队列中放入多少消息就放多少，然后在需要的时候再去处理它们。例如，在一些业务流程中，可能需要先处理创建订单的消息，再处理支付订单的消息，消息队列可以保证这种顺序性。
ZooKeeper实现分布式锁
Deep Water Slow
07-14 242
【代码】ZooKeeper实现分布式锁。
zookeeper+kafka群集
moluxiangfenglo的博客
07-16 562
完成了主、备节点的分配和协作。但是会出现主节点并没有出现故障，只是在回复ack响应的时候网络发生了故障，这样备用节点就无法收到回复，那么它就会认为主节点出现了故障，接着，备用节点将接管主节点的服务，并成为新的主节点，此时，分布式系统中就出现了两个主节点（双Master节点）的情况，双Master节点的出现，会导致分布式系统的服务发生混乱。所谓单点故障，就是在一个主从的分布式系统中，主节点负责任务调度分发，从节点负责任务的处理，而当主节点发生故障时，整个应用系统也就瘫痪了，那么这种故障就称为单点故障。
Jenkins-zookeeper-docker-xxljob-rancher
LXMXHJ的博客
07-18 326
该代码是Jenkinsfile，用于定义一个持续集成/持续交付（CI/CD）的流水线；
分布式服务框架zookeeper+消息队列kafaka
最新发布
2301_78327423的博客
07-18 510
在zookeeper集群中，有各自的角色，分为领导者Leader，学习者learner(跟随者Follower，观察者Observer)领导者主要工作：事务请求的唯一调度和处理者，保证集群事务处理的顺序性；集群内部个服务器的调度者。跟随者：处理客户端非事务请求，转发事务请求给leader服务器；参与事务请求proposal的投票；参与leader选举的投票。
zookeeper在哪里能用到
qq_38140936的博客
07-14 875
ZooKeeper 顾名思义 动物园管理员，他是拿来管大象(Hadoop) 、 蜜蜂(Hive) 、 小猪(Pig) 的管理员， Apache Hbase和 Apache Solr 以及LinkedIn sensei 等项目中都采用到了 Zookeeper。ZooKeeper是一个分布式的，开放源码的分布式应用程序协调服务，ZooKeeper是以Fast Paxos算法为基础，实现同步服务，配置维护和命名服务等分布式应用。
zookeeper基础知识学习
Deep Water Slow
07-14 476
客户端注册监听它关心的目录节点，当目录节点发生变化（数据改变、节点删除、子目录节点增加删除）时，ZooKeeper 会通知客户端。1）节点的值变化监听get -w /xx注意：在右边的客户端多次修改/dd0000000007的值，左边不会再收到监听。因为注册一次，只能监听一次。想再次监听，需要再次注册。2）节点的子节点变化监听（路径变化）ls -w /xx3）当某个节点创建或者删除的时候。
zookeeper+kafka消息队列集群部署
henanxiaoman的博客
07-15 1274
zookeeper是一种分布式协调技术，所谓分布式协调技术主要是用来解决分布式环境当中多个进程之间的同步控制，让它们有序的去访问某个共享资源，防止造成资源竞争（脑裂）的后果。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

NPException.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值