Zookeeper实现负载均衡原理

╰+攻爆jí腚メ 2022-01-28 13:17 319阅读 0赞

Zookeeper实现负载均衡原理

先玩个正常的，好玩的socket编程：

服务端：

首先公共的这个Handler：

  1. package com.toov5.zkDubbo;
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.io.PrintWriter;
  7. import java.net.Socket;
  9. public class ServerHandler implements Runnable {
  10.     private Socket socket;
  12.     public ServerHandler(Socket socket) {
  13.         this.socket = socket;
  14.     }
  16.     public void run() {
  17.         BufferedReader in = null;
  18.         PrintWriter out = null;
  19.         try {
  20.             in = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
  21.             out = new PrintWriter(this.socket.getOutputStream(), true);
  22.             String body = null;
  23.             while (true) {
  24.                 body = in.readLine();
  25.                 if (body == null)
  26.                     break;
  27.                 System.out.println("Receive : " + body);
  28.                 out.println("Hello, " + body);
  29.             }
  31.         } catch (Exception e) {
  32.             if (in != null) {
  33.                 try {
  34.                     in.close();
  35.                 } catch (IOException e1) {
  36.                     e1.printStackTrace();
  37.                 }
  38.             }
  39.             if (out != null) {
  40.                 out.close();
  41.             }
  42.             if (this.socket != null) {
  43.                 try {
  44.                     this.socket.close();
  45.                 } catch (IOException e1) {
  46.                     e1.printStackTrace();
  47.                 }
  48.                 this.socket = null;
  49.             }
  50.         }
  51.     }
  52. }
  56. package com.toov5.zkDubbo;
  58. import java.io.IOException;
  59. import java.net.ServerSocket;
  60. import java.net.Socket;
  62. import org.I0Itec.zkclient.ZkClient;
  64. //##ServerScoekt服务端
  65. public class ZkServerScoekt implements Runnable {
  66.     private static int port = 18080;  //socket 服务启动后的所使用的 端口号
  68.     public static void main(String[] args) throws IOException {
  69.         ZkServerScoekt server = new ZkServerScoekt(port);  //构造函数传入port
  70.     //    regServer();  //去zk注册
  71.         Thread thread = new Thread(server);
  72.         thread.start();
  73.     }
  75.     public ZkServerScoekt(int port) {
  76.         this.port = port;
  77.     }
  78. //  //注册服务
  79. //    public static void regServer(){
  80. //        //1、建立zk连接
  81. //    ZkClient zkClient = new ZkClient("192.168.91.5",5000,10000);
  82. //        //2.先创建父节点
  83. //    String root = "/toov5";
  84. //    if (!zkClient.exists(root)) {
  85. //        //如果父节点不存，直接创建父节点
  86. //        zkClient.createPersistent(root);  //持久节点
  87. //    }
  88. //       //3、创建子节点
  89. //     String nodeName = root+"/service_"+port;      
  90. //     String nodeValue="127.0.0.1:"+port;
  91. //     if (zkClient.exists(nodeName)) {  //如果存在 直接删除掉
  92. //        zkClient.delete(nodeName);
  93. //    }
  94. //     zkClient.createEphemeral(nodeName); //字节的 临时节点  如果服务宕机了 找不到了就
  95. //     System.out.println("服务注册成功"+nodeName);
  96. //     
  97. //    }
  98. //    
  99. //    
  101.     public void run() {
  102.         ServerSocket serverSocket = null;
  103.         try {
  104.             serverSocket = new ServerSocket(port);
  105.             System.out.println("Server start port:" + port);
  106.             Socket socket = null;
  107.             while (true) {
  108.                 socket = serverSocket.accept();
  109.                 new Thread(new ServerHandler(socket)).start();
  110.             }
  111.         } catch (Exception e) {
  112.             e.printStackTrace();
  113.         } finally {
  114.             try {
  115.                 if (serverSocket != null) {
  116.                     serverSocket.close();
  117.                 }
  118.             } catch (Exception e2) {
  120.             }
  121.         }
  122.     }
  124. }

