Zookeeper 扫盲

Posted 吼怠

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Zookeeper 扫盲相关的知识,希望对你有一定的参考价值。

Zookeeper 扫盲 :disappointed_relieved:

配置文件详解:

  • tickTime:基本事件单元,以毫秒为单位,这个时间作为 Zookeeper 服务器之间或客户端之间维持心跳的时间间隔
  • dataDir:存储内存中数据库快照的位置,顾名思义就是 Zookeeper 保存数据的目录,默认情况下,Zookeeper 将写数据的日志文件也保存到这个目录里
  • clientPort:这个端口就是客户端连接 Zookeeper 服务器的端口,Zookeeper 会监听这个端口,接受客户端的访问请求
  • initLimit:这个配置项是用来配置 Zookeeper 接受客户端初始化连接时最长能忍受多少个心跳时间间隔
    • 当已经超过 10 个心跳的时间也就是(ticktime)长度后 Zookeeper 服务器还没有收到客户端的返回信息,那么表明这个客户端连接失败,总的时间长度就是:10*2000 = 20s
  • syncLimit:这个配置项表示 Leader 与 Follower 之间发送消息,请求和应答时间长度,最长不能超过多少个 tickTime 的时间长度,总的时间长度就是:5*2000 = 10s
  • server.A = B:C:D
    • A:表示这是第几号服务器
    • B:服务器的 IP 地址
    • C:服务器与集群中的 Leader 服务器交换信息的端口
    • D:一旦集群中的 Leader 服务器挂了,需要一个端口重新进行选举,选出一个新的 Leader
    • 2181:对外提供端口
    • 2888:内部同步端口
    • 3888:节点挂了,选举端口

ZK 设计目标

  • 简单的数据结构(树形名字空间)
  • 构建集群(一般奇数,超过半数以上就可以正常访问)
  • 顺序访问
  • 高性能(12w QPS)

集群搭建

技术分享

Java 连接 ZK

  • 客户端通过创建一个 ZK 实例来连接 ZK 服务器

  • Zookeeper(Arguments) 方法

    • connectString:连接服务器列表,用“,”分隔
    • sessionTimeout:心跳检测时间周期(毫秒)
    • wather:时间处理通知器
    • canBeReadOnly:标识当前会话是否支持只读
    • SessionId 和 SessionPasswd:提供连接 Zookeeper 的sessionId 和 密码,通过这俩个确定唯一一台客户端,目的是可以提供重复会话
  • ZK 客户端和服务器会话的建立是一个异步的过程,我们程序方法在处理完客户端初始化后立即返回,
    • 也就是程序往下执行代码,这样,大多数情况下我们并没有真正构建好一个可用会话,在会话生命周期处于“CONNECTING”时,才算建立完毕

Zookeeper 组成

  • 根据其身份的特征分为三种:Leader、Follower、Observer,其中 Follower 和 Observer 统称为 Learner (学习者)
  • leader:负责客户端的 writer 类型请求
  • Follower:负责客户端 reader 类型请求,参与 leader 选举
  • Observer:特殊的“Follower”,其可以接收客户端 reader 请求,但不参与选举。(扩容系统支撑能力,提高读取速度)因为他不接受任何同步的写入请求,只负责 leader 同步数据

