zookeeper一文精通(上)

最新推荐文章于 2023-04-23 15:12:49 发布

ZPHuanLove

最新推荐文章于 2023-04-23 15:12:49 发布

阅读量188

点赞数

分类专栏： java开发

本文链接：https://blog.csdn.net/u013703461/article/details/108749950

版权

java开发专栏收录该内容

14 篇文章 1 订阅

订阅专栏

zookeeper一文精通(上)

一、zookeeper简介

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

想查看更多的文章请关注公众号：IT巡游屋

二、Zookeeper的数据模型

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

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FHqhPOnZ-1600832869702)(.\zookeeper01.assets\image-20200909112324014.png)]$

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

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

/ 动物 / 仓鼠

/ 植物 / 荷花

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

Znode节点中包含以下数据：

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-c9I6AdV1-1600832869704)(.\zookeeper01.assets\image-20200909112538559.png)]$

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列表。

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uHGfoYMn-1600832869709)(.\zookeeper01.assets\image-20200909113039944.png)]$

四、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();
    	        }
    	    }
    	
    	}