zookeeper之Curator

最新推荐文章于 2024-03-20 11:08:49 发布
最新推荐文章于 2024-03-20 11:08:49 发布
阅读量305 收藏
点赞数
文章标签： zookeeper Curator
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/usagoole/article/details/82944276
版权

文章目录

Curator客户端

  1. Curator包含了几个包：
    • curator-framework：对zookeeper的底层api的一些封装
    • curator-client：提供一些客户端的操作，例如重试策略等
    • curator-recipes：封装了一些高级特性，如：Cache事件监听、选举、分布式锁、分布式计数器、分布式Barrier等
  2. 版本
    • The are currently two released versions of Curator, 2.x.x and 3.x.x:
    • Curator 2.x.x - compatible with both ZooKeeper 3.4.x and ZooKeeper 3.5.x
    • Curator 3.x.x - compatible only with ZooKeeper 3.5.x and includes support for new features such as dynamic reconfiguration, etc.
  3. Curator主要解决了以下问题
    • 封装ZooKeeper client与ZooKeeper server之间的连接处理
    • 提供了一套Fluent风格的操作API
    • 提供ZooKeeper各种应用场景(recipe, 比如共享锁服务, 集群领导选举机制)的抽象封装
  4. 这里使用的版本
    • 服务端Zookeeper版本:3.4.6
    • Curator版本:compile "org.apache.curator:curator-recipes:2.11.0"

创建会话

  1. 创建会话

         @Test
    public void testCreateClient() throws Exception{
        String connectString = "zk-master:2180,zk-slave1:2182,zk-slave2:2183";
        int sessionTimeoutMs = 25000;
        int connectionTimeoutMs = 5000;
        /**
         *   失去连接重试策略
         *    baseSleepTimeMs 初始sleep时间
         *    maxRetries    最大重试次数
         *    maxSleepMs    最大sleep时间
         *    当前sleep时间=baseSleepTimeMs*Math.mac(1,random.next(1)) << (retryCount+1)
         */
        int baseSleepTimeMs;
        int maxRetries;
        int maxSleepMs;
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);

        //第一种方式，使用Builder fluent风格的API方式创建
        CuratorFramework curatorFramework1 = CuratorFrameworkFactory.builder()
                .connectString(connectString)
                .sessionTimeoutMs(sessionTimeoutMs)
                .connectionTimeoutMs(connectionTimeoutMs)
                .retryPolicy(retryPolicy)
                .build();
        CuratorFrameworkState state1 = curatorFramework1.getState();
        //zk-curator - LATENT
        logger.info(state1.toString());

        //当连接状态变化时触发
        curatorFramework1.getConnectionStateListenable().addListener(new ConnectionStateListener() {
            @Override
            public void stateChanged(CuratorFramework curatorFramework, ConnectionState connectionState) {
                //连接状态事件:true
                logger.info("连接状态事件:{}",connectionState.isConnected());
            }
        });

        //完成会话的创建
        curatorFramework1.start();



        //第二种方式，使用静态工厂方式创建，此方式本质上还是通过第一种方式创建
        CuratorFramework curatorFramework2 =
                CuratorFrameworkFactory.newClient(
                        connectString,
                        sessionTimeoutMs,
                        connectionTimeoutMs,
                        retryPolicy);
        CuratorFrameworkState state2 = curatorFramework2.getState();
        //zk-curator - LATENT
        logger.info(state2.toString());


        /**
         * 临时客户端:
         *      一定时间不活动后连接会被关闭，使用buildTemp()创建
         */
        CuratorTempFramework curatorFramewor3 = CuratorFrameworkFactory.builder()
                .connectString(connectString)
                .sessionTimeoutMs(sessionTimeoutMs)
                .connectionTimeoutMs(connectionTimeoutMs)
                .retryPolicy(retryPolicy)
                .buildTemp(2000,TimeUnit.SECONDS);
                //.buildTemp();
        TimeUnit.SECONDS.sleep(20);

    }

