08.Curator缓存

    可以利用ZooKeeper在集群的各个节点之间缓存数据。每个节点都可以得到最新的缓存的数据。Curator提供了三种类型的缓存方式：Path Cache,Node Cache 和Tree Cache。

1.Path Cache

    Path Cache用来监控一个ZNode的子节点。当一个子节点增加，更新，删除时，Path Cache会改变它的状态，会包含最新的子节点，子节点的数据和状态。
1.Path Cache介绍
    Path Cache的主要用途是监控某个节点的子节点，由于Zookeeper原生API的watch监控节点时注册一次只能触发一次，而Path Cache弥补了这个不足，它注册一次可以一直监控触发。
实际使用时会涉及到四个类：
  • PathChildrenCache - Path Cache主要实现类
  • PathChildrenCacheEvent - 监听触发时的事件对象，包含事件相关信息
  • PathChildrenCacheListener - 监听器接口
  • ChildData - 子节点数据封装类
通过下面的构造函数创建Path Cache:
  1. public PathChildrenCache(CuratorFramework client, String path, boolean cacheData)
注意：使用cache，必须调用它的start方法，不用之后调用close方法。其中的cacheData参数用来设置是否缓存节点数据。
start有两个，其中一个可以传入StartMode，用来为初始的cache设置暖场方式(warm)：
    1.NORMAL: 初始时为空。
    2.BUILD_INITIAL_CACHE: 在这个方法返回之前调用rebuild()。
    3.POST_INITIALIZED_EVENT: 当Cache初始化数据后发送一个PathChildrenCacheEvent.Type#INITIALIZED事件

PathChildrenCache.getListenable().addListener(PathChildrenCacheListener listener)可以增加listener监听缓存的改变。
getCurrentData()方法返回一个List对象，可以遍历所有的子节点。
2.编写示例程序
  1. public class PathCacheTest
  2. {
  3.     private static final String PATH = "/example/cache";
  4.     public static void main(String[] args) throws Exception
  5.     {
  6.         CuratorFramework client = CuratorFrameworkFactory.newClient("127.0.0.1:2181", new ExponentialBackoffRetry(1000, 3));
  7.         client.start();
  8.         PathChildrenCache cache = new PathChildrenCache(client, PATH, true);
  9.         cache.start();
  10.         PathChildrenCacheListener cacheListener = new PathChildrenCacheListener()
  11.         {
  12.             @Override
  13.             public void childEvent(CuratorFramework client, PathChildrenCacheEvent event) throws Exception
  14.             {
  15.                 System.out.println("事件类型：" + event.getType());
  16.                 System.out.println("节点数据：" + event.getData().getPath() + " = " + new String(event.getData().getData()));
  17.             }
  18.         };
  19.         cache.getListenable().addListener(cacheListener);
  20.         client.create().forPath("/example/cache/test01", "01".getBytes());
  21.         Thread.sleep(10);
  22.         client.create().forPath("/example/cache/test02", "02".getBytes());
  23.         Thread.sleep(10);
  24.         client.setData().forPath("/example/cache/test01", "01_V2".getBytes());
  25.         Thread.sleep(10);
  26.         for (ChildData data : cache.getCurrentData())
  27.         {
  28.             System.out.println("getCurrentData:" + data.getPath() + " = " + new String(data.getData()));
  29.         }
  30.         client.delete().forPath("/example/cache/test01");
  31.         Thread.sleep(10);
  32.         client.delete().forPath("/example/cache/test02");
  33.         Thread.sleep(1000 * 5);
  34.         cache.close();
  35.         client.close();
  36.         System.out.println("OK!");
  37.     }
  38. }
注意：如果new PathChildrenCache(client, PATH, true)中的参数cacheData值设置为false，则示例中的event.getData().getData()、data.getData()将返回null，cache将不会缓存节点数据。
注意：示例中的Thread.sleep(10)可以注释，但是注释后事件监听的触发次数会不全，这可能与cache的实现原理有关，不能太过频繁的触发事件！
3.示例程序运行结果
    运行结果控制台：
  1. 事件类型：CHILD_ADDED
  2. 节点数据：/example/cache/test01 = 01
  3. 事件类型：CHILD_ADDED
  4. 节点数据：/example/cache/test02 = 02
  5. 事件类型：CHILD_UPDATED
  6. 节点数据：/example/cache/test01 = 01_V2
  7. getCurrentData:/example/cache/test01 = 01_V2
  8. getCurrentData:/example/cache/test02 = 02
  9. 事件类型：CHILD_REMOVED
  10. 节点数据：/example/cache/test01 = 01_V2
  11. 事件类型：CHILD_REMOVED
  12. 节点数据：/example/cache/test02 = 02
  13. OK!

2.Node Cache

    Path Cache用来监控一个节点的子节点。当节点的数据修改或者删除时，Node Cache能更新它的状态包含最新的改变。
