zookeeper一文精通(上)

作者: OpenCoder | 来源:发表于2020-09-09 22:24 被阅读0次

更多文章请关注公众号：IT巡游屋

一、zookeeper简介

Zookeeper是一个高效的分布式协调服务，由雅虎创建，是 Google Chubby 的开源实现。它暴露了一些公用服务，比如命名服务/配置管理/同步控制/群组服务等。我们可以使用ZK来实现比如达成共识/集群管理/leader选举等。利用zookeeper的ZAB算法(原子消费广播协议)能够很好地保证分布式环境中数据的一致性，也正是基于这样的特性，使得Zookeeper成为了解决分布式一致性问题的利器。

二、Zookeeper的数据模型

Zookeeper的数据模型是什么样子呢？它很像数据结构当中的树，也很像文件系统的目录。

image

树是由节点所组成，Zookeeper的数据存储也同样是基于节点，这种节点叫做Znode。

但是，不同于树的节点，Znode的引用方式是路径引用，类似于文件路径：

/ 动物 / 仓鼠

/ 植物 / 荷花

这样的层级结构，让每一个Znode节点拥有唯一的路径，就像命名空间一样对不同信息作出清晰的隔离。

Znode节点中包含以下数据：

image

data：Znode存储的数据信息。
ACL：记录Znode的访问权限，即哪些人或哪些IP可以访问本节点。
stat：包含Znode的各种元数据，比如事务ID、版本号(version)、时间戳、大小等等。
child：当前节点的子节点引用，类似于二叉树的左孩子右孩子。

这里需要注意一点，Zookeeper是为读多写少的场景所设计。Znode并不是用来存储大规模业务数据，而是用于存储少量的状态和配置信息，每个节点的数据最大不能超过1MB。

三、Zookeeper的基本操作和事件通知

基本操作：

create ：创建节点
delete ：删除节点
exists ：判断节点是否存在
getData() ：获得一个节点的数据
setData ：设置一个节点的数据
getChildren ：获取节点下的所有子节点

这其中，exists，getData，getChildren属于读操作。Zookeeper客户端在请求读操作的时候，可以选择是否设置Watch。我们可以理解成是注册在特定Znode上的触发器。当这个Znode发生改变，也就是调用了create，delete，setData方法的时候，将会触发Znode上注册的对应事件，请求Watch的客户端会接收到异步通知。

具体交互过程如下：

1.客户端调用getData方法，watch参数是true。服务端接到请求，返回节点数据，并且在对应的哈希表里插入被Watch的Znode路径，以及Watcher列表。

image

四、java客户端操作Zookeeper

引入依赖

<dependency>
  <groupId>org.apache.zookeeper</groupId>
    <artifactId>zookeeper</artifactId>
    <version>3.4.6</version>
</dependency>

操作代码如下：

public class ZookeeperBase {
        static final String CONNECT_ADDR = "192.168.2.2:2181";
        /** session超时时间 */
        static final int SESSION_OUTTIME = 2000;// ms
        /** 信号量，阻塞程序执行，用于等待zookeeper连接成功，发送成功信号 */
        static final CountDownLatch connectedSemaphore = new CountDownLatch(1);
        
        public static void main(String[] args) throws Exception {
    
            ZooKeeper zk = new ZooKeeper(CONNECT_ADDR, SESSION_OUTTIME,
                    new Watcher() {
                        @Override
                        public void process(WatchedEvent event) {
                            // 获取事件的状态
                            KeeperState keeperState = event.getState();
                            EventType eventType = event.getType();
                            // 如果是建立连接
                            if (KeeperState.SyncConnected == keeperState) {
                                if (EventType.None == eventType) {
                                    // 如果建立连接成功，则发送信号量，让后续阻塞程序向下执行
                                    System.out.println("zk 建立连接");
                                    connectedSemaphore.countDown();
                                }
                            }
                        }
                    });
        
            // 进行阻塞
            connectedSemaphore.await();
        
            System.out.println("..");
            // 创建父节点
            // zk.create("/testRoot", "testRoot".getBytes(), Ids.OPEN_ACL_UNSAFE,
            // CreateMode.PERSISTENT);
        
            // 创建子节点
            // zk.create("/testRoot/children", "children data".getBytes(),
            // Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        
            // 获取节点洗信息
            // byte[] data = zk.getData("/testRoot", false, null);
            // System.out.println(new String(data));
            // System.out.println(zk.getChildren("/testRoot", false));
        
            // 修改节点的值
            // zk.setData("/testRoot", "modify data root".getBytes(), -1);
            // byte[] data = zk.getData("/testRoot", false, null);
            // System.out.println(new String(data));
        
            // 判断节点是否存在
            // System.out.println(zk.exists("/testRoot/children", false));
            // 删除节点
            // zk.delete("/testRoot/children", -1);
            // System.out.println(zk.exists("/testRoot/children", false));
            zk.close();
          }
      }