创建节点

  1. 创建节点

      @Test
  public void testCreateZnode() throws Exception {

      String connectString = "zk-master:2180,zk-slave1:2182,zk-slave2:2183";
      int sessionTimeoutMs = 25000;
      int connectionTimeoutMs = 5000;
      String rootPath = "jannal-create";
      RetryPolicy retryPolicy = new ExponentialBackoffRetry(4000, 3);

      CuratorFramework curatorFramework = CuratorFrameworkFactory.builder()
              .connectString(connectString)
              .sessionTimeoutMs(sessionTimeoutMs)
              .connectionTimeoutMs(connectionTimeoutMs)
              .retryPolicy(retryPolicy)
              .namespace(rootPath) //客户端对zk上的数据节点的操作都是基本此根节点进行的
              .build();
      //完成会话创建
      curatorFramework.start();

      //创建一个初始内容为空的znode，默认创建的是持久节点
      curatorFramework.create().forPath("/userEmpty");
      //创建一个附带内容的znode
      curatorFramework.create().forPath("/userData", "我是jannal".getBytes(Charsets.UTF_8));
      //创建一个临时节点
      curatorFramework.create().
              withMode(CreateMode.EPHEMERAL).
              forPath("/userTemp", "jannal".getBytes(Charsets.UTF_8));
      //自动递归创建父节点creatingParentsIfNeeded()
      curatorFramework.create()
              .creatingParentsIfNeeded()
              .withMode(CreateMode.PERSISTENT)
              .forPath("/user/password", "123456".getBytes(Charsets.UTF_8));


      curatorFramework.getCuratorListenable().addListener(new CuratorListener() {
          @Override
          public void eventReceived(CuratorFramework curatorFramework, CuratorEvent curatorEvent) throws Exception {

          }
      });

      ExecutorService executorService = Executors.newFixedThreadPool(2);
      CountDownLatch countDownLatch = new CountDownLatch(1);
      /**
       * 在原生的zookeeper客户端中，所有异步通知事件处理都是通过EventThread这个
       * 线程处理的(串行处理所有事件的通知)。一旦发生复杂的处理单元就会消耗很长事件
       * 从而影响其他事件的处理，Curator可以使用线程池来处理,如果不指定线程池
       * 则默认使用EventThread来处理
       */
      curatorFramework.create()
              .creatingParentsIfNeeded()
              .withMode(CreateMode.EPHEMERAL)
              .inBackground(new BackgroundCallback() {
                  @Override
                  public void processResult(CuratorFramework client, CuratorEvent event) throws Exception {
                      logger.info(event.toString());
                      countDownLatch.countDown();
                  }
              },executorService)
              .forPath("/user2","jannal2".getBytes(Charsets.UTF_8));



      countDownLatch.await();
      executorService.shutdown();

  }

获取节点和数据

  1. 获取节点和数据

        @Test
    public void testGetZnode() throws Exception {
        String connectString = "zk-master:2180,zk-slave1:2182,zk-slave2:2183";
        int sessionTimeoutMs = 25000;
        int connectionTimeoutMs = 5000;
        String rootPath = "jannal-get";
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(4000, 3);

        CuratorFramework client = CuratorFrameworkFactory.builder()
                .connectString(connectString)
                .sessionTimeoutMs(sessionTimeoutMs)
                .connectionTimeoutMs(connectionTimeoutMs)
                .retryPolicy(retryPolicy)
                .namespace(rootPath)
                .build();
        client.start();
        client.create()
                .creatingParentsIfNeeded()
                .forPath("/user/username/jannal", "jannal123".getBytes(Charsets.UTF_8));

        //获取数据
        byte[] bytes = client.getData().forPath("/user/username/jannal");

        Assert.assertEquals("jannal123", new String(bytes, Charsets.UTF_8));

        //读取一个节点的数据内容，同时获取到该节点的stat
        Stat stat = new Stat();
        bytes = client.getData().storingStatIn(stat).forPath("/user/username/jannal");
        logger.info(ToStringBuilder.reflectionToString(stat));

        client.create().creatingParentsIfNeeded().forPath("/user/username1", "abc".getBytes(Charsets.UTF_8));
        client.create().creatingParentsIfNeeded().forPath("/user/username2", "def".getBytes(Charsets.UTF_8));
        //获取节点的子节点路径
        List<String> strings = client.getChildren().forPath("/user");
        //[username2, username1, username]
        logger.info(strings.toString());

    }

