Zookeeper實現負載均衡原理

阿新 • • 發佈：2018-11-03

先玩個正常的，好玩的socket程式設計：

服務端：

package com.toov5.zkDubbo;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

import org.I0Itec.zkclient.ZkClient;

//##ServerScoekt服務端
public class ZkServerScoekt implements Runnable {
    private static int port = 18080;  //socket 服務啟動後的所使用的 埠號 


    public static void main(String[] args) throws IOException {
        ZkServerScoekt server = new ZkServerScoekt(port);  //建構函式傳入port
    //    regServer();  //去zk註冊
        Thread thread = new Thread(server);
        thread.start();
    }

    public ZkServerScoekt(int port) {
        this.port = port;
    }
 
//  //註冊服務
//    public static void regServer(){
//        //1、建立zk連線
//    ZkClient zkClient = new ZkClient("192.168.91.5",5000,10000);
//        //2.先建立父節點
//    String root = "/toov5";
//    if (!zkClient.exists(root)) {
//        //如果父節點不存，直接建立父節點
//        zkClient.createPersistent(root);  //持久節點
//    }
//       //3、建立子節點
//     String nodeName = root+"/service_"+port;      
 
//     String nodeValue="127.0.0.1:"+port;
//     if (zkClient.exists(nodeName)) {  //如果存在 直接刪除掉
//        zkClient.delete(nodeName);
//    }
//     zkClient.createEphemeral(nodeName); //位元組的 臨時節點  如果服務宕機了 找不到了就
//     System.out.println("服務註冊成功"+nodeName);
//     
//    }
//    
//    
    
    public void run() {
        ServerSocket serverSocket = null;
        try {
            serverSocket = new ServerSocket(port);
            System.out.println("Server start port:" + 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) {

            }
        }
    }

}

客戶端：

package com.toov5.zkDubbo;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

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();
        listServer.add("127.0.0.1:18080"); //連線服務 放到list中   存放叢集地址 做負載均衡用的
    }

    // 獲取當前server資訊
    public static String getServer() {
        return listServer.get(0);
    }
    
    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();
                }
            }
        }
    }
}

執行結果：

引申思路

使用Zookeeper實現負載均衡原理，伺服器端將啟動的服務註冊到，zk註冊中心上，採用臨時節點。客戶端從zk節點上獲取最新服務節點資訊，本地使用負載均衡演算法，隨機分配伺服器。

1、會員服務專案啟動時候會在zk上面建立臨時節點 /toov5 對應的value是127.0.0.1

如果是叢集 /toov5 下面會會以節點形式儲存節點名字就是IP+埠 value 分別也是 IP+埠有些是沒有用到value的哦

2、訂單直接去使用 /toov5 查詢下面的子節點資訊，獲取到之後。在本地使用負載均衡演算法實現呼叫，決定使用哪個。

127.0.0.1:8080

127.0.0.1:8081

PS：任何服務的底層都是 socke 技術

socket客戶端（客戶端去獲取註冊資訊） socket伺服器端

廢話不多說，專案：

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

這個不是Apache的哦注意

服務端程式碼：

package com.toov5.zkDubbo;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

import org.I0Itec.zkclient.ZkClient;

//##ServerScoekt服務端
public class ZkServerScoekt implements Runnable {
    private static int port = 18081;  //socket 服務啟動後的所使用的 埠號

    public static void main(String[] args) throws IOException {
        ZkServerScoekt server = new ZkServerScoekt(port);  //建構函式傳入port
        regServer();  //去zk註冊
        Thread thread = new Thread(server);
        thread.start();
    }

    public ZkServerScoekt(int port) {
        this.port = port;
    }
  //註冊服務
    public static void regServer(){
        //1、建立zk連線
    ZkClient zkClient = new ZkClient("192.168.91.5",5000,10000);
        //2.先建立父節點
    String root = "/toov5";
    if (!zkClient.exists(root)) {
        //如果父節點不存，直接建立父節點
        zkClient.createPersistent(root);  //持久節點
    }
       //3、建立子節點
     String nodeName = root+"/service_"+port;      
     String nodeValue="127.0.0.1:"+port;
     if (zkClient.exists(nodeName)) {  //如果存在 直接刪除掉
        zkClient.delete(nodeName);
    }
     zkClient.createEphemeral(nodeName); //位元組的 臨時節點  如果服務宕機了 找不到了就
     System.out.println("服務註冊成功"+nodeName);
     
    }
    
    
    
    public void run() {
        ServerSocket serverSocket = null;
        try {
            serverSocket = new ServerSocket(port);
            System.out.println("Server start port:" + 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) {

            }
        }
    }

}

