ZooKeeper学习之路 （六）ZooKeeper API的简单使用（二）级联删除与创建

编程思维训练

1、级联查看某节点下所有节点及节点值
2、删除一个节点，不管有有没有任何子节点
3、级联创建任意节点
4、清空子节点

ZKTest.java

public class ZKTest {

    private static final String CONNECT_STRING = "hadoop1,hadoop2,hadoop3";
    private static final int SESSION_TIMEOUT = 5000;
    private static ZooKeeper zk = null;

    public static void main(String[] args) throws Exception {
        zk = new ZooKeeper(CONNECT_STRING, SESSION_TIMEOUT, null);
        
        //1、级联查看某节点下所有节点及节点值 
        /*Map<String, String> map = new HashMap<>();
        Map<String, String> maps = ZKUtil.getChildNodeAndValue("/a",zk,map);
        maps.forEach((key, value) -> System.out.println(key + "\t" + value));*/
        
        //2、删除一个节点，不管有有没有任何子节点 
        /*boolean flag = ZKUtil.rmr("/x", zk);
        if(flag) {
            System.out.println("删除成功！");
        }else {
            System.out.println("删除失败");
        }*/
        
        
        //3、级联创建任意节点 
        /*boolean createZNode = ZKUtil.createZNode("/x/y/z/bb", "bb", zk);
        if(createZNode) {
            System.out.println("创建成功！");
        }else {
            System.out.println("创建失败");
        }*/
        
        
        //4、清空子节点
        boolean clearChildNode = ZKUtil.clearChildNode("/x", zk);
        if(clearChildNode) {
            System.out.println("删除成功！");
        }else {
            System.out.println("删除失败");
        }
        
    
        zk.close();
    }

    
}

ZKUtil.java

public class ZKUtil {
    
    private ZooKeeper zk;
    
    public ZKUtil() {}

    public ZooKeeper getZk() {
        return zk;
    }

    public void setZk(ZooKeeper zk) {
        this.zk = zk;
    }

    /**
     * 级联查看某节点下所有节点及节点值
     * @throws Exception 
     * @throws KeeperException 
     */
    public static Map<String, String> getChildNodeAndValue(String path,ZooKeeper zk,Map<String, String> map) throws Exception{
        
        //看看传入的节点是否存在
        if (zk.exists(path, false) != null) {
            //存在的话将该节点的数据存放到map中，key是绝对路径，value是存放的数据
            map.put(path, new String(zk.getData(path, false, null)));
            //查看该节点下是否还有子节点
            List<String> list = zk.getChildren(path, false);
            if (list.size() != 0) {
                //遍历子节点,递归调用自身的方法
                for (String child : list) {
                    getChildNodeAndValue( path + "/" + child,zk,map);
                }
            }
        }
        
        return map;
    }

    /**
     * 删除一个节点，不管有有没有任何子节点
     */
    public static boolean rmr(String path, ZooKeeper zk) throws Exception {
        //看看传入的节点是否存在
        if((zk.exists(path, false)) != null) {
            //查看该节点下是否还有子节点
            List<String> children = zk.getChildren(path, false);
            //如果没有子节点，直接删除当前节点
            if(children.size() == 0) {
                zk.delete(path, -1);
            }else {
                //如果有子节点，则先遍历删除子节点
                for(String child : children) {
                    rmr(path+"/"+child,zk);
                }
                //删除子节点之后再删除之前子节点的父节点
                rmr(path,zk);
            }
            return true;
        }else {
            //如果传入的路径不存在直接返回不存在
            System.out.println(path+" not exist");
            return false;
        }
        
        
    
    }

    /**
     * 级联创建任意节点
     * create znodePath data
     * create /a/b/c/xx 'xx'
     * @throws Exception 
     * @throws KeeperException 
     
     */
    public static boolean createZNode(String znodePath, String data, ZooKeeper zk) throws Exception{
        
        //看看要创建的节点是否存在
        if((zk.exists(znodePath, false)) != null) {
            return false;
        }else {        
            //获取父路径
            String parentPath = znodePath.substring(0, znodePath.lastIndexOf("/"));
            //如果父路径的长度大于0，则先创建父路径，再创建子路径
            if(parentPath.length() > 0) {
                createZNode(parentPath, data, zk);
                zk.create(znodePath, data.getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
            }else {
                //如果父路径的长度=0，则直接创建子路径
                zk.create(znodePath, data.getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
            }
            return true;
        }    
    }

    /**
     * 清空子节点
     */
    public static boolean clearChildNode(String znodePath, ZooKeeper zk) throws Exception {
        
        List<String> children = zk.getChildren(znodePath, false);
        
        for (String child : children) {    
            String childNode = znodePath + "/" + child;    
            if (zk.getChildren(childNode, null).size() != 0) {    
                clearChildNode(childNode, zk);    
            }    
            zk.delete(childNode, -1);    
        }    

        return true;
    }
}