这是使用原始的api操作的
可以使用封装的api curator操作zookeeper

0、依赖

  1. <!--        zookeeper-->
  2.         <dependency>
  3.             <groupId>org.apache.zookeeper</groupId>
  4.             <artifactId>zookeeper</artifactId>
  5.             <version>3.4.12</version>
  6.         </dependency>

1、客户端操作测试

ZooKeeperClientTest

  1. package com.lms.zookeeper;
  3. import org.apache.zookeeper.*;
  4. import org.apache.zookeeper.data.Stat;
  5. import org.junit.Before;
  6. import org.junit.Test;
  8. import java.io.IOException;
  9. import java.util.List;
  11. /**
  12.  * @Author: 李孟帅
  13.  * @CreateTime: 2020-08-20 22:07
  14.  * @Description:
  15.  */
  16. public class ZooKeeperClientTest {
  17.     private static final String CONNECTION_STRING = "192.168.189.100:2181,192.168.189.101:2181,192.168.189.102:2181";
  18.     private static final int SESSION_TIMEOUT = 2000;
  19.     private ZooKeeper zk = null;
  22.     /**
  23.     * @Author 李孟帅
  24.     * @Description 获取客户端连接
  25.     * @Date 2020/8/20 
  26.     **/
  27.     @Before
  28.     public void getConnection() throws IOException {
  29.         zk = new ZooKeeper(CONNECTION_STRING, SESSION_TIMEOUT, new Watcher() {
  30.             @Override
  31.             public void process(WatchedEvent event) {
  32.                 System.out.println(event);
  33.                 try {
  34.                     zk.getChildren("/",true);
  35.                 } catch (KeeperException | InterruptedException e) {
  36.                     e.printStackTrace();
  37.                 }
  38.             }
  39.         });
  40.     }
  42.     /**
  43.     * @Author 李孟帅
  44.     * @Description 创建节点
  45.     * @Date 2020/8/20 
  46.     **/
  47.     @Test
  48.     public void createNode() throws KeeperException, InterruptedException {
  49.         String s = zk.create("/app1", "this is a test!".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
  50.         System.out.println(s);
  51.     }
  53.     /**
  54.     * @Author 李孟帅
  55.     * @Description 获取节点数据
  56.     * @Date 2020/8/20 
  57.     **/
  58.     @Test
  59.     public void getData() throws KeeperException, InterruptedException {
  60.         byte[] data = zk.getData("/app1", false, null);
  61.         System.out.println(new String(data));
  62.     }
  64.     /**
  65.     * @Author 李孟帅
  66.     * @Description 获取子节点
  67.     * @Date 2020/8/20 
  68.     **/
  69.     @Test
  70.     public void getChildren() throws KeeperException, InterruptedException {
  71.         List<String> children = zk.getChildren("/app1", true);
  72.         for (String child : children) {
  73.             System.out.println(child);
  74.         }
  75.         Thread.sleep(Long.MAX_VALUE);
  76.     }
  77.     /**
  78.     * @Author 李孟帅
  79.     * @Description 修改节点数据
  80.     * @Date 2020/8/20 
  81.     **/
  82.     @Test
  83.     public void setData() throws KeeperException, InterruptedException {
  84.         Stat stat = zk.setData("/app1", "new data".getBytes(), -1);
  85.         System.out.println(stat);
  86.     }
  87.     /**
  88.     * @Author 李孟帅
  89.     * @Description 删除节点
  90.     * @Date 2020/8/20 
  91.     **/
  92.     @Test
  93.     public void deleteNode () throws KeeperException, InterruptedException {
  94.         zk.delete("/app1",-1);
  95.     }
  97.     /**
  98.     * @Author 李孟帅
  99.     * @Description 判断节点是否存在
  100.     * @Date 2020/8/21 
  101.     **/
  102.     @Test
  103.     public void exist() throws KeeperException, InterruptedException {
  104.         Stat exists = zk.exists("/app2", true);
  105.         System.out.println(exists);
  106.     }
  109. }

2、服务器动态上线下线监听 服务端

DistributedServer

  1. package com.lms.zookeeper;
  3. import org.apache.zookeeper.*;
  4. import java.io.IOException;
  6. /**
  7.  * @Author: 李孟帅
  8.  * @CreateTime: 2020-08-21 08:29
  9.  * @Description:
  10.  */
  11. public class DistributedServer {
  12.     private static final String CONNECTION_STRING = "192.168.189.100:2181,192.168.189.101:2181,192.168.189.102:2181";
  13.     private static final int SESSION_TIMEOUT = 2000;
  14.     private ZooKeeper zk = null;
  17.     /**
  18.      * @Author 李孟帅
  19.      * @Description 获取客户端连接
  20.      * @Date 2020/8/20
  21.      **/
  22.     public void getConnection() throws IOException {
  23.         zk = new ZooKeeper(CONNECTION_STRING, SESSION_TIMEOUT, new Watcher() {
  24.             @Override
  25.             public void process(WatchedEvent event) {
  26.                 System.out.println(event);
  28.             }
  29.         });
  30.     }
  32.     /**
  33.      * @Author 李孟帅
  34.      * @Description 注册
  35.      * @Date 2020/8/21
  36.      **/
  37.     public void registryServer(String hostname) throws KeeperException, InterruptedException {
  38.         String create = zk.create("/servers/"+hostname, hostname.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
  39.         System.out.println(hostname + " is online ," + create);
  41.     }
  43.     /**
  44.     * @Author 李孟帅
  45.     * @Description 业务功能
  46.     * @Date 2020/8/21 
  47.     **/
  48.     public void handleBusiness(String hostname) throws InterruptedException {
  49.         System.out.println(hostname+" start working...");
  50.         Thread.sleep(Long.MAX_VALUE);
  51.     }
  53.     public static void main(String[] args) throws IOException, KeeperException, InterruptedException {
  55.         //获取zk连接
  56.         DistributedServer distributedServer = new DistributedServer();
  57.         distributedServer.getConnection();
  58.         //利用zk注册服务器信息
  59.         distributedServer.registryServer(args[0]);
  60.         //启动业务功能
  61.         distributedServer.handleBusiness(args[0]);
  63.     }
  64. }

3、服务器动态上线下线监听 客户端

DistributedClient

  1. package com.lms.zookeeper;
  3. import org.apache.zookeeper.KeeperException;
  4. import org.apache.zookeeper.WatchedEvent;
  5. import org.apache.zookeeper.Watcher;
  6. import org.apache.zookeeper.ZooKeeper;
  8. import java.io.IOException;
  9. import java.util.ArrayList;
  10. import java.util.List;
  12. /**
  13.  * @Author: 李孟帅
  14.  * @CreateTime: 2020-08-21 08:48
  15.  * @Description:
  16.  */
  17. public class DistributedClient {
  18.     private static final String CONNECTION_STRING = "192.168.189.100:2181,192.168.189.101:2181,192.168.189.102:2181";
  19.     private static final int SESSION_TIMEOUT = 2000;
  20.     private ZooKeeper zk = null;
  21.     private volatile ArrayList<String> serverList=new ArrayList<String>();
  24.     /**
  25.      * @Author 李孟帅
  26.      * @Description 获取客户端连接
  27.      * @Date 2020/8/20
  28.      **/
  29.     public void getConnection() throws IOException {
  30.         zk = new ZooKeeper(CONNECTION_STRING, SESSION_TIMEOUT, new Watcher() {
  31.             @Override
  32.             public void process(WatchedEvent event) {
  33.                 try {
  34.                     getServerList();
  35.                 } catch (KeeperException | InterruptedException e) {
  36.                     e.printStackTrace();
  37.                 }
  39.             }
  40.         });
  41.     }
  43.     /**
  44.     * @Author 李孟帅
  45.     * @Description 获取服务器列表
  46.     * @Date 2020/8/21
  47.     **/
  48.     public void getServerList() throws KeeperException, InterruptedException {
  49.         //获取子节点信息，并监听父节点
  50.         List<String> children = zk.getChildren("/servers", true);
  51.         ArrayList<String> servers = new ArrayList<>();
  52.         for (String child : children) {
  53.             byte[] data = zk.getData("/servers/" + child, false, null);
  54.             servers.add(new String(data));
  55.         }
  56.         serverList=servers;
  57.         System.out.println(serverList);
  58.     }
  59.     //业务功能
  60.     public void handleBusiness() throws InterruptedException {
  61.         System.out.println("client start working...");
  62.         Thread.sleep(Long.MAX_VALUE);
  63.     }
  65.     public static void main(String[] args) throws IOException, KeeperException, InterruptedException {
  66.         //获取zk连接
  67.         DistributedClient distributedClient = new DistributedClient();
  68.         distributedClient.getConnection();
  69.         //获取/servers子节点信息（并监听），从中获取服务器列表
  70.         distributedClient.getServerList();
  71.         //业务功能
  72.         distributedClient.handleBusiness();
  73.     }
  74. }