zookeeper有watch事件，是一次性触发的，当watch监视的数据发生变化时，通知设置了该watch的client，即watcher。

同样，其watcher是监听数据发送了某些变化，那就一定会有对应的事件类型和状态类型。

事件类型：(znode节点相关的)

　　EventType.NodeCreated

　　EventType.NodeDataChanged

　　EventType.NodeChildrenChanged

　　EventType.NodeDeleted

状态类型：(跟客户端实例相关的)

　　keeperState.Disconnected

　　keeperState.SyncConnected

　　keeperState.AuthFailed

　　keeperState.Expired

watcher的特性：一次性、客户端串行执行、轻量

一次性：对于ZK的watcher，只需要记住一点：zookeeper有watch事件，是一次性触发的，当watch监视的数据发生变化时，通知设置了该watch的client，即watcher，由于zookeeper的监控都是一次性的，所以每次必须设置监控。

客户端串行执行：客户端Watcher回调的过程是一个串行同步的过程，这为我们保证了顺序，同事需要开发人员注意一点，千万不要因为一个Watcher的处理逻辑影响了整个客户端的Watcher回调。

轻量：WatchedEvent 是Zookeeper整个Watcher通知机制的最小通知单元，整个结构只包含三部分：通知状态、事件类型和节点路径。也就是说Watcher通知非常的简单，只会告诉客户端发生了事件，而不会告知其具体内容，需要客户端自己去进行获取，比如NodeDataChanged事件，Zookeeper只会通知客户端指定节点的数据发生了变更，而不会直接提供具体的数据内容。

  1.  package bjsxt.zookeeper.watcher;
  2.  
  3.  import java.util.List;
  4.  import java.util.concurrent.CountDownLatch;
  5.  import java.util.concurrent.atomic.AtomicInteger;
  6.  
  7.  import org.apache.zookeeper.CreateMode;
  8.  import org.apache.zookeeper.WatchedEvent;
  9.  import org.apache.zookeeper.Watcher;
  10.  import org.apache.zookeeper.Watcher.Event.EventType;
  11.  import org.apache.zookeeper.Watcher.Event.KeeperState;
  12.  import org.apache.zookeeper.ZooDefs.Ids;
  13.  import org.apache.zookeeper.ZooKeeper;
  14.  import org.apache.zookeeper.data.Stat;
  15.  
  16.  /**
  17.   * Zookeeper Wathcher
  18.   * 本类就是一个Watcher类（实现了org.apache.zookeeper.Watcher类）
  19.   * @author（alienware）
  20.   * @since 2015-6-14
  21.   */
  22.  public class ZooKeeperWatcher implements Watcher {
  23.  
  24.      /** 定义原子变量 */
  25.      AtomicInteger seq = new AtomicInteger();
  26.      /** 定义session失效时间 */
  27.      private static final int SESSION_TIMEOUT = 10000;
  28.      /** zookeeper服务器地址 */
  29.      private static final String CONNECTION_ADDR = "192.168.80.88:2181";
  30.      /** zk父路径设置 */
  31.      private static final String PARENT_PATH = "/testWatch";
  32.      /** zk子路径设置 */
  33.      private static final String CHILDREN_PATH = "/testWatch/children";
  34.      /** 进入标识 */
  35.      private static final String LOG_PREFIX_OF_MAIN = "【Main】";
  36.      /** zk变量 */
  37.      private ZooKeeper zk = null;
  38.      /** 信号量设置，用于等待zookeeper连接建立之后 通知阻塞程序继续向下执行 */
  39.      private CountDownLatch connectedSemaphore = new CountDownLatch(1);
  40.  
  41.      /**
  42.       * 创建ZK连接
  43.       * @param connectAddr ZK服务器地址列表
  44.       * @param sessionTimeout Session超时时间
  45.       */
  46.      public void createConnection(String connectAddr, int sessionTimeout) {
  47.          this.releaseConnection();
  48.          try {
  49.              zk = new ZooKeeper(connectAddr, sessionTimeout, this);
  50.              System.out.println(LOG_PREFIX_OF_MAIN + "开始连接ZK服务器");
  51.              connectedSemaphore.await();
  52.          } catch (Exception e) {
  53.              e.printStackTrace();
  54.          }
  55.      }
  56.  
  57.      /**
  58.       * 关闭ZK连接
  59.       */
  60.      public void releaseConnection() {
  61.          if (this.zk != null) {
  62.              try {
  63.                  this.zk.close();
  64.              } catch (InterruptedException e) {
  65.                  e.printStackTrace();
  66.              }
  67.          }
  68.      }
  69.  
  70.      /**
  71.       * 创建节点
  72.       * @param path 节点路径
  73.       * @param data 数据内容
  74.       * @return
  75.       */
  76.      public boolean createPath(String path, String data) {
  77.          try {
  78.              //设置监控(由于zookeeper的监控都是一次性的所以 每次必须设置监控)
  79.              this.zk.exists(path, true);
  80.              System.out.println(LOG_PREFIX_OF_MAIN + "节点创建成功, Path: " +
  81.                                 this.zk.create(    /**路径*/
  82.                                                     path,
  83.                                                     /**数据*/
  84.                                                     data.getBytes(),
  85.                                                     /**所有可见*/
  86.                                                     Ids.OPEN_ACL_UNSAFE,
  87.                                                     /**永久存储*/
  88.                                                     CreateMode.PERSISTENT ) +
  89.                                 ", content: " + data);
  90.          } catch (Exception e) {
  91.              e.printStackTrace();
  92.              return false;
  93.          }
  94.          return true;
  95.      }
  96.  
  97.      /**
  98.       * 读取指定节点数据内容
  99.       * @param path 节点路径
  100.       * @return
  101.       */
  102.      public String readData(String path, boolean needWatch) {
  103.          try {
  104.              return new String(this.zk.getData(path, needWatch, null));
  105.          } catch (Exception e) {
  106.              e.printStackTrace();
  107.              return "";
  108.          }
  109.      }
  110.  
  111.      /**
  112.       * 更新指定节点数据内容
  113.       * @param path 节点路径
  114.       * @param data 数据内容
  115.       * @return
  116.       */
  117.      public boolean writeData(String path, String data) {
  118.          try {
  119.              System.out.println(LOG_PREFIX_OF_MAIN + "更新数据成功，path：" + path + ", stat: " +
  120.                                  this.zk.setData(path, data.getBytes(), -1));
  121.          } catch (Exception e) {
  122.              e.printStackTrace();
  123.          }
  124.          return false;
  125.      }
  126.  
  127.      /**
  128.       * 删除指定节点
  129.       *
  130.       * @param path
  131.       *            节点path
  132.       */
  133.      public void deleteNode(String path) {
  134.          try {
  135.              this.zk.delete(path, -1);
  136.              System.out.println(LOG_PREFIX_OF_MAIN + "删除节点成功，path：" + path);
  137.          } catch (Exception e) {
  138.              e.printStackTrace();
  139.          }
  140.      }
  141.  
  142.      /**
  143.       * 判断指定节点是否存在
  144.       * @param path 节点路径
  145.       */
  146.      public Stat exists(String path, boolean needWatch) {
  147.          try {
  148.              return this.zk.exists(path, needWatch);
  149.          } catch (Exception e) {
  150.              e.printStackTrace();
  151.              return null;
  152.          }
  153.      }
  154.  
  155.      /**
  156.       * 获取子节点
  157.       * @param path 节点路径
  158.       */
  159.      private List<String> getChildren(String path, boolean needWatch) {
  160.          try {
  161.              return this.zk.getChildren(path, needWatch);
  162.          } catch (Exception e) {
  163.              e.printStackTrace();
  164.              return null;
  165.          }
  166.      }
  167.  
  168.      /**
  169.       * 删除所有节点
  170.       */
  171.      public void deleteAllTestPath() {
  172.          if(this.exists(CHILDREN_PATH, false) != null){
  173.              this.deleteNode(CHILDREN_PATH);
  174.          }
  175.          if(this.exists(PARENT_PATH, false) != null){
  176.              this.deleteNode(PARENT_PATH);
  177.          }
  178.      }
  179.  
  180.      /**
  181.       * 收到来自Server的Watcher通知后的处理。
  182.       */
  183.      @Override
  184.      public void process(WatchedEvent event) {
  185.  
  186.          System.out.println("进入 process 。。。。。event = " + event);
  187.  
  188.          try {
  189.              Thread.sleep(200);
  190.          } catch (InterruptedException e) {
  191.              e.printStackTrace();
  192.          }
  193.  
  194.          if (event == null) {
  195.              return;
  196.          }
  197.  
  198.          // 连接状态
  199.          KeeperState keeperState = event.getState();
  200.          // 事件类型
  201.          EventType eventType = event.getType();
  202.          // 受影响的path
  203.          String path = event.getPath();
  204.  
  205.          String logPrefix = "【Watcher-" + this.seq.incrementAndGet() + "】";
  206.  
  207.          System.out.println(logPrefix + "收到Watcher通知");
  208.          System.out.println(logPrefix + "连接状态:\t" + keeperState.toString());
  209.          System.out.println(logPrefix + "事件类型:\t" + eventType.toString());
  210.  
  211.          if (KeeperState.SyncConnected == keeperState) {
  212.              // 成功连接上ZK服务器
  213.              if (EventType.None == eventType) {
  214.                  System.out.println(logPrefix + "成功连接上ZK服务器");
  215.                  connectedSemaphore.countDown();
  216.              }
  217.              //创建节点
  218.              else if (EventType.NodeCreated == eventType) {
  219.                  System.out.println(logPrefix + "节点创建");
  220.                  try {
  221.                      Thread.sleep(100);
  222.                  } catch (InterruptedException e) {
  223.                      e.printStackTrace();
  224.                  }
  225.                  this.exists(path, true);
  226.              }
  227.              //更新节点
  228.              else if (EventType.NodeDataChanged == eventType) {
  229.                  System.out.println(logPrefix + "节点数据更新");
  230.                  System.out.println("我看看走不走这里........");
  231.                  try {
  232.                      Thread.sleep(100);
  233.                  } catch (InterruptedException e) {
  234.                      e.printStackTrace();
  235.                  }
  236.                  System.out.println(logPrefix + "数据内容: " + this.readData(PARENT_PATH, true));
  237.              }
  238.              //更新子节点
  239.              else if (EventType.NodeChildrenChanged == eventType) {
  240.                  System.out.println(logPrefix + "子节点变更");
  241.                  try {
  242.                      Thread.sleep(3000);
  243.                  } catch (InterruptedException e) {
  244.                      e.printStackTrace();
  245.                  }
  246.                  System.out.println(logPrefix + "子节点列表：" + this.getChildren(PARENT_PATH, true));
  247.              }
  248.              //删除节点
  249.              else if (EventType.NodeDeleted == eventType) {
  250.                  System.out.println(logPrefix + "节点 " + path + " 被删除");
  251.              }
  252.              else ;
  253.          }
  254.          else if (KeeperState.Disconnected == keeperState) {
  255.              System.out.println(logPrefix + "与ZK服务器断开连接");
  256.          }
  257.          else if (KeeperState.AuthFailed == keeperState) {
  258.              System.out.println(logPrefix + "权限检查失败");
  259.          }
  260.          else if (KeeperState.Expired == keeperState) {
  261.              System.out.println(logPrefix + "会话失效");
  262.          }
  263.          else ;
  264.  
  265.          System.out.println("--------------------------------------------");
  266.  
  267.      }
  268.  
  269.      /**
  270.       * <B>方法名称：</B>测试zookeeper监控<BR>
  271.       * <B>概要说明：</B>主要测试watch功能<BR>
  272.       * @param args
  273.       * @throws Exception
  274.       */
  275.      public static void main(String[] args) throws Exception {
  276.  
  277.          //建立watcher
  278.          ZooKeeperWatcher zkWatch = new ZooKeeperWatcher();
  279.          //创建连接
  280.          zkWatch.createConnection(CONNECTION_ADDR, SESSION_TIMEOUT);
  281.          //System.out.println(zkWatch.zk.toString());
  282.  
  283.          Thread.sleep(1000);
  284.  
  285.          // 清理节点
  286.          zkWatch.deleteAllTestPath();
  287.  
  288.          if (zkWatch.createPath(PARENT_PATH, System.currentTimeMillis() + "")) {
  289.  
  290.              Thread.sleep(1000);
  291.  
  292.              // 读取数据
  293.              System.out.println("---------------------- read parent ----------------------------");
  294.              //zkWatch.readData(PARENT_PATH, true);
  295.  
  296.              // 读取子节点
  297.              System.out.println("---------------------- read children path ----------------------------");
  298.              zkWatch.getChildren(PARENT_PATH, true);
  299.  
  300.              // 更新数据
  301.              zkWatch.writeData(PARENT_PATH, System.currentTimeMillis() + "");
  302.  
  303.              Thread.sleep(1000);
  304.  
  305.              // 创建子节点
  306.              zkWatch.createPath(CHILDREN_PATH, System.currentTimeMillis() + "");
  307.  
  308.              Thread.sleep(1000);
  309.  
  310.              zkWatch.writeData(CHILDREN_PATH, System.currentTimeMillis() + "");
  311.          }
  312.  
  313.          Thread.sleep(50000);
  314.          // 清理节点
  315.          zkWatch.deleteAllTestPath();
  316.          Thread.sleep(1000);
  317.          zkWatch.releaseConnection();
  318.      }
  319.  
  320.  }