Java 操作方法

  • 创建节点(znode)方法:create

    • 提供了两套创建节点的方法,同步和异步创建节点方法
    • 参数1:节点路径:/nodeName (不允许递归创建节点,也就是在父节点不存在的情况下,不允许创建子节点)
    • 参数2:节点内容:要求类型是字节数组(不支持序列化方式,如果需要实现程序化,可使用 Java 相关序列化框架,如 Hession、Kryo 框架)
    • 参数3:节点权限:使用 Ids.OPEN_ACL_UNSAFE 开放权限
    • 参数4:节点类型:创建节点的类型: CreateMode.*
    • persistent(持久节点)
    • persistent_sequential(持久顺序节点)
    • ephemeral(临时节点)
    • ephemeral_sequential(临时顺序节点)
    • 参数5:注册一个异步回调函数,要实现 AsynCallBack.StringCallBack 接口,重写 processResult(int rc, String path, Object ctx, String name) 方法,当节点创建完毕后执行此方法。
    • rc:为服务端相应码 0 表示调用成功、-4 表示端口连接、-110 表示指定节点存在、-112 表示会话已经过期
    • path:接口调用时传入 API 的数据节点的路径参数
    • ctx:为调用接口传入 API 的 ctx 值
    • name:实际在服务器端创建节点的名称
    • 参数6:传递给回调函数的参数,一般为上下文(Context)信息
  • 使用了 CountDownLatch 中的 countDown 只要是要确保我们的zk 连接成功再继续往下进行。

  • 对于 Zookeeper 中存在节点时,我们添加相同节点时,我们不能创建成功。

在创建临时节点时,在本次回话有效,当本次回话结束时,我们的临时节点就会失效

单一视图,三个节点上数据是一致的,消息广播,临时的 temp

分布式锁原理:对于临时节点,同一时间只能有一个 Client 操作一个节点,同时貌似加了一把锁的形式,可以对于相同的业务逻辑,不同的 Tomcat 操作,就确保了操作的唯一性。存在内存中,效率高 12WQPS

zk.create("/app/c1", "c1".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);

原生的API中 Zookeeper 不允许递归创建节点

public class ZookeeperBase {

    /** zookeeper地址 */
    static final String CONNECT_ADDR = "192.168.80.88:2181,192.168.80.87:2181,192.168.80.86: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){
                        //如果建立连接成功,则发送信号量,让后续阻塞程序向下执行
                        connectedSemaphore.countDown();
                        System.out.println("zk 建立连接");
                    }
                }
            }
        });

        //进行阻塞
        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();
    }

}

getChildren 只可以取下面直接的一层,

使用 -1 是跳过版本检查,如果再删除的时候,会检查本地版本和远程版本若相同则会删除,否则不删除。同时不支持递归的删除

getChildren 读取数据方法:包括子节点列表的获取和子节点数据的获取

  • 参数1:path:获取指定节点的下的数据(获取子节点列表)
  • 参数2:watcher:注册的 watcher ,一旦在本次子节点获取后,子节点列表发生变化的话,那么就会向客户端发送通知,该参数允许为 null。
  • 参数3:表明是否需要注册一个 watcher:如果为 true,则会使用到 zookeeper 客户端上下文中提到的那个默认 watcher ,如果为 false,则表明不需要注册 watcher。
  • 参数4:cb:回调函数
  • 参数5:ctx:上下文信息对象
  • 参数6:stat:指定数据节点的节点状态信息

注意:

  • 当我们获取指定节点的子节点列表后,还需要订阅这个子节点列表的变化通知,这时候就可以注册一个 watcher 来实现
  • 当子节点被添加或删除时,服务器端就会触发一个“NodeChildrenChanged“类型的时间通知,
  • 服务器端发送给客户端收到这个事件通知中,是不包含最新的节点列表的,客户端必须主动从新进行获取,通常在客户端收到这个事件通知后,就可以再次主动获取最新的子节点列表了
  • ZK 服务端在向客户端发送 watcher “NodeChildrenChanged”事件通知的时候,仅仅只发了一个通知,不会节点把节点的节点的变化情况发送给客户端,需要客户端自己重新获取
  • watcher 通知是一次性的,即触发后失效,因此客户端需要反复注册 watcher 才行。

getData 方法:获取指定节点的数据内容

  • path:路径
  • watcher:注册的 watcher 对象,一旦之后节点内容有变更,则会向客户端发送通知,该参数允许为 null,触发事件为“NodeDataChanged”事件通知
  • stat:指定节点的状态信息
  • watch:是否使用 watcher,如果为 true 则使用默认上下文中的 watcher, false 则不使用 watcher
  • cb:回调函数
  • ctx:传递上下文信息对象

