Netty对websocket的支持及ContinuationWebSocketFrame处理

文盲青年

已于 2023-09-26 18:17:17 修改

阅读量1.3k

点赞数 1

分类专栏： netty 文章标签： websocket 网络协议网络

于 2021-04-16 17:12:16 首次发布

本文链接：https://blog.csdn.net/qq_35890572/article/details/115767708

版权

netty 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

WebSocket是一种规范，是Html5规范的一部分，websocket解决什么问题呢？解决http协议的一些不足。我们知道，http协议是一种无状态的，基于请求响应模式的协议。

网页聊天的程序（基于http协议的），浏览器客户端发送一个数据，服务器接收到这个浏览器数据之后，如何将数据推送给其他的浏览器客户端呢？
这就涉及到服务器的推技术。早年为了实现这种服务器也可以像浏览器客户端推送消息的长连接需求，有很多方案，比如说最常用的采用一种轮询技术，就是客户端每隔一段时间，比如说2s或者3s向服务器发送请求，去请求服务器端是否还有信息没有响应给客户端，有就响应给客户端，当然没有响应就只是一种无用的请求。

这种长轮询技术的缺点有：
1）响应数据不是实时的，在下一次轮询请求的时候才会得到这个响应信息，只能说是准实时，而不是严格意义的实时。
2）大多数轮询请求的空轮询，造成大量的资源带宽的浪费，每次http请求携带了大量无用的头信息，而服务器端其实大多数都不关注这些头信息，而实际大多数情况下这些头信息都远远大于body信息，造成了资源的消耗。

拓展
比较新的技术去做轮询的效果是Comet。这种技术虽然可以双向通信，但依然需要反复发出请求。而且在Comet中，普遍采用的长链接，也会消耗服务器资源。

WebSocket是什么？

WebSocket一种在单个 TCP 连接上进行全双工通讯的协议。WebSocket通信协议于2011年被IETF定为标准RFC 6455，并被RFC7936所补充规范。WebSocket API也被W3C定为标准。

WebSocket 使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在 WebSocket API 中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输。

websocket的出现就是解决了客户端与服务端的这种长连接问题，这种长连接是真正意义上的长连接。客户端与服务器一旦连接建立双方就是对等的实体，不再区分严格意义的客户端和服务端。长连接只有在初次建立的时候，客户端才会向服务端发送一些请求，这些请求包括请求头和请求体，一旦建立好连接之后，客户端和服务器只会发送数据本身而不需要再去发送请求头信息，这样大量减少了
网络带宽。websocket协议本身是构建在http协议之上的升级协议，客户端首先向服务器端去建立连接，这个连接本身就是http协议只是在头信息中包含了一些websocket协议的相关信息，一旦http连接建立之后，服务器端读到这些websocket协议的相关信息就将此协议升级成websocket协议。websocket协议也可以应用在非浏览器应用，只需要引入相关的websocket库就可以了。

HTML5定义了WebSocket协议，能更好的节省服务器资源和带宽，并且能够更实时地进行通讯。Websocket使用ws或wss的统一资源标志符，类似于HTTPS，其中wss表示在TLS之上的Websocket。如：

ws://example.com/wsapi
wss://secure.example.com/

优点

较少的控制开销：相对与http请求的头部信息，websocket信息明显减少。
更强的实时性：由于协议是全双工的，所以服务器可以随时主动给客户端下发数据。相对于HTTP请求需要等待客户端发起请求服务端才能响应，延迟明显更少；即使是和Comet等类似的长轮询比较，其也能在短时间内更多次地传递数据。
保持连接状态。于HTTP不同的是，Websocket需要先创建连接，这就使得其成为一种有状态的协议，之后通信时可以省略部分状态信息。而HTTP请求可能需要在每个请求都携带状态信息（如身份认证等）。
更好的二进制支持。Websocket定义了二进制帧，相对HTTP，可以更轻松地处理二进制内容。
可以支持扩展。Websocket定义了扩展，用户可以扩展协议、实现部分自定义的子协议。如部分浏览器支持压缩等。
更好的压缩效果。相对于HTTP压缩，Websocket在适当的扩展支持下，可以沿用之前内容的上下文，在传递类似的数据时，可以显著地提高压缩率。