zookeeper的ACL （AUTH）

ACL（Access Control List）,Zookeeper作为一个分布式协调框架，其内部存储的都是一些关乎分布式系统运行时状态的元数据，尤其是涉及到一些分布式锁、Master选举和协调等应用场景。我们需要有效地保障Zookeeper中的数据安全，Zookeeper提供一套完善的ACL权限控制机制来保障数据的安全。

ZK提供了三种模式。权限模式，授权对象，权限。

权限模式：Scheme,开发人员最多使用一下四种权限模式：

　　IP：ip模式通过ip地址粒度来进行控制权限，例如配置了：ip:192.168.1.109即表示权限控制都是针对这个ip地址的，同时也支持按网段分配，比如192.168.1.*

　　Digest:digest是最常用的权限控制模式，也更符合我们对权限控制的认识，其类似于“username：password” 形式的权限标识进行权限配置，ZK会对形成的权限标识先后进行两次编码处理，分别是SHA-1加密算法、BASE64编码。

　　World：World是一直最开放的全校性控制模式，这种模式可以看作为特殊的Digest，他仅仅是一个标识而已。

　　Super：超级用户模式，在超级用户模式下可以对ZK任意进行操作

权限对象：指的是权限赋予的用户或者一个指定的实体，例如ip地址或机器等，在不同的模式下，授权对象是不同的，这种模式和权限对象一一对应。