更新数据

  1. 更新数据

        @Test
    public void testSetZnode() throws Exception {
        String connectString = "zk-master:2180,zk-slave1:2182,zk-slave2:2183";
        int sessionTimeoutMs = 25000;
        int connectionTimeoutMs = 5000;
        String rootPath = "jannal-update";
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(4000, 3);

        CuratorFramework curatorFramework = CuratorFrameworkFactory.builder()
                .connectString(connectString)
                .sessionTimeoutMs(sessionTimeoutMs)
                .connectionTimeoutMs(connectionTimeoutMs)
                .retryPolicy(retryPolicy)
                .namespace(rootPath) //客户端对zk上的数据节点的操作都是基本此根节点进行的
                .build();
        curatorFramework.start();

        String path = "/user/password";

        curatorFramework.create()
                .creatingParentsIfNeeded()
                .withMode(CreateMode.PERSISTENT)
                .forPath("/user/password", "123456".getBytes(Charsets.UTF_8));
        byte[] bytes = curatorFramework.getData().forPath(path);
        Assert.assertEquals("123456", new String(bytes, Charsets.UTF_8));

        Stat stat = curatorFramework.setData().forPath(path, "abcd".getBytes(Charsets.UTF_8));
        bytes = curatorFramework.getData().forPath(path);
        Assert.assertEquals("abcd", new String(bytes, Charsets.UTF_8));

        //更新一个节点的数据内容，强制指定版本进行更新
        curatorFramework.setData().withVersion(stat.getVersion()).forPath(path, "abcde".getBytes());

    }

删除节点

  1. 在删除一个节点时，由于网络原因，导致删除操作失败。这个异常在有些场景下是致命的，比如Master选举(先创建后删除)，针对这个问题Curator引入了一种重试机制，即如果我们调用了guaranteed()，那么只要客户端有效，就会在后台反复重试，直到节点删除成功。

  2. 删除节点示例

        @Test
    public void testDeleteZnode() throws Exception {
        String connectString = "zk-master:2180,zk-slave1:2182,zk-slave2:2183";
        int sessionTimeoutMs = 25000;
        int connectionTimeoutMs = 5000;
        String rootPath = "jannal-delete";
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(4000, 3);

        CuratorFramework client = CuratorFrameworkFactory.builder()
                .connectString(connectString)
                .sessionTimeoutMs(sessionTimeoutMs)
                .connectionTimeoutMs(connectionTimeoutMs)
                .retryPolicy(retryPolicy)
                .namespace(rootPath)
                .build();
        client.start();
        client.create()
                .creatingParentsIfNeeded()
                .forPath("/user/username/jannal", "jannal123".getBytes(Charsets.UTF_8));

        client.create()
                .creatingParentsIfNeeded()
                .forPath("/user2/username/jannal", "jannal123".getBytes(Charsets.UTF_8));
        client.create()
                .creatingParentsIfNeeded()
                .forPath("/user3/username/jannal", "jannal123".getBytes(Charsets.UTF_8));



        //删除节点且递归删除其所有的子节点
        client.delete().deletingChildrenIfNeeded().forPath("/user");
        //强制指定版本进行删除
        client.delete().deletingChildrenIfNeeded().withVersion(0).forPath("/user2");
        //强制保证删除，只要客户端有效，Curator会在后台持续进行删除操作，直到节点删除成功
        client.delete().guaranteed().forPath("/user3/username/jannal");

    }

事务

  1. 事务

     /**
     * inTransaction()开启事务，可以复合create, setData, check, and/or delete
     * 等操作然后调用commit()作为一个原子操作提交
     *
     * @throws Exception
     */
    @Test
    public void testTransaction() throws Exception {
        String connectString = "zk-master:2180,zk-slave1:2182,zk-slave2:2183";
        int sessionTimeoutMs = 25000;
        int connectionTimeoutMs = 5000;
        String rootPath = "jannal-transaction";
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(4000, 3);

        CuratorFramework client = CuratorFrameworkFactory.builder()
                .connectString(connectString)
                .sessionTimeoutMs(sessionTimeoutMs)
                .connectionTimeoutMs(connectionTimeoutMs)
                .retryPolicy(retryPolicy)
                .namespace(rootPath)
                .build();
        client.start();

        client.inTransaction()
                .create().withMode(CreateMode.EPHEMERAL).forPath("/transaction", "事务".getBytes(Charsets.UTF_8))
                .and()
                .delete().forPath("/transaction")
                .and()
                .commit();
    }