netty对websocket协议的支持

demo

浏览器页面向服务器发送消息，服务器将当前消息发送时间反馈给浏览器页面。

服务器端

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;

import java.net.InetSocketAddress;

//websocket长连接示例
public class MyServer {
    public static void main(String[] args) throws Exception{
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup wokerGroup = new NioEventLoopGroup();

        try{
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup,wokerGroup).channel(NioServerSocketChannel.class)
                    .handler(new LoggingHandler(LogLevel.INFO))
                    .childHandler(new WebSocketChannelInitializer());

            ChannelFuture channelFuture = serverBootstrap.bind(new InetSocketAddress(8899)).sync();
            channelFuture.channel().closeFuture().sync();
        }finally {
            bossGroup.shutdownGracefully();
            wokerGroup.shutdownGracefully();
        }

    }
}

服务器端初始化连接

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
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.stream.ChunkedWriteHandler;

public class WebSocketChannelInitializer extends ChannelInitializer<SocketChannel>{

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();

        //websocket协议本身是基于http协议的，所以这边也要使用http解编码器
        pipeline.addLast(new HttpServerCodec());
        //以块的方式来写的处理器
        pipeline.addLast(new ChunkedWriteHandler());
        //netty是基于分段请求的，HttpObjectAggregator的作用是将请求分段再聚合,参数是聚合字节的最大长度
        pipeline.addLast(new HttpObjectAggregator(8192));

        //ws://server:port/context_path
        //ws://localhost:9999/ws
        //参数指的是contex_path
        pipeline.addLast(new WebSocketServerProtocolHandler("/ws"));
        //websocket定义了传递数据的6中frame类型
        pipeline.addLast(new TextWebSocketFrameHandler());

    }
}

WebSocketServerProtocolHandler：参数是访问路径，这边指定的是ws，服务客户端访问服务器的时候指定的url是：ws://localhost:8899/ws。
它负责websocket握手以及处理控制框架（Close，Ping（心跳检检测request），Pong（心跳检测响应））。文本和二进制数据帧被传递到管道中的下一个处理程序进行处理。

桢：
WebSocket规范中定义了6种类型的桢，netty为其提供了具体的对应的POJO实现。
WebSocketFrame：所有桢的父类，所谓桢就是WebSocket服务在建立的时候，在通道中处理的数据类型。本列子中客户端和服务器之间处理的是文本信息。所以范型参数是TextWebSocketFrame。

WebSocketFrame继承类

自定义Handler

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;

import java.time.LocalDateTime;

//处理文本协议数据，处理TextWebSocketFrame类型的数据，websocket专门处理文本的frame就是TextWebSocketFrame
public class TextWebSocketFrameHandler extends SimpleChannelInboundHandler<TextWebSocketFrame>{

    //读到客户端的内容并且向客户端去写内容
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, TextWebSocketFrame msg) throws Exception {
        System.out.println("收到消息："+msg.text());

        /**
         * writeAndFlush接收的参数类型是Object类型，但是一般我们都是要传入管道中传输数据的类型，比如我们当前的demo
         * 传输的就是TextWebSocketFrame类型的数据
         */
        ctx.channel().writeAndFlush(new TextWebSocketFrame("服务时间："+ LocalDateTime.now()));
    }

    //每个channel都有一个唯一的id值
    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        //打印出channel唯一值，asLongText方法是channel的id的全名
        System.out.println("handlerAdded："+ctx.channel().id().asLongText());
    }

    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
        System.out.println("handlerRemoved：" + ctx.channel().id().asLongText());
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        System.out.println("异常发生");
        ctx.close();
    }
}