权限：权限就是指那些通过权限检测后可以被允许执行的操作，在ZK中，对数据的操作权限分为以下五大类：

　　CREATE，DELLETE，READ，WRITE，ADMIN

  1.  package bjsxt.zookeeper.auth;
  2.  
  3.  import java.util.ArrayList;
  4.  import java.util.List;
  5.  import java.util.concurrent.CountDownLatch;
  6.  import java.util.concurrent.atomic.AtomicInteger;
  7.  
  8.  import org.apache.zookeeper.CreateMode;
  9.  import org.apache.zookeeper.WatchedEvent;
  10.  import org.apache.zookeeper.Watcher;
  11.  import org.apache.zookeeper.Watcher.Event.EventType;
  12.  import org.apache.zookeeper.Watcher.Event.KeeperState;
  13.  import org.apache.zookeeper.ZooDefs.Ids;
  14.  import org.apache.zookeeper.ZooKeeper;
  15.  import org.apache.zookeeper.data.ACL;
  16.  import org.apache.zookeeper.data.Stat;
  17.  /**
  18.   * Zookeeper 节点授权
  19.   * @author（alienware）
  20.   * @since 2015-6-14
  21.   */
  22.  public class ZookeeperAuth implements Watcher {
  23.  
  24.      /** 连接地址 */
  25.      final static String CONNECT_ADDR = "192.168.80.88:2181";
  26.      /** 测试路径 */
  27.      final static String PATH = "/testAuth";
  28.      final static String PATH_DEL = "/testAuth/delNode";
  29.      /** 认证类型 */
  30.      final static String authentication_type = "digest";
  31.      /** 认证正确方法 */
  32.      final static String correctAuthentication = "123456";
  33.      /** 认证错误方法 */
  34.      final static String badAuthentication = "654321";
  35.  
  36.      static ZooKeeper zk = null;
  37.      /** 计时器 */
  38.      AtomicInteger seq = new AtomicInteger();
  39.      /** 标识 */
  40.      private static final String LOG_PREFIX_OF_MAIN = "【Main】";
  41.  
  42.      private CountDownLatch connectedSemaphore = new CountDownLatch(1);
  43.  
  44.      @Override
  45.      public void process(WatchedEvent event) {
  46.          try {
  47.              Thread.sleep(200);
  48.          } catch (InterruptedException e) {
  49.              e.printStackTrace();
  50.          }
  51.          if (event==null) {
  52.              return;
  53.          }
  54.          // 连接状态
  55.          KeeperState keeperState = event.getState();
  56.          // 事件类型
  57.          EventType eventType = event.getType();
  58.          // 受影响的path
  59.          String path = event.getPath();
  60.  
  61.          String logPrefix = "【Watcher-" + this.seq.incrementAndGet() + "】";
  62.  
  63.          System.out.println(logPrefix + "收到Watcher通知");
  64.          System.out.println(logPrefix + "连接状态:\t" + keeperState.toString());
  65.          System.out.println(logPrefix + "事件类型:\t" + eventType.toString());
  66.          if (KeeperState.SyncConnected == keeperState) {
  67.              // 成功连接上ZK服务器
  68.              if (EventType.None == eventType) {
  69.                  System.out.println(logPrefix + "成功连接上ZK服务器");
  70.                  connectedSemaphore.countDown();
  71.              }
  72.          } else if (KeeperState.Disconnected == keeperState) {
  73.              System.out.println(logPrefix + "与ZK服务器断开连接");
  74.          } else if (KeeperState.AuthFailed == keeperState) {
  75.              System.out.println(logPrefix + "权限检查失败");
  76.          } else if (KeeperState.Expired == keeperState) {
  77.              System.out.println(logPrefix + "会话失效");
  78.          }
  79.          System.out.println("--------------------------------------------");
  80.      }
  81.      /**
  82.       * 创建ZK连接
  83.       *
  84.       * @param connectString
  85.       *            ZK服务器地址列表
  86.       * @param sessionTimeout
  87.       *            Session超时时间
  88.       */
  89.      public void createConnection(String connectString, int sessionTimeout) {
  90.          this.releaseConnection();
  91.          try {
  92.              zk = new ZooKeeper(connectString, sessionTimeout, this);
  93.              //添加节点授权
  94.              zk.addAuthInfo(authentication_type,correctAuthentication.getBytes());
  95.              System.out.println(LOG_PREFIX_OF_MAIN + "开始连接ZK服务器");
  96.              //倒数等待
  97.              connectedSemaphore.await();
  98.          } catch (Exception e) {
  99.              e.printStackTrace();
  100.          }
  101.      }
  102.  
  103.      /**
  104.       * 关闭ZK连接
  105.       */
  106.      public void releaseConnection() {
  107.          if (this.zk!=null) {
  108.              try {
  109.                  this.zk.close();
  110.              } catch (InterruptedException e) {
  111.              }
  112.          }
  113.      }
  114.  
  115.      /**
  116.       *
  117.       * <B>方法名称：</B>测试函数<BR>
  118.       * <B>概要说明：</B>测试认证<BR>
  119.       * @param args
  120.       * @throws Exception
  121.       */
  122.      public static void main(String[] args) throws Exception {
  123.  
  124.          ZookeeperAuth testAuth = new ZookeeperAuth();
  125.          testAuth.createConnection(CONNECT_ADDR,2000);
  126.          List<ACL> acls = new ArrayList<ACL>(1);
  127.          for (ACL ids_acl : Ids.CREATOR_ALL_ACL) {
  128.              acls.add(ids_acl);
  129.          }
  130.  
  131.          try {
  132.              zk.create(PATH, "init content".getBytes(), acls, CreateMode.PERSISTENT);
  133.              System.out.println("使用授权key：" + correctAuthentication + "创建节点："+ PATH + ", 初始内容是: init content");
  134.          } catch (Exception e) {
  135.              e.printStackTrace();
  136.          }
  137.          try {
  138.              zk.create(PATH_DEL, "will be deleted! ".getBytes(), acls, CreateMode.PERSISTENT);
  139.              System.out.println("使用授权key：" + correctAuthentication + "创建节点："+ PATH_DEL + ", 初始内容是: init content");
  140.          } catch (Exception e) {
  141.              e.printStackTrace();
  142.          }
  143.  
  144.          // 获取数据
  145.          getDataByNoAuthentication();
  146.          getDataByBadAuthentication();
  147.          getDataByCorrectAuthentication();
  148.  
  149.          // 更新数据
  150.          updateDataByNoAuthentication();
  151.          updateDataByBadAuthentication();
  152.          updateDataByCorrectAuthentication();
  153.  
  154.          // 删除数据
  155.          deleteNodeByBadAuthentication();
  156.          deleteNodeByNoAuthentication();
  157.          deleteNodeByCorrectAuthentication();
  158.          //
  159.          Thread.sleep(1000);
  160.  
  161.          deleteParent();
  162.          //释放连接
  163.          testAuth.releaseConnection();
  164.      }
  165.      /** 获取数据：采用错误的密码 */
  166.      static void getDataByBadAuthentication() {
  167.          String prefix = "[使用错误的授权信息]";
  168.          try {
  169.              ZooKeeper badzk = new ZooKeeper(CONNECT_ADDR, 2000, null);
  170.              //授权
  171.              badzk.addAuthInfo(authentication_type,badAuthentication.getBytes());
  172.              Thread.sleep(2000);
  173.              System.out.println(prefix + "获取数据：" + PATH);
  174.              System.out.println(prefix + "成功获取数据：" + badzk.getData(PATH, false, null));
  175.          } catch (Exception e) {
  176.              System.err.println(prefix + "获取数据失败，原因：" + e.getMessage());
  177.          }
  178.      }
  179.  
  180.      /** 获取数据：不采用密码 */
  181.      static void getDataByNoAuthentication() {
  182.          String prefix = "[不使用任何授权信息]";
  183.          try {
  184.              System.out.println(prefix + "获取数据：" + PATH);
  185.              ZooKeeper nozk = new ZooKeeper(CONNECT_ADDR, 2000, null);
  186.              Thread.sleep(2000);
  187.              System.out.println(prefix + "成功获取数据：" + nozk.getData(PATH, false, null));
  188.          } catch (Exception e) {
  189.              System.err.println(prefix + "获取数据失败，原因：" + e.getMessage());
  190.          }
  191.      }
  192.  
  193.      /** 采用正确的密码 */
  194.      static void getDataByCorrectAuthentication() {
  195.          String prefix = "[使用正确的授权信息]";
  196.          try {
  197.              System.out.println(prefix + "获取数据：" + PATH);
  198.  
  199.              System.out.println(prefix + "成功获取数据：" + zk.getData(PATH, false, null));
  200.          } catch (Exception e) {
  201.              System.out.println(prefix + "获取数据失败，原因：" + e.getMessage());
  202.          }
  203.      }
  204.  
  205.      /**
  206.       * 更新数据：不采用密码
  207.       */
  208.      static void updateDataByNoAuthentication() {
  209.  
  210.          String prefix = "[不使用任何授权信息]";
  211.  
  212.          System.out.println(prefix + "更新数据： " + PATH);
  213.          try {
  214.              ZooKeeper nozk = new ZooKeeper(CONNECT_ADDR, 2000, null);
  215.              Thread.sleep(2000);
  216.              Stat stat = nozk.exists(PATH, false);
  217.              if (stat!=null) {
  218.                  nozk.setData(PATH, prefix.getBytes(), -1);
  219.                  System.out.println(prefix + "更新成功");
  220.              }
  221.          } catch (Exception e) {
  222.              System.err.println(prefix + "更新失败，原因是：" + e.getMessage());
  223.          }
  224.      }
  225.  
  226.      /**
  227.       * 更新数据：采用错误的密码
  228.       */
  229.      static void updateDataByBadAuthentication() {
  230.  
  231.          String prefix = "[使用错误的授权信息]";
  232.  
  233.          System.out.println(prefix + "更新数据：" + PATH);
  234.          try {
  235.              ZooKeeper badzk = new ZooKeeper(CONNECT_ADDR, 2000, null);
  236.              //授权
  237.              badzk.addAuthInfo(authentication_type,badAuthentication.getBytes());
  238.              Thread.sleep(2000);
  239.              Stat stat = badzk.exists(PATH, false);
  240.              if (stat!=null) {
  241.                  badzk.setData(PATH, prefix.getBytes(), -1);
  242.                  System.out.println(prefix + "更新成功");
  243.              }
  244.          } catch (Exception e) {
  245.              System.err.println(prefix + "更新失败，原因是：" + e.getMessage());
  246.          }
  247.      }
  248.  
  249.      /**
  250.       * 更新数据：采用正确的密码
  251.       */
  252.      static void updateDataByCorrectAuthentication() {
  253.  
  254.          String prefix = "[使用正确的授权信息]";
  255.  
  256.          System.out.println(prefix + "更新数据：" + PATH);
  257.          try {
  258.              Stat stat = zk.exists(PATH, false);
  259.              if (stat!=null) {
  260.                  zk.setData(PATH, prefix.getBytes(), -1);
  261.                  System.out.println(prefix + "更新成功");
  262.              }
  263.          } catch (Exception e) {
  264.              System.err.println(prefix + "更新失败，原因是：" + e.getMessage());
  265.          }
  266.      }
  267.  
  268.      /**
  269.       * 不使用密码 删除节点
  270.       */
  271.      static void deleteNodeByNoAuthentication() throws Exception {
  272.  
  273.          String prefix = "[不使用任何授权信息]";
  274.  
  275.          try {
  276.              System.out.println(prefix + "删除节点：" + PATH_DEL);
  277.              ZooKeeper nozk = new ZooKeeper(CONNECT_ADDR, 2000, null);
  278.              Thread.sleep(2000);
  279.              Stat stat = nozk.exists(PATH_DEL, false);
  280.              if (stat!=null) {
  281.                  nozk.delete(PATH_DEL,-1);
  282.                  System.out.println(prefix + "删除成功");
  283.              }
  284.          } catch (Exception e) {
  285.              System.err.println(prefix + "删除失败，原因是：" + e.getMessage());
  286.          }
  287.      }
  288.  
  289.      /**
  290.       * 采用错误的密码删除节点
  291.       */
  292.      static void deleteNodeByBadAuthentication() throws Exception {
  293.  
  294.          String prefix = "[使用错误的授权信息]";
  295.  
  296.          try {
  297.              System.out.println(prefix + "删除节点：" + PATH_DEL);
  298.              ZooKeeper badzk = new ZooKeeper(CONNECT_ADDR, 2000, null);
  299.              //授权
  300.              badzk.addAuthInfo(authentication_type,badAuthentication.getBytes());
  301.              Thread.sleep(2000);
  302.              Stat stat = badzk.exists(PATH_DEL, false);
  303.              if (stat!=null) {
  304.                  badzk.delete(PATH_DEL, -1);
  305.                  System.out.println(prefix + "删除成功");
  306.              }
  307.          } catch (Exception e) {
  308.              System.err.println(prefix + "删除失败，原因是：" + e.getMessage());
  309.          }
  310.      }
  311.  
  312.      /**
  313.       * 使用正确的密码删除节点
  314.       */
  315.      static void deleteNodeByCorrectAuthentication() throws Exception {
  316.  
  317.          String prefix = "[使用正确的授权信息]";
  318.  
  319.          try {
  320.              System.out.println(prefix + "删除节点：" + PATH_DEL);
  321.              Stat stat = zk.exists(PATH_DEL, false);
  322.              if (stat!=null) {
  323.                  zk.delete(PATH_DEL, -1);
  324.                  System.out.println(prefix + "删除成功");
  325.              }
  326.          } catch (Exception e) {
  327.              System.out.println(prefix + "删除失败，原因是：" + e.getMessage());
  328.          }
  329.      }
  330.  
  331.      /**
  332.       * 使用正确的密码删除节点
  333.       */
  334.      static void deleteParent() throws Exception {
  335.          try {
  336.              Stat stat = zk.exists(PATH_DEL, false);
  337.              if (stat == null) {
  338.                  zk.delete(PATH, -1);
  339.              }
  340.          } catch (Exception e) {
  341.              e.printStackTrace();
  342.          }
  343.      }
  344.  
  345.  }

