java netty 實現 websocket 服務端和客戶端雙向通信 實現心跳和斷線重連 完整示例

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();
        }
    }
}

測試

測試一

步驟：先啓動服務端，再啓動客戶端
現象：客戶端與服務端互發消息，消息發完後，互發心跳

測試二

步驟：先啓動服務端，再啓動客戶端，然後關閉服務端，過一會再啓動服務端
現象：客戶端斷線重連，通信恢復，正常發消息和心跳

測試三

步驟：先啓動客戶端，過一會再啓動服務端
現象：服務端啓動後，客戶端連上服務端，正常通信，互發消息，消息發完互發心跳

遇到的問題

1. 心跳問題
   如果客戶端想確認服務端是否以線，就向服務端發PING，如果服務端在線，服務端就會回一個PONG，客戶端就能收到PONG，如果客戶端收不到PONG，就會觸發讀空閒，然後斷線重連。
   如果服務端想確認客戶端是否在線，就向客戶端發PING，如果客戶端在線，客戶端就會回一個PONG，服務端就能收到PONG，如果服務端收不到PONG，就會觸發讀空閒，然後斷開與客戶端的連接。
   WebSocketClientProtocolHandler和WebSocketServerProtocolHandler類都有一個dropPongFrames參數，默認爲true，如果你在讀空閒時寫了斷開連接的操作，要把dropPongFrames設置爲false，這樣就可以在消息處理handler中接收到PONG，就不會觸發讀空閒，否則連接就會被你自己寫的斷開連接的操作給斷開。