页面：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>WebSocket客户端</title>
</head>
<body>
<script type="text/javascript">
    var socket;

    //如果浏览器支持WebSocket
    if(window.WebSocket){
        //参数就是与服务器连接的地址
        socket = new WebSocket("ws://localhost:8899/ws");

        //客户端收到服务器消息的时候就会执行这个回调方法
        socket.onmessage = function (event) {
            var ta = document.getElementById("responseText");
            ta.value = ta.value + "\n"+event.data;
        }

        //连接建立的回调函数
        socket.onopen = function(event){
            var ta = document.getElementById("responseText");
            ta.value = "连接开启";
        }

        //连接断掉的回调函数
        socket.onclose = function (event) {
            var ta = document.getElementById("responseText");
            ta.value = ta.value +"\n"+"连接关闭";
        }
    }else{
        alert("浏览器不支持WebSocket！");
    }

    //发送数据
    function send(message){
        if(!window.WebSocket){
            return;
        }

        //当websocket状态打开
        if(socket.readyState == WebSocket.OPEN){
            socket.send(message);
        }else{
            alert("连接没有开启");
        }
    }
</script>
<form onsubmit="return false">
    <textarea name = "message" style="width: 400px;height: 200px"></textarea>

    <input type ="button" value="发送数据" onclick="send(this.form.message.value);">

    <h3>服务器输出：</h3>

    <textarea id ="responseText" style="width: 400px;height: 300px;"></textarea>

    <input type="button" onclick="javascript:document.getElementById('responseText').value=''" value="清空数据">
</form>
</body>
</html>

启动服务器，然后运行客户端页面，当客户端和服务器端连接建立的时候，服务器端执行handlerAdded回调方法，客户端执行onopen回调方法

服务器端控制台：

handlerAdded：acde48fffe001122-00005c11-00000001-4ce4764fffa940fe-df037eb5

页面：

在这里插入图片描述

客户端连接建立

客户端发送消息，服务器端进行响应，
在这里插入图片描述

浏览器客户端发送消息

服务端控制台打印：

收到消息：websocket程序

客户端也收到服务器端的响应：

在这里插入图片描述

浏览器客户端收到服务器端响应

打开开发者工具：

页面发送websocket请求.png

在从标准的HTTP或者HTTPS协议切换到WebSocket时，将会使用一种升级握手的机制。因此，使用WebSocket的应用程序将始终以HTTP/S作为开始，然后再执行升级。这个升级动作发生的确定时刻特定与应用程序；它可能会发生在启动时候，也可能会发生在请求了某个特定的IURL之后。

首次http自定义返回

由于ws建立连接时，第一次请求是HTTP，然后服务端收到HTTP后，校验成功了返回101状态码，此时才切换成ws。如果第一次返回其他状态码，则不会成功建立连接。这里展示后台如何控制第一次HTTP请求的返回：
Main要调节一下，不能直接用ws：

public class Main {
    public static void main(String[] args) throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .handler(new LoggingHandler(LogLevel.DEBUG))
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            //http解编码器
                            pipeline.addLast(new HttpServerCodec());
                            //以块的方式来写的处理器
                            pipeline.addLast(new ChunkedWriteHandler());
                            //netty是基于分段请求的，HttpObjectAggregator的作用是将请求分段再聚合,参数是聚合字节的最大长度
                            pipeline.addLast(new HttpObjectAggregator(8192));
							pipeline.addLast(new WebSocketServerHandler());
                        }
                    });
            ChannelFuture f = serverBootstrap.bind(new InetSocketAddress(8899)).sync();
            f.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

@Slf4j
public class WebSocketServerHandler extends SimpleChannelInboundHandler<Object> {

