Netty WebSocket协议开发

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/shenchaohao12321/article/details/88635636

1、WebSocket服务端功能介绍

WebSocket服务端的功能如下:支持 WebSocket的浏览器通过 WebSocket协议发送请求消息给服务端,服务端对请求消息进行判断,如果是合法的 WebSocket请求,则获取请求消息体(文本),并在后面追加字符串“欢迎使用 Netty WebSocket服务,现在时刻:系统时间”。
客户端HTML通过内嵌的JS脚本创建 WebSocket连接,如果握手成功,在文本框中打印“打开 WebSocket服务正常,浏览器支持 WebSocket!”。

2、WebSocket服务端开发

首先对 Web Socket服务端的功能进行简单地讲解。 WebSocket服务端接收到请求消息之后,先对消息的类型进行判断,如果不是WebSocket握手请求消息,则返回HTTP400 BAD REQUEST响应给客户端。客户端的握手请求消息如图11-8所示。


服务端对握手请求消息进行处理,构造握手响应返回,双方的 Socket连接正式建立服务端返回的握手应答消息如图11-9所示。

连接建立成功后,到被关闭之前,双方都可以主动向对方发送消息,这点跟HTTP的请求一应答模式存在很大的差别。相比于HTTP,它的网络利用率更高,可以通过全双工的方式进行消息发送和接收，下面一起来看下服务端代码的具体实现,首先看服务启动类。

public class WebSocketServer {
    public void run(int port) throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {

                        @Override
                        protected void initChannel(SocketChannel ch)
                                throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            pipeline.addLast("http-codec",
                                    new HttpServerCodec());
                            pipeline.addLast("aggregator",
                                    new HttpObjectAggregator(65536));
                            ch.pipeline().addLast("http-chunked",
                                    new ChunkedWriteHandler());
                            pipeline.addLast("handler",
                                    new WebSocketServerHandler());
                        }
                    });

            Channel ch = b.bind(port).sync().channel();
            System.out.println("Web socket server started at port " + port
                    + '.');
            System.out
                    .println("Open your browser and navigate to http://localhost:"
                            + port + '/');

            ch.closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        int port = 8080;
        if (args.length > 0) {
            try {
                port = Integer.parseInt(args[0]);
            } catch (NumberFormatException e) {
                e.printStackTrace();
            }
        }
        new WebSocketServer().run(port);
    }
}

第15~16行首先添加HttpServercodec,将请求和应答消息编码或者解码为HTTP消息:第17~18行增加HttpobjectaggRegator,它的目的是将HTTP消息的多个部分组合成条完整的HTTP消息;第19~20行添加ChunkedWriteHandler,来向客户端发送HTML5文件,它主要用于支持浏览器和服务端进行 WebSocket通信;最后21~22行增加 WebSocket服务端 Handler。
看了 WebSocket的服务启动类,很多读者会心存疑惑:怎么 WebSocket服务端的代码跟HTTP协议的非常类似呢?没有看到在ChannelPipeline中增加WebSocket的Handler,那如何处理 WebSocket消息?这个疑问很好,下面就一起来从WebSocketServerHandler的实现中寻找答案。

public class WebSocketServerHandler extends SimpleChannelInboundHandler<Object> {
    private static final Logger logger = Logger
            .getLogger(WebSocketServerHandler.class.getName());

    private WebSocketServerHandshaker handshaker;

    @Override
    public void messageReceived(ChannelHandlerContext ctx, Object msg)
            throws Exception {
        // 传统的HTTP接入
        if (msg instanceof FullHttpRequest) {
            handleHttpRequest(ctx, (FullHttpRequest) msg);
        }
        // WebSocket接入
        else if (msg instanceof WebSocketFrame) {
            handleWebSocketFrame(ctx, (WebSocketFrame) msg);
        }
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.flush();
    }

    private void handleHttpRequest(ChannelHandlerContext ctx,
                                   FullHttpRequest req) throws Exception {

        // 如果HTTP解码失败，返回HHTP异常
        if (!req.getDecoderResult().isSuccess()
                || (!"websocket".equals(req.headers().get("Upgrade")))) {
            sendHttpResponse(ctx, req, new DefaultFullHttpResponse(HTTP_1_1,
                    BAD_REQUEST));
            return;
        }

        // 构造握手响应返回，本机测试
        WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(
                "ws://localhost:8080/websocket", null, false);
        handshaker = wsFactory.newHandshaker(req);
        if (handshaker == null) {
            WebSocketServerHandshakerFactory
                    .sendUnsupportedWebSocketVersionResponse(ctx.channel());
        } else {
            handshaker.handshake(ctx.channel(), req);
        }
    }

