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:

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.编写示例程序

public class PathCacheTest
{
    private static final String PATH = "/example/cache";
    public static void main(String[] args) throws Exception
    {
        CuratorFramework client = CuratorFrameworkFactory.newClient("127.0.0.1:2181", new ExponentialBackoffRetry(1000, 3));
        client.start();
        PathChildrenCache cache = new PathChildrenCache(client, PATH, true);
        cache.start();
        PathChildrenCacheListener cacheListener = new PathChildrenCacheListener()
        {
            @Override
            public void childEvent(CuratorFramework client, PathChildrenCacheEvent event) throws Exception
            {
                System.out.println("事件类型：" + event.getType());
                System.out.println("节点数据：" + event.getData().getPath() + " = " + new String(event.getData().getData()));
            }
        };
        cache.getListenable().addListener(cacheListener);
        client.create().forPath("/example/cache/test01", "01".getBytes());
        Thread.sleep(10);
        client.create().forPath("/example/cache/test02", "02".getBytes());
        Thread.sleep(10);
        client.setData().forPath("/example/cache/test01", "01_V2".getBytes());
        Thread.sleep(10);
        for (ChildData data : cache.getCurrentData())
        {
            System.out.println("getCurrentData:" + data.getPath() + " = " + new String(data.getData()));
        }
        client.delete().forPath("/example/cache/test01");
        Thread.sleep(10);
        client.delete().forPath("/example/cache/test02");
        Thread.sleep(1000 * 5);
        cache.close();
        client.close();
        System.out.println("OK!");
    }
}

注意：如果new PathChildrenCache(client, PATH, true)中的参数cacheData值设置为false，则示例中的event.getData().getData()、data.getData()将返回null，cache将不会缓存节点数据。

注意：示例中的Thread.sleep(10)可以注释，但是注释后事件监听的触发次数会不全，这可能与cache的实现原理有关，不能太过频繁的触发事件！

3.示例程序运行结果

    运行结果控制台：

事件类型：CHILD_ADDED
节点数据：/example/cache/test01 = 01
事件类型：CHILD_ADDED
节点数据：/example/cache/test02 = 02
事件类型：CHILD_UPDATED
节点数据：/example/cache/test01 = 01_V2
getCurrentData:/example/cache/test01 = 01_V2
getCurrentData:/example/cache/test02 = 02
事件类型：CHILD_REMOVED
节点数据：/example/cache/test01 = 01_V2
事件类型：CHILD_REMOVED
节点数据：/example/cache/test02 = 02
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.编写示例程序

public class NodeCacheExample
{
    private static final String PATH = "/example/cache";
    public static void main(String[] args) throws Exception
    {
        CuratorFramework client = CuratorFrameworkFactory.newClient("127.0.0.1:2181", new ExponentialBackoffRetry(1000, 3));
        client.start();
        final NodeCache cache = new NodeCache(client, PATH);
        cache.start();
        NodeCacheListener listener = new NodeCacheListener()
        {
            @Override
            public void nodeChanged() throws Exception
            {
                ChildData data = cache.getCurrentData();
                if (null != data)
                {
                    System.out.println("节点数据：" + new String(cache.getCurrentData().getData()));
                }
                else
                {
                    System.out.println("节点被删除!");
                }
            }
        };
        cache.getListenable().addListener(listener);
        client.create().creatingParentsIfNeeded().forPath(PATH, "01".getBytes());
        Thread.sleep(10);
        client.setData().forPath(PATH, "02".getBytes());
        Thread.sleep(10);
        client.delete().deletingChildrenIfNeeded().forPath(PATH);
        Thread.sleep(1000 * 2);
        cache.close();
        client.close();
        System.out.println("OK!");
    }
}

注意：示例中的Thread.sleep(10)可以注释，但是注释后事件监听的触发次数会不全，这可能与cache的实现原理有关，不能太过频繁的触发事件！

3.示例程序运行结果

    运行结果控制台：

节点数据：01
节点数据：02
节点被删除!
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.编写示例程序

public class TreeCacheExample
{
    private static final String PATH = "/example/cache";
    public static void main(String[] args) throws Exception
    {
        CuratorFramework client = CuratorFrameworkFactory.newClient("127.0.0.1:2181", new ExponentialBackoffRetry(1000, 3));
        client.start();
        TreeCache cache = new TreeCache(client, PATH);
        cache.start();
        TreeCacheListener listener = new TreeCacheListener()
        {
            @Override
            public void childEvent(CuratorFramework client, TreeCacheEvent event) throws Exception
            {
                System.out.println("事件类型：" + event.getType() + " | 路径：" + event.getData().getPath());
            }
        };
        cache.getListenable().addListener(listener);
        client.create().creatingParentsIfNeeded().forPath("/example/cache/test01/child01");
        client.setData().forPath("/example/cache/test01", "12345".getBytes());
        client.delete().deletingChildrenIfNeeded().forPath(PATH);
        Thread.sleep(1000 * 2);
        cache.close();
        client.close();
        System.out.println("OK!");
    }
}

注意：在此示例中没有使用Thread.sleep(10)，但是事件触发次数也是正常的。

3.示例程序运行结果

    运行结果控制台：

事件类型：NODE_ADDED | 路径：/example/cache
事件类型：NODE_ADDED | 路径：/example/cache/test01
事件类型：NODE_ADDED | 路径：/example/cache/test01/child01
事件类型：NODE_UPDATED | 路径：/example/cache/test01
事件类型：NODE_REMOVED | 路径：/example/cache/test01/child01
事件类型：NODE_REMOVED | 路径：/example/cache/test01
事件类型：NODE_REMOVED | 路径：/example/cache
OK!

-------------------------------------------------------------------------------------------------------------------------------

来自为知笔记(Wiz)