    private WebSocketServerHandshaker handshaker;

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
        if (msg instanceof FullHttpRequest) {
            //第一次握手是HTTP协议承载
            handleHttpRequest(ctx, (FullHttpRequest) msg);
        } else if (msg instanceof WebSocketFrame) {
            //处理WS消息
            handleWebSocketMsg(ctx, (WebSocketFrame) msg);
        }
    }

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

    private void handleWebSocketMsg(ChannelHandlerContext ctx, WebSocketFrame msg) {
        //判断是否关闭链路的指令
        if (msg instanceof CloseWebSocketFrame) {
            handshaker.close(ctx.channel(), ((CloseWebSocketFrame) msg).retain());
            return;
        }
        //判断是否Ping消息
        if (msg instanceof PingWebSocketFrame) {
            ctx.channel().write(new PongWebSocketFrame(msg.content()).retain());
            return;
        }
        if (!(msg instanceof TextWebSocketFrame)) {
            throw new UnsupportedOperationException(String.format("%s types not supported", msg.getClass().getName()));
        }
        String reqText = ((TextWebSocketFrame) msg).text();
        System.out.println("s收到：" + reqText);
        ctx.channel().writeAndFlush("resp from server:" + DateTimeUtil.dateToStr(new Date()));
    }


    private void handleHttpRequest(ChannelHandlerContext ctx, FullHttpRequest req) {
        //首先对握手的消息进行判断，如果不是ws，那么则返回400
        if (req.decoderResult().isSuccess() || (!"websocket".equals(req.headers().get("Upgrade")))) {
            sendHttpResponse(ctx, req, new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.BAD_REQUEST));
            return;
        }
        WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory("ws://localhost:8899/ws", null, false);
        handshaker = wsFactory.newHandshaker(req);
        if (handshaker == null) {
            WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
        } else {
            handshaker.handshake(ctx.channel(), req);
        }
    }


    private void sendHttpResponse(ChannelHandlerContext ctx, FullHttpRequest req, FullHttpResponse resp) {
        //返回应答给客户端
        if (resp.status().code() != 200) {
            ByteBuf buf = Unpooled.copiedBuffer(resp.status().toString(), CharsetUtil.UTF_8);
            resp.content().writeBytes(buf);
            buf.release();
            setContentLength(resp, resp.content().readableBytes());
        }
        ChannelFuture f = ctx.channel().writeAndFlush(resp);
        //如果是非Keep-Alive连接，关闭连接
        if (!isKeepAlive(req) || resp.status().code() != 200) {
            f.addListener(ChannelFutureListener.CLOSE);
        }
    }


    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        log.error("WebSocketServerHandler error:{}", cause.getMessage(), cause);
        ctx.close();
    }
}

当然接收端还会遇到拆包问题（不同于传统的TCP拆包），即一个消息过长，会被Netty拆分，此时消息类型为：ContinuationWebSocketFrame，故需要处理，我们可以使用一个StringBuffer来缓存，等待拿到完整的消息再做处理即可：

@Slf4j
public class WebSocketServerHandler extends SimpleChannelInboundHandler<Object> {

    private static final int HTTP_OK = 200;

    /**
     * ws第一次请求握手时，走HTTP，并且会携带固定的header：[Upgrade:websocket]
     */
    private static final String WS_HEADER_KEY = "Upgrade";

    private static final String WS_HEADER_VALUE = "websocket";

    public static final Map<String, StringBuffer> TCP_MSG_HOLDER = new ConcurrentHashMap<>();