节点存在

  1. 判断节点是否存在

     @Test
    public void testExist() throws Exception {
        String connectString = "zk-master:2180,zk-slave1:2182,zk-slave2:2183";
        int sessionTimeoutMs = 25000;
        int connectionTimeoutMs = 5000;
        String rootPath = "jannal-Exist";
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(4000, 3);

        CuratorFramework client = CuratorFrameworkFactory.builder()
                .connectString(connectString)
                .sessionTimeoutMs(sessionTimeoutMs)
                .connectionTimeoutMs(connectionTimeoutMs)
                .retryPolicy(retryPolicy)
                .namespace(rootPath)
                .build();
        client.start();
        //节点不存在返回null
        Stat stat = client.checkExists().forPath("/jannal");
        Assert.assertEquals(null, stat);
        logger.info(ToStringBuilder.reflectionToString(stat));
    }

事件监听

  1. 原生客户端支持通过注册Watch来进行事件监听，但是收到事件通知后每次都需要手动再次注册Watch。Curator引入了Cache来实现对Zookeeper服务端事件的监听，并且自动处理反复注册监听，简化了原生API的繁琐。

  2. Cache分为两类监听

    • 节点监听
    • 子节点监听

  3. NodeCache用于监听指定Zookeeper数据节点本身的变化，数据内容发生变化时，就会回调此方法。

      @Test
    public void testNodeCacheEventListener() throws Exception {
        String connectString = "zk-master:2180,zk-slave1:2182,zk-slave2:2183";
        int sessionTimeoutMs = 25000;
        int connectionTimeoutMs = 5000;
        String rootPath = "jannal-listener";
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(4000, 3);

        CuratorFramework client = CuratorFrameworkFactory.builder()
                .connectString(connectString)
                .sessionTimeoutMs(sessionTimeoutMs)
                .connectionTimeoutMs(connectionTimeoutMs)
                .retryPolicy(retryPolicy)
                .namespace(rootPath)
                .build();
        client.start();
        String path = "/user/username/jannal";
        client.create()
                .creatingParentsIfNeeded()
                .forPath(path, "jannal123".getBytes(Charsets.UTF_8));
        //是否进行数据压缩
        boolean dataIsCompressed = false;
        final NodeCache cache = new NodeCache(client, path, dataIsCompressed);
        cache.start(true);
        CountDownLatch countDownLatch = new CountDownLatch(2);
        cache.getListenable().addListener(new NodeCacheListener() {
            @Override
            public void nodeChanged() throws Exception {
                ChildData currentData = cache.getCurrentData();
                if (currentData != null) {
                    logger.info("数据发生变更,新数据:{}", new String(currentData.getData(), StandardCharsets.UTF_8));
                }else{
                    logger.info("数据发生变更,新数据:{},节点可能被删除", currentData, StandardCharsets.UTF_8);
                }

                countDownLatch.countDown();
            }
        });

        client.setData().forPath(path, "jannal".getBytes(Charsets.UTF_8));
        client.delete().deletingChildrenIfNeeded().forPath(path);
        countDownLatch.await();
    }

  4. PathChildrenCache用于监听指定Zookeeper数据节点的子节点变化情况。当指定节点的子节点发生变化时，就会回调Listener。Curator无法对二级子节点触发变更事件。比如对/zk-jannal子节点进行监听，当/zk-jannal/user/password节点被创建或者删除的时候，无法触发子节点变更事件

        @Test
    public void testPathChildrenCacheEventListener() throws Exception {
        String connectString = "zk-master:2180,zk-slave1:2182,zk-slave2:2183";
        int sessionTimeoutMs = 25000;
        int connectionTimeoutMs = 5000;
        String rootPath = "jannal-parent-listener";
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(4000, 3);

        CuratorFramework client = CuratorFrameworkFactory.builder()
                .connectString(connectString)
                .sessionTimeoutMs(sessionTimeoutMs)
                .connectionTimeoutMs(connectionTimeoutMs)
                .retryPolicy(retryPolicy)
                .namespace(rootPath)
                .build();
        client.start();
        String path = "/user";
        client.create()
                .creatingParentsIfNeeded()
                .forPath(path, "jannal123".getBytes(Charsets.UTF_8));
        //是否进行数据压缩
        boolean dataIsCompressed = false;
        /**
         * 是否把节点内容缓存起来，如果配置为true，则client在接收
         * 到节点列表变更的同时，也能够获取到节点的数据内容，如果为false
         * 则无法获取节点的数据内容
         */
        boolean cacheData = true;
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        CountDownLatch countDownLatch = new CountDownLatch(3);
        final PathChildrenCache cache = new PathChildrenCache(client, path, cacheData, dataIsCompressed, executorService);

        /**
         * BUILD_INITIAL_CACHE 同步初始化客户端的cache，及创建cache后，就从服务器端拉入对应的数据(这个是NodeCache使用的方式)
         * NORMAL 异步初始化cache
         * POST_INITIALIZED_EVENT 异步初始化，初始化完成触发事件PathChildrenCacheEvent.Type.INITIALIZED
         */
        cache.start(PathChildrenCache.StartMode.BUILD_INITIAL_CACHE);
        cache.getListenable().addListener(new PathChildrenCacheListener() {
            @Override
            public void childEvent(CuratorFramework curatorFramework, PathChildrenCacheEvent pathChildrenCacheEvent) throws Exception {
                ChildData currentData = pathChildrenCacheEvent.getData();
                //事件类型，可通过判断事件类型来做相应的处理
                PathChildrenCacheEvent.Type type = pathChildrenCacheEvent.getType();
                switch (type) {
                    //初始化会触发这个事件
                    case INITIALIZED:
                        logger.info("子类缓存系统初始化完成");
                        break;
                    case CHILD_ADDED:
                        //新增子节点/user/username
                        logger.info("新增子节点{}", currentData.getPath());
                        break;
                    case CHILD_UPDATED:
                        // 子节点数据变更[106, 97, 110, 110, 97, 108]
                        logger.info("子节点数据变更{}", new String(currentData.getData(),Charsets.UTF_8));
                        break;
                    case CHILD_REMOVED:
                        //子节点数据删除/user/username
                        logger.info("子节点数据删除{}", currentData.getPath());
                        break;
                }
                countDownLatch.countDown();
            }


        });
        client.create()
                .creatingParentsIfNeeded()
                .forPath(path+"/username", "jannal123".getBytes(Charsets.UTF_8));
        TimeUnit.SECONDS.sleep(1);
        client.setData().forPath(path+"/username", "jannal".getBytes(Charsets.UTF_8));
        TimeUnit.SECONDS.sleep(1);
        client.delete().deletingChildrenIfNeeded().forPath(path);
        countDownLatch.await();
    }

  5. TreeCache可以监听整个树上的所有节点。即可以监控节点的状态，还监控节点的子节点的状态

        @Test
    public void testTreeCache() throws Exception {
        String connectString = "zk-master:2180,zk-slave1:2182,zk-slave2:2183";
        int sessionTimeoutMs = 25000;
        int connectionTimeoutMs = 5000;
        String rootPath = "jannal-tree-listener";
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(4000, 3);

        CuratorFramework client = CuratorFrameworkFactory.builder()
                .connectString(connectString)
                .sessionTimeoutMs(sessionTimeoutMs)
                .connectionTimeoutMs(connectionTimeoutMs)
                .retryPolicy(retryPolicy)
                .namespace(rootPath)
                .build();
        client.start();
        String path = "/user";
        client.create()
                .creatingParentsIfNeeded()
                .forPath(path, "jannal123".getBytes(Charsets.UTF_8));

        CountDownLatch countDownLatch = new CountDownLatch(1);
        TreeCache cache = new TreeCache(client, path);
        cache.getListenable().addListener(new TreeCacheListener() {
            @Override
            public void childEvent(CuratorFramework curatorFramework, TreeCacheEvent treeCacheEvent) throws Exception {
                TreeCacheEvent.Type type = treeCacheEvent.getType();
                ChildData childData = treeCacheEvent.getData();

                switch (type) {
                    //子类缓存系统初始化完成
                    case INITIALIZED:
                        logger.info("子类缓存系统初始化完成");
                        break;
                    case NODE_ADDED:
                        //新增子节点/user/username
                        logger.info("新增子节点{}", childData != null ? childData.getPath() : null);
                        break;
                    case NODE_UPDATED:
                        // 子节点数据变更jannal
                        // 子节点数据变更jannal2
                        logger.info("子节点数据变更{}", childData != null ? new String(childData.getData(), Charsets.UTF_8) : null);
                        break;
                    case NODE_REMOVED:
                        //子节点数据删除/user
                        logger.info("子节点数据删除{}", childData != null ? childData.getPath() : null);
                        break;
                }
                countDownLatch.countDown();
            }
        });
        cache.start();
        client.setData().forPath(path, "jannal".getBytes());
        Thread.sleep(1000);
        client.setData().forPath(path, "jannal2".getBytes());
        Thread.sleep(1000);
        client.delete().deletingChildrenIfNeeded().forPath(path);
        Thread.sleep(1000 * 2);
        countDownLatch.await();

    }

