netty websocket 示例代码

以下是一个 Netty WebSocket 示例代码，它使用了 Netty 4.x 版本的 API：

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
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;

public class WebSocketServer {
    
    private final int port;
    
    public WebSocketServer(int port) {
        this.port = port;
    }

    public void run() 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
                 public void initChannel(SocketChannel ch) throws Exception {
                     ch.pipeline().addLast(new HttpServerCodec(),
                                           new HttpObjectAggregator(65536),
                                           new WebSocketServerProtocolHandler("/websocket"),
                                           new WebSocketFrameHandler());
                 }
             })
             .option(ChannelOption.SO_BACKLOG, 128)
             .childOption(ChannelOption.SO_KEEPALIVE, true);

            ChannelFuture f = b.bind(port).sync();
            f.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        int port = 8080;
        new WebSocketServer(port).run();
    }
}

上述代码创建了一个 WebSocket 服务器，监听指定端口，使用了 Netty 的 API 实现，具体如下：

1. 创建了两个 `EventLoopGroup`，一个用于处理连接，另一个用于处理请求；
2. 创建了一个 `ServerBootstrap`，它是用于启动服务器的类；
3. 配置了服务器参数，包括使用 NIO、设置连接和请求处理的线程组、设置 Channel 类型为 `NioServerSocketChannel`、设置连接参数（backlog 和 keepalive）等；
4. 添加了一个 `ChannelInitializer`，它是用于初始化新连接的 Channel 的，它会添加一系列的 ChannelHandler，包括 HTTP 编解码器、HTTP 消息聚合器、WebSocket 协议处理器和自定义的 WebSocket 帧处理器；
5. 绑定了端口并启动服务器；
6. 最后，关闭线程组。

下面是自定义的 `WebSocketFrameHandler` 类，它继承了 Netty 的 `SimpleChannelInboundHandler` 类，用于处理 WebSocket 帧：

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

public class WebSocketFrameHandler extends SimpleChannelInboundHandler<WebSocketFrame> {

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, WebSocketFrame frame) throws Exception {
        if (frame instanceof TextWebSocketFrame) {
            handleTextFrame(ctx, (TextWebSocketFrame) frame);
        } else if (frame instanceof BinaryWebSocketFrame) {
            handleBinaryFrame(ctx, (BinaryWebSocketFrame) frame);
        } else {
            throw new UnsupportedOperationException(String.format("%s frame types not supported", frame.getClass().getName()));
        }
    }

    private void handleTextFrame(ChannelHandlerContext ctx, TextWebSocketFrame frame) {
        // 处理文本帧
        String text = frame.text();
        System.out.println("Received text: " + text);
        ctx.channel().writeAndFlush(new TextWebSocketFrame("Echo: " + text));
    }

    private void handleBinaryFrame(ChannelHandlerContext ctx, BinaryWebSocketFrame frame) {
        // 处理二进制帧
        byte[] data = frame.content().array();
        System.out.println("Received binary data: " + data);
        ctx.channel().writeAndFlush(new BinaryWebSocketFrame(frame.content()));
    }
}

上述代码中的 `WebSocketFrameHandler` 类重写了 Netty 的 `SimpleChannelInboundHandler` 的 `channelRead0` 方法，用于处理接收到的 WebSocket 帧。它通过判断帧的类型，分别处理文本帧和二进制帧，最后将处理结果写回客户端。在这个示例中，处理结果是接收到的数据的回显。

需要注意的是，在使用 WebSocket 时，客户端和服务器之间的数据传输是基于帧（Frame）的，每个帧包含了帧头和帧体两部分。帧头包含了帧的类型、长度、是否是结束帧等信息，而帧体则是实际的数据内容。在上述代码中，我们分别处理了文本帧和二进制帧，并将处理结果写回客户端。