zookeeper

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

二、zookeeper的数据模型
zookeeper的数据模型类似于数据结构中的树。

树是由节点所组成，Zookeeper的数据存储也同样是基于节点，这种节点叫做Znode。
这样的层级结构，让每一个Znode节点拥有唯一的路径，就像命名空间一样对不同信息作出清晰的隔离。

znode节点中包含以下数据
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的客户端会接收到异步通知。

Watcher --数据变更通知
Zookeeper使用Watcher机制实现分布式数据的发布/订阅功能。

Zookeeper的Watcher机制主要包括客户端线程、客户端WatcherManager、Zookeeper服务器三部分。客户端在向Zookeeper服务器注册的同时，会将Watcher对象存储在客户端的WatcherManager当中。当Zookeeper服务器触发Watcher事件后，会向客户端发送通知，客户端线程从WatcherManager中取出对应的Watcher对象来执行回调逻辑。
具体交互过程：
1、客户端调用getData方法，watch参数是true。服务端接到请求，返回节点数据，并且在对应的哈希表里插入被Watch的Znode路径，以及Watcher列表。
2、当被Watch的Znode已删除，服务端会查找哈希表，找到该Znode对应的所有Watcher，异步通知客户端，并且删除哈希表中对应的Key-Value。

四、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核心原理 wather、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的ALC（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

六、Zookeeper选举机制以及ZAB协议