Watcher、ZK状态、事件类型 ，权限的更多相关文章

  1. AS3事件类型

    Event事件类型: ACTIVATE       激活事件 DEACTIVATE 对象休眠事件 ADDED      可视对象添加事件 ADDED_TO_STAGE 可视对象添加到舞台事件 REMO ...

  2. Zookeeper学习之Watcher事件类型和ZK状态

    1.Zookeepe  Watcherr的事件类型和ZK状态. zookeeper:Watcher.ZK状态,事件类型(一)zookeeper有watch事件,是一次性触发的,当watch监视的数据发 ...

  3. openerp学习笔记 视图样式（表格行颜色、按钮，字段只读、隐藏，按钮状态、类型、图标、权限，group边距，聚合[合计、平均]，样式）

    表格行颜色:             <tree string="请假单列表" colors="red:state == 'refuse';blue:state = ...

  4. MySQL binlog中的事件类型

    MySQL binlog记录的所有操作实际上都有对应的事件类型的,譬如STATEMENT格式中的DML操作对应的是QUERY_EVENT类型,ROW格式下的DML操作对应的是ROWS_EVENT类型. ...

  5. 深入理解DOM事件类型系列第二篇——键盘事件

    × 目录 [1]类型 [2]顺序 [3]按键信息[4]应用 前面的话 鼠标和键盘是电脑端主要的输入设备,上篇介绍了鼠标事件,本文将详细介绍键盘事件 类型 键盘事件用来描述键盘行为,主要有keydown ...

  6. DOM事件类型详解

    一.表单事件: input事件当<input>.<textarea>的值发生变化时触发.此外,打开contenteditable属性的元素,只要值发生变化,也会触发input事 ...

  7. JS中的事件类型和事件属性的基础知识

    周末无聊, 这几天又复习了下JS搞基程序设计3, 想着好记性不如浪笔头哇, 要么把这些东西写下来, 这样基础才能更加扎实么么哒, 知道的同学也可以直接过一下,当做复习,  小姨子再也不用担心我的学习啦 ...

  8. 在 SharePoint Server 2013 中配置建议和使用率事件类型

    http://technet.microsoft.com/zh-cn/library/jj715889.aspx 适用于: SharePoint Server 2013 利用使用事件,您可以跟踪用户与 ...

  9. WWF3事件类型活动<第三篇>

    WWF将工作流分为两大类: 面向Human:在工作流运行时通过用户对外部应用程序的操作来影响工作流的业务流转. 面向System:应用程序控制流程. 工作流与应用程序都是可以单独存在的,因此它们之间的 ...

