JAVAEE分布式技术之Zookeeper技术

总结：   只要是临时节点，都不可以有孩子

<dependency>
      <groupId>org.apache.zookeeper</groupId>
      <artifactId>zookeeper</artifactId>
      <version>3.4.13</version>
    </dependency>
       <!--日志 start-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.25</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.25</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>1.7.25</version>
            <scope>test</scope>
        </dependency>
        <!--日志end-->

config.properties
#链接字符串 C:\Windows\System32\drivers\etc\hosts  和/etc/hosts
connectString=zk1:2181,zk2:2181,zk3:2181,zk4:2181,zk5:2181
#链接超时时长
sessionTimeout=2000
```java
package com.aaa.util;
import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.util.List;
import java.util.Properties;
/**
 * fileName:ZookeeperUtil
 * description:
 * author:zz
 * createTime:2020/5/16 9:34
 * version:1.0.0
 */
public class ZookeeperUtil {
    private  Properties properties;
    //各个方法共享
    private ZooKeeper zooKeeper;
    /**
     * 空构造，初始化配置文件
     */
    public ZookeeperUtil(){
        InputStream inputStream = null;
        try {
            // Properties 是Map子孙类
             properties = new Properties();
            //使用任意类的Class对象中提供的getResourceAsStream读取配置文件为 输入字节流
            inputStream =ZookeeperUtil.class.getResourceAsStream("/config.properties");
            //加载内容
            properties.load(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if(inputStream!=null){
                    inputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 初始化zk
     */
    public void initZk(){
        try {
             zooKeeper = new ZooKeeper(properties.getProperty("connectString"),
                    Integer.valueOf(properties.getProperty("sessionTimeout")), new Watcher() {
                    @Override
                    public void process(WatchedEvent watchedEvent) {
                        System.out.println("当查看子节点或者查看节点数据时，使用watch时，在这回调");
                    }
            });
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    /**
     * 节点的创建
     * @param path  节点路径
     * @param nodeData  节点数据
     * @param type  节点类型 type=0 持久节点  type=1 临时节点  type=2 持久有序  type=3 临时有序
     * @return
     */
    public boolean createZKNode(String path,String nodeData,int type){
        //String path, byte[] data, List<ACL> acl, CreateMode createMode
        try {
            // nodeData.getBytes("utf-8") 支持中文的
            zooKeeper.create(path,nodeData.getBytes("utf-8"),
                    ZooDefs.Ids.OPEN_ACL_UNSAFE,// world:anyone:crwda
                    CreateMode.fromFlag(type)  //type=0 持久节点  type=1 临时节点  type=2 持久有序  type=3 临时有序
            );
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }
    /**
     * 根据节点路径查询子节点
     * @param path  节点路径
     * @param isWatch  是否监控
     * @return
     */
    public List<String>  getChirdrenByPath(String path,boolean isWatch){
        try {
            //查询并返回
            return  zooKeeper.getChildren(path, isWatch);
        } catch (Exception e) {
            e.printStackTrace();
        } 
        return null;
    }
    /**
     * 根据节点路径删除节点
     * @param path
     * @return
     */
    public boolean deleteNodeByPath(String path){
        try {
            // version=-1 删除所有版本
            zooKeeper.delete(path,-1);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }
    /**
     * 获取节点数据
     * @param path
     * @param isWatch
     * @return
     */
     public String getNodeData(String path,boolean isWatch){
         try {
             byte[] byteArray = zooKeeper.getData(path, isWatch, null);
             return new String(byteArray);
         } catch (KeeperException e) {
             e.printStackTrace();
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         return null;
     }
    /**
     * 节点数据的更新
     * @param path
     * @return
     */
     public boolean updateNodeData(String path,String nodeData){
         try {
             zooKeeper.setData(path,nodeData.getBytes("utf-8"),-1);
             return true;
         } catch (Exception e) {
             e.printStackTrace();
         }
         return false;
     }
    /**
     * 判断节点是否存在
     * @param path
     * @return
     */
     public boolean  isNodeExist(String path){
         try {
             Stat exists = zooKeeper.exists(path, false);
             if(exists!=null)
                 return true;
         } catch (Exception e) {
             e.printStackTrace();
         }
         return false;
     }
}

ZKUtilTest
package com.aaa.test;
import com.aaa.util.ZookeeperUtil;
import org.apache.zookeeper.ZooKeeper;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.util.List;
/**
 * fileName:ZKUtilTest
 * description:
 * author:zz
 * createTime:2020/5/16 11:13
 * version:1.0.0
 */
public class ZKUtilTest {
    private ZookeeperUtil zookeeperUtil;
    /**
     * 执行Test之前执行的方法
     */
    @Before
    public void init(){
        //加载配置读取配置
        zookeeperUtil = new ZookeeperUtil();
        //使用配置连接zk集群
        zookeeperUtil.initZk();
    }
    /**
     * 测试创建节点方法
     */
    @Test
    public void testCreateZKNode(){
        boolean result = zookeeperUtil.createZKNode("/testCreateNode1/cnode", "子节点3", 2);
        if(result){
            System.out.println("操作成功");
        }else {
            System.out.println("操作失败");
        }
    }
    /**
     * 测试获取子节点
     */
    @Test
    public void testGetChirdrenByPath(){
        List<String> chirdren = zookeeperUtil.getChirdrenByPath("/testCreateNode1", false);
        System.out.println("子节点有：");
        for (String s : chirdren) {
            System.out.println(s);
        }
    }
    /**
     * 测试获取接单数据
     */
    @Test
    public void testGetNodeData(){
        String nodeData = zookeeperUtil.getNodeData("/testCreateNode1", false);
        System.out.println(nodeData);
    }
    /**
     * 测试更新数据
     */
    @Test
    public void testUpdateNodeData(){
        //测试节点是否存在
        if(zookeeperUtil.isNodeExist("/testCreateNode1")){
            boolean result = zookeeperUtil.updateNodeData("/testCreateNode1", "根节点。。。");
            if(result){
                System.out.println("操作成功");
            }else {
                System.out.println("操作失败");
            }
        }
    }
    /**
     * 测试删除节点
     */
    @Test
    public void testDeleteNodeByPath(){
        List<String> chirdren = zookeeperUtil.getChirdrenByPath("/testCreateNode1", false);
        //判断是否有子节点
        if(chirdren!=null&&chirdren.size()>0){
            //循环删除子节点
            for (String c : chirdren) {
                zookeeperUtil.deleteNodeByPath("/testCreateNode1/"+c);
            }
        }
        //在删除父节点
        boolean result  = zookeeperUtil.deleteNodeByPath("/testCreateNode1");
        if(result){
            System.out.println("操作成功");
        }else {
            System.out.println("操作失败");
        }
    }
    @After
    public void  distory(){
        System.out.println("最终执行的方法。。。");
    }
}

回顾：
           zk数据存储  树状，节点类型4中：
               持久节点，持久有序节点，临时节点，临时有序节点
           命令：
                  help   帮助命令（查看所有命令）
                  connect   ip(或者主机名称):端口（2181）
                  close   关闭当前的会话
                  quit    退出
                  create  [-s]  [-e]  /路径   内容   创建节点,默认就是持久节点，根据参数不同，创建不同节点
                  set   /路径    内容     修改节点内容
                  get   /路径   [watch]    获取节点内容[是否监听（只监听一次）]
                  getAcl   /路径       ACL （访问控制列表，对每个节点进行设置，不会级联子节点）
                                             默认: world:anyone:crwda
                  setAcl   /路径     schema:id:permission 
                                            schema:    world   ip   auth   digest 
                                            id:       anyone   ip     自定义用户（scott,admin） 
                                            permission:   create  是否创建子节点   
                                                                  read   获取当前节点内容
                                                                  write  修改当前节点内容
                                                                  delete   删除当前节点内容
                                                                  admin   是否可以修改ACL访问控制列表  
               delete  /路径     只能删除没有子节点的节点
               rmr     /路径     可以删除所有节点（有字节点也可以）
                ls      /路径   [watch]   查看子节点   [可以使用监听，子节点发生变化（添加和删除），只监听一次]
               histroy   返回最近使用的10条命令
           java  对zk的操作（和命令操作类似，只不过换成了 java代码）

package com.aaa.test;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
/**
 * fileName:LoadP
 * description:
 * author:zz
 * createTime:2020/7/14 21:11
 * version:1.0.0
 */
public class LoadP {
    /**
     * 加载配置文件方法
      * @param path
     * @return
     */
    public static Properties load(String path){
        Properties properties = new Properties();
        InputStream inputStream = LoadP.class.getResourceAsStream("/"+path);
        try {
            properties.load(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return properties;
    }
}
  服务注册：
package com.aaa.test.file;
import com.aaa.test.LoadP;
import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;
import java.util.Properties;
/**
 * fileName:HdfsServer
 * description:
 * author:zz
 * version:1.0.0
 */
public class HdfsServer {
    private ZooKeeper zooKeeper;
   // private static final String parentPath="/servers";
    private  Properties load = LoadP.load("zk.properties");
    /**
     * 获取连接
     * @throws Exception
     */
    public void getZKConnect() throws Exception{
        zooKeeper = new ZooKeeper(load.getProperty("cstr"), Integer.valueOf(load.getProperty("to")), new Watcher() {
            public void process(WatchedEvent watchedEvent) {
            }
        });
    }
    /**
     * 注册
     * @param serverName
     * @throws KeeperException
     * @throws InterruptedException
     */
    public void registerToZkCluster(String serverName) throws KeeperException, InterruptedException {
        Stat stat = zooKeeper.exists(load.getProperty("parentPath"), false);
        if(stat==null) {
            String parentPath = zooKeeper.create(load.getProperty("parentPath"), serverName.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
            System.out.println("无父节点，创建："+parentPath);
        }
        String s = zooKeeper.create(load.getProperty("parentPath") + "/hdfs", serverName.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
        System.out.println(serverName+"主机上线了，注册节点为"+s);
    }
    /**
     * 处理业务
     * @param serverName
     * @throws InterruptedException
     */
    public void handleService(String serverName) throws InterruptedException {
        System.out.println(serverName+"开始工作，准备存储或者下载文件。。。");
        Thread.sleep(Integer.MAX_VALUE);
    }
    public static void main(String[] args) throws Exception {
        HdfsServer hdfsServer =new HdfsServer();
        hdfsServer.getZKConnect();
        //args[0]="cs1";
        hdfsServer.registerToZkCluster(args[0]);
        hdfsServer.handleService(args[0]);
    }
}
web服务感知：
package com.aaa.test.file;
import com.aaa.test.LoadP;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
/**
 * fileName:WebServer
 * description:
 * author:zz
 * version:1.0.0
 */
public class WebServer {
    private ZooKeeper zooKeeper;
    private  Properties load = LoadP.load("zk.properties");
    /**
     * 获取连接
     * @throws Exception
     */
    public void getZKConnect() throws Exception{
        zooKeeper = new ZooKeeper(load.getProperty("cstr"), Integer.valueOf(load.getProperty("to")), new Watcher() {
            public void process(WatchedEvent watchedEvent) {
                try {
                    watchServerList();
                } catch (KeeperException e) {
                    e.printStackTrace();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }
    /**
     * 监控集群中服务器状态
     * @throws KeeperException
     * @throws InterruptedException
     */
    public void watchServerList() throws KeeperException, InterruptedException {
        List<String> children = zooKeeper.getChildren(load.getProperty("parentPath"), true);
        List<String> hdfsList =new ArrayList<String>();
        for (String child : children) {
            byte[] data = zooKeeper.getData(load.getProperty("parentPath") + "/" + child, false, null);
             hdfsList.add(new String(data));
        }
        System.out.println("工作的HDFS有："+hdfsList);
    }
    /**
     * 运行web业务
     * @throws InterruptedException
     */
    public  void handleWebService() throws InterruptedException {
        System.out.println("web 服务器在正常工作。。。");
        Thread.sleep(Integer.MAX_VALUE);
    }
    public static void main(String[] args) throws Exception {
        WebServer webServer=new WebServer();
        webServer.getZKConnect();
        webServer.watchServerList();
        webServer.handleWebService();
    }
}

java -cp  *.jar  含有main的类  参数