程序博客网 > 英语三级单词软件

zookeeper学习之三（Curator客户端）

来源：互联网 发布：英语三级单词软件 编辑：程序博客网 时间：2024/05/16 06:31

Curator框架是最好用，最流行的zookeeper的客户端。

它有以下三个优点

1.提供了一套非常友好的操作API;

2. 提供一些高级特性（包括但不仅限于前篇文章中提到的）的封装

3.易测试

 

maven依赖如下

 

Xml代码 复制代码 收藏代码
  1. <dependency>  
  2.     <groupId>org.apache.curator</groupId>  
  3.     <artifactId>curator-recipes</artifactId>  
  4.     <version>2.5.0</version>  
  5. </dependency>  

 

 

按照官方给出的文档和包结构，可以轻松的看出Curator功能分两大类，一是对zookeeper的一些基本命令的封装，比如增删改查。是他的framework模块，一个是他的高级特性，即recipes模块。

 

一、framework模块

Curator提供了一套Fluent风格的操作API。这在很多脚本类语言里比较流行。

 

比如他创建client的代码是这样

Java代码 复制代码 收藏代码
  1. CuratorFramework client = builder.connectString("192.168.11.56:2180")   
  2.         .sessionTimeoutMs(30000)   
  3.         .connectionTimeoutMs(30000)   
  4.         .canBeReadOnly(false)   
  5.         .retryPolicy(new ExponentialBackoffRetry(1000, Integer.MAX_VALUE))   
  6.         .namespace(namespace)   
  7.         .defaultData(null)   
  8.         .build();   
  9. client.start();  

 一路点到底，这就是所谓的Fluent风格。 

 

我们再看增删改查的

Java代码 复制代码 收藏代码
  1. public class CrudExamples {   
  2.     private static CuratorFramework client = ClientFactory.newClient();   
  3.     private static final String PATH = "/crud";   
  4.   
  5.     public static void main(String[] args) {   
  6.         try {   
  7.             client.start();   
  8.   
  9.             client.create().forPath(PATH, "I love messi".getBytes());   
  10.   
  11.             byte[] bs = client.getData().forPath(PATH);   
  12.             System.out.println("新建的节点，data为:" + new String(bs));   
  13.   
  14.             client.setData().forPath(PATH, "I love football".getBytes());   
  15.   
  16.             // 由于是在background模式下获取的data，此时的bs可能为null  
  17.             byte[] bs2 = client.getData().watched().inBackground().forPath(PATH);   
  18.             System.out.println("修改后的data为" + new String(bs2 != null ? bs2 : new byte[0]));   
  19.   
  20.             client.delete().forPath(PATH);   
  21.             Stat stat = client.checkExists().forPath(PATH);   
  22.   
  23.             // Stat就是对zonde所有属性的一个映射， stat=null表示节点不存在！  
  24.             System.out.println(stat);   
  25.         } catch (Exception e) {   
  26.             e.printStackTrace();   
  27.         } finally {   
  28.             CloseableUtils.closeQuietly(client);   
  29.         }   
  30.     }   
  31. }  

 常用接口有

create()增

delete(): 删

checkExists(): 判断是否存在

setData():  改

getData(): 查

所有这些方法都以forpath()结尾，辅以watch(监听)，withMode（指定模式），和inBackground（后台运行）等方法来使用。

 

 此外，Curator还支持事务，一组crud操作同生同灭。代码如下

Java代码 复制代码 收藏代码
  1. /**  
  2.  * 事务操作  
  3.  *   
  4.  * @author shencl  
  5.  */  
  6. public class TransactionExamples {   
  7.     private static CuratorFramework client = ClientFactory.newClient();   
  8.   
  9.     public static void main(String[] args) {   
  10.         try {   
  11.             client.start();   
  12.             // 开启事务   
  13.             CuratorTransaction transaction = client.inTransaction();   
  14.   
  15.             Collection<CuratorTransactionResult> results = transaction.create()   
  16.                     .forPath("/a/path", "some data".getBytes()).and().setData()   
  17.                     .forPath("/another/path", "other data".getBytes()).and().delete().forPath("/yet/another/path")   
  18.                     .and().commit();   
  19.   
  20.             for (CuratorTransactionResult result : results) {   
  21.                 System.out.println(result.getForPath() + " - " + result.getType());   
  22.             }   
  23.         } catch (Exception e) {   
  24.             e.printStackTrace();   
  25.         } finally {   
  26.             // 释放客户端连接   
  27.             CloseableUtils.closeQuietly(client);   
  28.         }   
  29.   
  30.     }   
  31. }  

 这段的代码的运行结果，由于最后一步delete的节点不存在，所以整个事务commit失败。失败的原因会放在Collection<CuratorTransactionResult>中，非常友好。

 

