zookeeper学习（六）ZooKeeper实现软负载均衡

素颜马尾好姑娘i 2022-05-30 09:50 258阅读 0赞

ZooKeeper是一个分布式的，开放源码的分布式应用程序协调服务，提供的功能包括配置维护、名字服务、分布式同步、组服务等。

ZooKeeper会维护一个树形的数据结构，类似于Windows资源管理器目录，其中EPHEMERAL类型的节点会随着创建它的客户端断开而被删除，利用这个特性很容易实现软负载均衡。

一、获取服务器列表，通过随机数，客户端随机获取一台服务器进行访问

基本原理是，每个应用的Server启动时创建一个EPHEMERAL节点，应用客户端通过读取节点列表获得可用服务器列表，并订阅节点事件，有Server宕机断开时触发事件，客户端监测到后把该Server从可用列表中删除。

在项目中添加zkclient的maven依赖

**\[java\]**  [view plain][]  [copy][view plain]

1.    
2.  <dependency>  
3.      <groupId>com.101tec</groupId>  
4.      <artifactId>zkclient</artifactId>  
5.      <version>0.8</version>  
6.  </dependency>

Server代码

**\[java\]**  [view plain][]  [copy][view plain]

1.  import java.io.BufferedReader;  
2.  import java.io.IOException;  
3.  import java.io.InputStreamReader;  
4.  import java.io.PrintWriter;  
5.  import java.net.ServerSocket;  
6.  import java.net.Socket;  
7.    
8.  import org.I0Itec.zkclient.ZkClient;  
9.    
10. public class SimpleServer implements Runnable \{  
11.   
12.     public static void main(String\[\] args) throws IOException \{  
13.         int port = 18080;  
14.         SimpleServer server = new SimpleServer(port);  
15.         Thread thread = new Thread(server);  
16.         thread.start();  
17.     \}  
18.   
19.     private int port;  
20.   
21.     public SimpleServer(int port) \{  
22.         this.port = port;  
23.     \}  
24.       
25.     private void regServer() \{  
26.         //向ZooKeeper注册当前服务器  
27.         ZkClient client = new ZkClient("127.0.0.1:2181", 60000, 1000);  
28.         String path = "/test/server" + port;  
29.         if(client.exists(path))  
30.             client.delete(path);  
31.         client.createEphemeral(path, "127.0.0.1:" + port);  
32.     \}  
33.   
34.     @Override  
35.     public void run() \{  
36.         ServerSocket server = null;  
37.         try \{  
38.             server = new ServerSocket(port);  
39.             regServer();  
40.             System.out.println("Server started at " + port);  
41.             Socket socket = null;  
42.             while (true) \{  
43.                 socket = server.accept();  
44.                 new Thread(new SimpleServerHandler(socket)).start();  
45.             \}  
46.         \} catch(IOException ex) \{  
47.             ex.printStackTrace();  
48.         \} finally \{  
49.             if (server != null) \{  
50.                 try \{  
51.                     server.close();  
52.                 \} catch (IOException e) \{\}  
53.             \}  
54.         \}  
55.   
56.     \}  
57. \}  
58. //SimpleServerHandler略

客户端代码

**\[java\]**  [view plain][]  [copy][view plain]

1.  import java.io.BufferedReader;  
2.  import java.io.IOException;  
3.  import java.io.InputStreamReader;  
4.  import java.io.PrintWriter;  
5.  import java.net.Socket;  
6.  import java.util.ArrayList;  
7.  import java.util.Arrays;  
8.  import java.util.List;  
9.  import java.util.Random;  
10.   
11. import org.I0Itec.zkclient.IZkChildListener;  
12. import org.I0Itec.zkclient.ZkClient;  
13.   
14. public class SimpleClient \{  
15.   
16.     private static List<String> servers = new ArrayList<>();  
17.       
18.     public static void main(String\[\] args) \{  
19.           
20.         initServerList();  
21.           
22.         SimpleClient client = new SimpleClient();  
23.         BufferedReader console = new BufferedReader(new InputStreamReader(System.in));  
24.         while (true) \{  
25.             String name;  
26.             try \{  
27.                 name = console.readLine();  
28.                 if("exit".equals(name)) \{  
29.                     System.exit(0);  
30.                 \}  
31.                 client.send(name);  
32.             \} catch (IOException e) \{  
33.                 e.printStackTrace();  
34.             \}  
35.         \}  
36.     \}  
37.       
38.     private static void initServerList() \{  
39.         //启动时从ZooKeeper读取可用服务器  
40.         String path = "/test";  
41.         ZkClient zkClient = new ZkClient("127.0.0.1:2181", 60000, 1000);  
42.         List<String> childs = zkClient.getChildren(path);  
43.         servers.clear();  
44.         for(String p : childs) \{  
45.             servers.add(zkClient.readData(path + "/" + p));  
46.         \}  
47.         //订阅节点变化事件  
48.         zkClient.subscribeChildChanges("/test", new IZkChildListener() \{  
49.             @Override  
50.             public void handleChildChange(String parentPath, List<String> currentChilds)  
51.                     throws Exception \{  
52.                 System.out.println(String.format("\[ZookeeperRegistry\] service list change: path=%s, currentChilds=%s", parentPath, currentChilds.toString()));  
53.                 servers.clear();  
54.                 for(String p : currentChilds) \{  
55.                     servers.add(zkClient.readData(path + "/" + p));  
56.                 \}  
57.                 System.out.println("Servers: " + servers.toString());  
58.             \}  
59.         \});  
60.           
61.     \}  
62.       
63.     public static String getServer() \{  
64.         return servers.get(new Random().nextInt(servers.size()));  
65.     \}  
66.     //其他无变化, 略  
67. \}

