zookeeper 回调和Watcher

　　ZooKeeper客户端可以对指定节点设置指定Watcher，当服务器指定节点发生变化是，客户端会收到服务器的通知，然后客户端可以执行相应Watcher的代码。

　　默认ZooKeeper内置了一个watcher,用于打印收到的服务器的通知。

源码ZooKeeperMain.Watcher：

 protected void connectToZK(String newHost) throws InterruptedException, IOException {
         if (zk != null && zk.getState().isAlive()) {
             zk.close();
         }
         host = newHost;
         zk = new ZooKeeper(host,
                  Integer.parseInt(cl.getOption("timeout")),
                  new MyWatcher());
  }

 private class MyWatcher implements Watcher {
         public void process(WatchedEvent event) {
             if (getPrintWatches()) {
                 ZooKeeperMain.printMessage("WATCHER::");
                 ZooKeeperMain.printMessage(event.toString());
             }
         }
  }

　　在获取子节点、获取数据、获取状态可以设置Watcher，该Watcher会被存储到Packet包中，当Packet包收到响应时注册该Watcher，当收到服务器notification时，执行Watcher代码。

源码ZooKeeper.getChildren:

 public List<String> getChildren(final String path, Watcher watcher)
         throws KeeperException, InterruptedException
     {
         //将watcher封装成childwatcher
         WatchRegistration wcb = null;
         if (watcher != null) {
             wcb = new ChildWatchRegistration(watcher, clientPath);
         }

         final String serverPath = prependChroot(path);
         RequestHeader h = new RequestHeader();
         h.setType(ZooDefs.OpCode.getChildren);
         GetChildrenRequest request = new GetChildrenRequest();
         request.setPath(serverPath);
         request.setWatch(watcher != null);
         GetChildrenResponse response = new GetChildrenResponse();
         ReplyHeader r = cnxn.submitRequest(h, request, response, wcb);
         if (r.getErr() != 0) {
             throw KeeperException.create(KeeperException.Code.get(r.getErr()),
                     clientPath);
         }
         return response.getChildren();
     }

源码ClientCnxn.submitRequest:

 public ReplyHeader submitRequest(RequestHeader h, Record request,
             Record response, WatchRegistration watchRegistration)
             throws InterruptedException {
         ReplyHeader r = new ReplyHeader();
 //watchRegistration被封装到Packet中
         Packet packet = queuePacket(h, r, request, response, null, null, null,
                     null, watchRegistration);
         synchronized (packet) {
             while (!packet.finished) {
                 packet.wait();
             }
         }
         return r;
     }

源码ClientCnxn.queuePacket:

 Packet queuePacket(RequestHeader h, ReplyHeader r, Record request,
             Record response, AsyncCallback cb, String clientPath,
             String serverPath, Object ctx, WatchRegistration watchRegistration)
     {
         Packet packet = null;
         synchronized (outgoingQueue) {
             if (h.getType() != OpCode.ping && h.getType() != OpCode.auth) {
                 h.setXid(getXid());
             }
 //watchRegistration被封装到Packet中
             packet = new Packet(h, r, request, response, null,
                     watchRegistration);
             packet.cb = cb;
             packet.ctx = ctx;
             packet.clientPath = clientPath;
             packet.serverPath = serverPath;
             if (!zooKeeper.state.isAlive() || closing) {
                 conLossPacket(packet);
             } else {
                 // If the client is asking to close the session then
                 // mark as closing
                 if (h.getType() == OpCode.closeSession) {
                     closing = true;
                 }
                 outgoingQueue.add(packet);
             }
         }

         sendThread.wakeup();
         return packet;
     }

当Packet包收到响应时注册该Watcher，源码ClientCnxn.finishPacket：

 private void finishPacket(Packet p) {
         if (p.watchRegistration != null) {
             p.watchRegistration.register(p.replyHeader.getErr());
         }

         if (p.cb == null) {
             synchronized (p) {
                 p.finished = true;
                 p.notifyAll();
             }
         } else {
             p.finished = true;
             eventThread.queuePacket(p);
         }
     }

当收到服务器notification时，执行Watcher代码，源码ClientCnxn.EventThread：

 private void processEvent(Object event) {
    if (event instanceof WatcherSetEventPair) {
 //执行watcher
                   WatcherSetEventPair pair = (WatcherSetEventPair) event;
                   for (Watcher watcher : pair.watchers) {
                       try {
                           watcher.process(pair.event);
                       } catch (Throwable t) {
                           LOG.error("Error while calling watcher ", t);
                       }
                   }
               }
 }

在删除节点、创建节点、获取子节点、设置数据、获取数据、获取权限、设置权限等异步操作时，可以设置CallBack回调函数，该回调对象会被存储到Packet包中，当Packet包收到响应时执行CallBack代码。