    private void handleWebSocketFrame(ChannelHandlerContext ctx,
                                      WebSocketFrame frame) {

        // 判断是否是关闭链路的指令
        if (frame instanceof CloseWebSocketFrame) {
            handshaker.close(ctx.channel(),
                    (CloseWebSocketFrame) frame.retain());
            return;
        }
        // 判断是否是Ping消息
        if (frame instanceof PingWebSocketFrame) {
            ctx.channel().write(
                    new PongWebSocketFrame(frame.content().retain()));
            return;
        }
        // 本例程仅支持文本消息，不支持二进制消息
        if (!(frame instanceof TextWebSocketFrame)) {
            throw new UnsupportedOperationException(String.format(
                    "%s frame types not supported", frame.getClass().getName()));
        }

        // 返回应答消息
        String request = ((TextWebSocketFrame) frame).text();
        if (logger.isLoggable(Level.FINE)) {
            logger.fine(String.format("%s received %s", ctx.channel(), request));
        }
        ctx.channel().write(
                new TextWebSocketFrame(request
                        + " , 欢迎使用Netty WebSocket服务，现在时刻："
                        + new java.util.Date().toString()));
    }

    private static void sendHttpResponse(ChannelHandlerContext ctx,
                                         FullHttpRequest req, FullHttpResponse res) {
        // 返回应答给客户端
        if (res.getStatus().code() != 200) {
            ByteBuf buf = Unpooled.copiedBuffer(res.getStatus().toString(),
                    CharsetUtil.UTF_8);
            res.content().writeBytes(buf);
            buf.release();
            setContentLength(res, res.content().readableBytes());
        }

        // 如果是非Keep-Alive，关闭连接
        ChannelFuture f = ctx.channel().writeAndFlush(res);
        if (!isKeepAlive(req) || res.getStatus().code() != 200) {
            f.addListener(ChannelFutureListener.CLOSE);
        }
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
            throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

首先从第11行看起,第一次握手请求消息由HTTP协议承载,所以它是一个HTTP消息,执行handlehttprequest方法来处理WebSocket握手请求。第29~34行首先对握手请求消息进行判断,如果消息头中没有包含 Upgrade字段或者它的值不是 websocket,则返回HTTP400响应。
握手请求简单校验通过之后,开始构造握手工厂,创建握手处理类 WebSocketServerHandshaker,通过它构造握手响应消息返回给客户端,同时将 WebSocket相关的编码和解码类动态添加到 ChannelPipeline中,用于 WebSocket消息的编解码,代码如图11-10所示。

添加 WebSocketEncoder和 WebSocketDecoder之后,服务端就可以自动对 WebSocket消息进行编解码了,后面的业务 handler可以直接对 WebSocket对象进行操作。下面继续分析链路建立成功之后的操作:客户端通过文本框提交请求消息给服务端, WebSocketServerHandler接收到的是已经解码后的 WebSocketFrame消息。第48~96行对 WebSocket请求消息进行处理,首先需要对控制帧进行判断,如果是关闭链路的控制消息,就调用WebSocket ServerHandshaker的 close方法关闭 WebSocket连接;如果是维持链路的ping消息,则构造Pong消息返回。由于本例程的 Web Socket通信双方使用的都是文本消息,所以对请求消息的类型进行判断,不是文本的抛出异常。
最后,从 TextWebSocketFrame中获取请求消息字符串,对它处理后通过构造新的TextWebSocketFrame消息返回给客户端,由于握手应答时动态增加了 TextWebSocketFrame的编码类,所以,可以直接发送 TextWebSocketFrame对象。
客户端浏览器接收到服务端的应答消息后,将其内容取出展示到浏览器页面中。我们简单分析客户端 WebSocketServer. html的源码。

<html>
<head>
    <meta charset=UTF-8">
    <title>Netty WebSocket时间服务器</title>
</head>
<br>
<body>
<br>
<script type="text/javascript">
    var socket;
    if (!window.WebSocket) {
        window.WebSocket = window.MozWebSocket;
    }
    if (window.WebSocket) {
        socket = new WebSocket("ws://localhost:8080/websocket");
        socket.onmessage = function (event) {
            var ta = document.getElementById('responseText');
            ta.value = "";
            ta.value = event.data;
        };
        socket.onopen = function (event) {
            var ta = document.getElementById('responseText');
            ta.va1ue = "打开 Web Socket服务正常,浏览器支持 WebSocket!";
        };
        socket.onclose = function (event) {
            var ta = document.getElementById('responseText');
            ta.va1ue = " WebSocket关闭!";
        };
    } else {
        alert("抱歉,您的浏览器不支持 WebSocket协议!");
    }
    function send(message) {
        if (!window.WebSocket) {
            return;
        }
        if (socket.readyState = WebSocket.OPEN) {
            socket.send(message);
        } else {
            alert(" Web socket连接没有建立成功!");
        }
    }
</script>
<form onsubmit="return false;">
    <input type="text" name="message" value="Netty最佳实践"/>
    <br><br>
    <input type="button" value="发送 Websocket请求消息" onclick="send(this.form.message.value)"/>
    <hr color="blue"/>
    <h3>服务端返回的应答消息</h3>
    <textarea id="responseText" style="width:500px; height:300px;"></textarea>
</form>
</body>
</html>