public class ClientFactory {

    /**

     * @param connectionString zk的连接地址

     * @return CuratorFramework 实例

     */

    public static CuratorFramework createSimple(String connectionString) {

        // 重试策略:第一次重试等待1s，第二次重试等待2s，第三次重试等待4s

        // 第一个参数：等待时间的基础单位，单位为毫秒

        // 第二个参数：最大重试次数

        ExponentialBackoffRetry retryPolicy = new ExponentialBackoffRetry(1000, 3);

        // 获取 CuratorFramework 实例的最简单的方式

        // 第一个参数：zk的连接地址

        // 第二个参数：重试策略

  return CuratorFrameworkFactory.newClient(connectionString, retryPolicy);

    }

    /**

     * @param connectionString    zk的连接地址

     * @param retryPolicy         重试策略

     * @param connectionTimeoutMs 连接

     * @param sessionTimeoutMs

     * @return CuratorFramework 实例

     */

    public static CuratorFramework createWithOptions(String connectionString, RetryPolicy retryPolicy,

            int connectionTimeoutMs, int sessionTimeoutMs) {

        // builder 模式创建 CuratorFramework 实例

        return CuratorFrameworkFactory.builder()

                .connectString(connectionString)

                .retryPolicy(retryPolicy)

                .connectionTimeoutMs(connectionTimeoutMs)

                .sessionTimeoutMs(sessionTimeoutMs)

                // 其他的创建选项

                .build();

    }

}

public class ZKclient {

    private CuratorFramework client;

    //Zk集群地址

    private static final String ZK_ADDRESS = "127.0.0.1:2181";

    public static ZKclient instance = null;

    static {

        instance = new ZKclient();

        instance.init();

    }

    private ZKclient() {

    }

    public void init() {

        if (null != client) {

            return;

        }

        //创建客户端

        client = ClientFactory.createSimple(ZK_ADDRESS);

        //启动客户端实例,连接服务器

        client.start();

    }

    public void destroy() {

        CloseableUtils.closeQuietly(client);

    }

    /**

     * 创建节点

     */