setData 方法:修改指定节点的数据内容

  • path:路径
  • data:数据内容
  • 版本号:(-1 覆盖之前的所有的版本)
  • cb:回调函数
  • ctx:用于传递的下文信息对象

exists 方法:检测节点是否存在

  • path:路径
  • watcher:注册的 watcher 对象,用于三类时间监听(节点的创建,删除,更新)
  • cb:回调函数
  • ctx:传递的上下文信息对象
  • exits 方法的意义在于无论节点是否存在,都可以进行注册 watcher,能够对节点的创建,删除和修改进行监听,但是其子节点发送各种变化,都不会通知客户端。

事件类型

  • ZK 有 watch 事件,是一次性触发的,当 watch 监视的数据发生变化时,通知设置了该watch 的 client ,即 watcher

  • watcher 是监听数据发送了某些变化,那就一定会有对应的事件类型和状态类型

  • 事件类型:(znode节点相关)
    • EventType.NodeCreated
    • EventType.NodeDataChanged
    • EventType.NodeChildrenChaged
    • EventType.NodeDeleted
  • 状态类型:(客户端实例相关)

    • KeeperState.Disconnected
    • KeeperState.SyncConnected
    • KeeperState.AuthFailed
    • KeeperState.Expired
  • watch事件是一次性的,watcher 表示 client

package bjsxt.zookeeper.watcher;

import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.Watcher.Event.EventType;
import org.apache.zookeeper.Watcher.Event.KeeperState;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;

/**
* Zookeeper Wathcher
* 本类就是一个Watcher类(实现了org.apache.zookeeper.Watcher类)
* @author(alienware)
* @since 2015-6-14
*/
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 List),Zookeeper 作为一个分布式协调框架,其内部存储的都是一些关乎分布式系统运行时状态的元数据,尤其是涉及到一些分布式锁、Master选举和协调等应用场景。我们需要有效地保障 Zookeeper 中的数据安全,Zookeeper 提供一套完善的 ACL 权限控制机制来保障数据的安全。

ZK 提供了三种模式:权限模式、授权对象、权限

权限模式:Scheme 开发人员最多使用的如下四种权限模式:

  • IP :IP 模式通过 IP 地址粒度来进行控制权限,例如配置了:IP:192.168.1.107 即表示权限控制都是针对这个 IP 地址的,同时也支持按网段分配,比如 192.168.1.*
  • Digest:digest 是最常用的权限控制模式,更符合我们对权限控制的认识,起类似于 username:password 形式的权限标识进行权限配置,ZK 会对形成的权限标识先后进行两次编码处理,分别是 SHA-1 加密算法、BASE64 编码
  • world:world 是一直最开放的权限控制模式,这种模式可以看做为特殊的 Disgest,它仅仅是一个标识而已
  • Super:超级用户模式,在超级用户模式下可以对 ZK 任意进行控制

权限对象:指的是权限赋予用户或者一个指定的实体,例如 IP 地址或机器等,在不同的模式下,授权对象是不同的,这种模式和权限对象一一对应。

权限:权限就是指那些通过权限检测后可以被允许执行的操作,在 ZK 中,对数据的操作权限分为五大类:CREATE、DELETE、READ、WRITE、ADMIN

认证只是针对某一个节点。

zkClient 的使用

创建客户端方法:ZKClient(Arguments)

  • arg1:zkServers zookeeper服务器的地址,用“,”分隔
  • arg2:sessionTimeout 超时会话,为毫秒,默认为 30 000ms
  • arg3:connectionTimeout 连接超时会话
  • arg4:IZkConnection 接口的实现类
  • arg5:zkSerializer 自定义序列化实现

可以使用递归创建,每个节点没法指定 value,可以递归删除

zkclient 最大的一个优点就是: 把重复watch的那个事情去掉,不需要再写数据时watch

