Zookeeper客户端Curator基本API

        CuratorFramework client = getClient();
        client.start();
        // 创建普通节点(默认是持久节点),内容为空
        client.create().forPath("/t1");
        // 创建普通节点(默认是持久节点)
        client.create().forPath("/t2", "123456".getBytes());
        // 创建永久顺序节点
        client.create().withMode(CreateMode.PERSISTENT_SEQUENTIAL).forPath("/t3", "123456".getBytes());
        // 地柜创建，如果父节点不存在也会创建
        client.create().creatingParentContainersIfNeeded().withMode(CreateMode.PERSISTENT_SEQUENTIAL)
                .forPath("/t4/t41/t411", "123456".getBytes());

        client.create().inBackground(new BackgroundCallback() {
            @Override
            public void processResult(CuratorFramework curatorFramework, CuratorEvent curatorEvent) throws Exception {
                System.out.println(curatorEvent.getType() + "   " + curatorEvent.getResultCode());
            }
        }, Executors.newFixedThreadPool(2)).forPath("/t2", "测试值".getBytes());

    /**
     * 
     * @param client
     * @throws Exception
     */
    private static void setListenterThreeOne(CuratorFramework client) throws Exception {
        PathChildrenCache childrenCache = new PathChildrenCache(client, "/t4", true);
        PathChildrenCacheListener childrenCacheListener = new PathChildrenCacheListener() {
            @Override
            public void childEvent(CuratorFramework client, PathChildrenCacheEvent event) throws Exception {
                ChildData data = event.getData();
                switch (event.getType()) {
                case CHILD_ADDED:
                    System.out.println("CHILD_ADDED : " + data.getPath() + "  数据:" + data.getData());
                    break;
                case CHILD_REMOVED:
                    System.out.println("CHILD_REMOVED : " + data.getPath() + "  数据:" + data.getData());
                    break;
                case CHILD_UPDATED:
                    System.out.println("CHILD_UPDATED : " + data.getPath() + "  数据:" + data.getData());
                    break;
                default:
                    break;
                }
            }
        };

        // 在注册监听器的时候，如果传入此参数，当事件触发时，逻辑由线程池处理。如果不传会采用默认的线程池
        ExecutorService pool = Executors.newFixedThreadPool(2);
        // childrenCache.getListenable().addListener(childrenCacheListener);
        childrenCache.getListenable().addListener(childrenCacheListener, pool);
        // 设置监听模式
        childrenCache.start(StartMode.BUILD_INITIAL_CACHE);
    }

    // Node Cache 监控本节点的变化情况 连接 目录 是否压缩
    // 监听本节点的变化 节点可以进行修改操作 删除节点后会再次创建(空节点)
    private static void setListenterThreeTwo(CuratorFramework client) throws Exception {
        ExecutorService pool = Executors.newCachedThreadPool();
        // 设置节点的cache
        final NodeCache nodeCache = new NodeCache(client, "/t5", false);
        nodeCache.getListenable().addListener(new NodeCacheListener() {
            @Override
            public void nodeChanged() throws Exception {
                System.out.println("the test node is change and result is :");
                System.out.println("path : " + nodeCache.getCurrentData().getPath());
                System.out.println("data : " + new String(nodeCache.getCurrentData().getData()));
                System.out.println("stat : " + nodeCache.getCurrentData().getStat());
            }
        });
        nodeCache.start();
    }

    // 监控 指定节点和节点下的所有的节点的变化--无限监听 
    private static void setListenterThreeThree(CuratorFramework client) throws Exception {
        // 设置节点的cache
        TreeCache treeCache = new TreeCache(client, "/t5");
        // 设置监听器和处理过程
        treeCache.getListenable().addListener(new TreeCacheListener() {
            @Override
            public void childEvent(CuratorFramework client, TreeCacheEvent event) throws Exception {
                ChildData data = event.getData();
                if (data != null) {
                    switch (event.getType()) {
                    case NODE_ADDED:
                        System.out.println("NODE_ADDED : " + data.getPath() + "  数据:" + new String(data.getData()));
                        break;
                    case NODE_REMOVED:
                        System.out.println("NODE_REMOVED : " + data.getPath() + "  数据:" + new String(data.getData()));
                        break;
                    case NODE_UPDATED:
                        System.out.println("NODE_UPDATED : " + data.getPath() + "  数据:" + new String(data.getData()));
                        break;

                    default:
                        break;
                    }
                } else {
                    System.out.println("data is null : " + event.getType());
                }
            }
        });
        // 开始监听
        treeCache.start();
    }

        // 在注册监听器的时候，如果传入此参数，当事件触发时，逻辑由线程池处理。如果不传会采用默认的线程池
        ExecutorService pool = Executors.newFixedThreadPool(2);
        // childrenCache.getListenable().addListener(childrenCacheListener);
        childrenCache.getListenable().addListener(childrenCacheListener, pool);