客户端：

  1. package com.toov5.zkDubbo;
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.io.PrintWriter;
  7. import java.net.Socket;
  8. import java.util.ArrayList;
  9. import java.util.List;
  11. public class ZkServerClient {
  12.     public static List<String> listServer = new ArrayList<String>();
  14.     public static void main(String[] args) {
  15.         initServer();
  16.         ZkServerClient     client= new ZkServerClient();
  17.         BufferedReader console = new BufferedReader(new InputStreamReader(System.in));
  18.         while (true) {
  19.             String name;
  20.             try {
  21.                 name = console.readLine();
  22.                 if ("exit".equals(name)) {
  23.                     System.exit(0);
  24.                 }
  25.                 client.send(name);
  26.             } catch (IOException e) {
  27.                 e.printStackTrace();
  28.             }
  29.         }
  30.     }
  32.     // 注册所有server 
  33.     public static void initServer() {
  34.         listServer.clear();
  35.         listServer.add("127.0.0.1:18080"); //连接服务 放到list中   存放集群地址 做负载均衡用的
  36.     }
  38.     // 获取当前server信息
  39.     public static String getServer() {
  40.         return listServer.get(0);
  41.     }
  43.     public void send(String name) {
  45.         String server = ZkServerClient.getServer();
  46.         String[] cfg = server.split(":"); 
  48.         Socket socket = null;
  49.         BufferedReader in = null;
  50.         PrintWriter out = null;
  51.         try {
  52.             socket = new Socket(cfg[0], Integer.parseInt(cfg[1]));
  53.             in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
  54.             out = new PrintWriter(socket.getOutputStream(), true);
  56.             out.println(name);
  57.             while (true) {
  58.                 String resp = in.readLine();
  59.                 if (resp == null)
  60.                     break;
  61.                 else if (resp.length() > 0) {
  62.                     System.out.println("Receive : " + resp);
  63.                     break;
  64.                 }
  65.             }
  66.         } catch (Exception e) {
  67.             e.printStackTrace();
  68.         } finally {
  69.             if (out != null) {
  70.                 out.close();
  71.             }
  72.             if (in != null) {
  73.                 try {
  74.                     in.close();
  75.                 } catch (IOException e) {
  76.                     e.printStackTrace();
  77.                 }
  78.             }
  79.             if (socket != null) {
  80.                 try {
  81.                     socket.close();
  82.                 } catch (IOException e) {
  83.                     e.printStackTrace();
  84.                 }
  85.             }
  86.         }
  87.     }
  88. }

运行结果：

1179709-20181103002051183-439886477.png

引申思路

使用Zookeeper实现负载均衡原理，服务器端将启动的服务注册到，zk注册中心上，采用临时节点。客户端从zk节点上获取最新服务节点信息，本地使用负载均衡算法，随机分配服务器。

1179709-20181102205858298-1781058.png

1、会员服务 项目启动时候 会在zk上面创建临时节点 /toov5 对应的value是127.0.0.1 

  1.    如果是集群  /toov5 下面会会以 节点形式存储 节点名字就是IP+端口    value 分别也是 IP+端口   有些是没有用到value的哦

2、订单直接去使用 /toov5 查询下面的子节点信息，获取到之后。在本地使用负载均衡算法实现调用，决定使用哪个。 

  1.   127.0.0.1:8080 
  3.   127.0.0.1:8081

PS： 任何服务的底层都是 socke 技术

socket客户端 （ 客户端去获取注册信息） socket服务器端

废话不多说，项目：

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

这个不是Apache的哦注意

服务端代码：

  1. package com.toov5.zkDubbo;
  3. import java.io.IOException;
  4. import java.net.ServerSocket;
  5. import java.net.Socket;
  7. import org.I0Itec.zkclient.ZkClient;
  9. //##ServerScoekt服务端
  10. public class ZkServerScoekt implements Runnable {
  11.     private static int port = 18081;  //socket 服务启动后的所使用的 端口号
  13.     public static void main(String[] args) throws IOException {
  14.         ZkServerScoekt server = new ZkServerScoekt(port);  //构造函数传入port
  15.         regServer();  //去zk注册
  16.         Thread thread = new Thread(server);
  17.         thread.start();
  18.     }
  20.     public ZkServerScoekt(int port) {
  21.         this.port = port;
  22.     }
  23.   //注册服务
  24.     public static void regServer(){
  25.         //1、建立zk连接
  26.     ZkClient zkClient = new ZkClient("192.168.91.5",5000,10000);
  27.         //2.先创建父节点
  28.     String root = "/toov5";
  29.     if (!zkClient.exists(root)) {
  30.         //如果父节点不存，直接创建父节点
  31.         zkClient.createPersistent(root);  //持久节点
  32.     }
  33.        //3、创建子节点
  34.      String nodeName = root+"/service_"+port;      
  35.      String nodeValue="127.0.0.1:"+port;
  36.      if (zkClient.exists(nodeName)) {  //如果存在 直接删除掉
  37.         zkClient.delete(nodeName);
  38.     }
  39.      zkClient.createEphemeral(nodeName); //字节的 临时节点  如果服务宕机了 找不到了就
  40.      System.out.println("服务注册成功"+nodeName);
  42.     }
  46.     public void run() {
  47.         ServerSocket serverSocket = null;
  48.         try {
  49.             serverSocket = new ServerSocket(port);
  50.             System.out.println("Server start port:" + port);
  51.             Socket socket = null;
  52.             while (true) {
  53.                 socket = serverSocket.accept();
  54.                 new Thread(new ServerHandler(socket)).start();
  55.             }
  56.         } catch (Exception e) {
  57.             e.printStackTrace();
  58.         } finally {
  59.             try {
  60.                 if (serverSocket != null) {
  61.                     serverSocket.close();
  62.                 }
  63.             } catch (Exception e2) {
  65.             }
  66.         }
  67.     }
  69. }