1.Node Cache介绍
Node Cache与Path Cache类似，Node Cache只是监听某一个特定的节点。它涉及到下面的三个类：
  • NodeCache - Node Cache实现类
  • NodeCacheListener - 节点监听器
  • ChildData - 节点数据
注意：使用cache，依然要调用它的start方法，不用之后调用close方法。
getCurrentData()将得到节点当前的状态，通过它的状态可以得到当前的值。
2.编写示例程序
  1. public class NodeCacheExample
  2. {
  3.     private static final String PATH = "/example/cache";
  4.     public static void main(String[] args) throws Exception
  5.     {
  6.         CuratorFramework client = CuratorFrameworkFactory.newClient("127.0.0.1:2181", new ExponentialBackoffRetry(1000, 3));
  7.         client.start();
  8.         final NodeCache cache = new NodeCache(client, PATH);
  9.         cache.start();
  10.         NodeCacheListener listener = new NodeCacheListener()
  11.         {
  12.             @Override
  13.             public void nodeChanged() throws Exception
  14.             {
  15.                 ChildData data = cache.getCurrentData();
  16.                 if (null != data)
  17.                 {
  18.                     System.out.println("节点数据：" + new String(cache.getCurrentData().getData()));
  19.                 }
  20.                 else
  21.                 {
  22.                     System.out.println("节点被删除!");
  23.                 }
  24.             }
  25.         };
  26.         cache.getListenable().addListener(listener);
  27.         client.create().creatingParentsIfNeeded().forPath(PATH, "01".getBytes());
  28.         Thread.sleep(10);
  29.         client.setData().forPath(PATH, "02".getBytes());
  30.         Thread.sleep(10);
  31.         client.delete().deletingChildrenIfNeeded().forPath(PATH);
  32.         Thread.sleep(1000 * 2);
  33.         cache.close();
  34.         client.close();
  35.         System.out.println("OK!");
  36.     }
  37. }
注意：示例中的Thread.sleep(10)可以注释，但是注释后事件监听的触发次数会不全，这可能与cache的实现原理有关，不能太过频繁的触发事件！
3.示例程序运行结果
    运行结果控制台：
  1. 节点数据：01
  2. 节点数据：02
  3. 节点被删除!
  4. OK!

3.Tree Node

    这种类型的即可以监控节点的状态，还监控节点的子节点的状态，类似上面两种cache的组合。这也就是Tree的概念。它监控整个树中节点的状态。
1.Tree Node介绍
Tree Node可以监控整个树上的所有节点，涉及到下面四个类。
  • TreeCache - Tree Cache实现类
  • TreeCacheListener - 监听器类
  • TreeCacheEvent - 触发的事件类
  • ChildData - 节点数据
注意：使用cache，依然要调用它的start方法，不用之后调用close方法。
getCurrentChildren(path)返回监控节点下的某个节点的直接子节点数据，类型为Map。 而getCurrentData()返回监控节点的数据。
2.编写示例程序
  1. public class TreeCacheExample
  2. {
  3.     private static final String PATH = "/example/cache";
  4.     public static void main(String[] args) throws Exception
  5.     {
  6.         CuratorFramework client = CuratorFrameworkFactory.newClient("127.0.0.1:2181", new ExponentialBackoffRetry(1000, 3));
  7.         client.start();
  8.         TreeCache cache = new TreeCache(client, PATH);
  9.         cache.start();
  10.         TreeCacheListener listener = new TreeCacheListener()
  11.         {
  12.             @Override
  13.             public void childEvent(CuratorFramework client, TreeCacheEvent event) throws Exception
  14.             {
  15.                 System.out.println("事件类型：" + event.getType() + " | 路径：" + event.getData().getPath());
  16.             }
  17.         };
  18.         cache.getListenable().addListener(listener);
  19.         client.create().creatingParentsIfNeeded().forPath("/example/cache/test01/child01");
  20.         client.setData().forPath("/example/cache/test01", "12345".getBytes());
  21.         client.delete().deletingChildrenIfNeeded().forPath(PATH);
  22.         Thread.sleep(1000 * 2);
  23.         cache.close();
  24.         client.close();
  25.         System.out.println("OK!");
  26.     }
  27. }
注意：在此示例中没有使用Thread.sleep(10)，但是事件触发次数也是正常的。
3.示例程序运行结果
    运行结果控制台：
  1. 事件类型：NODE_ADDED | 路径：/example/cache
  2. 事件类型：NODE_ADDED | 路径：/example/cache/test01
  3. 事件类型：NODE_ADDED | 路径：/example/cache/test01/child01
  4. 事件类型：NODE_UPDATED | 路径：/example/cache/test01
  5. 事件类型：NODE_REMOVED | 路径：/example/cache/test01/child01
  6. 事件类型：NODE_REMOVED | 路径：/example/cache/test01
  7. 事件类型：NODE_REMOVED | 路径：/example/cache
  8. OK!
-------------------------------------------------------------------------------------------------------------------------------



posted on 2015-11-06 14:59  技术江湖-小焕  阅读(2734)  评论(0)  编辑  收藏  举报