五、zookeeper核心原理-Watcher、ZK状态、事件类型、权限
zookeeper有watch事件，是一次性触发的，当watch监视的数据发生变化时，通知设置了该watch的client，即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只会通知客户端指定节点的数据发生了变更，而不会直接提供具体的数据内容。

操作代码如下:

public class ZooKeeperWatcher implements Watcher {
/** 定义原子变量 */
AtomicInteger seq = new AtomicInteger();
/** 定义session失效时间 */
private static final int SESSION_TIMEOUT = 10000;
/** zookeeper服务器地址 */
private static final String CONNECTION_ADDR = "192.168.80.88:2181";
/** zk父路径设置 */
private static final String PARENT_PATH = "/testWatch";
/** zk子路径设置 */
private static final String CHILDREN_PATH = "/testWatch/children";
/** 进入标识 */
private static final String LOG_PREFIX_OF_MAIN = "【Main】";
/** zk变量 */
private ZooKeeper zk = null;
/** 信号量设置，用于等待zookeeper连接建立之后 通知阻塞程序继续向下执行 */
private CountDownLatch connectedSemaphore = new CountDownLatch(1);

/**
* 创建ZK连接
* @param connectAddr ZK服务器地址列表
* @param sessionTimeout Session超时时间
*/
public void createConnection(String connectAddr, int sessionTimeout) {
  this.releaseConnection();
  try {
    zk = new ZooKeeper(connectAddr, sessionTimeout, this);
    System.out.println(LOG_PREFIX_OF_MAIN + "开始连接ZK服务器");
    connectedSemaphore.await();
  } catch (Exception e) {
    e.printStackTrace();
  }
}

/**
* 关闭ZK连接
*/
public void releaseConnection() {
  if (this.zk != null) {
    try {
        this.zk.close();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
  }
}

/**
* 创建节点
* @param path 节点路径
* @param data 数据内容
* @return 
*/
public boolean createPath(String path, String data) {
  try {
    //设置监控(由于zookeeper的监控都是一次性的所以 每次必须设置监控)
    this.zk.exists(path, true);
    System.out.println(LOG_PREFIX_OF_MAIN + "节点创建成功, Path: " + 
         this.zk.create(    /**路径*/ 
                             path, 
                             /**数据*/
                             data.getBytes(), 
                             /**所有可见*/
                             Ids.OPEN_ACL_UNSAFE, 
                             /**永久存储*/
                             CreateMode.PERSISTENT ) +     
         ", content: " + data);
  } catch (Exception e) {
    e.printStackTrace();
    return false;
  }
  return true;
}

/**
* 读取指定节点数据内容
* @param path 节点路径
* @return
*/
public String readData(String path, boolean needWatch) {
  try {
    return new String(this.zk.getData(path, needWatch, null));
  } catch (Exception e) {
    e.printStackTrace();
    return "";
  }
}

/**
* 更新指定节点数据内容
* @param path 节点路径
* @param data 数据内容
* @return
*/
public boolean writeData(String path, String data) {
  try {
    System.out.println(LOG_PREFIX_OF_MAIN + "更新数据成功，path：" + path + ", stat: " +
                        this.zk.setData(path, data.getBytes(), -1));
  } catch (Exception e) {
    e.printStackTrace();
  }
  return false;
}

/**
* 删除指定节点
* 
* @param path
*            节点path
*/
public void deleteNode(String path) {
  try {
    this.zk.delete(path, -1);
    System.out.println(LOG_PREFIX_OF_MAIN + "删除节点成功，path：" + path);
  } catch (Exception e) {
    e.printStackTrace();
  }
}
/**
* 判断指定节点是否存在
* @param path 节点路径
*/
public Stat exists(String path, boolean needWatch) {
  try {
    return this.zk.exists(path, needWatch);
  } catch (Exception e) {
    e.printStackTrace();
    return null;
  }
}
/**
* 获取子节点
* @param path 节点路径
*/
private List<String> getChildren(String path, boolean needWatch) {
  try {
    return this.zk.getChildren(path, needWatch);
  } catch (Exception e) {
    e.printStackTrace();
    return null;
  }
}
/**
* 删除所有节点
*/
public void deleteAllTestPath() {
  if(this.exists(CHILDREN_PATH, false) != null){
    this.deleteNode(CHILDREN_PATH);
  }
  if(this.exists(PARENT_PATH, false) != null){
    this.deleteNode(PARENT_PATH);
  }        
}
/**
* 收到来自Server的Watcher通知后的处理。
*/
@Override
public void process(WatchedEvent event) {     
  System.out.println("进入 process 。。。。。event = " + event);
  try {
    Thread.sleep(200);
  } catch (InterruptedException e) {
    e.printStackTrace();
  }
  if (event == null) {
    return;
}
// 连接状态
KeeperState keeperState = event.getState();
// 事件类型
EventType eventType = event.getType();
// 受影响的path
String path = event.getPath();

String logPrefix = "【Watcher-" + this.seq.incrementAndGet() + "】";

System.out.println(logPrefix + "收到Watcher通知");
System.out.println(logPrefix + "连接状态:\t" + keeperState.toString());
System.out.println(logPrefix + "事件类型:\t" + eventType.toString());

if (KeeperState.SyncConnected == keeperState) {
  // 成功连接上ZK服务器
  if (EventType.None == eventType) {
      System.out.println(logPrefix + "成功连接上ZK服务器");
      connectedSemaphore.countDown();
  } 
  //创建节点
  else if (EventType.NodeCreated == eventType) {
      System.out.println(logPrefix + "节点创建");
      try {
          Thread.sleep(100);
      } catch (InterruptedException e) {
          e.printStackTrace();
      }
      this.exists(path, true);
  } 
  //更新节点
  else if (EventType.NodeDataChanged == eventType) {
      System.out.println(logPrefix + "节点数据更新");
      System.out.println("我看看走不走这里........");
      try {
          Thread.sleep(100);
      } catch (InterruptedException e) {
          e.printStackTrace();
      }
      System.out.println(logPrefix + "数据内容: " + this.readData(PARENT_PATH, true));
  } 
  //更新子节点
  else if (EventType.NodeChildrenChanged == eventType) {
      System.out.println(logPrefix + "子节点变更");
      try {
          Thread.sleep(3000);
      } catch (InterruptedException e) {
          e.printStackTrace();
      }
      System.out.println(logPrefix + "子节点列表：" + this.getChildren(PARENT_PATH, true));
  } 
  //删除节点
  else if (EventType.NodeDeleted == eventType) {
      System.out.println(logPrefix + "节点 " + path + " 被删除");
  }
  else ;
  } 
  else if (KeeperState.Disconnected == keeperState) {
    System.out.println(logPrefix + "与ZK服务器断开连接");
  } 
  else if (KeeperState.AuthFailed == keeperState) {
    System.out.println(logPrefix + "权限检查失败");
  } 
  else if (KeeperState.Expired == keeperState) {
    System.out.println(logPrefix + "会话失效");
  }
  else ;
  System.out.println("--------------------------------------------");
  
}

/**
* <B>方法名称：</B>测试zookeeper监控<BR>
* <B>概要说明：</B>主要测试watch功能<BR>
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
//建立watcher
ZooKeeperWatcher zkWatch = new ZooKeeperWatcher();
//创建连接
zkWatch.createConnection(CONNECTION_ADDR, SESSION_TIMEOUT);
//System.out.println(zkWatch.zk.toString());
Thread.sleep(1000);
// 清理节点
zkWatch.deleteAllTestPath();

if (zkWatch.createPath(PARENT_PATH, System.currentTimeMillis() + "")) {
  Thread.sleep(1000);
  // 读取数据
  System.out.println("---------------------- read parent ----------------------------");
  //zkWatch.readData(PARENT_PATH, true);
  
  // 读取子节点
  System.out.println("---------------------- read children path ----------------------------");
  zkWatch.getChildren(PARENT_PATH, true);

  // 更新数据
  zkWatch.writeData(PARENT_PATH, System.currentTimeMillis() + "");
  
  Thread.sleep(1000);
  
  // 创建子节点
  zkWatch.createPath(CHILDREN_PATH, System.currentTimeMillis() + "");
  
  Thread.sleep(1000);
  
  zkWatch.writeData(CHILDREN_PATH, System.currentTimeMillis() + "");
}
Thread.sleep(50000);
// 清理节点
zkWatch.deleteAllTestPath();
Thread.sleep(1000);
zkWatch.releaseConnection();
}

}

zookeeper的ACL(AUTH):ACL（Access Control ListZookeeper)提供一套完善的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

操作代码如下：

public class ZookeeperAuth implements Watcher {
/** 连接地址 */
final static String CONNECT_ADDR = "192.168.80.88:2181";
/** 测试路径 */
final static String PATH = "/testAuth";
final static String PATH_DEL = "/testAuth/delNode";
/** 认证类型 */
final static String authentication_type = "digest";
/** 认证正确方法 */
final static String correctAuthentication = "123456";
/** 认证错误方法 */
final static String badAuthentication = "654321";

static ZooKeeper zk = null;
/** 计时器 */
AtomicInteger seq = new AtomicInteger();
/** 标识 */
private static final String LOG_PREFIX_OF_MAIN = "【Main】";

private CountDownLatch connectedSemaphore = new CountDownLatch(1);

@Override
public void process(WatchedEvent event) {
  try {
      Thread.sleep(200);
  } catch (InterruptedException e) {
      e.printStackTrace();
  }
  if (event==null) {
      return;
  }
  // 连接状态
  KeeperState keeperState = event.getState();
  // 事件类型
  EventType eventType = event.getType();
  // 受影响的path
  String path = event.getPath();
  
  String logPrefix = "【Watcher-" + this.seq.incrementAndGet() + "】";

  System.out.println(logPrefix + "收到Watcher通知");
  System.out.println(logPrefix + "连接状态:\t" + keeperState.toString());
  System.out.println(logPrefix + "事件类型:\t" + eventType.toString());
  if (KeeperState.SyncConnected == keeperState) {
      // 成功连接上ZK服务器
      if (EventType.None == eventType) {
          System.out.println(logPrefix + "成功连接上ZK服务器");
          connectedSemaphore.countDown();
      } 
  } else if (KeeperState.Disconnected == keeperState) {
      System.out.println(logPrefix + "与ZK服务器断开连接");
  } else if (KeeperState.AuthFailed == keeperState) {
      System.out.println(logPrefix + "权限检查失败");
  } else if (KeeperState.Expired == keeperState) {
      System.out.println(logPrefix + "会话失效");
  }
  System.out.println("--------------------------------------------");
}
/**
 * 创建ZK连接
 * 
 * @param connectString
 *            ZK服务器地址列表
 * @param sessionTimeout
 *            Session超时时间
 */
public void createConnection(String connectString, int sessionTimeout) {
    this.releaseConnection();
    try {
        zk = new ZooKeeper(connectString, sessionTimeout, this);
        //添加节点授权
        zk.addAuthInfo(authentication_type,correctAuthentication.getBytes());
        System.out.println(LOG_PREFIX_OF_MAIN + "开始连接ZK服务器");
        //倒数等待
        connectedSemaphore.await();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

/**
 * 关闭ZK连接
 */
public void releaseConnection() {
    if (this.zk!=null) {
        try {
            this.zk.close();
        } catch (InterruptedException e) {
        }
    }
}

/**
 * 
 * <B>方法名称：</B>测试函数<BR>
 * <B>概要说明：</B>测试认证<BR>
 * @param args
 * @throws Exception
 */
public static void main(String[] args) throws Exception {
    
    ZookeeperAuth testAuth = new ZookeeperAuth();
    testAuth.createConnection(CONNECT_ADDR,2000);
    List<ACL> acls = new ArrayList<ACL>(1);
    for (ACL ids_acl : Ids.CREATOR_ALL_ACL) {
        acls.add(ids_acl);
    }

    try {
        zk.create(PATH, "init content".getBytes(), acls, CreateMode.PERSISTENT);
        System.out.println("使用授权key：" + correctAuthentication + "创建节点："+ PATH + ", 初始内容是: init content");
    } catch (Exception e) {
        e.printStackTrace();
    }
    try {
        zk.create(PATH_DEL, "will be deleted! ".getBytes(), acls, CreateMode.PERSISTENT);
        System.out.println("使用授权key：" + correctAuthentication + "创建节点："+ PATH_DEL + ", 初始内容是: init content");
    } catch (Exception e) {
        e.printStackTrace();
    }

    // 获取数据
    getDataByNoAuthentication();
    getDataByBadAuthentication();
    getDataByCorrectAuthentication();

    // 更新数据
    updateDataByNoAuthentication();
    updateDataByBadAuthentication();
    updateDataByCorrectAuthentication();

    // 删除数据
    deleteNodeByBadAuthentication();
    deleteNodeByNoAuthentication();
    deleteNodeByCorrectAuthentication();
    //
    Thread.sleep(1000);
    
    deleteParent();
    //释放连接
    testAuth.releaseConnection();
}
/** 获取数据：采用错误的密码 */
static void getDataByBadAuthentication() {
    String prefix = "[使用错误的授权信息]";
    try {
        ZooKeeper badzk = new ZooKeeper(CONNECT_ADDR, 2000, null);
        //授权
        badzk.addAuthInfo(authentication_type,badAuthentication.getBytes());
        Thread.sleep(2000);
        System.out.println(prefix + "获取数据：" + PATH);
        System.out.println(prefix + "成功获取数据：" + badzk.getData(PATH, false, null));
    } catch (Exception e) {
        System.err.println(prefix + "获取数据失败，原因：" + e.getMessage());
    }
}

/** 获取数据：不采用密码 */
static void getDataByNoAuthentication() {
    String prefix = "[不使用任何授权信息]";
    try {
        System.out.println(prefix + "获取数据：" + PATH);
        ZooKeeper nozk = new ZooKeeper(CONNECT_ADDR, 2000, null);
        Thread.sleep(2000);
        System.out.println(prefix + "成功获取数据：" + nozk.getData(PATH, false, null));
    } catch (Exception e) {
        System.err.println(prefix + "获取数据失败，原因：" + e.getMessage());
    }
}

/** 采用正确的密码 */
static void getDataByCorrectAuthentication() {
    String prefix = "[使用正确的授权信息]";
    try {
        System.out.println(prefix + "获取数据：" + PATH);
        
        System.out.println(prefix + "成功获取数据：" + zk.getData(PATH, false, null));
    } catch (Exception e) {
        System.out.println(prefix + "获取数据失败，原因：" + e.getMessage());
    }
}

/**
 * 更新数据：不采用密码
 */
static void updateDataByNoAuthentication() {

    String prefix = "[不使用任何授权信息]";

    System.out.println(prefix + "更新数据：" + PATH);
    try {
        ZooKeeper nozk = new ZooKeeper(CONNECT_ADDR, 2000, null);
        Thread.sleep(2000);
        Stat stat = nozk.exists(PATH, false);
        if (stat!=null) {
            nozk.setData(PATH, prefix.getBytes(), -1);
            System.out.println(prefix + "更新成功");
        }
    } catch (Exception e) {
        System.err.println(prefix + "更新失败，原因是：" + e.getMessage());
    }
}

/**
 * 更新数据：采用错误的密码
 */
static void updateDataByBadAuthentication() {

    String prefix = "[使用错误的授权信息]";

    System.out.println(prefix + "更新数据：" + PATH);
    try {
        ZooKeeper badzk = new ZooKeeper(CONNECT_ADDR, 2000, null);
        //授权
        badzk.addAuthInfo(authentication_type,badAuthentication.getBytes());
        Thread.sleep(2000);
        Stat stat = badzk.exists(PATH, false);
        if (stat!=null) {
            badzk.setData(PATH, prefix.getBytes(), -1);
            System.out.println(prefix + "更新成功");
        }
    } catch (Exception e) {
        System.err.println(prefix + "更新失败，原因是：" + e.getMessage());
    }
}

/**
 * 更新数据：采用正确的密码
 */
static void updateDataByCorrectAuthentication() {

    String prefix = "[使用正确的授权信息]";

    System.out.println(prefix + "更新数据：" + PATH);
    try {
        Stat stat = zk.exists(PATH, false);
        if (stat!=null) {
            zk.setData(PATH, prefix.getBytes(), -1);
            System.out.println(prefix + "更新成功");
        }
    } catch (Exception e) {
        System.err.println(prefix + "更新失败，原因是：" + e.getMessage());
    }
}

/**
 * 不使用密码 删除节点
 */
static void deleteNodeByNoAuthentication() throws Exception {

    String prefix = "[不使用任何授权信息]";

    try {
        System.out.println(prefix + "删除节点：" + PATH_DEL);
        ZooKeeper nozk = new ZooKeeper(CONNECT_ADDR, 2000, null);
        Thread.sleep(2000);
        Stat stat = nozk.exists(PATH_DEL, false);
        if (stat!=null) {
            nozk.delete(PATH_DEL,-1);
            System.out.println(prefix + "删除成功");
        }
    } catch (Exception e) {
        System.err.println(prefix + "删除失败，原因是：" + e.getMessage());
    }
}

/**
 * 采用错误的密码删除节点
 */
static void deleteNodeByBadAuthentication() throws Exception {

    String prefix = "[使用错误的授权信息]";

    try {
        System.out.println(prefix + "删除节点：" + PATH_DEL);
        ZooKeeper badzk = new ZooKeeper(CONNECT_ADDR, 2000, null);
        //授权
        badzk.addAuthInfo(authentication_type,badAuthentication.getBytes());
        Thread.sleep(2000);
        Stat stat = badzk.exists(PATH_DEL, false);
        if (stat!=null) {
            badzk.delete(PATH_DEL, -1);
            System.out.println(prefix + "删除成功");
        }
    } catch (Exception e) {
        System.err.println(prefix + "删除失败，原因是：" + e.getMessage());
    }
}

/**
 * 使用正确的密码删除节点
 */
static void deleteNodeByCorrectAuthentication() throws Exception {

    String prefix = "[使用正确的授权信息]";

    try {
        System.out.println(prefix + "删除节点：" + PATH_DEL);
        Stat stat = zk.exists(PATH_DEL, false);
        if (stat!=null) {
            zk.delete(PATH_DEL, -1);
            System.out.println(prefix + "删除成功");
        }
    } catch (Exception e) {
        System.out.println(prefix + "删除失败，原因是：" + e.getMessage());
    }
}

/**
 * 使用正确的密码删除节点
 */
static void deleteParent() throws Exception {
    try {
        Stat stat = zk.exists(PATH_DEL, false);
        if (stat == null) {
            zk.delete(PATH, -1);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}
}

zookeeper一文精通(中)预告：中篇主要简介zk的Curator框架和ZkClient框架,著名的RPC框架dubbo就使用这2个框架来操作zk。

zookeeper一文精通(上)

一、zookeeper简介

二、Zookeeper的数据模型

三、Zookeeper的基本操作和事件通知

四、java客户端操作Zookeeper

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读