學會了負載均衡演算法,卻沒有用起來?
今天就來實戰一遍,感受下平滑加權輪詢演算法的魅力。
通過Java語言,自己編寫的平滑加權輪詢演算法,結合執行緒池和Socket 網路程式設計等,實現了反向代理叢集服務的平滑分配,並通過降權/提權實現當機服務的”剔除“和緩衝恢復。
1.理解全過程
1.1.概述
需要具備的知識
Socket網路程式設計 反向代理的理解 平滑加權輪詢演算法的理解 執行緒池的理解
目的:實現Socket 叢集服務的平滑加權輪詢負載。
業務實現:客戶端通過使用者名稱來查詢叢集服務中的使用者資訊。
1.2.整個流程
客戶端發起Socket請求給反向代理的Socket服務(客戶端並不知道服務端是反向代理伺服器) 反向代理伺服器接收到Socket服務請求 執行緒池開啟服務執行緒去處理請求 執行緒服務通過平滑加權輪詢演算法尋找當前權重最高的下游服務 通過負載均衡演算法返回的服務節點資訊來建立Socket請求 反向代理伺服器使用客戶端資訊,發起Socket請求給下游服務 Socket叢集服務節點收到Socket請求,查詢使用者資訊,再將處理結果返回給反向代理伺服器 反向代理伺服器再將結果返回給客戶端。
幾個細節點
使用反向代理服務,對客戶端無感,客戶端並不知道具體訪問了哪個真實伺服器; 反向代理伺服器每次訪問下游服務失敗時,就會降低該下游伺服器器的有效權重;每次訪問下游服務成功時,就會提高該下游伺服器的有效權重(不超過配置的權重值); 平滑加權輪詢演算法會對當機服務降權和提權,起到”剔除“當機服務和緩衝恢復當機服務的效果; 反向代理伺服器重啟後,所有配置恢復為配置引數; 反向代理伺服器使用執行緒池釋出Socket服務,支援多個客戶端同時請求同時分發。
2.程式碼實現
2.1.節點類
用於儲存服務節點相關資訊
package com.yty.proxy.lba;
public class Node implements Comparable<Node>{
private String ip;
private Integer port;
private final Integer weight;
private Integer effectiveWeight;
private Integer currentWeight;
// 預設權重為:1
public Node(String ip,Integer port){
this(ip,port,1);
}
public Node(String ip,Integer port, Integer weight){
this.ip = ip;
this.port = port;
this.weight = weight;
this.effectiveWeight = weight;
this.currentWeight = weight;
}
public String getIp() {
return ip;
}
public void setIp(String ip) {
this.ip = ip;
}
public Integer getPort() {
return port;
}
public void setPort(Integer port) {
this.port = port;
}
public Integer getWeight() {
return weight;
}
public Integer getEffectiveWeight() {
return effectiveWeight;
}
public void setEffectiveWeight(Integer effectiveWeight) {
this.effectiveWeight = effectiveWeight;
}
public Integer getCurrentWeight() {
return currentWeight;
}
public void setCurrentWeight(Integer currentWeight) {
this.currentWeight = currentWeight;
}
// 每成功一次,恢復有效權重1,不超過配置的起始權重
public void onInvokeSuccess(){
if(effectiveWeight < weight) effectiveWeight++;
}
// 每失敗一次,有效權重減少1,無底線的減少
public void onInvokeFault(){
effectiveWeight--;
}
@Override
public int compareTo(Node node) {
return currentWeight > node.currentWeight ? 1 : (currentWeight.equals(node.currentWeight) ? 0 : -1);
}
@Override
public String toString() {
return "Node{" +
"ip='" + ip + '\'' +
", port=" + port +
", weight=" + weight +
", effectiveWeight=" + effectiveWeight +
", currentWeight=" + currentWeight +
'}';
}
}
2.2.代理配置類
一般都是放在配置檔案中配置,然後讀取指定key的配置檔案資訊來完成配置。模擬為了簡單就直接寫程式碼裡了。
package com.yty.proxy;
import com.yty.proxy.lba.Node;
import java.util.ArrayList;
import java.util.List;
public class ProxyConfig {
private static List<Node> nodes = new ArrayList<>();
// 在配置檔案中讀取:節點集合資訊。如果在同一臺伺服器測試,那就將ip配成一樣
static {
nodes.add(new Node("192.168.233.100",8001,2));
nodes.add(new Node("127.0.0.1",8002,5));
nodes.add(new Node("127.0.0.1",8003,3));
}
public static List<Node> getProxyConfig(){
return nodes;
}
}
2.3.負載均衡演算法介面
package com.yty.proxy.lba;
public interface Robin {
Node selectNode();
}
2.4.平滑加權輪詢演算法
詳細介紹可以閱讀前兩篇負載均衡演算法的文章
package com.yty.proxy.lba;
import com.yty.proxy.ProxyConfig;
import java.util.List;
/**
* 加權輪詢演算法:平滑加權輪詢演算法
*/
public class WeightedRoundRobin implements Robin {
private static List<Node> nodes;
// 讀取配置資訊
static {
nodes = ProxyConfig.getProxyConfig();
}
/**
* 按照當前權重(currentWeight)最大值獲取IP
* @return Node
*/
public Node selectNode(){
if (nodes ==null || nodes.size()<=0) return null;
if (nodes.size() == 1) return nodes.get(0);
// 權重之和
Integer totalWeight = 0;
for(Node node : nodes){
totalWeight += node.getEffectiveWeight();
}
synchronized (nodes){
// 選出當前權重最大的節點
Node nodeOfMaxWeight = null;
for (Node node : nodes) {
if (nodeOfMaxWeight == null)
nodeOfMaxWeight = node;
else
nodeOfMaxWeight = nodeOfMaxWeight.compareTo(node) > 0 ? nodeOfMaxWeight : node;
}
// 平滑負載均衡
nodeOfMaxWeight.setCurrentWeight(nodeOfMaxWeight.getCurrentWeight() - totalWeight);
nodes.forEach(node -> node.setCurrentWeight(node.getCurrentWeight()+node.getEffectiveWeight()));
return nodeOfMaxWeight;
}
}
}
2.5.代理服務執行緒類
用於處理代理服務請求的執行緒類,不同請求建立不同執行緒來處理
package com.yty.proxy;
import java.io.*;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
public class ProxyServerThread implements Runnable {
private Socket proxySocket;
private OutputStream proxyOut;
private InputStream proxyIn;
private Socket socket;
private OutputStream serverOut;
private InputStream serverIn;
public ProxyServerThread(Socket proxySocket) throws IOException {
this.proxySocket = proxySocket;
this.proxySocket.setSoTimeout(6000);
this.proxyOut = proxySocket.getOutputStream();
this.proxyIn = proxySocket.getInputStream();
}
@Override
public void run() {
try {
this.proxyService();
} catch (IOException e) {
e.printStackTrace();
}finally {
this.close();
}
}
private void proxyService() throws IOException {
// 代理接收客戶端請求
byte[] proxyDataBytes =null;
proxyDataBytes = getData(proxyIn);
System.out.println("代理收到請求資料:"+new String(proxyDataBytes));
if (proxyDataBytes == null){
proxyOut.write("請求內容異常".getBytes());
}
byte[] serverData = this.dispatcherService(proxyDataBytes);
// 代理響應客戶端
assert serverData != null;
proxyOut.write(serverData);
proxySocket.shutdownOutput();
System.out.println("代理響應客戶端資料:"+new String(proxyDataBytes));
}
private byte[] dispatcherService(byte[] proxyDataBytes){
// 選擇節點:傳送請求和接收響應資訊
Robin wrr = new WeightedRoundRobin();
Node node = wrr.selectNode();
byte[] serverData = null;
try {
this.socket = new Socket(node.getIp(), node.getPort());
socket.setSoTimeout(6000);
serverIn = socket.getInputStream();
serverOut= socket.getOutputStream();
serverOut.write(proxyDataBytes);
socket.shutdownOutput();
serverData = getData(serverIn);
System.out.println("真實服務端響應資料:"+ new String(serverData));
node.onInvokeSuccess();//提權
} catch (IOException e) {
node.onInvokeFault();//降權
serverData = "代理的下游伺服器異常".getBytes();
}
System.out.println("負載均衡到:" + node);
return serverData;
}
private byte[] getData(InputStream in) throws IOException {
List<Byte> byteList = new ArrayList<>();
int temp = -1;
while (true) {
temp = in.read();
if (temp != -1)
byteList.add((byte) temp);
else
break;
}
byte[] bytes = new byte[byteList.size()];
for (int i=0;i<byteList.size();i++){
bytes[i]=byteList.get(i);
}
return bytes;
}
private void close() {
try {
if (proxySocket!=null){
proxySocket.shutdownInput();
proxySocket.close();
}
if (socket!=null){
socket.shutdownInput();
socket.close();
}
}catch (IOException e){
e.printStackTrace();
System.out.println("代理服務關閉socket資源異常");
}
}
}
2.6.代理服務類
通過執行緒池來管理代理服務執行緒,不同的請求分發到不同執行緒處理。這裡用的是newCachedThreadPool 執行緒池。
代理伺服器在本地啟動。這裡也可以新建一個類來啟動服務,這樣可以啟動多個代理服務,這裡為了簡單就直接在本類的main方法啟動。可以對比後面的業務服務類,業務服務類就是這麼起的,因為要放到不同的伺服器啟動業務服務。
package com.yty.proxy;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ProxyServer {
private final Integer port;
private ServerSocket serverSocket;
public ProxyServer(Integer port) {
this.port = port;
}
public void start(){
ExecutorService threadPool = Executors.newCachedThreadPool();
try {
serverSocket = new ServerSocket(port);
while (true){
Socket socket = serverSocket.accept();
threadPool.execute(new ProxyServerThread(socket));
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
Integer proxyPort=8000;
ProxyServer proxyServer = new ProxyServer(proxyPort);
System.out.println("開啟代理服務……");
proxyServer.start();
}
}
2.7.業務實體類
package com.yty.proxy.server;
public class MyUser {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public MyUser(String name, int age) {
this.name = name;
this.age = age;
}
public MyUser() {
}
@Override
public String toString() {
return "{" +"name='" + name + '\'' + ", age=" + age + '}';
}
}
2.8.業務類
處理具體業務的類,通過使用者名稱稱簡單獲取資訊
package com.yty.proxy.server;
import java.util.ArrayList;
import java.util.List;
public class MyUserService {
private static List<MyUser> list = new ArrayList<>();
static{
list.add(new MyUser("張三",18));
list.add(new MyUser("張三丰",38));
list.add(new MyUser("小白",18));
}
public MyUser findByUsername(String username){
for (MyUser user:list){
if (user.getName().equals(username)){
return user;
}
}
return null;
}
}
2.9.業務服務執行緒類
用於處理業務服務請求的執行緒類,不同請求建立不同執行緒來處理
package com.yty.proxy.server;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
public class SocketServerThread implements Runnable {
private Socket socket;
private OutputStream serverOut;
private InputStream serverIn;
public SocketServerThread(Socket socket) throws IOException {
this.socket = socket;
socket.setSoTimeout(6000);
this.serverOut = socket.getOutputStream();
this.serverIn = socket.getInputStream();
}
@Override
public void run() {
try {
this.service();
} catch (IOException e) {
e.printStackTrace();
}finally {
this.close();
}
}
private void service() throws IOException {
// 接收客戶端請求
byte[] dataBytes =null;
dataBytes = getData(serverIn);
if (dataBytes == null){
serverOut.write("請求內容異常".getBytes());
}
String username = new String(dataBytes);
System.out.println("收到請求資料:"+username);
// 具體業務程式碼
MyUserService myUserService = new MyUserService();
MyUser user = myUserService.findByUsername(new String(dataBytes));
String serverData = "沒有查詢到使用者" + username + "的資料";
if(user!=null){
serverData = user.toString();
serverOut.write(user.toString().getBytes());
}
System.out.println("響應客戶端資料:" + serverData);
}
private byte[] getData(InputStream in) throws IOException {
List<Byte> byteList = new ArrayList<>();
int temp = -1;
while (true) {
temp = in.read();
if (temp != -1)
byteList.add((byte) temp);
else
break;
}
byte[] bytes = new byte[byteList.size()];
for (int i=0;i<byteList.size();i++){
bytes[i]=byteList.get(i);
}
return bytes;
}
private void close() {
try {
if (socket!=null){
socket.shutdownInput();
socket.shutdownOutput();
socket.close();
}
}catch (IOException e){
e.printStackTrace();
System.out.println("服務關閉socket資源異常");
}
}
}
2.10.業務服務類
通過執行緒池來管理業務服務執行緒,不同的請求分發到不同執行緒處理。這裡用的也是newCachedThreadPool 執行緒池。
package com.yty.proxy.server;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class SocketServer {
private final Integer port;
private ServerSocket serverSocket;
private Integer threads = 3;
public SocketServer(Integer port) {
this.port = port;
}
public void start(){
ExecutorService threadPool = Executors.newFixedThreadPool(threads);
try {
serverSocket = new ServerSocket(port);
while (true){
Socket socket = serverSocket.accept();
threadPool.execute(new SocketServerThread(socket));
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
2.11.啟動三個業務服務(服務叢集)
本次測試是分在兩臺伺服器測試,1臺【192.168.233.100】、另外都是本地【127.0.0.1】。如果覺得麻煩,那就都配成本地【127.0.0.1】,然後起服務都在本地起。
服務1:在IP為192.168.233.100 的伺服器啟動
package com.yty.proxy.test;
import com.yty.proxy.server.SocketServer;
public class StartServer1 {
public static void main(String[] args) {
System.out.println("開啟後端服務8001……");
new SocketServer(8001).start();
}
}
服務2:在本地伺服器啟動
package com.yty.proxy.test;
import com.yty.proxy.server.SocketServer;
public class StartServer2 {
public static void main(String[] args) {
System.out.println("開啟後端服務8002……");
new SocketServer(8002).start();
}
}
服務3:在本地伺服器啟動
package com.yty.proxy.test;
import com.yty.proxy.server.SocketServer;
public class StartServer3 {
public static void main(String[] args) {
System.out.println("開啟後端服務8003……");
new SocketServer(8003).start();
}
}
2.12.客戶端
package com.yty.proxy.test;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
public class Client {
public static void main(String[] args) throws IOException {
String ip = "127.0.0.1";
int port = 8000;
Socket socket = new Socket(ip, port);
socket.setSoTimeout(6000);
OutputStream out = socket.getOutputStream();
InputStream in = socket.getInputStream();
// 傳送資料
out.write("小白".getBytes());
out.flush();
socket.shutdownOutput();
// 讀取資料
byte[] data = new Client().getData(in);
System.out.println("響應資料:"+new String(data));
out.close();
}
private byte[] getData(InputStream in) throws IOException {
BufferedInputStream bin = new BufferedInputStream(in);
List<Byte> byteList = new ArrayList<>();
while (true) {
int temp = bin.read();
if (temp != -1)
byteList.add((byte) temp);
else
break;
}
byte[] bytes = new byte[byteList.size()];
for (int i=0;i<byteList.size();i++){
bytes[i]=byteList.get(i);
}
return bytes;
}
}
3.開始測試
3.1.啟動所有服務
在代理配置類(ProxyConfig)中指定的伺服器啟動三個業務服務;
在你喜歡的伺服器中啟動代理服務(ProxyServer),這裡在本地啟動【127.0.0.1】;
客戶端在本地測試咯(IP必須是代理伺服器的IP,這裡測試的代理伺服器IP是【127.0.0.1】。
所有服務啟動後的截圖:
3.2.客戶端發起第一次請求
正常命中權重最高的節點2服務:節點資訊在代理伺服器中列印出來了【127.0.0.1、8002】。這些日誌資訊正常情況是寫入到日誌檔案,這裡只在控制檯列印出來。
3.3.客戶端發起第二次請求
改了使用者名稱再請求試試,發現忘記列印請求資料了……
第二次命中節點3服務,跟平滑加權演算法預定的結果一樣。
3.4.客戶端發起第三次請求
這次命中了節點2:192.168.233.100,8001的服務。到此可以看到平滑加權輪詢演算法正常運作中。
3.5.客戶端發起第四次請求(測試降權)
通過平滑加權輪詢演算法運算,我們知道這次肯定命中節點2服務。所以,在發起請求前,先關閉節點2服務,再由客戶端發起請求。
細心的應該發現,有效權重沒變小啊,是不是降權有問題?
其實不是,是列印資訊的位置沒放對……。要在下次訪問才可以看到上一次的降權結果,額,有點呆(上面的程式碼我已經改了)。
3.6.客戶端發起第N次請求(測試提權)
先把當機的服務啟動起來,然後多測試幾次,看看測試結果。可以看到,權重降低後又提起來了,說明測試提權成功。
還有兩個點沒測:第一個是一直降權後,會不會出現當機的服務不再分配到?這就起到”剔除“當機服務的效果?第二個是服務恢復後,會不會出現當機再起的服務需要慢慢恢復權重,直到一定值後才可以分配到?
4.結論
使用自己編寫的平滑加權輪詢演算法,結合執行緒池和Socket 網路程式設計等,實現了反向代理叢集服務的平滑分配,並通過降權/提權實現當機服務的”剔除“和緩衝恢復。
更多優質文章,請關注WX公眾號:Java全棧佈道師
原創不易,三聯支援!!!