随机推荐

  1. java解析文件

    遇到两个小坑: 1.使用String.split,部分分隔符需要转义:https://www.cnblogs.com/mingforyou/archive/2013/09/03/3299569.htm ...

  2. CentOS 7.0安装配置Vsftp服务器步骤详解

    安装Vsftp讲过最多的就是在centos6.x版本中了,这里小编看到有朋友写了一篇非常不错的CentOS 7.0安装配置Vsftp服务器教程,下面整理分享给各位. 一.配置防火墙,开启FTP服务器需 ...

  3. IUSER 匿名帐户密码获取

    如何获取IUSR帐号和密码呢?有两种方法 1.安装IIS Resources,打开IIS Resources中的Metabase Explorer->机器名->LM->W3SVC-& ...

  4. 机器学习进阶-案例实战-图像全景拼接-书籍SIFT特征点连接 1.cv2.drawMatches(对两个图像的关键点进行连线操作)

    1.cv2.drawMatches(imageA, kpsA, imageB, kpsB, matches[:10], None, flags=2)  # 对两个图像关键点进行连线操作 参数说明:im ...

  5. JAVA版开源微信管家—JeeWx捷微3.2版本发布，支持微信公众号，微信企业号，支付窗、小程序

    JeeWx捷微3.2微信企业号升级版本发布^_^ JeeWx捷微V3.2——多触点管理平台(支持微信公众号,微信企业号,支付窗.小程序)   JeeWx捷微V3.2.0版本引入了更多新特性,支持微信公 ...

  6. Vue 修改dist 目录.

    前后端分析之后,前端 打包处理 2

  7. 一个Tparams小测试

    var aParams: TParams; aPar: TParam; I:Integer; begin aParams := TParams.Create(nil); aPar := aParams ...

  8. 火狐的3d视图插件Tilt 3D

    15年的时候,使用过此功能.后来没注意就发现没了.firefox在47之后就停止自带了. 换成插件了. https://addons.mozilla.org/en-US/firefox/addon/t ...

  9. UploadFtp

    #!/bin/bash FILENAME=$ DSTDIR=$ FTPSRV=ip FTPUSER="user" FTPPWD="password" SRCDI ...

  10. DAX2012 R3安装

    安装程序跟DAX2009大同小异,不过这验证需要的组件也太多了,简直是.NET Framework大阅兵啊,各种版本都需要安装,特别是VC++从2008一直装到2012,有点崩溃... DEMO数据的 ...