使用分布式协调工具ZooKeeper——实现服务注册发现与动态负载均衡 （二）

1.在pom.xml中添加zookeeper的maven依赖

   <dependency>
            <groupId>com.101tec</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.8</version>
        </dependency>

2.创建一个 ServerHandler 类接收以及返回数据

public class ServerHandler implements Runnable {
    private Socket socket;

    public ServerHandler(Socket socket) {
        this.socket = socket;
    }

    public void run() {
        BufferedReader in = null;
        PrintWriter out = null;
        try {
            in = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
            out = new PrintWriter(this.socket.getOutputStream(), true);
            String body = null;
            while (true) {
                body = in.readLine();
                if (body == null)
                    break;
                System.out.println("Receive : " + body);
                out.println("Hello, " + body);
            }
        } catch (Exception e) {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
            if (out != null) {
                out.close();
            }
            if (this.socket != null) {
                try {
                    this.socket.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
                this.socket = null;
            }
        }
    }
}

3.创建可以注册到zookeeper上的服务器 ZkServerSocket 类

public class ZkServerSocket implements Runnable {
    private static int port = 8082;

    public static void main(String[] args) throws IOException {
        ZkServerSocket server = new ZkServerSocket(port);
        Thread thread = new Thread(server);
        thread.start();
    }

    public ZkServerSocket(int port) {
        this.port = port;
    }

    public void run() {
        ServerSocket serverSocket = null;
        try {
            serverSocket = new ServerSocket(port);
            registServer();
            System.out.println("服务启动成功，端口为:" + port);
            Socket socket = null;
            while (true) {
                socket = serverSocket.accept();
                new Thread(new ServerHandler(socket)).start();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (serverSocket != null) {
                    serverSocket.close();
                }
            } catch (Exception e2) {

            }
        }
    }

    //注册服务
    public void registServer() {
        //1.创建zk连接
        ZkClient zkClient = new ZkClient("127.0.0.1:2181", 5000, 10000);
        //2.创建父节点
        String root = "/test";
        //3.如果父节点不存在，创建父节点
        if (!zkClient.exists(root)) {
            //创建一个持久节点
            zkClient.createPersistent(root);
        }
        //4.创建子节点
        String nodeName = root + "/service_" + port;
        String nodeValue = "127.0.0.1:" + port;
        //如果子节点存在则删除子节点
        if (zkClient.exists(nodeName)) {
            zkClient.delete(nodeName);
        }
        //创建一个临时的子节点,类似于dubbo中的服务发现
        zkClient.createEphemeral(nodeName, nodeValue);
        System.out.println("服务注册成功： " + nodeValue);
    }
}

4.创建客户端，用来读取zookeeper上的节点数据

public class ZkServerClient {

    //存放服务器端集群
    public static List<String> listServer = new ArrayList<String>();

    public static void main(String[] args) {
        initServer();
        ZkServerClient client = new ZkServerClient();
        BufferedReader console = new BufferedReader(new InputStreamReader(System.in));
        while (true) {
            String name;
            try {
                name = console.readLine();
                if ("exit".equals(name)) {
                    System.exit(0);
                }
                client.send(name);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    // 注册所有server
    public static void initServer() {
        listServer.clear();
        //1.创建zk连接
        final ZkClient zkClient = new ZkClient("127.0.0.1:2181", 5000, 10000);
        //2.读取注册到节点上的信息
        final String root = "/test";
        final List<String> childrens = zkClient.getChildren(root);
        //3.获取子节点值
        for (String node : childrens) {
            //子节点路径
            String path = root + "/" + node;
            //获取子节点的值
            String value = zkClient.readData(path);
            //将子节点值放置在集合
            listServer.add(value);
        }
        System.out.println("服务发现成功 ：" + listServer.toString());
        serverCount = listServer.size();
        //使用zk事件监听,如果服务宕机，重新读取新的节点
        zkClient.subscribeChildChanges(root, new IZkChildListener() {
            public void handleChildChange(String parentPath, List<String> currentChilds) throws Exception {
                System.out.println("有服务器数量有变化时，重新获取服务器的节点信息");
                listServer.clear();
                for (String node : currentChilds) {
                    //子节点路径
                    String path = root + "/" + node;
                    //获取子节点的值
                    String value = zkClient.readData(path);
                    //将子节点值放置在集合
                    listServer.add(value);
                }
                serverCount = listServer.size();
                System.out.println("服务发现成功 ：" + listServer.toString());
            }
        });

    }

    //请求总数
    private static int reqCount = 1;
    //服务器总数
    private static int serverCount = 0;

    // 获取当前server信息
    public static String getServer() {
        //本地轮询算法
        String serverName = listServer.get(reqCount % serverCount);
        System.out.println("客户端请求次数： " + reqCount + "  对应服务器： " + serverName);
        reqCount++;
        return serverName;
    }

    public void send(String name) {

        String server = ZkServerClient.getServer();
        String[] cfg = server.split(":");

        Socket socket = null;
        BufferedReader in = null;
        PrintWriter out = null;
        try {
            socket = new Socket(cfg[0], Integer.parseInt(cfg[1]));
            in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            out = new PrintWriter(socket.getOutputStream(), true);

            out.println(name);
            while (true) {
                String resp = in.readLine();
                if (resp == null)
                    break;
                else if (resp.length() > 0) {
                    System.out.println("Receive : " + resp);
                    break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (out != null) {
                out.close();
            }
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

5.测试注册与发现功能

①启动zookeeper服务

②启动服务器代码，可以发现创建了一个test的父节点以及service_8082的子节点，其值为127.0.0.1:8082

③启动客户端代码,从控制台的信息可以看到，客户端发现了一个8082的服务

④修改服务器端口为8081，再次启动

客户端会监听zzookeeper的节点信息，然后动态读取服务器的信息

⑤当有服务器宕机时，假如8082宕机，关闭8082服务

 

以上zookeeper实现了服务的注册发现，类似于注册中心的功能

6.测试负载均衡功能

①修改服务端口，启动8081以及8082两个服务：

②在客户端发送多次消息如下图

③观测服务器控制台消息

  8081:服务

 

8082服务：

又以上两次日志信息，说明该服务实现了负载均衡的轮询算法。

 

注：如果需要实现别的算法，修改客户端中的server算法即可。

 

码云地址