• 创建会话
  1.  package org.zln.zk;
  2.  
  3.  import org.apache.zookeeper.WatchedEvent;
  4.  import org.apache.zookeeper.Watcher;
  5.  import org.apache.zookeeper.ZooKeeper;
  6.  
  7.  import java.io.IOException;
  8.  
  9.  /**
  10.   * Created by sherry on 16/8/27.
  11.   */
  12.  public class TestZooKeeperClientApi {
  13.  
  14.      private static ZooKeeper zooKeeper;
  15.  
  16.      public static void main(String[] args) throws IOException, InterruptedException {
  17.          createSession();
  18.      }
  19.  
  20.      /**
  21.       * 创建会话
  22.       */
  23.      private static ZooKeeper createSession() throws IOException, InterruptedException {
  24.          //实例化的过程,同时也是与ZooKeeper建立连接的过程,参数说明:ip:port 超时时间  监听器(实现water接口,监听器用于接收通知)
  25.          zooKeeper = new ZooKeeper("127.0.0.1:2181", 5000, new Watcher() {
  26.              @Override
  27.              public void process(WatchedEvent watchedEvent) {
  28.                  System.out.println("收到事件:"+watchedEvent);//收到事件:WatchedEvent state:SyncConnected type:None path:null
  29.  
  30.                  //TODO
  31.              }
  32.          });
  33.          System.out.println("查看状态:"+zooKeeper.getState());//查看状态:CONNECTING
  34.  
  35.          //如果不停一段时间,那么,监听器还没收到监听,方法就已经退出了
  36.          Thread.sleep(5000);
  37.  
  38.          return zooKeeper;
  39.  
  40.      }
  41.  }