其他工具类

  1. Curator提供了一些工具类。比如ZKPaths和EnsurePath

  2. ZKPaths提供更简单的API来构建Znode路径、递归创建和删除节点。

  3. EnsurePath提供了一种确保数据节点存在的机制。在分布式环境下，A和B机器都同时创建节点，由于并发操作的存在，可能抛出节点已经存在的异常。 EnsurePath内部实现就是试图创建指定节点，如果节点存在，那么就不进行任何操作，也不抛出异常，否则正常创建节点。从Curator 2.9.0版本开始此类已经过时，首选 CuratorFramework.create().creatingParentContainersIfNeeded() or CuratorFramework.exists().creatingParentContainersIfNeeded()

  4. 代码示例

        @Test
    public void testOther() throws Exception {
        String connectString = "zk-master:2180,zk-slave1:2182,zk-slave2:2183";
        int sessionTimeoutMs = 25000;
        int connectionTimeoutMs = 5000;
        String rootPath = "zk-other";
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(4000, 3);

        CuratorFramework client = CuratorFrameworkFactory.builder()
                .connectString(connectString)
                .sessionTimeoutMs(sessionTimeoutMs)
                .connectionTimeoutMs(connectionTimeoutMs)
                .retryPolicy(retryPolicy)
                .namespace(rootPath)
                .build();
        client.start();
        String path = ZKPaths.fixForNamespace(rootPath, "/user");
        // 输出:/zk-other/user
        logger.info(path);
        ZKPaths.PathAndNode pathAndNode = ZKPaths.getPathAndNode("/zk-other/user/username");
        // path:/zk-other/user,node:username
        logger.info("path:{},node:{}", pathAndNode.getPath(), pathAndNode.getNode());

        CuratorZookeeperClient zookeeperClient = client.getZookeeperClient();
        //创建节点
        ZKPaths.mkdirs(zookeeperClient.getZooKeeper(), "/zk-other/user/password");

        //获取子节点
        List<String> sortedChildren = ZKPaths.getSortedChildren(zookeeperClient.getZooKeeper(), "/zk-other");
        logger.info(sortedChildren.toString());




    }