    private WebSocketServerHandshaker handShaker;

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
        if (msg instanceof FullHttpRequest) {
            //第一次握手是HTTP协议承载
            handleHttpRequest(ctx, (FullHttpRequest) msg);
        } else if (msg instanceof WebSocketFrame) {
            //处理WS消息
            handleWebSocketMsg(ctx, (WebSocketFrame) msg);
        }
    }


    private void handleWebSocketMsg(ChannelHandlerContext ctx, WebSocketFrame msg) {
        SocketAddress socketAddress = ctx.channel().remoteAddress();
        InetAddress address = ((InetSocketAddress) socketAddress).getAddress();
        String ip = address.getHostAddress();
        //判断是否关闭链路的指令
        if (msg instanceof CloseWebSocketFrame) {
            log.info("[handler]{} receive close msg!", ip);
            handShaker.close(ctx.channel(), ((CloseWebSocketFrame) msg).retain());
            return;
        }
        //判断是否Ping消息
        if (msg instanceof PingWebSocketFrame) {
            log.info("[handler]{} receive ping msg!", ip);
            ctx.channel().write(new PongWebSocketFrame(msg.content()).retain());
            return;
        }
        if (msg instanceof TextWebSocketFrame) {
            String wsText = ((TextWebSocketFrame) msg).text();
            if (!msg.isFinalFragment()) {
                //发生了TCP拆包，创建缓存区，等待拼装完整的包
                log.warn("[handler]{} text msg only start, create buffer to get more...", ip);
                StringBuffer buffer = new StringBuffer(wsText);
                TCP_MSG_HOLDER.put(ip, buffer);
            } else {
                handMsg(ctx, ip, wsText);
            }
            return;
        }
        //没有发完的包
        if (msg instanceof ContinuationWebSocketFrame) {
            StringBuffer buffer = TCP_MSG_HOLDER.get(ip);
            if (Objects.isNull(buffer)) {
                log.warn("[handler]{} continuation msg no with start, force disconnect!", ip);
                ctx.channel().close();
                return;
            }
            String wsText = ((ContinuationWebSocketFrame) msg).text();
            buffer.append(wsText);
            if (!msg.isFinalFragment()) {
                log.info("[handler]{} continuation msg, wait more...", ip);
            } else {
                log.info("[handler]{} continuation msg, get final.", ip);
                handMsg(ctx, ip, buffer.toString());
                TCP_MSG_HOLDER.remove(ip);
            }
            return;
        }
        log.warn("[handler]{} receive no text msg! type:[{}]", ip, msg.getClass().getName());
        ctx.channel().close();
    }

    /**
     * 处理客户端的请求
     */
    private void handMsg(ChannelHandlerContext ctx, String ip, String wsText) {
        System.out.println("服务端收到消息");
        //具体处理逻辑
    }


    private void handleHttpRequest(ChannelHandlerContext ctx, FullHttpRequest req) {
        HttpHeaders headers = req.headers();
        String wsHeaderValue = headers.get(WS_HEADER_KEY);
        //首先对握手的消息进行判断，如果不是ws，那么则返回400
        if (!req.decoderResult().isSuccess() || (!WS_HEADER_VALUE.equals(wsHeaderValue))) {
            sendHttpResponse(ctx, req, new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.BAD_REQUEST));
            return;
        }
        String sign = headers.get("sign");
        SocketAddress socketAddress = ctx.channel().remoteAddress();
        InetAddress address = ((InetSocketAddress) socketAddress).getAddress();
        String ip = address.getHostAddress();
        String hostName = address.getHostName();
        //认证
        log.info("[connect]{}, sign[{}]", ip, sign);
        if (!verify(ctx, ip, sign)) {
            sendHttpResponse(ctx, req, new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.BAD_REQUEST));
            return;
        }
        String wsUrl = String.format("ws://localhost:%s/ws", "6698");
        WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(wsUrl, null, false);
        handShaker = wsFactory.newHandshaker(req);
        if (handShaker == null) {
            WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
        } else {
            handShaker.handshake(ctx.channel(), req);
        }
    }

    private boolean verify(ChannelHandlerContext ctx, String ip, String identitySign) {
        //认证逻辑
        return true;
    }

    private void sendHttpResponse(ChannelHandlerContext ctx, FullHttpRequest req, FullHttpResponse resp) {
        //返回应答给客户端
        if (resp.status().code() != HTTP_OK) {
            ByteBuf buf = Unpooled.copiedBuffer(resp.status().toString(), CharsetUtil.UTF_8);
            resp.content().writeBytes(buf);
            buf.release();
            setContentLength(resp, resp.content().readableBytes());
        }
        ChannelFuture f = ctx.channel().writeAndFlush(resp);
        //如果是非Keep-Alive连接，关闭连接
        if (!isKeepAlive(req) || resp.status().code() != HTTP_OK) {
            f.addListener(ChannelFutureListener.CLOSE);
        }
    }

    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
        SocketAddress socketAddress = ctx.channel().remoteAddress();
        InetAddress address = ((InetSocketAddress) socketAddress).getAddress();
        String ip = address.getHostAddress();
        log.error("[handler]{} removed", ip);
        ctx.channel().close();
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        log.error("[handler] error: {}", cause.getMessage(), cause);
        ctx.channel().close();
    }

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