基于Apache Curator框架的ZooKeeper基本用法详解

一、Curator简介

介绍了zookeeper原生API的使用,使用过原生API不得不说,有很多的问题,比如：不能递归创建和删除节点、Watcher只能使用一次、还有很多可以解决分布式应用问题的api(比如分布式锁,leader选举等)，但由于ZooKeeper提供的原始API并不是很易用，在其基础上封装一些高级应用又是一件很复杂的事情。

这个时候，Curator出现了，Curator是Netflix公司开源的一个Zookeeper客户端，后捐献给Apache，Curator框架在zookeeper原生API接口上进行了包装，解决了很多ZooKeeper客户端非常底层的细节开发。
提供ZooKeeper各种应用场景(recipe， 比如：分布式锁服务、集群领导选举、共享计数器、缓存机制、分布式队列等)的抽象封装，实现了Fluent风格的API接口,是最好用，最流行的zookeeper的客户端。

Curator主要从以下几个方面降低了zk使用的复杂性：

重试机制:

提供可插拔的重试机制, 它将给捕获所有可恢复的异常配置一个重试策略，并且内部也提供了几种标准的重试策略(比如指数补偿)

连接状态监控:

Curator初始化之后会一直对zk连接进行监听，一旦发现连接状态发生变化将会作出相应的处理
zk客户端实例管理:Curator会对zk客户端到server集群的连接进行管理，并在需要的时候重建zk实例，保证与zk集群连接的可靠性

各种使用场景支持:

Curator实现了zk支持的大部分使用场景（甚至包括zk自身不支持的场景），这些实现都遵循了zk的最佳实践，并考虑了各种极端情况

二、Curator的使用

1、创建会话

上面已经说过了，curator是Fluent风格API，采用链式编程即Java建造者模式。

Curator的创建会话方式与原生的API创建方式区别很大。Curator创建客户端为CuratorFramework，是由CuratorFrameworkFactory工厂类来实现的，CuratorFramework是线程安全的，要连接的每个ZooKeeper集群只需要一个 CuratorFramework对象就可以了。

CuratorFrameworkFactory提供了两种构造CuratorFramework的方法,一种是直接newClient，还有一种方式是使用CuratorFrameworkFactory.builder()，提供了细粒度的控制。

CuratorFrameworkFactory提供了两个默认的直接构造CuratorFramework的方法,如下：

public static CuratorFramework newClient(String connectString, RetryPolicy retryPolicy);

public static CuratorFramework newClient(String connectString, int sessionTimeoutMs, int connectionTimeoutMs, RetryPolicy retryPolicy);

其中connectString参数就是zk的地址，
参数RetryPolicy提供重试策略的接口，可以让用户实现自定义的重试策略。
connectionTimeoutMs：连接超时时间，如上是30s，默认是15s
sessionTimeoutMs：会话超时时间，如上是50s，默认是60s

使用上面方法创建出一个CuratorFramework之后，需要再调用其start()方法完成会话创建。

2、下面给出创建CuratorFramework例子代码：

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.retry.ExponentialBackoffRetry;

public class CreateClientExamples{

    public static void main(String[] args) {

        String connectionString = "127.0.0.1";
        ExponentialBackoffRetry retryPolicy = new ExponentialBackoffRetry(1000, 3,Integer.MAX_VALUE);

        /**
         * connectionString zk地址
         * retryPolicy 重试策略
         * 默认的sessionTimeoutMs为60000
         * 默认的connectionTimeoutMs为15000
         */
        CuratorFramework curatorFramework = CuratorFrameworkFactory.newClient(connectionString, retryPolicy);
        curatorFramework.start();

        /**
         * connectionString zk地址
         * sessionTimeoutMs 会话超时时间
         * connectionTimeoutMs 连接超时时间
         * retryPolicy 重试策略
         */
        CuratorFramework curatorFramework1 = CuratorFrameworkFactory.newClient(connectionString, 60000, 15000, retryPolicy);
        curatorFramework1.start();

        /**
         * connectionString zk地址
         * sessionTimeoutMs 会话超时时间
         * connectionTimeoutMs 连接超时时间
         * namespace 每个curatorFramework 可以设置一个独立的命名空间,之后操作都是基于该命名空间，比如操作 /app1/message 其实操作的是/node1/app1/message
         * retryPolicy 重试策略
         */
        CuratorFramework curatorFramework2 = CuratorFrameworkFactory.builder().connectString(connectionString)
                .sessionTimeoutMs(60000)
                .connectionTimeoutMs(15000)
                .namespace("/node1")
                .retryPolicy(retryPolicy)
                .build();
        curatorFramework2.start();
    }
}

3、CuratorFrameworkFactory重试策略（RetryPolicy策略）

上面创建会话的例子中,我们使用了ExponentialBackoffRetry的重试策略， retryPolicy默认提供了以下实现，分别为：

ExponentialBackoffRetry：（每次重试时间间隔变大）