客户端代码：

  1. package com.toov5.zkDubbo;
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.io.PrintWriter;
  7. import java.net.Socket;
  8. import java.util.ArrayList;
  9. import java.util.List;
  11. public class ZkServerClient {
  12.     public static List<String> listServer = new ArrayList<String>();
  14.     public static void main(String[] args) {
  15.         initServer();
  16.         ZkServerClient     client= new ZkServerClient();
  17.         BufferedReader console = new BufferedReader(new InputStreamReader(System.in));
  18.         while (true) {
  19.             String name;
  20.             try {
  21.                 name = console.readLine();
  22.                 if ("exit".equals(name)) {
  23.                     System.exit(0);
  24.                 }
  25.                 client.send(name);
  26.             } catch (IOException e) {
  27.                 e.printStackTrace();
  28.             }
  29.         }
  30.     }
  32.     // 注册所有server 
  33.     public static void initServer() {
  34.         listServer.clear();
  35.         listServer.add("127.0.0.1:18080"); //连接服务 放到list中   存放集群地址 做负载均衡用的
  36.     }
  38.     // 获取当前server信息
  39.     public static String getServer() {
  40.         return listServer.get(0);
  41.     }
  43.     public void send(String name) {
  45.         String server = ZkServerClient.getServer();
  46.         String[] cfg = server.split(":"); 
  48.         Socket socket = null;
  49.         BufferedReader in = null;
  50.         PrintWriter out = null;
  51.         try {
  52.             socket = new Socket(cfg[0], Integer.parseInt(cfg[1]));
  53.             in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
  54.             out = new PrintWriter(socket.getOutputStream(), true);
  56.             out.println(name);
  57.             while (true) {
  58.                 String resp = in.readLine();
  59.                 if (resp == null)
  60.                     break;
  61.                 else if (resp.length() > 0) {
  62.                     System.out.println("Receive : " + resp);
  63.                     break;
  64.                 }
  65.             }
  66.         } catch (Exception e) {
  67.             e.printStackTrace();
  68.         } finally {
  69.             if (out != null) {
  70.                 out.close();
  71.             }
  72.             if (in != null) {
  73.                 try {
  74.                     in.close();
  75.                 } catch (IOException e) {
  76.                     e.printStackTrace();
  77.                 }
  78.             }
  79.             if (socket != null) {
  80.                 try {
  81.                     socket.close();
  82.                 } catch (IOException e) {
  83.                     e.printStackTrace();
  84.                 }
  85.             }
  86.         }
  87.     }
  88. }

1179709-20181102233640889-670850507.png

启动服务端后的结果：

可以看到 去zk注册了信息。服务的名字 和子节点

其中子节点是 临时节点 相当于如果服务宕机了 就查不到了哦

1179709-20181103000813179-1038410821.png

启动三次服务端后：

1179709-20181103003633234-1677646649.png

然后 去zk读取节点信息：

客户端 负载均衡轮训算法

请求次数 % 服务端数 = 服务器端口号的奇数偶数