好了framework部分的内容就这么多，是不是特别简单呢。下面就来看看recipes包的内容吧。。

 

Recipes部分提供的功能官网列的很详细，点击这里。注意文章第一段：Curator宣称，Recipes模块实现了除二阶段提交之外的所有zookeeper特性。

 

二、Recipes模块

 

主要有

Elections(选举)，Locks（锁），Barriers（关卡），Atomic（原子量），Caches，Queues等

 

1、 Elections

选举主要依赖于LeaderSelector和LeaderLatch2个类。前者是所有存活的客户端不间断的轮流做Leader，大同社会。后者是一旦选举出Leader，除非有客户端挂掉重新触发选举，否则不会交出领导权。某党？

 

这两者在实现上是可以切换的，直接上代码，怎么切换注释里有。由于篇幅所限，这里仅贴出基于LeaderSelector的选举，更多代码见附件

Java代码 复制代码 收藏代码
  1. /**  
  2.  * 本类基于leaderSelector实现,所有存活的client会公平的轮流做leader  
  3.  * 如果不想频繁的变化Leader，需要在takeLeadership方法里阻塞leader的变更！ 或者使用 {@link} 
  4.  * LeaderLatchClient  
  5.  */  
  6. public class LeaderSelectorClient extends LeaderSelectorListenerAdapter implements Closeable {   
  7.     private final String name;   
  8.     private final LeaderSelector leaderSelector;   
  9.     private final String PATH = "/leaderselector";   
  10.   
  11.     public LeaderSelectorClient(CuratorFramework client, String name) {   
  12.         this.name = name;   
  13.         leaderSelector = new LeaderSelector(client, PATH, this);   
  14.         leaderSelector.autoRequeue();   
  15.     }   
  16.   
  17.     public void start() throws IOException {   
  18.         leaderSelector.start();   
  19.     }   
  20.   
  21.     @Override  
  22.     public void close() throws IOException {   
  23.         leaderSelector.close();   
  24.     }   
  25.   
  26.     /**  
  27.      * client成为leader后，会调用此方法  
  28.      */  
  29.     @Override  
  30.     public void takeLeadership(CuratorFramework client) throws Exception {   
  31.         int waitSeconds = (int) (5 * Math.random()) + 1;   
  32.         System.out.println(name + "是当前的leader");   
  33.         try {   
  34.             Thread.sleep(TimeUnit.SECONDS.toMillis(waitSeconds));   
  35.         } catch (InterruptedException e) {   
  36.             Thread.currentThread().interrupt();   
  37.         } finally {   
  38.             System.out.println(name + " 让出领导权\n");   
  39.         }   
  40.     }  

 

Java代码 复制代码 收藏代码
  1. /**  
  2.  * leader选举  
  3.  *   
  4.  * @author shencl  
  5.  */  
  6. public class LeaderSelectorExample {   
  7.   
  8.     public static void main(String[] args) {   
  9.   
  10.         List<CuratorFramework> clients = Lists.newArrayList();   
  11.         List<LeaderSelectorClient> examples = Lists.newArrayList();   
  12.         try {   
  13.             for (int i = 0; i < 10; i++) {   
  14.                 CuratorFramework client = ClientFactory.newClient();   
  15.                 LeaderSelectorClient example = new LeaderSelectorClient(client, "Client #" + i);   
  16.                 clients.add(client);   
  17.                 examples.add(example);   
  18.   
  19.                 client.start();   
  20.                 example.start();   
  21.             }   
  22.   
  23.             System.out.println("----------先观察一会选举的结果-----------");   
  24.             Thread.sleep(10000);   
  25.   
  26.             System.out.println("----------关闭前5个客户端，再观察选举的结果-----------");   
  27.             for (int i = 0; i < 5; i++) {   
  28.                 clients.get(i).close();   
  29.             }   
  30.   
  31.             // 这里有个小技巧，让main程序一直监听控制台输入，异步的代码就可以一直在执行。不同于while(ture)的是，按回车或esc可退出  
  32.             new BufferedReader(new InputStreamReader(System.in)).readLine();   
  33.   
  34.         } catch (Exception e) {   
  35.             e.printStackTrace();   
  36.         } finally {   
  37.             for (LeaderSelectorClient exampleClient : examples) {   
  38.                 CloseableUtils.closeQuietly(exampleClient);   
  39.             }   
  40.             for (CuratorFramework client : clients) {   
  41.                 CloseableUtils.closeQuietly(client);   
  42.             }   
  43.         }   
  44.     }   
  45. }  

 

2、locks

curator lock相关的实现在recipes.locks包里。顶级接口都是InterProcessLock。我们直接看最有代表性的InterProcessReadWriteLock 进程内部读写锁（可重入读写锁）。什么叫可重入，什么叫读写锁。不清楚的先查好资料吧。总之读写锁一定是成对出现的。    简易传送门

 

我们先定义两个任务，可并行的执行的，和互斥执行的。

Java代码 复制代码 收藏代码
  1. /**  
  2.  * 并行任务  
  3.  *   
  4.  * @author shencl  
  5.  */  
  6. public class ParallelJob implements Runnable {   
  7.   
  8.     private final String name;   
  9.   
  10.     private final InterProcessLock lock;   
  11.   
  12.     // 锁等待时间   
  13.     private final int wait_time = 5;   
  14.   
  15.     ParallelJob(String name, InterProcessLock lock) {   
  16.         this.name = name;   
  17.         this.lock = lock;   
  18.     }   
  19.   
  20.     @Override  
  21.     public void run() {   
  22.         try {   
  23.             doWork();   
  24.         } catch (Exception e) {   
  25.             // ingore;   
  26.         }   
  27.     }   
  28.   
  29.     public void doWork() throws Exception {   
  30.         try {   
  31.             if (!lock.acquire(wait_time, TimeUnit.SECONDS)) {   
  32.                 System.err.println(name + "等待" + wait_time + "秒，仍未能获取到lock,准备放弃。");   
  33.             }   
  34.             // 模拟job执行时间0-4000毫秒   
  35.             int exeTime = new Random().nextInt(4000);   
  36.             System.out.println(name + "开始执行,预计执行时间= " + exeTime + "毫秒----------");   
  37.             Thread.sleep(exeTime);   
  38.         } catch (Exception e) {   
  39.             e.printStackTrace();   
  40.         } finally {   
  41.             lock.release();   
  42.         }   
  43.     }   
  44. }  

 

Java代码 复制代码 收藏代码
  1. /**  
  2.  * 互斥任务  
  3.  *   
  4.  * @author shencl  
  5.  */  
  6. public class MutexJob implements Runnable {   
  7.   
  8.     private final String name;   
  9.   
  10.     private final InterProcessLock lock;   
  11.   
  12.     // 锁等待时间   
  13.     private final int wait_time = 10;   
  14.   
  15.     MutexJob(String name, InterProcessLock lock) {   
  16.         this.name = name;   
  17.         this.lock = lock;   
  18.     }   
  19.   
  20.     @Override  
  21.     public void run() {   
  22.         try {   
  23.             doWork();   
  24.         } catch (Exception e) {   
  25.             // ingore;   
  26.         }   
  27.     }   
  28.   
  29.     public void doWork() throws Exception {   
  30.         try {   
  31.             if (!lock.acquire(wait_time, TimeUnit.SECONDS)) {   
  32.                 System.err.println(name + "等待" + wait_time + "秒，仍未能获取到lock,准备放弃。");   
  33.             }   
  34.             // 模拟job执行时间0-2000毫秒   
  35.             int exeTime = new Random().nextInt(2000);   
  36.             System.out.println(name + "开始执行,预计执行时间= " + exeTime + "毫秒----------");   
  37.             Thread.sleep(exeTime);   
  38.         } catch (Exception e) {   
  39.             e.printStackTrace();   
  40.         } finally {   
  41.             lock.release();   
  42.         }   
  43.     }   
  44. }  

 

锁测试代码

 

Java代码 复制代码 收藏代码
  1. /**  
  2.  * 分布式锁实例  
  3.  *   
  4.  * @author shencl  
  5.  */  
  6. public class DistributedLockExample {   
  7.     private static CuratorFramework client = ClientFactory.newClient();   
  8.     private static final String PATH = "/locks";   
  9.   
  10.     // 进程内部（可重入）读写锁   
  11.     private static final InterProcessReadWriteLock lock;   
  12.     // 读锁   
  13.     private static final InterProcessLock readLock;   
  14.     // 写锁   
  15.     private static final InterProcessLock writeLock;   
  16.   
  17.     static {   
  18.         client.start();   
  19.         lock = new InterProcessReadWriteLock(client, PATH);   
  20.         readLock = lock.readLock();   
  21.         writeLock = lock.writeLock();   
  22.     }   
  23.   
  24.     public static void main(String[] args) {   
  25.         try {   
  26.             List<Thread> jobs = Lists.newArrayList();   
  27.             for (int i = 0; i < 10; i++) {   
  28.                 Thread t = new Thread(new ParallelJob("Parallel任务" + i, readLock));   
  29.                 jobs.add(t);   
  30.             }   
  31.   
  32.             for (int i = 0; i < 10; i++) {   
  33.                 Thread t = new Thread(new MutexJob("Mutex任务" + i, writeLock));   
  34.                 jobs.add(t);   
  35.             }   
  36.   
  37.             for (Thread t : jobs) {   
  38.                 t.start();   
  39.             }   
  40.         } catch (Exception e) {   
  41.             e.printStackTrace();   
  42.         } finally {   
  43.             CloseableUtils.closeQuietly(client);   
  44.         }   
  45.     }   
  46. }  

 

看到没，用法和java concurrent包里的ReentrantReadWriteLock 是一模一样的。

事实上，整个recipes包的目录结构、实现原理同java concurrent包的设置是很一致的。比如有queue，Semaphore，Barrier等类，。他整个就是模仿jdk的实现，只不过是基于分布式的！

 

后边的几项，Barriers（关卡），Atomic（原子量），Caches，Queues和java concurrent包里的类的用法是一样的，就不继续贴了，有些附件里有。

要说明的是：有的功能性能不是特别理想，网上也没见有大的项目的使用案例。比如基于CAS机制的atomic，在某些情况重试的效率还不如硬同步，要是zookeeper节点再一多，各个节点之间通过event触发的数据同步极其频繁。那性能可以想象。

 

三、测试方法

 curator提供了很好的测试工具，你甚至是可以在完全没有搭建zookeeper server端的情况下，完成测试。

有2个重要的类

TestingServer 模拟单点， TestingCluster模拟集群。

需要使用的话，得依赖

Xml代码 复制代码 收藏代码
  1. <dependency>  
  2.     <groupId>org.apache.curator</groupId>  
  3.     <artifactId>curator-test</artifactId>  
  4.     <version>2.5.0</version>  
  5. </dependency>  

 

 

 

全文完。

 

本文参考：

http://curator.apache.org/

http://www.cnblogs.com/hzhuxin/archive/2012/11/01/2749341.html

http://www.chengxuyuans.com/Java+/72042.html

http://macrochen.iteye.com/blog/1366136

0 0
英语三级单词软件 英语三级单词软件
原创粉丝点击
热门IT博客
打开淘宝店铺服务出错打开淘宝店铺服务出错
什么牌子的牙刷好 知乎什么牌子的牙刷好 知乎
淘宝宠物托运靠谱吗
爱因斯坦人工智能
mars 绝地求生数据
电信80端口如何申请
php技术发展前景
电脑慢镜头拍摄软件
北大光华mba 知乎
数组的排序方法
doe实验设计软件下载
阿里云虚拟主机怎么用
2016年网络购物人数
淘宝人工客服没有了
js 自定义window方法
手机夜间护眼软件
psd源码
javascript拼图游戏
check in sql
张国荣演技知乎
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 新发地买菜 梦到买菜 冒菜是什么菜 网上能买菜吗 淘宝买菜 看菜 地方菜 梦幻买菜 做梦梦见买菜 跟妈妈去买菜 不出门买菜 饭店买菜 栽菜 做梦梦到买菜 辣的菜 写话买菜 孕妇梦见买菜 可以网上买菜吗 买菜用的拉杆箱 白树纯菜 帮买菜的app 厨师买菜 梦见去买菜 买菜用的拉杆车 来菜 白音若菜 蓬哈菜 用菜 买菜的篮子 怀扬菜 菹菜 梦见自己买菜 及菜 浇菜 爬楼买菜车 毛湘土菜 菜价查询软件 菜价查询 什么网站可以买菜 哪个网站可以买菜 哪里可以网上买菜

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里