客戶端程式碼：

package com.toov5.zkDubbo;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

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();
        listServer.add("127.0.0.1:18080"); //連線服務 放到list中   存放叢集地址 做負載均衡用的
    }

    // 獲取當前server資訊
    public static String getServer() {
        return listServer.get(0);
    }
    
    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();
                }
            }
        }
    }
}

啟動服務端後的結果：

可以看到去zk註冊了資訊。服務的名字和子節點

其中子節點是臨時節點相當於如果服務宕機了就查不到了哦

啟動三次服務端後：

然後去zk讀取節點資訊：

客戶端 負載均衡輪訓演算法

請求次數 % 服務端數 = 伺服器埠號的奇數偶數

客戶端：

package com.toov5.zkDubbo;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

import org.I0Itec.zkclient.ZkClient;

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();
//        listServer.add("127.0.0.1:18080"); //連線服務 放到list中   存放叢集地址 做負載均衡用的   
        //建立zk連線
        ZkClient zkClient = new ZkClient("192.168.91.5",5000,10000);
        //讀取父節點資訊
        String root = "/toov5";
        List<String> children=zkClient.getChildren(root);
        for(String pString : children){
            //父+子 =完整的路徑
            String path = root+"/"+pString;
            String nodeValue =zkClient.readData(path);
            //把值放到集合中去
            listServer.add(nodeValue);
        }
        //服務發現成功
         System.out.println("服務發現:"+listServer.toString());
         //然後給 serverCount賦值
         serverCount=listServer.size();
         
    }
 
  //請求總數
    private static  int  reqCount = 1;
  //服務個數    
    private static int  serverCount = 0; //初始值是0
    
    // 獲取當前server資訊
    public static String getServer() {
//        return listServer.get(0);  不能寫死  本地負載均衡輪詢演算法
    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();
                }
            }
        }
    }
}

啟動後（後端服務啟動三個）：

訪問一次：取模演算法後的結果

第二次、第三次：

看到結果太美妙了！

美妙集中在此：

好好欣賞下~~

Zookeeper實現負載均衡原理

先玩個正常的，好玩的socket程式設計：服務端： package com.toov5.zkDubbo; import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; import org.I

使用LVS實現負載均衡原理及安裝配置詳解

配置 png 負載均衡 iptables .cn 詳解文章配置詳解 logs LVS是一個開源軟件，由章文嵩博士於1998年5月創立，可以實現Linux平臺下的簡單負載均衡。LVS是Linux Virtual Server的簡寫，是一個虛擬的服務器集群系統。LVS是基於

zookeeper實現負載均衡

zookeeper是一個針對大型分散式系統的可靠的協調系統，提供的功能包括命名服務、配置維護、分散式同步、叢集服務等。分散式叢集: 由於zookeeper主要扮演的角色是分散式叢集中的協調者，所以首先介紹一下分散式和叢集的概念。簡單來說，分散式是將一個完整的系統拆分成多個能實現不同業務需

Zookeeper 實現負載均衡

原理解析架構圖每臺WorkServer啟動的時候都會到Server建立臨時節點。每臺ClientServer啟動的時候，都會到Server節點下面取得所有WorksServer節點，並通過一定演算法取得一臺並與之

使用 LVS 實現負載均衡原理及安裝配置詳解

負載均衡叢集是 load balance 叢集的簡寫，翻譯成中文就是負載均衡叢集。常用的負載均衡開源軟體有nginx、lvs、haproxy，商業的硬體負載均衡裝置F5、Netscale。這裡主要是學習 LVS 並對其進行了詳細的總結記錄。一、負載均衡LVS基本介

使用LVS實現負載均衡原理及安裝配置詳解（轉）

bin 瀏覽器 gate 裏的高性能 target 相關 asq 空間負載均衡集群是 load balance 集群的簡寫，翻譯成中文就是負載均衡集群。常用的負載均衡開源軟件有nginx、lvs、haproxy，商業的硬件負載均衡設備F5、Netscale。這裏主要是

zookeeper HA 實現負載均衡

在網上看到太多千篇一律的zookeeper相關的文章，都是定義，沒有一個是有完整程式碼的，這對自己學習zk十分困難，其實要用zk實現主備切換、負載均衡其實沒有自己想象的那麼難，只需要瞭解zk的基本特性即可。在這裡貼上自己寫的程式碼與自己的理解，大家多多指教！一、

LVS 實現負載均衡的原理

LVS 實現負載均衡的原理 LVS 負載均衡負載均衡叢集是 Load Balance 叢集。是一種將網路上的訪問流量分佈於各

