详解 负载均衡技术 的基本实现
当 一段时间内 客户端的访问量较多，很容易造成 服务器崩溃
(例如：某东618、桃饱双十一、志愿填报结束前半小时 等)
这时候，就需要我们采用 负载均衡技术，来 减轻服务器的压力
那么，在本篇博文中，本人就来 基本实现 下 负载均衡技术
基本 概念：
首先，本人来介绍下什么是 负载均衡：
定义：
负载均衡，英文名称为Load Balance，
其含义就是指将负载（工作任务）进行平衡、分摊到多个操作单元上进行运行
例如FTP服务器、Web服务器、企业核心应用服务器和其它主要任务服务器等，从而协同完成工作任务
那么，使用 负载均衡 技术，有什么 好处 呢？
功能：
负载均衡构建在原有网络结构之上，
它提供了一种透明、廉价有效的方法 来 扩展服务器和网络设备的带宽、加强网络数据处理能力、增加吞吐量、提高网络的可用性 和 灵活性
那么，在本篇博文中，本人就来 基本实现 下 负载均衡技术：
在本篇博文中，主要实现 两种 负载均衡 —— 轮询式 和 随机式
实现 代码:
由于 负载均衡 是 针对网络编程、在 现有的服务器列表 中 通过 一定的策略 挑选出来 部分的服务器列表
因此，本人在这里先来提供一个 节点信息获取 功能接口：
节点信息获取 功能接口 —— INetNode：
package edu.youzg.balance;
/**
* 网络节点 基本功能接口
*/
public interface INetNode {
String getIp();
int getPort();
void setIp(String ip);
void setPort(int port);
}
接下来，本人来提供一个 上述接口的 默认实现类：
默认网络节点 —— DefaultNetNode：
package edu.youzg.balance;
import java.util.Objects;
/**
* 网络节点 默认实现类
*/
public class DefaultNetNode implements INetNode {
private String ip; // 当前网络节点 的ip
private int port; // 当前网络节点 的port
public DefaultNetNode() {
}
public DefaultNetNode(String ip, int port) {
this.ip = ip;
this.port = port;
}
@Override
public void setIp(String ip) {
this.ip = ip;
}
@Override
public void setPort(int port) {
this.port = port;
}
@Override
public String getIp() {
return this.ip;
}
@Override
public int getPort() {
return this.port;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
DefaultNetNode that = (DefaultNetNode) o;
return port == that.port &&
Objects.equals(ip, that.ip);
}
@Override
public int hashCode() {
return Objects.hash(ip, port);
}
@Override
public String toString() {
return "[" + this.ip + ":" + this.port + "]";
}
}
那么，我们就通过上述的 接口和类，提供一个 负载均衡 的功能接口：
负载均衡 功能接口 —— INetNodeBalance：
实现 思路：
由于本人在上文中讲到过：
负载均衡的 实现思路 为：
在 现有的服务器列表 中 通过 一定的策略 挑选出 部分的服务器列表
因此，我们提供的 负载均衡 功能接口，要具有如下功能：
- 录入 现有的服务器 节点信息
- 移除 现有的服务器 节点信息
(与上个功能 呼应)- 从 录入的 服务器节点信息 列表 中，按照所选的策略 提取节点信息
实现 代码：
package edu.youzg.balance;
import java.util.List;
/**
* 负载均衡 功能接口<br/>
* 用于 增、删、获取 网络节点
*/
public interface INetNodeBalance {
void addNode(DefaultNetNode node);
void addNodeList(List<DefaultNetNode> nodeList);
INetNode removeNode(INetNode node);
DefaultNetNode getNode();
}
那么，针对上面的接口，为了方便扩展，本人在这里提供一个 负载均衡 功能抽象类：
负载均衡 功能抽象类 —— AbstractNetNodeBalance：
package edu.youzg.balance;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* 负载均衡 基本功能 基本实现类<br/>
* 设置了一个 以当前网络节点的hashcode为键，以当前节点的信息为值 的map
*/
public abstract class AbstractNetNodeBalance implements INetNodeBalance {
protected final Map<Integer, INetNode> nodePool;
public AbstractNetNodeBalance() {
this.nodePool = new ConcurrentHashMap<>();
}
/**
* 向nodePool中 新增一个 网络节点
* @param node 目标 网络节点
*/
@Override
public void addNode(DefaultNetNode node) {
if (node == null) {
return;
}
int nodeHashCode = node.hashCode();
if (nodePool.containsKey(nodeHashCode)) {
return;
}
nodePool.put(nodeHashCode, node);
}
/**
* 向nodePool中 新增一个 网络节点列表
* @param nodeList 目标 网络节点列表
*/
@Override
public void addNodeList(List<DefaultNetNode> nodeList) {
if (nodeList == null) {
return;
}
for (DefaultNetNode node : nodeList) {
addNode(node);
}
}
/**
* 判断nodepool是否为空
* @return
*/
public boolean isNodePoolEmpty() {
return nodePool.isEmpty();
}
/**
* 删除指定的网络节点
* @param node
* @return
*/
@Override
public INetNode removeNode(INetNode node) {
if (node == null) {
return null;
}
return nodePool.remove(node.hashCode());
}
}
那么，在上面 几个类和接口 的基础上，本人来实现下 “随机式”负载均衡：
[核心]“随机式”负载均衡 —— RandomBalance：
package edu.youzg.balance;
import java.util.LinkedList;
import java.util.List;
/**
* 随机实现 负载均衡
*/
public class RandomBalance extends AbstractNetNodeBalance {
private final List<INetNode> nodeList = new LinkedList();
public RandomBalance() {
}
/**
* 增加一个 网络节点
* @param node 要增加的网络节点
*/
@Override
public void addNode(DefaultNetNode node) {
super.addNode(node);
if (node!=null && !this.nodeList.contains(node)) {
this.nodeList.add(node);
}
}
@Override
public void addNodeList(List<DefaultNetNode> nodeList) {
if (nodeList == null) {
return;
}
for (DefaultNetNode node : nodeList) {
addNode(node);
}
}
/**
* 删除一个 网络节点
* @param node 要删除的网络节点
* @return 被删除的网络节点
*/
@Override
public INetNode removeNode(INetNode node) {
if (node != null && this.nodeList.contains(node)) {
this.nodeList.remove(node);
return super.removeNode(node);
} else {
return null;
}
}
/**
* 通过随机数，<br/>
* 获取一个网络节点
* @return 随机获取的网络节点
*/
@Override
public DefaultNetNode getNode() {
if (this.isNodePoolEmpty()) {
return null;
} else {
int index = (int) Math.random() * (nodeList.size() + 1);
return (DefaultNetNode) this.nodeList.get(index);
}
}
}
那么，接下来本人就来实现下 “轮询式”负载均衡
不过，既然要 轮询，就需要 双向链表类似的 数据存储结构
那么，本人在这里提供一个 INetNode接口 的 “轮询式”网络节点:
“轮询式” 网络节点 —— PollingNetNode：
package edu.youzg.balance;
/**
* 用于“轮询” 的 双向链表式 网络节点
*/
public class PollingNetNode extends DefaultNetNode {
private PollingNetNode next = this;
private PollingNetNode pre = this;
public PollingNetNode() {
}
public PollingNetNode(String ip, int port) {
super(ip, port);
}
public void setNext(PollingNetNode next) {
this.next = next;
}
public void setPre(PollingNetNode pre) {
this.pre = pre;
}
public PollingNetNode getNext() {
return next;
}
public PollingNetNode getPre() {
return pre;
}
}
package edu.youzg.balance;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* 负载均衡 基本功能 基本实现类<br/>
* 设置了一个 以当前网络节点的hashcode为键，以当前节点的信息为值 的map
*/
public abstract class AbstractNetNodeBalance implements INetNodeBalance {
protected final Map<Integer, INetNode> nodePool;
public AbstractNetNodeBalance() {
this.nodePool = new ConcurrentHashMap<>();
}
/**
* 向nodePool中 新增一个 网络节点
* @param node 目标 网络节点
*/
@Override
public void addNode(DefaultNetNode node) {
if (node == null) {
return;
}
int nodeHashCode = node.hashCode();
if (nodePool.containsKey(nodeHashCode)) {
return;
}
nodePool.put(nodeHashCode, node);
}
/**
* 向nodePool中 新增一个 网络节点列表
* @param nodeList 目标 网络节点列表
*/
@Override
public void addNodeList(List<DefaultNetNode> nodeList) {
if (nodeList == null) {
return;
}
for (DefaultNetNode node : nodeList) {
addNode(node);
}
}
/**
* 判断nodepool是否为空
* @return
*/
public boolean isNodePoolEmpty() {
return nodePool.isEmpty();
}
/**
* 删除指定的网络节点
* @param node
* @return
*/
@Override
public INetNode removeNode(INetNode node) {
if (node == null) {
return null;
}
return nodePool.remove(node.hashCode());
}
}
那么，最后，本人再来根据上面的铺垫，实现下 “轮询式”负载均衡：
[核心]“轮询式”负载均衡 —— PollingBalance：
package edu.youzg.balance;
import java.util.List;
/**
* “轮询式” 均衡策略
*/
public class PollingBalance extends AbstractNetNodeBalance {
private PollingNetNode headNode; // 头节点
private PollingNetNode currentNode; // 当前应该遍历的节点(还未遍历)
public PollingBalance() {
}
/**
* 新增一个 网络节点
* @param node 要新增的节点
*/
@Override
public synchronized void addNode(DefaultNetNode node) {
PollingNetNode newNode = new PollingNetNode(node.getIp(), node.getPort());
if (this.headNode == null) {
this.headNode = newNode;
this.currentNode = this.headNode;
} else {
newNode.setPre(this.headNode.getPre());
newNode.setNext(this.headNode);
this.headNode.setPre(newNode);
newNode.getPre().setNext(newNode);
}
super.addNode(newNode);
}
@Override
public void addNodeList(List<DefaultNetNode> nodeList) {
if (nodeList == null) {
return;
}
for (DefaultNetNode node : nodeList) {
addNode(node);
}
}
/**
* 删除一个指定的节点
* @param node 要删除的节点
* @return 被删除的节点
*/
@Override
public synchronized INetNode removeNode(INetNode node) {
PollingNetNode target = new PollingNetNode(node.getIp(), node.getPort());
target = (PollingNetNode) super.removeNode(target);
if (target == null) {
return null;
} else if (this.isNodePoolEmpty()) {
this.headNode = null;
this.currentNode = null;
return this.headNode;
} else {
if (this.currentNode == target) {
this.currentNode = target.getNext();
}
if (this.headNode == target) {
this.headNode = target.getNext();
}
target.getPre().setNext(target.getNext());
target.getNext().setPre(target.getPre());
target.setPre(target);
target.setNext(target);
return target;
}
}
/**
* 按照 存储顺序，依次遍历获取 一个网络节点
* @return 一个网络节点
*/
@Override
public synchronized DefaultNetNode getNode() {
PollingNetNode resNode = this.currentNode;
if (resNode!=null) {
this.currentNode = this.currentNode.getNext();
}
return new DefaultNetNode(resNode.getIp(), resNode.getPort());
}
}
若有需要上述源码的同学，本人已将本文所讲解到的代码打成了Jar包：
工具 Jar包：
如有需要，请点击下方链接：
Load-Balance
心得体会：
那么，到这里，负载均衡 技术 就基本实现了
我们在使用时，只需要将 目标服务器节点信息列表 录入，再通过选取的 负载均衡 策略 逐个取出
这样，就能在 一定的程度 上减少 服务器的压力
至于使用，将在本人之后的博文《【多文件自平衡云传输】专栏总集篇》中 进行巧妙地运用，
并在最后会有视频展示，有兴趣的同学请前往围观哦！
(最后，附上 本人《多文件自平衡云传输框架》专栏 展示视频的封面，希望大家多多支持哦！)