    public void createNode(String zkPath, String data) {

        try {

            // 创建一个 ZNode 节点

            // 节点的数据为 payload

            byte[] payload = "to set content".getBytes("UTF-8");

            if (data != null) {

                payload = data.getBytes("UTF-8");

            }

            client.create().creatingParentsIfNeeded().withMode(CreateMode.PERSISTENT).forPath(zkPath, payload);

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

    /**

     * 删除节点

     */

    public void deleteNode(String zkPath) {

        try {

            if (!isNodeExist(zkPath)) {

                return;

            }

            client.delete().forPath(zkPath);

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

    /**

     * 检查节点

     */

    public boolean isNodeExist(String zkPath) {

        try {

            Stat stat = client.checkExists().forPath(zkPath);

            if (null == stat) {

                log.info("节点不存在:", zkPath);

                return false;

            } else {

                log.info("节点存在 stat is:", stat.toString());

                return true;

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

        return false;

    }

    /**

     * 创建 临时 顺序 节点

     */

    public String createEphemeralSeqNode(String srcpath) {

        try {

            // 创建一个 ZNode 节点

            String path = client.create().creatingParentsIfNeeded()

                    .withMode(CreateMode.EPHEMERAL_SEQUENTIAL).forPath(srcpath);

            return path;

        } catch (Exception e) {

            e.printStackTrace();

        }

        return null;

    }

}

public class CRUD {

    private static final String ZK_ADDRESS = "127.0.0.1:2181";

    /**

     * 检查节点

     */

    @Test

public void checkNode() {

        CuratorFramework client = ClientFactory.createSimple(ZK_ADDRESS); //创建客户端

        try {

            client.start();//启动客户端实例,连接服务器

            // 创建一个 ZNode 节点，节点的数据为 payload

            String zkPath = "/test/CRUD/remoteNode-1";

            Stat stat = client.checkExists().forPath(zkPath);

            if (null == stat) {

                log.info("节点不存在:", zkPath);

            } else {

                log.info("节点存在 stat is:", stat.toString());

            }

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            CloseableUtils.closeQuietly(client);

        }

    }

    /**

     * 创建节点  持久化节点、临时节点、持久化顺序节点

     */

    @Test

    public void createNode() {

        CuratorFramework client = ClientFactory.createSimple(ZK_ADDRESS); //创建客户端

        try {

            client.start();//启动客户端实例,连接服务器

            // 创建一个 ZNode 节点，节点的数据为 payload

            String data = "hello";

            byte[] payload = data.getBytes("UTF-8");

            String zkPath = "/test/CRUD/remoteNode-1";

     client.create().creatingParentsIfNeeded().withMode(CreateMode.PERSISTENT)

.forPath(zkPath, payload);

// client.create().creatingParentsIfNeeded().withMode(CreateMode.EPHEMERAL)

.forPath(zkPath, payload);

// client.create().creatingParentsIfNeeded().withMode(CreateMode.PERSISTENT_SEQUENTIAL)

.forPath(zkPath, payload);

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            CloseableUtils.closeQuietly(client);

        }

    }

    /**

     * 读取节点

     */

    @Test

    public void readNode() {

        //创建客户端

        CuratorFramework client = ClientFactory.createSimple(ZK_ADDRESS);

        try {

            //启动客户端实例,连接服务器

            client.start();

            String zkPath = "/test/CRUD/remoteNode-1";

            Stat stat = client.checkExists().forPath(zkPath);

            if (null != stat) {

                //读取节点的数据

                byte[] payload = client.getData().forPath(zkPath);

                String data = new String(payload, "UTF-8");

                log.info("read data:", data);

                String parentPath = "/test";

                List<String> children = client.getChildren().forPath(parentPath);

                for (String child : children) {

                    log.info("child:", child);

                }

            }

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            CloseableUtils.closeQuietly(client);

        }

    }

    /**

     * 更新节点

     */

    @Test

    public void updateNode() {

        //创建客户端

        CuratorFramework client = ClientFactory.createSimple(ZK_ADDRESS);

        try {

            //启动客户端实例,连接服务器

            client.start();

            String data = "hello world";

            byte[] payload = data.getBytes("UTF-8");

            String zkPath = "/test/remoteNode-1";

            client.setData().forPath(zkPath, payload);

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            CloseableUtils.closeQuietly(client);

        }

    }

    /**

     * 更新节点 - 异步模式

     */

    @Test

    public void updateNodeAsync() {

        //创建客户端

        CuratorFramework client = ClientFactory.createSimple(ZK_ADDRESS);

        try {

            //更新完成监听器

            AsyncCallback.StringCallback callback = new AsyncCallback.StringCallback() {

                @Override

                public void processResult(int i, String s, Object o, String s1) {

                    System.out.println(

                            "i = " + i + " | " +

                                    "s = " + s + " | " +

                                    "o = " + o + " | " +

                                    "s1 = " + s1

                    );

                }

            };

            //启动客户端实例,连接服务器

            client.start();

            String data = "hello ,every body! ";

            byte[] payload = data.getBytes("UTF-8");

            String zkPath = "/test/CRUD/remoteNode-1";

            client.setData().inBackground(callback).forPath(zkPath, payload);

            Thread.sleep(10000);

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            CloseableUtils.closeQuietly(client);

        }

    }

    /**

     * 删除节点

     */

    @Test

    public void deleteNode() {

        //创建客户端

        CuratorFramework client = ClientFactory.createSimple(ZK_ADDRESS);

        try {

            //启动客户端实例,连接服务器

            client.start();

            //删除节点

            String zkPath = "/test/CRUD/remoteNode-1";

            client.delete().forPath(zkPath);

            //删除后查看结果

            String parentPath = "/test";

            List<String> children = client.getChildren().forPath(parentPath);

            for (String child : children) {

                log.info("child:", child);

            }

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            CloseableUtils.closeQuietly(client);

        }

    }

}