java netty 實現 websocket 服務端和客戶端雙向通信 實現心跳和斷線重連 完整示例
maven依賴
<dependency>
<groupId>io.netty</groupId>
<artifactId>netty-all</artifactId>
<version>4.1.97.Final</version>
</dependency>
服務端
一個接口 IGetHandshakeFuture
package com.sux.demo.websocket2;
import io.netty.channel.ChannelPromise;
public interface IGetHandshakeFuture {
ChannelPromise getHandshakeFuture();
}
服務端心跳 ServerHeartbeatHandler
package com.sux.demo.websocket2;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.handler.codec.http.websocketx.PingWebSocketFrame;
import io.netty.handler.codec.http.websocketx.PongWebSocketFrame;
import io.netty.handler.timeout.IdleState;
import io.netty.handler.timeout.IdleStateEvent;
public class ServerHeartbeatHandler extends ChannelInboundHandlerAdapter {
@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
if (evt instanceof IdleStateEvent) {
IdleStateEvent event = (IdleStateEvent) evt;
if (event.state() == IdleState.READER_IDLE) { // 讀空閒
System.out.println("關閉客戶端連接, channel id=" + ctx.channel().id());
ctx.channel().close();
} else if (event.state() == IdleState.WRITER_IDLE) { // 寫空閒
System.out.println("服務端向客戶端發送心跳");
ctx.writeAndFlush(new PingWebSocketFrame());
} else if (event.state() == IdleState.ALL_IDLE) { // 讀寫空閒
}
}
}
}
服務端封裝 WebSocketServer
package com.sux.demo.websocket2;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandler;
import io.netty.handler.timeout.IdleStateHandler;
import java.util.concurrent.TimeUnit;
public class WebSocketServer {
private EventLoopGroup bossGroup;
private EventLoopGroup workerGroup;
public WebSocketServer() {
//創建兩個線程組 boosGroup、workerGroup
bossGroup = new NioEventLoopGroup();
workerGroup = new NioEventLoopGroup();
}
public void start(int port, WebSocketServerHandler handler, String name) {
try {
//創建服務端的啓動對象,設置參數
ServerBootstrap bootstrap = new ServerBootstrap();
//設置兩個線程組boosGroup和workerGroup
bootstrap.group(bossGroup, workerGroup)
//設置服務端通道實現類型
.channel(NioServerSocketChannel.class)
//設置線程隊列得到連接個數
.option(ChannelOption.SO_BACKLOG, 128)
//設置保持活動連接狀態
.childOption(ChannelOption.SO_KEEPALIVE, true)
//使用匿名內部類的形式初始化通道對象
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel socketChannel) throws Exception {
//給pipeline管道設置處理器
socketChannel.pipeline().addLast(new HttpServerCodec());
socketChannel.pipeline().addLast(new HttpObjectAggregator(65536));
socketChannel.pipeline().addLast(new WebSocketServerProtocolHandler("/websocket", null, false, 65536, false, false, false, 10000));
socketChannel.pipeline().addLast(new IdleStateHandler(5, 2, 0, TimeUnit.SECONDS));
socketChannel.pipeline().addLast(new ServerHeartbeatHandler());
socketChannel.pipeline().addLast(handler);
}
});//給workerGroup的EventLoop對應的管道設置處理器
//綁定端口號,啓動服務端
ChannelFuture channelFuture = bootstrap.bind(port).sync();
System.out.println(name + " 已啓動");
//對通道關閉進行監聽
channelFuture.channel().closeFuture().sync();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
}
}
}
服務端消息處理 WebSocketServerHandler
package com.sux.demo.websocket2;
import io.netty.buffer.Unpooled;
import io.netty.channel.*;
import io.netty.handler.codec.http.websocketx.*;
import io.netty.util.CharsetUtil;
import java.util.ArrayList;
import java.util.List;
@ChannelHandler.Sharable
public class WebSocketServerHandler extends SimpleChannelInboundHandler<Object> {
private List<Channel> channelList;
public WebSocketServerHandler() {
channelList = new ArrayList<>();
}
public boolean hasClient() {
return channelList.size() > 0;
}
@Override
protected void channelRead0(ChannelHandlerContext ctx, Object msg) {
if (msg instanceof PongWebSocketFrame) {
System.out.println("收到客戶端" + ctx.channel().remoteAddress() + "發來的心跳:PONG");
}
if (msg instanceof TextWebSocketFrame) {
TextWebSocketFrame frame = (TextWebSocketFrame) msg;
System.out.println("收到客戶端" + ctx.channel().remoteAddress() + "發來的消息:" + frame.text());
/*for (Channel channel : channelList) {
if (!ctx.channel().id().toString().equals(channel.id().toString())) {
channel.writeAndFlush(new TextWebSocketFrame(Unpooled.copiedBuffer(frame.text(), CharsetUtil.UTF_8)));
System.out.println("服務端向客戶端 " + channel.id().toString() + " 轉發消息:" + frame.text());
}
}*/
}
}
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
channelList.add(ctx.channel());
System.out.println("客戶端連接:" + ctx.channel().id().toString());
}
@Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
channelList.remove(ctx.channel());
}
@Override
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
ctx.flush();
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
ctx.close();
}
public void send(String text) {
for (Channel channel : channelList) {
channel.writeAndFlush(new TextWebSocketFrame(Unpooled.copiedBuffer(text, CharsetUtil.UTF_8)));
}
}
}
服務端測試主機 WebSocketClientHost
package com.sux.demo.websocket2;
public class WebSocketServerHost {
public static void main(String[] args) {
WebSocketServerHandler handler = new WebSocketServerHandler();
WebSocketServer webSocketServer = new WebSocketServer();
SendDataToClientThread thread = new SendDataToClientThread(handler);
thread.start();
webSocketServer.start(40005, handler, "WebSocket服務端");
}
}
class SendDataToClientThread extends Thread {
private WebSocketServerHandler handler;
private int index = 1;
public SendDataToClientThread(WebSocketServerHandler handler) {
this.handler = handler;
}
@Override
public void run() {
try {
while (index <= 5) {
if (handler.hasClient()) {
String msg = "服務端發送的測試消息, index = " + index;
handler.send(msg);
index++;
}
Thread.sleep(1000);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
客戶端
客戶端心跳 ClientHeartbeatHandler
package com.sux.demo.websocket2;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.handler.codec.http.websocketx.PingWebSocketFrame;
import io.netty.handler.codec.http.websocketx.PongWebSocketFrame;
import io.netty.handler.timeout.IdleState;
import io.netty.handler.timeout.IdleStateEvent;
public class ClientHeartbeatHandler extends ChannelInboundHandlerAdapter {
@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) {
if (evt instanceof IdleStateEvent) {
IdleStateEvent event = (IdleStateEvent) evt;
if (event.state() == IdleState.READER_IDLE) { // 讀空閒
System.out.println("斷線重連");
ctx.channel().close();
} else if (event.state() == IdleState.WRITER_IDLE) { // 寫空閒
System.out.println("客戶端向服務端發送心跳");
ctx.writeAndFlush(new PingWebSocketFrame());
} else if (event.state() == IdleState.ALL_IDLE) { // 讀寫空閒
}
}
}
}
客戶端封裝 WebSocketClient
package com.sux.demo.websocket2;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.http.DefaultHttpHeaders;
import io.netty.handler.codec.http.HttpClientCodec;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.websocketx.WebSocketClientHandshaker;
import io.netty.handler.codec.http.websocketx.WebSocketClientHandshakerFactory;
import io.netty.handler.codec.http.websocketx.WebSocketClientProtocolHandler;
import io.netty.handler.codec.http.websocketx.WebSocketVersion;
import io.netty.handler.timeout.IdleStateHandler;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.concurrent.TimeUnit;
public class WebSocketClient {
private NioEventLoopGroup eventExecutors;
private Channel channel;
public WebSocketClient() {
eventExecutors = new NioEventLoopGroup();
}
public Channel getChannel() {
return channel;
}
public void connect(String ip, int port, String name) {
try {
WebSocketClientHandshaker handshaker = WebSocketClientHandshakerFactory.newHandshaker(
new URI("ws://" + ip + ":" + port + "/websocket"), WebSocketVersion.V13, null, false, new DefaultHttpHeaders());
WebSocketClientHandler handler = new WebSocketClientHandler(handshaker);
ClientHeartbeatHandler heartbeatHandler = new ClientHeartbeatHandler();
//創建bootstrap對象,配置參數
Bootstrap bootstrap = new Bootstrap();
//設置線程組
bootstrap.group(eventExecutors)
//設置客戶端的通道實現類型
.channel(NioSocketChannel.class)
//使用匿名內部類初始化通道
.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
//添加客戶端通道的處理器
ch.pipeline().addLast(new HttpClientCodec());
ch.pipeline().addLast(new HttpObjectAggregator(65536));
ch.pipeline().addLast(new WebSocketClientProtocolHandler(handshaker, true, false));
ch.pipeline().addLast(new IdleStateHandler(5, 2, 0, TimeUnit.SECONDS));
ch.pipeline().addLast(heartbeatHandler);
ch.pipeline().addLast(handler);
}
});
// 連接服務端
ChannelFuture channelFuture = bootstrap.connect(ip, port);
// 在連接關閉後嘗試重連
channelFuture.channel().closeFuture().addListener(future -> {
try {
Thread.sleep(2000);
System.out.println("重新連接");
connect(ip, port, name); // 重新連接
} catch (Exception e) {
e.printStackTrace();
}
});
channelFuture.sync();
// 等待握手完成
// IGetHandshakeFuture getHadnshakeFuture = handler;
// getHadnshakeFuture.getHandshakeFuture().sync();
channel = channelFuture.channel();
System.out.println(name + " 已啓動");
//對通道關閉進行監聽
channelFuture.channel().closeFuture().sync();
} catch (InterruptedException | URISyntaxException e) {
e.printStackTrace();
} finally {
}
}
}
客戶端消息處理 WebSocketClientHandler
package com.sux.demo.websocket2;
import io.netty.channel.*;
import io.netty.handler.codec.http.FullHttpResponse;
import io.netty.handler.codec.http.websocketx.*;
@ChannelHandler.Sharable
public class WebSocketClientHandler extends SimpleChannelInboundHandler<Object> implements IGetHandshakeFuture {
private WebSocketClientHandshaker handshaker;
private ChannelPromise handshakeFuture;
public WebSocketClientHandler(WebSocketClientHandshaker handshaker) {
this.handshaker = handshaker;
}
public ChannelPromise getHandshakeFuture() {
return this.handshakeFuture;
}
@Override
protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
if (!handshaker.isHandshakeComplete()) {
try {
handshaker.finishHandshake(ctx.channel(), (FullHttpResponse) msg);
handshakeFuture.setSuccess();
} catch (WebSocketHandshakeException e) {
handshakeFuture.setFailure(e);
}
return;
}
if (msg instanceof PongWebSocketFrame) {
System.out.println("收到服務端" + ctx.channel().remoteAddress() + "發來的心跳:PONG");
}
if (msg instanceof TextWebSocketFrame) {
TextWebSocketFrame frame = (TextWebSocketFrame) msg;
System.out.println("收到服務端" + ctx.channel().remoteAddress() + "發來的消息:" + frame.text()); // 接收服務端發送過來的消息
}
}
@Override
public void handlerAdded(ChannelHandlerContext ctx) {
handshakeFuture = ctx.newPromise();
}
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
// handshaker.handshake(ctx.channel());
}
@Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
}
@Override
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
ctx.flush();
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
ctx.close();
}
}
客戶端測試主機 WebSocketServerHost
package com.sux.demo.websocket2;
import io.netty.buffer.Unpooled;
import io.netty.channel.Channel;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
import io.netty.util.CharsetUtil;
public class WebSocketClientHost {
public static void main(String[] args) {
WebSocketClient webSocketClient = new WebSocketClient();
SendDataToServerThread thread = new SendDataToServerThread(webSocketClient);
thread.start();
webSocketClient.connect("127.0.0.1", 40005, "WebSocket客戶端");
}
}
class SendDataToServerThread extends Thread {
private WebSocketClient webSocketClient;
private int index = 1;
public SendDataToServerThread(WebSocketClient webSocketClient) {
this.webSocketClient = webSocketClient;
}
@Override
public void run() {
try {
while (index <= 5) {
Channel channel = webSocketClient.getChannel();
if (channel != null && channel.isActive()) {
String msg = "客戶端發送的測試消息, index = " + index;
channel.writeAndFlush(new TextWebSocketFrame(Unpooled.copiedBuffer(msg, CharsetUtil.UTF_8)));
index++;
}
Thread.sleep(1000);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
測試
測試一
步驟:先啓動服務端,再啓動客戶端
現象:客戶端與服務端互發消息,消息發完後,互發心跳
測試二
步驟:先啓動服務端,再啓動客戶端,然後關閉服務端,過一會再啓動服務端
現象:客戶端斷線重連,通信恢復,正常發消息和心跳
測試三
步驟:先啓動客戶端,過一會再啓動服務端
現象:服務端啓動後,客戶端連上服務端,正常通信,互發消息,消息發完互發心跳
遇到的問題
- 心跳問題
如果客戶端想確認服務端是否以線,就向服務端發PING,如果服務端在線,服務端就會回一個PONG,客戶端就能收到PONG,如果客戶端收不到PONG,就會觸發讀空閒,然後斷線重連。
如果服務端想確認客戶端是否在線,就向客戶端發PING,如果客戶端在線,客戶端就會回一個PONG,服務端就能收到PONG,如果服務端收不到PONG,就會觸發讀空閒,然後斷開與客戶端的連接。
WebSocketClientProtocolHandler和WebSocketServerProtocolHandler類都有一個dropPongFrames參數,默認爲true,如果你在讀空閒時寫了斷開連接的操作,要把dropPongFrames設置爲false,這樣就可以在消息處理handler中接收到PONG,就不會觸發讀空閒,否則連接就會被你自己寫的斷開連接的操作給斷開。