readeata 时,直接读取的就是字符串,不是byte字节流

创建节点方法:create、createEphemeral、createEphemeralSequential、createPersistent、createPersistentSequential

  • arg1:path,路径
  • arg2:data,数据内容,可以传入 null
  • arg3:mode,节点类型,为一个枚举类型,四种形式
  • arg4:acl 策略
  • arg5:callback 回调函数
  • arg6:context 上下文对象
  • arg7:createParents 是否创建父节点

删除节点方法:delete、deleteRecursive

  • arg1:Path,路径
  • arg2:callback,回调函数
  • arg3:context,上下文对象

读取子节点数据方法:getChildren

  • arg1:path,路径

读取节点数据方法:readData

  • arg1:path,路径
  • arg2:returnNullIFPathNotExists (避免为空节点抛出异常,直接返回 null)
  • arg3:节点状态

更新数据方法:writeData

  • arg1:path,路径
  • arg2:data,数据信息
  • arg3:version 版本号

检测节点是否存在方法:exists

  • arg:path,路径

我们发现,ZkClient 里面并没有类似的 watcher、watch 参数,这也就是我们说开发人员无需关心反复注册 Watcher 的问题,ZkClient 给我们提供了一套监听方式,我们可以使用监听节点的方式进行操作,剔除了繁琐的反复 watcher 操作,简化了代码复杂程度

subscribeChildChanges 方法

  • arg1:path,路径
  • 实现 IZkChildListener 接口的类,只需要重写其 handleChaildChanges(String parentPath,List<String> currentChilds) 方法,其中参数 parentPath 为所监听节点全路径,currentChilds 为最新的子节点列表(相对路径)
  • IZkChildListener 事件说明针对于下面三个事件触发:
    • 新增子节点
    • 减少子节点
    • 删除节点

IZkChildListener 有以下特点:

  1. 客户端可以对一个不存在的节点进行变更的监听

  2. 一旦客户端对一个节点注册了子节点列表变更监听后,那么当前节点的子节点雷彪发送变更的时候,服务端都会通知客户端,并将最新的自己诶单列表发送给客户端

  3. 该节点本身创建或删除也会通知到客户端

  4. 另外最重要的是这个监听是一直存在的,不是单次监听,相比较原生 API 提供的要简单的多

  5. subscribeChildChange("/super",new IZkChildListener() {})

    • 对于 Zkclient 会告诉你变化之后的数据是多少,对于节点的当前和子级的状态

    • 当对于一个节点的update 的时候,并不会监听,只会监听当前节点或子节点的添加和删除

  6. subscribeDataChange("/super",new IZkDataListener() {})

    • 对于变更的状态包括:删除和修改,其中的状态分开走

原先zk设计的状况:

  • event 只会告诉你变化的事件,触发什么事件,自己根据path,读取数据,并且还是一次,

  • 通知,状态,节点路径,对于变化的之后的数据没有告诉,设计的理念就是轻量,敏捷。

Curator 封装

是否可以监控一个节点下面所有节点的状态,分布式锁,原子统计

Curator 框架中使用了链式编程风格,易读性更强,使用工程方法创建连接对象

使用 CuratorFrameworkFactory 的两个静态工厂方法(参数不同)来实现

  • arg1:connectString,连接串
  • arg2:retryPolicy,重试连接策略,有四种实现分别为:
    • ExponentialBackoffRetry
    • RetryNTimes
    • RetryOneTimes
    • RetryUntilElapsed
  • arg3:sessionTimeoutMs 会话超时时间 默认为 60 000ms
  • arg4:connectionTimeoutMs 连接超时时间,默认为15 000ms
  • 对于 retryPolicy 策略通过一个接口来让用户自定义实现

创建节点 create 方法,可选链式项:

  • creatingParentsIfNeeded
  • withMode
  • forPath
  • withACL

删除节点 delete 方法,可选链式项

  • deletingChildrenIfNedded
  • guaranteed
  • withVersion
  • forPath