创建会话

  • 创建节点
  1.  package org.zln.zk;
  2.  
  3.  import org.apache.zookeeper.*;
  4.  import org.apache.zookeeper.data.ACL;
  5.  import org.slf4j.Logger;
  6.  import org.slf4j.LoggerFactory;
  7.  
  8.  import java.io.IOException;
  9.  import java.io.UnsupportedEncodingException;
  10.  import java.util.ArrayList;
  11.  
  12.  /**
  13.   * Created by sherry on 16/8/27.
  14.   */
  15.  public class TestZooKeeperClientApi {
  16.  
  17.      private static Logger logger = LoggerFactory.getLogger(TestZooKeeperClientApi.class);
  18.  
  19.      private static ZooKeeper zooKeeper;
  20.  
  21.      public static void main(String[] args) throws IOException, InterruptedException {
  22.          createSession();
  23.      }
  24.  
  25.      /**
  26.       * 创建会话
  27.       */
  28.      private static ZooKeeper createSession() throws IOException, InterruptedException {
  29.          //实例化的过程,同时也是与ZooKeeper建立连接的过程,参数说明:ip:port 超时时间  监听器(实现water接口,监听器用于接收通知)
  30.          zooKeeper = new ZooKeeper("127.0.0.1:2181", 5000, new Watcher() {
  31.              @Override
  32.              public void process(WatchedEvent watchedEvent) {
  33.                  //TODO 与 ZooKeeper 的交互,一般都放在这里
  34.                  if (watchedEvent.getState() == Event.KeeperState.SyncConnected){//已连接
  35.                      logger.info("连接上了");
  36.  
  37.                      try {
  38.                          //参数说明:节点路径  数据的字节数组 权限 创建节点模式
  39.                          String nodePath = createNode(zooKeeper,"/node_1","123".getBytes("UTF-8"), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
  40.                          logger.info("创建节点:"+nodePath);
  41.                      } catch (UnsupportedEncodingException|KeeperException|InterruptedException e) {
  42.                          e.printStackTrace();
  43.                      }
  44.  
  45.                  }
  46.              }
  47.          });
  48.          logger.info("查看状态:"+zooKeeper.getState());//查看状态:CONNECTING
  49.  
  50.          //如果不停一段时间,那么,监听器还没收到监听,方法就已经退出了
  51.          Thread.sleep(5000);
  52.  
  53.          return zooKeeper;
  54.  
  55.      }
  56.  
  57.      /**
  58.       * 创建ZooKeeper节点
  59.       * @param zooKeeper ZooKeeper连接
  60.       * @return 节点路径
  61.       */
  62.      public static String createNode(ZooKeeper zooKeeper, String path, byte[] bytes, ArrayList<ACL> acls,CreateMode createMode) throws UnsupportedEncodingException, KeeperException, InterruptedException {
  63.          //参数说明:节点路径  数据的字节数组 权限 创建节点模式
  64.          return zooKeeper.create(path,bytes, acls, createMode);
  65.      }
  66.  }

创建节点

  1. 创建模式

PERSISTENT 　　　　　　　　 持久节点
PERSISTENT_SEQUENTIAL 　持久顺序节点
EPHEMERAL 　　　　　　　　 临时节点
EPHEMERAL_SEQUENTIAL 　 临时顺序节点

以上代码，是属于同步创建

  1.  /**
  2.       * 异步创建节点
  3.       * @param zooKeeper
  4.       * @param path
  5.       * @param bytes
  6.       * @param acls
  7.       * @param createMode
  8.       * @throws KeeperException
  9.       * @throws InterruptedException
  10.       */
  11.      public static void asCreateNode(ZooKeeper zooKeeper, String path, byte[] bytes, ArrayList<ACL> acls,CreateMode createMode) throws KeeperException, InterruptedException {
  12.  
  13.          //异步创建需要增加 AsyncCallback.StringCallback 接口的实现类 以及 一个上下文对象参数
  14.          zooKeeper.create(path, bytes, acls, createMode, new AsyncCallback.StringCallback() {
  15.              /**
  16.               *
  17.               * @param rc  节点创建结果返回码  0-节点创建成功
  18.               * @param path 节点真实路径
  19.               * @param ctx  异步调用上下文  就是 create方法本地调用的那个最后一个参数
  20.               * @param name
  21.               */
  22.              @Override
  23.              public void processResult(int rc, String path, Object ctx, String name) {
  24.                  StringBuilder stringBuilder = new StringBuilder();
  25.                  stringBuilder.append("\nrc="+rc+"\n" +
  26.                          "path="+path+"\n" +
  27.                          "ctx="+ctx+"\n" +
  28.                          "name="+name+"\n");
  29.                  logger.info(stringBuilder.toString());
  30.              }
  31.          },"异步创建");
  32.      }

异步方式创建节点

  • 获取子节点
  1.      /**
  2.       * 同步方式获取子节点
  3.       * @param zooKeeper     连接
  4.       * @param parentPath    父路径
  5.       * @return
  6.       * @throws KeeperException
  7.       * @throws InterruptedException
  8.       */
  9.      public static List<String> getChildList(ZooKeeper zooKeeper,String parentPath) throws KeeperException, InterruptedException {
  10.          //参数说明:  父节点路径  是否需要关注子节点的变化
  11.          List<String> childs = zooKeeper.getChildren(parentPath,false);
  12.          return childs;
  13.      }

同步方式获取子节点且不关注子节点的变化

异步方式获取子节点且关注子节点的变化
  1.      /**
  2.       * 异步方式获取子节点 关注子节点变化
  3.       * @param zooKeeper     连接
  4.       * @param parentPath    父路径
  5.       */
  6.      public static void asGetChildListAndWatch(ZooKeeper zooKeeper,String parentPath){
  7.          zooKeeper.getChildren(parentPath, true, new AsyncCallback.Children2Callback() {
  8.              @Override
  9.              public void processResult(int rc, String path, Object ctx, List<String> children, Stat stat) {
  10.                  logger.info("变化后的子节点:");
  11.                  for (String name:children){
  12.                      logger.info("子节点:"+name);
  13.                  }
  14.              }
  15.          },"关注子节点变化");
  16.      }

AsyncCallback.Children2Callback接口实现异步关注

目前为止可以发现这个规律，有回调函数的是异步方式调用，没有回调函数的是同步调用

问：同步调用和异步调用的使用场景是？？？

答：下面的操作依赖调用结果的时候，就需要调用同步方法

  1.  package org.zln.zk;
  2.  
  3.  import org.apache.zookeeper.*;
  4.  import org.apache.zookeeper.data.ACL;
  5.  import org.apache.zookeeper.data.Stat;
  6.  import org.slf4j.Logger;
  7.  import org.slf4j.LoggerFactory;
  8.  
  9.  import java.io.IOException;
  10.  import java.io.UnsupportedEncodingException;
  11.  import java.util.ArrayList;
  12.  import java.util.List;
  13.  
  14.  /**
  15.   * Created by sherry on 16/8/27.
  16.   */
  17.  public class TestZooKeeperClientApi {
  18.  
  19.      private static Logger logger = LoggerFactory.getLogger(TestZooKeeperClientApi.class);
  20.  
  21.      private static ZooKeeper zooKeeper;
  22.  
  23.      public static void main(String[] args) throws IOException, InterruptedException {
  24.          createSession();
  25.  
  26.          Thread.sleep(Integer.MAX_VALUE);
  27.      }
  28.  
  29.      /**
  30.       * 创建会话
  31.       */
  32.      private static ZooKeeper createSession() throws IOException, InterruptedException {
  33.          //实例化的过程,同时也是与ZooKeeper建立连接的过程,参数说明:ip:port 超时时间  监听器(实现water接口,监听器用于接收通知)
  34.          zooKeeper = new ZooKeeper("127.0.0.1:2181", 5000, new Watcher() {
  35.              @Override
  36.              public void process(WatchedEvent watchedEvent) {
  37.                  //TODO 与 ZooKeeper 的交互,一般都放在这里
  38.                  if (watchedEvent.getState() == Event.KeeperState.SyncConnected){//已连接
  39.                      logger.info("连接上了");
  40.                      try {
  41.                      //同步方式创建节点
  42.                      //String nodePath = sysCreateNode(zooKeeper,"/node_1","123".getBytes("UTF-8"), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
  43.                      //logger.info("创建节点:"+nodePath);
  44.  
  45.                      //异步方式创建节点
  46.                      //asCreateNode(zooKeeper,"/node_2","234".getBytes("UTF-8"), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
  47.  
  48.                      //同步方式获取子节点  不关注子节点变化
  49.  //                  List<String> list = getChildListNoWatch(zooKeeper,"/");
  50.  //                  for (String name:list){
  51.  //                      logger.info("子节点:"+name);
  52.  //                  }
  53.  
  54.                      //异步方式获取节点 关注子节点变化
  55.  //                    asGetChildListAndWatch(zooKeeper,"/");
  56.  
  57.                      //同步方式获取节点数据 sysGetNodeData
  58.  
  59.                          byte[] bytes = sysGetNodeDataNoWatch(zooKeeper,"/node_1");
  60.                          logger.info("获取节点数据"+new String(bytes,"UTF-8"));
  61.  
  62.                          deleteNode(zooKeeper,"/node_1",0);
  63.                      } catch (KeeperException|InterruptedException|UnsupportedEncodingException e) {
  64.                          e.printStackTrace();
  65.                      }
  66.  
  67.                  }
  68.              }
  69.          });
  70.          logger.info("查看状态:"+zooKeeper.getState());//查看状态:CONNECTING
  71.  
  72.          return zooKeeper;
  73.  
  74.      }
  75.  
  76.      /**
  77.       * 同步创建节点
  78.       * @param zooKeeper  连接
  79.       * @param path       节点路径
  80.       * @param bytes      字节数组数据
  81.       * @param acls       权限
  82.       * @param createMode 创建模式
  83.       * @return
  84.       * @throws UnsupportedEncodingException
  85.       * @throws KeeperException
  86.       * @throws InterruptedException
  87.       */
  88.      public static String sysCreateNode(ZooKeeper zooKeeper, String path, byte[] bytes, ArrayList<ACL> acls,CreateMode createMode) throws UnsupportedEncodingException, KeeperException, InterruptedException {
  89.          return zooKeeper.create(path,bytes, acls, createMode);
  90.      }
  91.  
  92.      /**
  93.       * 异步创建节点
  94.       * @param zooKeeper  连接
  95.       * @param path       节点路径
  96.       * @param bytes      字节数组数据
  97.       * @param acls       权限
  98.       * @param createMode 创建模式
  99.       * @throws KeeperException
  100.       * @throws InterruptedException
  101.       */
  102.      public static void asCreateNode(ZooKeeper zooKeeper, String path, byte[] bytes, ArrayList<ACL> acls,CreateMode createMode) throws KeeperException, InterruptedException {
  103.  
  104.          //异步创建需要增加 AsyncCallback.StringCallback 接口的实现类 以及 一个上下文对象参数
  105.          zooKeeper.create(path, bytes, acls, createMode, new AsyncCallback.StringCallback() {
  106.              /**
  107.               *
  108.               * @param rc  节点创建结果返回码  0-节点创建成功
  109.               * @param path 节点真实路径
  110.               * @param ctx  异步调用上下文  就是 create方法本地调用的那个最后一个参数
  111.               * @param name
  112.               */
  113.              @Override
  114.              public void processResult(int rc, String path, Object ctx, String name) {
  115.                  StringBuilder stringBuilder = new StringBuilder();
  116.                  stringBuilder.append("\nrc="+rc+"\n" +
  117.                          "path="+path+"\n" +
  118.                          "ctx="+ctx+"\n" +
  119.                          "name="+name+"\n");
  120.                  logger.info(stringBuilder.toString());
  121.              }
  122.          },"异步创建");
  123.      }
  124.  
  125.      /**
  126.       * 同步方式获取子节点  不关注子节点变化
  127.       * @param zooKeeper     连接
  128.       * @param parentPath    父路径
  129.       * @return
  130.       * @throws KeeperException
  131.       * @throws InterruptedException
  132.       */
  133.      public static List<String> sysGetChildListNoWatch(ZooKeeper zooKeeper,String parentPath) throws KeeperException, InterruptedException {
  134.          //参数说明:  父节点路径  是否需要关注子节点的变化  如果 true,则子节点发生变化后,会产生  NodeChildrenChanged 事件
  135.          List<String> childs = zooKeeper.getChildren(parentPath,false);
  136.          return childs;
  137.      }
  138.  
  139.      /**
  140.       * 异步方式获取子节点 关注子节点变化
  141.       * @param zooKeeper     连接
  142.       * @param parentPath    父路径
  143.       */
  144.      public static void asGetChildListAndWatch(ZooKeeper zooKeeper,String parentPath){
  145.          zooKeeper.getChildren(parentPath, true, new AsyncCallback.Children2Callback() {
  146.              @Override
  147.              public void processResult(int rc, String path, Object ctx, List<String> children, Stat stat) {
  148.                  logger.info("变化后的子节点:");
  149.                  for (String name:children){
  150.                      logger.info("子节点:"+name);
  151.                  }
  152.              }
  153.          },"关注子节点变化");
  154.      }
  155.  
  156.      /**
  157.       * 同步方式获取数据
  158.       * @param zooKeeper
  159.       * @param path
  160.       * @return
  161.       * @throws KeeperException
  162.       * @throws InterruptedException
  163.       */
  164.      public static byte[] sysGetNodeDataNoWatch(ZooKeeper zooKeeper,String path) throws KeeperException, InterruptedException {
  165.          //路径 是否关注数据变化 状态
  166.          return zooKeeper.getData(path,false,new Stat());
  167.      }
  168.  
  169.      /**
  170.       * 删除节点
  171.       * @param zooKeeper
  172.       * @param nodePath
  173.       * @param version
  174.       * @throws KeeperException
  175.       * @throws InterruptedException
  176.       */
  177.      public static void deleteNode(ZooKeeper zooKeeper,String nodePath,int version) throws KeeperException, InterruptedException {
  178.          zooKeeper.delete(nodePath,version);
  179.      }
  180.  
  181.  }

客户端代码汇总

除了ZooKeeper提供的Java API外，还有两种客户端，ZKClient和Curator两种客户端，都是对原生API的封装，使得操作更方便

《从PAXOS到ZOOKEEPER分布式一致性原理与实践》，可以参考这本书

Java API操作ZooKeeper的更多相关文章

  1. 六、Java API操作zookeeper节点

    目录 前文 pom.xml文件增加依赖 新建java文件:ZookeeperTest GitHub文件下载 前文 一.CentOS7 hadoop3.3.1安装(单机分布式.伪分布式.分布式 二.JA ...

  2. Java API 操作Zookeeper

    一.依赖 <dependency> <groupId>org.apache.zookeeper</groupId> <artifactId>zookee ...

  3. zookeeper的java api操作

    zookeeper的java api操作 创建会话: Zookeeper(String connectString,int sessionTimeout,Watcher watcher) Zookee ...

  4. Java curator操作zookeeper获取kafka

    Java curator操作zookeeper获取kafka Curator是Netflix公司开源的一个Zookeeper客户端,与Zookeeper提供的原生客户端相比,Curator的抽象层次更 ...

  5. hadoop2-HBase的Java API操作

    Hbase提供了丰富的Java API,以及线程池操作,下面我用线程池来展示一下使用Java API操作Hbase. 项目结构如下: 我使用的Hbase的版本是 hbase-0.98.9-hadoop ...

  6. java api操作

    java api操作 导入开发包 将hbase安装包中lib下包导入java项目   创建表   Configuration conf = HBaseConfiguration.create(); c ...

  7. hive-通过Java API操作

    通过Java API操作hive,算是测试hive第三种对外接口 测试hive 服务启动 package org.admln.hive; import java.sql.SQLException; i ...

  8. 使用Java API操作HDFS文件系统

    使用Junit封装HFDS import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.*; import org ...

  9. Kafka系列三 java API操作

    使用java API操作kafka 1.pom.xml <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xs ...

随机推荐

  1. input的placeholder的颜色、字号、边距设置

    #scbar_txt::-webkit-input-placeholder { /* WebKit browsers */    text-indent: 10px; font-size:16px; ...

  2. Java +安卓 定时任务

    1.android 自带闹钟定时任务 安卓闹钟可以配合广播来实现(不推荐),系统资源浪费,安卓系统在5.0以后的定时 任务貌似触发时间不准了,因为了为了省电. //获取系统闹钟 AlarmManage ...

  3. BZOJ4198: [Noi2015]荷马史诗(哈夫曼树)

    Time Limit: 10 Sec  Memory Limit: 512 MBSubmit: 1824  Solved: 983[Submit][Status][Discuss] Descripti ...

  4. 1237: [SCOI2008]配对

    Time Limit: 10 Sec  Memory Limit: 162 MBSubmit: 1789  Solved: 715[Submit][Status][Discuss] Descripti ...

  5. CSU1216: 异或最大值(01Trie树)

    Description 给定一些数,求这些数中两个数的异或值最大的那个值 Input 多组数据.第一行为数字个数n,1 <= n <= 10 ^ 5.接下来n行每行一个32位有符号非负整数 ...

  6. 线段树的应用xx中学模拟lites

    跟昨天那个自己写的,没有按照模板来的一看风格就不相类似,今天模拟赛的时候就是用的我的那个自己YY的代码,才拿了10分.个人认为关键的问题应该在于对于数据的处理太过繁琐了,所以回来之后,就拿了大佬的程序 ...

  7. 基于Xtrabackup恢复单个innodb表

      Preface       We all know that Xtrabackup is a backup tool of percona for innodb or Xtradb.It's us ...

  8. MySQL备份工具percona-xtrabackup安装

    1.安装xtrabackup的yum源 rpm -ivh https://www.percona.com/redir/downloads/percona-release/redhat/latest/p ...

  9. PHP获取异常信息

    try { } catch (\Exception $e) { $extra = [ 'code' => $e->getCode(), 'msg' => $e->getMess ...

  10. 超简单开发自己的php框架一点都不难

    (转)https://blog.csdn.net/qq_33862644/article/details/79344331 写框架的极简思路: 接收,打印参数想怎么弄.如 获取配置文件的方法,根据传过 ...