源码ZooKeeper.getChildren:

 public void getChildren(final String path, Watcher watcher,
             ChildrenCallback cb, Object ctx)
     {
         final String clientPath = path;
         WatchRegistration wcb = null;
         if (watcher != null) {
             wcb = new ChildWatchRegistration(watcher, clientPath);
         }

         final String serverPath = prependChroot(clientPath);

         RequestHeader h = new RequestHeader();
         h.setType(ZooDefs.OpCode.getChildren);
         GetChildrenRequest request = new GetChildrenRequest();
         request.setPath(serverPath);
         request.setWatch(watcher != null);
         GetChildrenResponse response = new GetChildrenResponse();
         cnxn.queuePacket(h, new ReplyHeader(), request, response, cb,
                 clientPath, serverPath, ctx, wcb);
     }

源码ClientCnxn.queuePacket:

 Packet queuePacket(RequestHeader h, ReplyHeader r, Record request,
             Record response, AsyncCallback cb, String clientPath,
             String serverPath, Object ctx, WatchRegistration watchRegistration)
     {
         Packet packet = null;
         synchronized (outgoingQueue) {
             if (h.getType() != OpCode.ping && h.getType() != OpCode.auth) {
                 h.setXid(getXid());
             }
             packet = new Packet(h, r, request, response, null,
                     watchRegistration);
             packet.cb = cb;
             packet.ctx = ctx;
             packet.clientPath = clientPath;
             packet.serverPath = serverPath;
             if (!zooKeeper.state.isAlive() || closing) {
                 conLossPacket(packet);
             } else {
                 // If the client is asking to close the session then
                 // mark as closing
                 if (h.getType() == OpCode.closeSession) {
                     closing = true;
                 }
                 outgoingQueue.add(packet);
             }
         }

         sendThread.wakeup();
         return packet;
     }

源码ClientCnxn.EventThread：

 private void processEvent(Object event) {
           try {
                   Packet p = (Packet) event;
                   int rc = 0;
                   String clientPath = p.clientPath;
                   if (p.replyHeader.getErr() != 0) {
                       rc = p.replyHeader.getErr();
                   }
                   if (p.response instanceof ExistsResponse
                           || p.response instanceof SetDataResponse
                           || p.response instanceof SetACLResponse) {
                       StatCallback cb = (StatCallback) p.cb;
                       if (rc == 0) {
                           if (p.response instanceof ExistsResponse) {
                               cb.processResult(rc, clientPath, p.ctx,
                                       ((ExistsResponse) p.response)
                                               .getStat());
                           } else if (p.response instanceof SetDataResponse) {
                               cb.processResult(rc, clientPath, p.ctx,
                                       ((SetDataResponse) p.response)
                                               .getStat());
                           } else if (p.response instanceof SetACLResponse) {
                               cb.processResult(rc, clientPath, p.ctx,
                                       ((SetACLResponse) p.response)
                                               .getStat());
                           }
                       } else {
                           cb.processResult(rc, clientPath, p.ctx, null);
                       }
                   } else if (p.response instanceof GetDataResponse) {
                       DataCallback cb = (DataCallback) p.cb;
                       GetDataResponse rsp = (GetDataResponse) p.response;
                       if (rc == 0) {
                           cb.processResult(rc, clientPath, p.ctx, rsp
                                   .getData(), rsp.getStat());
                       } else {
                           cb.processResult(rc, clientPath, p.ctx, null,
                                   null);
                       }
                   } else if (p.response instanceof GetACLResponse) {
                       ACLCallback cb = (ACLCallback) p.cb;
                       GetACLResponse rsp = (GetACLResponse) p.response;
                       if (rc == 0) {
                           cb.processResult(rc, clientPath, p.ctx, rsp
                                   .getAcl(), rsp.getStat());
                       } else {
                           cb.processResult(rc, clientPath, p.ctx, null,
                                   null);
                       }
                   } else if (p.response instanceof GetChildrenResponse) {
                       ChildrenCallback cb = (ChildrenCallback) p.cb;
                       GetChildrenResponse rsp = (GetChildrenResponse) p.response;
                       if (rc == 0) {
                           cb.processResult(rc, clientPath, p.ctx, rsp
                                   .getChildren());
                       } else {
                           cb.processResult(rc, clientPath, p.ctx, null);
                       }
                   } else if (p.response instanceof GetChildren2Response) {
                       Children2Callback cb = (Children2Callback) p.cb;
                       GetChildren2Response rsp = (GetChildren2Response) p.response;
                       if (rc == 0) {
                           cb.processResult(rc, clientPath, p.ctx, rsp
                                   .getChildren(), rsp.getStat());
                       } else {
                           cb.processResult(rc, clientPath, p.ctx, null, null);
                       }
                   } else if (p.response instanceof CreateResponse) {
                       StringCallback cb = (StringCallback) p.cb;
                       CreateResponse rsp = (CreateResponse) p.response;
                       if (rc == 0) {
                           cb.processResult(rc, clientPath, p.ctx,
                                   (chrootPath == null
                                           ? rsp.getPath()
                                           : rsp.getPath()
                                     .substring(chrootPath.length())));
                       } else {
                           cb.processResult(rc, clientPath, p.ctx, null);
                       }
                   } else if (p.cb instanceof VoidCallback) {
                       VoidCallback cb = (VoidCallback) p.cb;
                       cb.processResult(rc, clientPath, p.ctx);
                   }
           } catch (Throwable t) {
               LOG.error("Caught unexpected throwable", t);
           }
        }
     }