使用Zookeeper实现负载均衡原理
思路
使用Zookeeper实现负载均衡原理,服务器端将启动的服务注册到,zk注册中心上,采用临时节点。客户端从zk节点上获取最新服务节点信息,本地使用负载均衡算法,随机分配服务器。当其中一台服务宕机后,本地监听节点变化,实现故障转移。
创建项目工程
Maven依赖
<dependencies>
<dependency>
<groupId>com.101tec</groupId>
<artifactId>zkclient</artifactId>
<version>0.8</version>
</dependency>
</dependencies>
创建Server服务端
ZkServerScoekt服务
package com.test.zookeeper.loadbalancing;
import org.I0Itec.zkclient.ZkClient;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
//##ServerScoekt服务端
public class ZkServerScoekt implements Runnable {
private int port;
public static void main(String[] args) throws IOException {
/* ZkClient zkClient = new ZkClient("127.0.0.1:2181", 6000, 1000);
zkClient.createPersistent("/member");*/
int port = 18081;
ZkServerScoekt server = new ZkServerScoekt(port);
Thread thread = new Thread(server);
thread.start();
}
public ZkServerScoekt(int port) {
this.port = port;
}
// 将服务信息注册到注册中心上去
public void regServer() {
ZkClient zkClient = new ZkClient("127.0.0.1:2181", 6000, 1000);
String path = "/member/server-" + port;
if (zkClient.exists(path)) {
zkClient.delete(path);
}
String value="127.0.0.1:" + port;
zkClient.createEphemeral(path, "127.0.0.1:" + port);
System.out.println("##服务注册成功###"+value);
}
public void run() {
ServerSocket serverSocket = null;
try {
serverSocket = new ServerSocket(port);
regServer();
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) {
}
}
}
}
ZkServerScoekt1服务
package com.test.zookeeper.loadbalancing;
import org.I0Itec.zkclient.ZkClient;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
//##ServerScoekt服务端
public class ZkServerScoekt1 implements Runnable {
private int port=18082;
public static void main(String[] args) throws IOException {
/* ZkClient zkClient = new ZkClient("127.0.0.1:2181", 6000, 1000);
zkClient.createPersistent("/member");*/
ZkServerScoekt1 server = new ZkServerScoekt1();
Thread thread = new Thread(server);
thread.start();
}
// 将服务信息注册到注册中心上去
public void regServer() {
ZkClient zkClient = new ZkClient("127.0.0.1:2181", 6000, 1000);
String path = "/member/server-" + port;
if (zkClient.exists(path)) {
zkClient.delete(path);
}
String value="127.0.0.1:" + port;
zkClient.createEphemeral(path, "127.0.0.1:" + port);
System.out.println("##服务注册成功###"+value);
}
public void run() {
ServerSocket serverSocket = null;
try {
serverSocket = new ServerSocket(port);
regServer();
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) {
}
}
}
}
ServerHandler
package com.test.zookeeper.loadbalancing;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
//ServerHandler
public class ServerHandler implements Runnable {
private Socket socket;
public ServerHandler(Socket socket) {
this.socket = socket;
}
public void run() {
BufferedReader in = null;
PrintWriter out = null;
try {
in = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
out = new PrintWriter(this.socket.getOutputStream(), true);
String body = null;
while (true) {
body = in.readLine();
if (body == null)
break;
System.out.println("Receive : " + body);
out.println("Hello, " + body);
}
} catch (Exception e) {
if (in != null) {
try {
in.close();
} catch (IOException e1) {
e1.printStackTrace();
}
}
if (out != null) {
out.close();
}
if (this.socket != null) {
try {
this.socket.close();
} catch (IOException e1) {
e1.printStackTrace();
}
this.socket = null;
}
}
}
}
客户端
ZkServerClient
package com.test.zookeeper.loadbalancing;
import org.I0Itec.zkclient.IZkChildListener;
import org.I0Itec.zkclient.ZkClient;
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();
// 从zk获取最新获取的注册服务连接
final String memberServerPath = "/member";
final ZkClient zkClient = new ZkClient("127.0.0.1:2181", 6000, 1000);
// 获当前下子节点
List<String> children = zkClient.getChildren(memberServerPath);
listServer.clear();
for (String p : children) {
// 读取子节点value值
listServer.add((String) zkClient.readData(memberServerPath + "/" + p));
}
System.out.println("最新服务信息listServer:" + listServer.toString());
// 订阅子节点事件
zkClient.subscribeChildChanges(memberServerPath, new IZkChildListener() {
@Override
public void handleChildChange(String s, List<String> childrens) throws Exception {
listServer.clear();
for (String subP : childrens) {
// 读取子节点value值
listServer.add((String) zkClient.readData(memberServerPath + "/" + subP));
}
System.out.println("节点更改后最新服务信息listServer:" + listServer.toString());
}
});
}
private static int count=0;
// 获取当前server信息
public static String getServer() {
int serverSize=listServer.size();
++count;
//取模
return listServer.get(count%serverSize);
}
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();
}
}
}
}
}
启动两个服务端和客户端
效果:
负载均衡轮询策略
两个服务端注册到注册中心,客户端通过注册中心获取到服务端
通过我们写的代码在下方输入 数据 都会通过取模算法 发送给其中一台服务器,实现了类似nginx轮询的负载均衡策略
客户端发送数据
第一台服务端接收到数据
再次发送数据
第二台服务端接收到数据
宕机故障转移
当服务端其中一台宕机后(停止ZkServerScoekt),客户端监听到获取到的节点发送改变,再次发送消息会发给ZkServerScoekt1也就是18082,完成了故障转移