读取和修改数据

  • getData
  • setData

异步绑定回调方法

  • 创建节点时绑定一个回调函数,该回调函数可以输出服务器的状态码以及服务器事件类型
  • 可以加入线程池进行优化

读取子节点方法

  • getChildren

判断子节点是否存在

  • checkExists

回调函数为什么会使用线程池:

  • 一次性批量创建多个节点,不必要每次都回调
  • ThreadPoolExcutor 底层自定义线程
  • 批量节点操作,自己规划 callback ,多余的缓冲在队列中

Watcher 监听功能

  • 依赖 maven jar包

    <dependency>
      <groupid>org.apache.curator</groupid>
        <artifactid>curator-recipes</artifactid>
        <version>2.4.2</version>
    </dependency>
  • 我们使用 NodeCache 的方式去客户端实例中注册一个监听缓存,然后实现对应的监听方法即可,

  • 主要的监听方式:
    • NodeCacheListener:监听节点的新增,修改操作
    • PathchildrenCacheListener:监听子节点的新增、修改、删除操作

在客户端使用缓存,在服务端进行变化时,和本地的进行对比,有差异数据同步,空间换取时间,替换了原来的注册的思路。

只能监听一级节点,再下一级就不能实现,对于删除也不能迭代删除

分布式锁

分布式锁就是在共享的一段代码中,一个服务器使用,其他的服务器不允许访问,分布式锁

实现分布式锁,对于Java程序写出花来也没用,就是只针对同一个JVM,当多个JVM如何同步

分布式计数器:DistributedAtomicInteger

使用了distribute,

重试的时间次数,

barrier 同时开始,同时结束,代码,

DistributedDoubleBarrier barrier = new DistributedDoubleBarrier(cf, "/super", 5);

其中的 5 代表五个客户端的连接,当五个连接上就可以同时开始,我们使用

barrier.enter();

此时就同时开始,

barrier.leave();

同时结束

在声明 Barrier 的时候也可以不设置程序的数量

同时还有另外一种写法:

实现声明 barrier

/** zookeeper地址 */
    static final String CONNECT_ADDR = "192.168.1.171:2181,192.168.1.172:2181,192.168.1.173:2181";
    /** session超时时间 */
    static final int SESSION_OUTTIME = 5000;//ms

    static DistributedBarrier barrier = null;

    public static void main(String[] args) throws Exception {



        for(int i = 0; i < 5; i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 10);
                        CuratorFramework cf = CuratorFrameworkFactory.builder()
                                    .connectString(CONNECT_ADDR)
                                    .sessionTimeoutMs(SESSION_OUTTIME)
                                    .retryPolicy(retryPolicy)
                                    .build();
                        cf.start();
                        barrier = new DistributedBarrier(cf, "/super");
                        System.out.println(Thread.currentThread().getName() + "设置barrier!");
                        barrier.setBarrier();    //设置
                        barrier.waitOnBarrier();    //等待
                        System.out.println("---------开始执行程序----------");
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            },"t" + i).start();
        }

        Thread.sleep(5000);
        barrier.removeBarrier();    //释放


    }

其中 barrier 作为第六人就是吹哨的人,一般我们自己设定的 const 包,用于设置的吹哨的公共

使用 curator 的分布式锁,对于监听的相同节点,若之前发生了变更,之后连接还会貌似数据恢复一点,数据同步,相当于重复注册,当前 /super 节点,持续订阅服务,

curator 人性化操作:

  • 对于一个节点的CRUD监控
  • 实现分布式锁
  • 实现barrier、原子计数器
  • 实现队列

以上是关于Zookeeper 扫盲的主要内容,如果未能解决你的问题,请参考以下文章

zookeeper扫盲

在ansible模板中使用动态组名称

汇编知识扫盲之16位汇编跟32位汇编的保护模式以及汇编代码编写

用VS2010编C#程序扫盲 2

C++快速扫盲(基础篇)

HTML - 扫盲