負載均衡原理與技術實現

負載均衡(Load Balance，簡稱LB)是一種伺服器或網路裝置的叢集技術。負載均衡將特定的業務(網路服務、網路流量等)分擔給多個伺服器或網路裝置，從而提高了業務處理能力，保證了業務的高可用性。負載均衡基本概念有：實服務、實服務組、虛服務、排程演算法、持續性等，其常用應用

lvs負載均衡的四種模式原理，LVS之DR模型，LVS+keeaplived實現負載均衡，keepalived實現高可用

一，LVS的簡介： Linux virtual system，是由目前阿里著名工程師章文嵩開發的一寬開源的軟體。LVS工作在一臺server上提供Directory（負載均衡器）的功能，它本身並不提供任何服務，只是把特定的請求轉發給對應的realserver（

雙網絡卡實現負載均衡技術的實現與原理

網絡卡出錯冗餘 : AFT（Adapter Fault Tolerance）技術是一種在伺服器和交換機之間建立冗餘連線的技術，亦即在伺服器上安裝兩塊網絡卡，一塊為主網絡卡，另一塊作為備用網絡卡，然後用兩根網線將兩塊網絡卡都連到交換機上。 : AFT技術的基本工作

搞懂分布式技術10：LVS實現負載均衡的原理與實踐

系列 lvs slb 設備同時 backend png 基本原理節點搞懂分布式技術10：LVS實現負載均衡的原理與實踐淺析負載均衡及LVS實現原創： fireflyc 寫程序的康德 2017-09-19 負載均衡負載均衡（Load Balance，縮寫LB）

深入理解Spring Cloud Ribbon客戶端負載均衡原理（一實現服務實例地址轉換）

missing 組織 not final str dynamics string pla pan 在使用spring cloud搭建微服務架構時，需要進行負載均衡操作。負載均衡分為硬件負載均衡和軟件負載均衡，軟件負載均衡又分為服務端負載均衡和客戶端負載均衡。本系列主要介紹利

3-2-基於LVS實現4層負載均衡原理講解

網站響應報文 tunnel 數量傳輸層協議 pat 相關請求報文對負載均衡來講，最關鍵的就是調度器了網絡傳輸層數：下四層由內核來管理及實現，被稱為通信子網，最上面三層，叫應用層，在用戶空間實現，叫做資源子網lvs是四層的負載均衡器，而且是真正附著在netfilte

【一起學原始碼-微服務】Feign 原始碼三：Feign結合Ribbon實現負載均衡的原理分析

前言前情回顧上一講我們已經知道了Feign的工作原理其實是在專案啟動的時候，通過JDK動態代理為每個FeignClinent生成一個動態代理。動態代理的資料結構是：ReflectiveFeign.FeignInvocationHandler。其中包含target(裡面是serviceName等資訊)和d

lvs+keepalived實現負載均衡

keepalive 裝載 announce log loopback -s scheduler sad apr LVS簡介： lvs是負載均衡較常用的軟件之一，lvs官方提供了一個命名的約定： vip：虛擬ip地址，縮寫是vip，vip是負載均衡器對外提供服務的ip。 ri

Nginx配置upstream實現負載均衡

不同實現負載均衡不能多臺 bake crc 實現所有 crc32 Nginx可以配置代理多臺服務器，當一臺服務器宕機之後，仍能保持系統可用。具體配置過程如下： 1. 在http節點下，添加upstream節點。 upstream linuxidc {

nginx+tomcat實現負載均衡以及session共享(linux centos7環境)

processes 解壓 smo eve cti 下載 gen cli -c 一、nginx的安裝 1.準備三份tomcat tomcat1 設置端口 8080 tomcat2 設置端口 8081 tomcat3 設置端口 8082 2. 下載nginx 3. 解壓到/ho

EG:nginx反向代理兩臺web服務器,實現負載均衡所有的web服務共享一臺nfs的存儲

分享代理服 /dev/ 負載均衡 chmod 修改修改配置防火墻 usr step1：三臺web服務器環境配置：iptables -F; setenforce 0 關閉防火墻；關閉setlinux step2:三臺web服務器裝軟件 step3:主機修改配置文件

Nginx 服務器之Nginx與tomcat實現負載均衡

nobody 服務器 listen server events 本文講解我們如何使用Nginx做反向帶服務器，實現nginx與tomcat服務器集群做負載均衡。一、nginx與tomcat實現負載均衡1、在/usr/local/ngnix/conf 創建文件 nginx-tomcat.

Zookeeper實現負載均衡原理

先玩個正常的，好玩的socket程式設計：

引申思路

相關推薦