客户端：

  1. package com.toov5.zkDubbo;
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.io.PrintWriter;
  7. import java.net.Socket;
  8. import java.util.ArrayList;
  9. import java.util.List;
  11. import org.I0Itec.zkclient.ZkClient;
  13. public class ZkServerClient {
  14.     public static List<String> listServer = new ArrayList<String>();
  16.     public static void main(String[] args) {
  17.         initServer();
  18.         ZkServerClient     client= new ZkServerClient();
  19.         BufferedReader console = new BufferedReader(new InputStreamReader(System.in));
  20.         while (true) {
  21.             String name;
  22.             try {
  23.                 name = console.readLine();
  24.                 if ("exit".equals(name)) {
  25.                     System.exit(0);
  26.                 }
  27.                 client.send(name);
  28.             } catch (IOException e) {
  29.                 e.printStackTrace();
  30.             }
  31.         }
  32.     }
  34.     // 注册所有server 
  35.     public static void initServer() {
  36.         listServer.clear();
  37. //        listServer.add("127.0.0.1:18080"); //连接服务 放到list中   存放集群地址 做负载均衡用的   
  38.         //建立zk连接
  39.         ZkClient zkClient = new ZkClient("192.168.91.5",5000,10000);
  40.         //读取父节点信息
  41.         String root = "/toov5";
  42.         List<String> children=zkClient.getChildren(root);
  43.         for(String pString : children){
  44.             //父+子 =完整的路径
  45.             String path = root+"/"+pString;
  46.             String nodeValue =zkClient.readData(path);
  47.             //把值放到集合中去
  48.             listServer.add(nodeValue);
  49.         }
  50.         //服务发现成功
  51.          System.out.println("服务发现:"+listServer.toString());
  52.          //然后给 serverCount赋值
  53.          serverCount=listServer.size();
  55.     }
  57.   //请求总数
  58.     private static  int  reqCount = 1;
  59.   //服务个数    
  60.     private static int  serverCount = 0; //初始值是0
  62.     // 获取当前server信息
  63.     public static String getServer() {
  64. //        return listServer.get(0);  不能写死  本地负载均衡轮询算法
  65.     String serverName = listServer.get(reqCount%serverCount );
  66.     System.out.println("客户端请求次数："+reqCount+"对应服务器"+serverName);
  67.     reqCount++;
  68.     return serverName;    
  69.     }
  71.     public void send(String name) {
  73.         String server = ZkServerClient.getServer();
  74.         String[] cfg = server.split(":"); 
  76.         Socket socket = null;
  77.         BufferedReader in = null;
  78.         PrintWriter out = null;
  79.         try {
  80.             socket = new Socket(cfg[0], Integer.parseInt(cfg[1]));
  81.             in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
  82.             out = new PrintWriter(socket.getOutputStream(), true);
  84.             out.println(name);
  85.             while (true) {
  86.                 String resp = in.readLine();
  87.                 if (resp == null)
  88.                     break;
  89.                 else if (resp.length() > 0) {
  90.                     System.out.println("Receive : " + resp);
  91.                     break;
  92.                 }
  93.             }
  94.         } catch (Exception e) {
  95.             e.printStackTrace();
  96.         } finally {
  97.             if (out != null) {
  98.                 out.close();
  99.             }
  100.             if (in != null) {
  101.                 try {
  102.                     in.close();
  103.                 } catch (IOException e) {
  104.                     e.printStackTrace();
  105.                 }
  106.             }
  107.             if (socket != null) {
  108.                 try {
  109.                     socket.close();
  110.                 } catch (IOException e) {
  111.                     e.printStackTrace();
  112.                 }
  113.             }
  114.         }
  115.     }
  116. }

启动后（后端服务启动三个）：

1179709-20181103010756253-4521993.png

访问一次：取模算法后的结果

1179709-20181103010942606-1195397108.png

第二次、第三次：

1179709-20181103011134065-448809196.png

看到结果 太美妙了！

美妙集中在此：

1179709-20181103011310933-1708484618.png

好好欣赏下~~

发表评论

表情：
评论列表 （有 0 条评论，319人围观）

还没有评论，来说两句吧...

相关阅读

    相关 解析负载均衡原理

    不能狭义地理解为分配给所有实际服务器一样多的工作量，因为多台服务器的承载能力各不相同，这可能体现在硬件配置、网络带宽的差异，也可能因为某台服务器身兼多职，我们所说的“均衡”，也

    Bertha 。Bertha 。/ 0 赞/ 320 阅读

    相关 nginx负载均衡原理

    负载均衡在服务端开发中算是一个比较重要的特性。因为Nginx除了作为常规的Web服务器外，还会被大规模的用于反向代理前端，因为Nginx的异步框架可以处理很大的并发请求，把这些

    你的名字你的名字/ 0 赞/ 463 阅读