开发测试

  1. 为了便于开发人员进行zk的开发与测试，可以使用curator-test模块。依赖compile "org.apache.curator:curator-test:2.11.0"

  2. 单元测试

    
    @Test
    public void testSingleServer() throws Exception {
        File dataDir = new File(".");
        TestingServer server = new TestingServer(2000, dataDir);
        server.start();
        CuratorFramework curatorFramework = CuratorFrameworkFactory.
                builder().
                connectString(server.getConnectString()).
                sessionTimeoutMs(1000).
                retryPolicy(new RetryNTimes(3, 1000)).
                build();
        curatorFramework.start();
        System.out.println(curatorFramework.getChildren().forPath("/"));
        curatorFramework.close();
        server.stop();

    }

  3. 集群测试

        @Test
    public void testClusterServer() throws Exception {
        TestingCluster server = new TestingCluster(3);
        server.start();
        Thread.sleep(2000);
        TestingZooKeeperServer leader = null;
        for (TestingZooKeeperServer zs : server.getServers()) {
            logger.info(zs.getInstanceSpec().getServerId() + "-");
            logger.info(zs.getQuorumPeer().getServerState() + "-");
            logger.info(zs.getInstanceSpec().getDataDirectory().getAbsolutePath());
            if (zs.getQuorumPeer().getServerState().equals("leading")) {
                leader = zs;
            }
        }
        //模拟leader挂掉
        leader.kill();
        logger.info("leader 挂掉之后");
        for (TestingZooKeeperServer zs : server.getServers()) {
            logger.info(zs.getInstanceSpec().getServerId() + "-");
            logger.info(zs.getQuorumPeer().getServerState() + "-");
            logger.info(zs.getInstanceSpec().getDataDirectory().getAbsolutePath());

        }
        server.stop();

    }