/**
 * 随着重试次数增加重试时间间隔变大,指数倍增长baseSleepTimeMs * Math.max(1, random.nextInt(1 << (retryCount + 1)))。
 * 有两个构造方法
 * baseSleepTimeMs初始sleep时间
 * maxRetries最多重试几次
 * maxSleepMs最大的重试时间
 * 如果在最大重试次数内,根据公式计算出的睡眠时间超过了maxSleepMs，将打印warn级别日志,并使用最大sleep时间。
 * 如果不指定maxSleepMs，那么maxSleepMs的默认值为Integer.MAX_VALUE。
 */
public ExponentialBackoffRetry(int baseSleepTimeMs, int maxRetries);

BoundedExponentialBackoffRetry：

/**
 * 继承与ExponentialBackoffRetry ，BoundedExponentialBackoffRetry只有一个三个参数构造器，效果跟ExponentialBackoffRetry三个函数构造器是一样的,只是内部实现不一样。
 * baseSleepTimeMs初始sleep时间
 * maxSleepTimeMs最大sleep时间
 * maxRetries最大重试次数
 */
public BoundedExponentialBackoffRetry(int baseSleepTimeMs, int maxSleepTimeMs, int maxRetries);

RetryForever：永远重试策略

/**
 * RetryForever：永远重试策略
 * retryIntervalMs重试时间间隔
 */
public RetryForever(int retryIntervalMs);

RetryNTimes：重试N次

/**
 * RetryNTimes：重试N次
 * n重试几次
 * sleepMsBetweenRetries每次重试间隔时间
 */
public RetryNTimes(int n, int sleepMsBetweenRetries);

RetryOneTime：只重试一次

/**
 * RetryOneTime：只重试一次
 * sleepMsBetweenRetry:每次重试间隔的时间
 */
public RetryOneTime(int sleepMsBetweenRetry);

RetryUntilElapsed：一直重试，直到超过指定时间

/**
 * RetryUntilElapsed：一直重试，直到超过指定时间
 * maxElapsedTimeMs最大重试时间
 * sleepMsBetweenRetries每次重试间隔时间
 */
public RetryUntilElapsed(int maxElapsedTimeMs, int sleepMsBetweenRetries);

SleepingRetry：抽象类，上面的RetryNTimes就是继承它

4、常用的API操作

public class CuratorBase {
    /** zookeeper地址 */
static final String CONNECT_ADDR = "172.16.158.11:2181,"
            + "172.16.158.12:2181,"
            + "172.16.158.13:2181";
        /** session超时时间 */
        static final int SESSION_OUTTIME = 5000;//ms

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

            //1 重试策略：初试时间为1s 重试10次
            RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 10);
            //2 通过工厂创建连接
            CuratorFramework cf = CuratorFrameworkFactory.builder()
                    .connectString(CONNECT_ADDR)
                    .sessionTimeoutMs(SESSION_OUTTIME)
                    .retryPolicy(retryPolicy)
//					.namespace("super")
                    .build();
            //3 开启连接
            cf.start();

		System.out.println(ZooKeeper.States.CONNECTED);
		System.out.println(cf.getState());

            // 新加、删除

/*
             //4 建立节点 指定节点类型（不加withMode默认为持久类型节点）、路径、数据内容
             cf.create().creatingParentsIfNeeded().withMode(CreateMode.PERSISTENT).forPath("/super/c1","c1内容".getBytes());
             //5 删除节点
             cf.delete().guaranteed().deletingChildrenIfNeeded().forPath("/super");
*/

            // 读取、修改

//             创建节点
//             		cf.create().creatingParentsIfNeeded().withMode(CreateMode.PERSISTENT).forPath("/super/c1","c1内容".getBytes());
//             		cf.create().creatingParentsIfNeeded().withMode(CreateMode.PERSISTENT).forPath("/super/c2","c2内容".getBytes());
//             读取节点
             		String ret1 = new String(cf.getData().forPath("/super/c2"));
             		System.out.println(ret1);
//             修改节点
             		cf.setData().forPath("/super/c2", "修改c2内容".getBytes());
             		String ret2 = new String(cf.getData().forPath("/super/c2"));
             		System.out.println(ret2);


            // 绑定回调函数

             ExecutorService pool = Executors.newCachedThreadPool();
             cf.create().creatingParentsIfNeeded().withMode(CreateMode.PERSISTENT)
             .inBackground(new BackgroundCallback() {
            public void processResult(CuratorFramework cf, CuratorEvent ce) throws Exception {
            System.out.println("code:" + ce.getResultCode());
            System.out.println("type:" + ce.getType());
            System.out.println("线程为:" + Thread.currentThread().getName());
            }
            }, pool)
             .forPath("/super/c3","c3内容".getBytes());
//             Thread.sleep(Integer.MAX_VALUE);



            // 读取子节点getChildren方法 和 判断节点是否存在checkExists方法

             List<String> list = cf.getChildren().forPath("/super");
             for(String p : list){
             System.out.println(p);
             }

             Stat stat = cf.checkExists().forPath("/super/c3");
             System.out.println(stat);

             Thread.sleep(2000);
             cf.delete().guaranteed().deletingChildrenIfNeeded().forPath("/super");


            //cf.delete().guaranteed().deletingChildrenIfNeeded().forPath("/super");

        }
}