溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
本文小編為大家詳細介紹“怎么通過Java實現反向代理集群服務的平滑分配”，內容詳細，步驟清晰，細節處理妥當，希望這篇“怎么通過Java實現反向代理集群服務的平滑分配”文章能幫助大家解決疑惑，下面跟著小編的思路慢慢深入，一起來學習新知識吧。
需要具備的知識
Socket網絡編程
反向代理的理解
平滑加權輪詢算法的理解
線程池的理解
目的：實現Socket 集群服務的平滑加權輪詢負載。
業務實現：客戶端通過用戶名來查詢集群服務中的用戶信息。
客戶端發起Socket請求給反向代理的Socket服務（客戶端并不知道服務端是反向代理服務器）
反向代理服務器接收到Socket服務請求
線程池開啟服務線程去處理請求
線程服務通過平滑加權輪詢算法尋找當前權重最高的下游服務
通過負載均衡算法返回的服務節點信息來創建Socket請求
反向代理服務器使用客戶端信息，發起Socket請求給下游服務
Socket集群服務節點收到Socket請求，查詢用戶信息，再將處理結果返回給反向代理服務器
反向代理服務器再將結果返回給客戶端。
幾個細節點
使用反向代理服務，對客戶端無感，客戶端并不知道具體訪問了哪個真實服務器；
反向代理服務器每次訪問下游服務失敗時，就會降低該下游服務器器的有效權重；每次訪問下游服務成功時，就會提高該下游服務器的有效權重（不超過配置的權重值）；
平滑加權輪詢算法會對宕機服務降權和提權，起到”剔除“宕機服務和緩沖恢復宕機服務的效果；
反向代理服務器重啟后，所有配置恢復為配置參數；
反向代理服務器使用線程池發布Socket服務，支持多個客戶端同時請求同時分發。
用于保存服務節點相關信息
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 +
'}';
}
}一般都是放在配置文件中配置，然后讀取指定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;
}
}package com.yty.proxy.lba;
public interface Robin {
Node selectNode();
}詳細介紹可以閱讀前兩篇負載均衡算法的文章
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;
}
}
}用于處理代理服務請求的線程類，不同請求創建不同線程來處理
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資源異常");
}
}
}通過線程池來管理代理服務線程，不同的請求分發到不同線程處理。這里用的是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();
}
}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 + '}';
}
}處理具體業務的類，通過用戶名稱簡單獲取信息
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;
}
}用于處理業務服務請求的線程類，不同請求創建不同線程來處理
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資源異常");
}
}
}通過線程池來管理業務服務線程，不同的請求分發到不同線程處理。這里用的也是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();
}
}
}本次測試是分在兩臺服務器測試，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();
}
}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;
}
}在代理配置類（ProxyConfig）中指定的服務器啟動三個業務服務；
在你喜歡的服務器中啟動代理服務（ProxyServer），這里在本地啟動【127.0.0.1】；
客戶端在本地測試咯（IP必須是代理服務器的IP，這里測試的代理服務器IP是【127.0.0.1】。
所有服務啟動后的截圖：
正常命中權重最高的節點2服務：節點信息在代理服務器中打印出來了【127.0.0.1、8002】。這些日志信息正常情況是寫入到日志文件，這里只在控制臺打印出來。
改了用戶名再請求試試，發現忘記打印請求數據了……
第二次命中節點3服務，跟平滑加權算法預定的結果一樣。
這次命中了節點2：192.168.233.100，8001的服務。到此可以看到平滑加權輪詢算法正常運作中。
通過平滑加權輪詢算法運算，我們知道這次肯定命中節點2服務。所以，在發起請求前，先關閉節點2服務，再由客戶端發起請求。
細心的應該發現，有效權重沒變小啊，是不是降權有問題？
其實不是，是打印信息的位置沒放對……。要在下次訪問才可以看到上一次的降權結果，額，有點呆（上面的代碼我已經改了）。
先把宕機的服務啟動起來，然后多測試幾次，看看測試結果。可以看到，權重降低后又提起來了，說明測試提權成功。
還有兩個點沒測：第一個是一直降權后，會不會出現宕機的服務不再分配到？這就起到”剔除“宕機服務的效果？第二個是服務恢復后，會不會出現宕機再起的服務需要慢慢恢復權重，直到一定值后才可以分配到？
讀到這里，這篇“怎么通過Java實現反向代理集群服務的平滑分配”文章已經介紹完畢，想要掌握這篇文章的知識點還需要大家自己動手實踐使用過才能領會，如果想了解更多相關內容的文章，歡迎關注億速云行業資訊頻道。
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