jannals
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
使用Apache Curator连接Zookeeper版本问题
浅汐
04-10 8624
在项目中使用到Apache Curator Framework连接zookeeper-3.4.5-cdh5.7.0，使用的Curator Framework版本是最新版4.0.1 <!-- https://mvnrepository.com/artifact/org.apache.curator/curator-framework --> <dependency> ...
springboot-zookeeper-curator.rar
04-15
zookeeper的curator使用代码
ZooKeeper-Curator:zookeeper的curator客户端
04-28
ZooKeeper-Curator zookeeper的curator客户端 #在学习时的代码上传以备工作时获取。
Zookeeper（五）Zokeeper 环境搭建与Curator使用
最新发布
长安不及十里的博客
03-20 1218
其中 A 是一个数字，表示这个是第几号服务器；B 是这个服务器的 ip 地址；C 表示的是这个服务器与集群中的 Leader 服务器交换信息的端口；D 表示的是万一集群中的 Leader 服务器挂了，需要一个端口来重新进行选举，选出一个新的 Leader，而这个端口就是用来执行选举时服务器相互通信的端口。如果是伪集群的配置方式，由于 B 都是一样，所以不同的 Zookeeper 实例通信端口号不能一样，所以要给它们分配不同的端口号。这个命令就需要自己去练了。
zookeeper 使用 Curator 示例监听、分布式锁
02-04
zookeeper 使用 Curator 进行增、删、改、查、监听、分布式锁
zookeeper开源客户端Curator
03-25
Curator是Netflix公司开源的一套ZooKeeper客户端框架，Curator解决了很多ZooKeeper客户端非常底层的细节开发工作，包括连接重连、反复注册Watcher和NodeExistsException异常等，实现了Fluent风格的API接口，目前已经成为Apache的顶级项目，是全世界范围内使用最广泛的ZooKeeper客户端之一。
Zookeeper客户端Curator Framework使用代码
05-05
Zookeeper客户端Curator Framework示例代码，博客详解链接：https://blog.csdn.net/u010889616/article/details/80209629
Curator 框架与 Zookeeer 版本 适配
天道酬勤
07-24 6900
问题 在使用 curator 框架测试的时候，出现了如下问题 Exception in thread "main" org.apache.zookeeper.KeeperException$UnimplementedException: KeeperErrorCode = Unimplemented for /test1 at org.apache.zookeeper.KeeperException.create(KeeperException.java:106) at org.apache.zooke
超强总结，用心分享丨大数据超神之路(四)：ZooKeeper开发必知必会
许晨的博客
07-13 1320
  高并发系统为了应对流量增长需要进行节点的横向扩展，所以高并发系统往往都是分布式系统。高并发系统基本都需要进行节点与节点之间的配合协调，这就需要用到分布式协调中间件（如ZooKeeper）。   简单来说，ZooKeeper=文件系统+通知机制，和设计模式里的观察者模式很像。   ZooKeeper在实际生产环境中应用非常广泛，比如SOA的服务监控系统，大数据基础平台Hadoop、Spark的分布式调度系统。ZooKeeper提供的服务包括：统一命名服务、统一配置管理、统一集群管理、服务器节点动态上下线、