分别启动Server和Client，然后修改Server的端口号，再启动一个实例，可以看到客户端检测到了这个新服务器的存在

二、采用计数器方式，连接上加一，断开减一，获取计数最少的连接

zookeeper本身是不提供负载均衡的策略,需要自己来实现，所以这里确切的说，是在负载均衡中应用到了zookeeper做集群的协调。

对于HTTP请求的负载均衡，成熟的解决方案是Nginx（或Haproxy） +keepalived。其中Niginx负责代理HTTP请求，通过某种均衡策略访问集群中的服务器，keepalived负责检测集群中的服务器运行情况（有故障的机器移除，机器恢复工作后重新加入）

而对于TCP层的负载均衡，比如用Apache Mina做的网络通信应用，上面那种方案明显不适合，因为网络通信客户端和服务端要保持长连接

所以要针对这种长连接做负载均衡，一般都是基于连接数这种均衡策略，也就是在第一次连接时，分配服务器IP时，取当前连接数最少的那台

集群中有几台服务器处于运行状态，每一台服务器当前连接的客户数量，最大连接数量，等等这些信息需要记录起来，然后每次做负载均衡时根据这些信息来做分配，一般首先想到的是把这些信息存放在数据库里

简单的做法就是服务器启动时，把数据库里相应的状态改为运行，有客户连接或断开时，把连接数做加数或减数运算。

当服务器关闭时，问题就来了：

1、服务器关闭，可能数据源也已经被关闭，没法操作数据库，该机器在数据库里一直处于运行状态

2、服务器宕机，这种问题就很致命，这是连关闭的程序都没有执行，更不用说能操作数据库了

解决的方式就是用zookeeper保存服务器的连接信息

1、当服务器启动时，往zookeeper的节点里写入数据（节点类型是临时节点）

2、当服务器关闭时，从zookeeper移除相应的节点数据

3、当服务器宕机，zookeeper因为没有检测到心跳，自动把该节点移除，并通知其他服务器，其他服务器得知该机器已宕机，在分配连接时，不会分配到这台机器上，这点也是标题说的在负载均衡中用到zookeeper的原因。

对比了一下保存在数据库那种方式，zookeeper其实就是一个具有通知功能的数据库，也就是它底下节点数据有变化时，会通知它的所有客户端（这里的客户端指的连接到zookeeper的服务器）。

**原理解析**

架构图

![Center][]

每台WorkServer启动的时候都会到Server创建临时节点。

每台ClientServer启动的时候，都会到Server节点下面取得所有WorksServer节点，并通过一定算法取得一台并与之连接。

服务端主体流程

![Center 1][]

有ClientServer与之建立连接，这台WorksServer的负载计数器加一，断开连接负载计数器减一。负载计数器作为客户端负载均衡算法的依据，客户端会选择负载最轻的WorksServer建立连接。

客户端流程

![Center 2][]

服务端核心类

![Center 3][]

ServerRunner 调度类

RegistProvider 服务端启动时的注册过程

ServerHander 处理与客户端之间的连接

DefaultBalanceUpdateProvider 连接建立与断开，修改负载信息

客户端核心类

![Center 4][]

ClientRunner 调度类

ClientHander 处理与服务器之间的通信

BanceProvider 负载的算法

ServerData 服务器和客户端公用的类，计算负载等使用

[view plain]: http://blog.csdn.net/autfish/article/details/51576695#
[Center]: /images/20220530/a642cf860c1a4489af901c1eb5e1de54.png
[Center 1]: /images/20220530/f15c4237614d40c08289dcdd795e6352.png
[Center 2]: /images/20220530/e6705326d9784d16a5f3daf0e78c894e.png
[Center 3]: /images/20220530/b4a3451ed0234da58fa680b793fe819c.png
[Center 4]: /images/20220530/14175d650ebe4c4c89e7f96cada12dad.png