WatcherZK状态事件类型 ，权限

Posted 2020-11-09 小~虎

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             // 读取数据
294             System.out.println("---------------------- read parent ----------------------------");
295             //zkWatch.readData(PARENT_PATH, true);
296             
297             // 读取子节点
298             System.out.println("---------------------- read children path ----------------------------");
299             zkWatch.getChildren(PARENT_PATH, true);
300 
301             // 更新数据
302             zkWatch.writeData(PARENT_PATH, System.currentTimeMillis() + "");
303             
304             Thread.sleep(1000);
305             
306             // 创建子节点
307             zkWatch.createPath(CHILDREN_PATH, System.currentTimeMillis() + "");
308             
309             Thread.sleep(1000);
310             
311             zkWatch.writeData(CHILDREN_PATH, System.currentTimeMillis() + "");
312         }
313         
314         Thread.sleep(50000);
315         // 清理节点
316         zkWatch.deleteAllTestPath();
317         Thread.sleep(1000);
318         zkWatch.releaseConnection();
319     }
320 
321 }

 

 

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 }