Zookeeper Java客户端Curator
codedot
12-21 1206
开篇
springboot整合zookeeper3.4+Curator
yzh_1346983557的博客
04-02 1150
zookeeper与Curator存在兼容性问题，官网描述使用官网方案，自测不行，所以回退到使用Curator 2.x。zookeeper 3.4.x服务器版本与Curator 2.x是兼容的。
SpringBoot整合Zookeeper的Curator连接
qq_28421487的博客
08-09 367
SpringBoot整合Zookeeper的Curator连接
Morris算法遍历二叉树
qq_40585050的博客
09-09 540
中序遍历步骤 如果当前节点左子节点(cur.left)为空，输出当前节点(cur)，进入右子节点(cur.right)。 如果当前节点左子节点(cur.left)非空，找到当前节点左子树的最右节点(mostRight)： 1）如果该节点的右子节点(mostRight.right)为空，则将其指针指向当前节点(cur)，进入左子节点(cur.left)。 2）如果该节点的右子节点(mostRight.right)非空，则将其指针置为空，输出当前节点(cur)，进入右子节点(cur.right)。
Zookeeper客户端Curator使用详解
BigManing的博客
04-21 494
文章目录前提简介Curator的基本Api创建会话1.使用静态工程方法创建客户端2.使用Fluent风格的Api创建会话3.创建包含隔离命名空间的会话启动客户端数据节点操作创建数据节点删除数据节点读取数据节点数据更新数据节点数据检查节点是否存在获取某个节点的所有子节点路径事务异步接口Path CacheNode CacheTree Cache 前提 因为最近项目需要使用Zookeeper这个中间件，提前了解一下它的客户端Curator的使用。 简介 Curator是Netflix公司开源的一套zookeep
Zookeeper系列文章-Curator
abc123mma的博客
11-22 1186
Zk的与框架curator
Curator与zookeeper版本问题，分布式锁
robinson_911的专栏
07-15 1609
pom.xml如下： <!-- zookeeper --> <dependency> <groupId>org.apache.zookeeper</groupId> <artifactId>zookeeper</artifactId> <version>3.4.8</version>
Zookeeper-Curator学习资料
qq_35336312的博客
09-17 182
前提 因为最近项目需要使用Zookeeper这个中间件，提前了解一下它的客户端Curator的使用。 简介 Curator是Netflix公司开源的一套zookeeper客户端框架，解决了很多Zookeeper客户端非常底层的细节开发工作，包括连接重连、反复注册Watcher和NodeExistsException异常等等。Patrixck Hunt（Zookeeper）以一句“Guava is to Java that Curator to Zookeeper”给Curator予高度评价。 引
Zookeeper开源客户端框架Curator简介
疯狂的菠菜
01-21 533
Curator是Netflix开源的一套ZooKeeper客户端框架. Netflix在使用ZooKeeper的过程中发现ZooKeeper自带的客户端太底层, 应用方在使用的时候需要自己处理很多事情, 于是在它的基础上包装了一下, 提供了一套更好用的客户端框架. Netflix在用ZooKeeper的过程中遇到的问题, 我们也遇到了, 所以开始研究一下, 首先从他在github上的源码, wik...
4、zookeeper第三方客户端curator
yisuyanyu的博客
07-08 232
curator简介 curator是Netflix公司开源的一个 zookeeper客户端，后捐献给 apache,，curator框架在zookeeper原生API接口上进行了包装，解决了很多zooKeeper客户端非常底层的细节开发。提供zooKeeper各种应用场景(比如:分布式锁服务、集群领导选举、共享计数器、缓存机制、分布式队列等的抽象封装，实现了Fluent风格的APl接口，是最好用，最流行的zookeeper的客户端 原生zookeeperAPI的不足 连接对象异步创建，需要开发人员
zookeeper curator 分布式
05-10
zookeeper是一种分布式的开源协调服务，通过它可以实现分布式应用程序中的数据管理、配置管理、命名服务等功能。zookeeper的核心就是znode，它是zookeeper中存储数据的基本单元，类似于文件系统中的文件或目录。zookeeper可以为znode设置watcher，当znode中的数据发生变化时，可以通知注册了watcher的客户端。 Curator是一个高层次的zookeeper客户端库，提供一系列APIs和工具类，方便开发人员使用zookeeper实现各种分布式应用场景。Curator对zookeeper客户端进行了封装，简化了zookeeper的操作。Curator包含了诸如缓存、领导选举、分布式锁等常见的分布式应用场景的实现。 在分布式应用场景中，多个节点需要协同完成一项任务，但每个节点之间又需要共享数据、维护状态和进行协调。zookeeper和curator正是用来解决这些问题的。以分布式锁为例，一个系统中多个节点需要竞争资源，但需要保证只有一个节点能够获得资源的使用权，其他节点需要等待。通过zookeeper和curator提供的分布式锁实现，可以很方便地解决这个问题。 总之，zookeeper和curator是在分布式应用中所必需的两个开源工具，可以大部分解决分布式应用中的协调和管理问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值