Websocket与Netty

lljjmm
711 阅读4分钟

WebSocket - Netty服务端/客户端构建

文章目录
在线websocket测试-online tool-postjson (coolaf.com)
WebSocket协议深入探究 - 云+社区 - 腾讯云 (tencent.com)
/

一、概要

初步总结几句话

  1. 是单个TCP连接上的全双工通信协议
  2. 服务端与客户端之间仅需一次握手，即可创建持久性连接进行双向数据传输

WebSocket和Socket的区别

  • Socket：客户端主动请求，服务器被动应答，单向数据传输；
  • WebSocket：全双工模式，仅需一次握手；

实际上，WebSocket使用的场景在于实时要求高的场景。

二、基于Netty构建WebSocket服务端

2.1 入门案例

NettyServer基本配置

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;

/**
 * @author 李家民
 */
public class NettyServer {
    public void ServerStart() throws InterruptedException {
        // 连接请求处理
        EventLoopGroup bossGroup = new NioEventLoopGroup(3);
        // IO请求处理
        EventLoopGroup workerGroup = new NioEventLoopGroup(5);
        // 基本配置
        ServerBootstrap serverBootstrap =
                new ServerBootstrap().group(bossGroup, workerGroup)
                        .channel(NioServerSocketChannel.class)
                        .option(ChannelOption.SO_BACKLOG, 128)
                        .childOption(ChannelOption.SO_KEEPALIVE, true);
        // 处理器管道配置
        serverBootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
            @Override
            protected void initChannel(SocketChannel ch) throws Exception {
                System.out.println("此时客户端进来了：" + "客户 SocketChannel hashcode=" + ch.hashCode());
                ChannelPipeline pipeline = ch.pipeline();
                // 请求/响应的编解码器
                pipeline.addLast(new HttpServerCodec());

                // 将多消息转换为单一请求/响应对象,解码成FullHttpRequest
                // maxContentLength – 聚合内容的最大长度（以字节为单位）
                pipeline.addLast(new HttpObjectAggregator(65535));

                // WebSocket协议处理
                pipeline.addLast(new WebSocketServerProtocolHandler("/ws"));
                // 下面才是自定义的WebSocket业务处理器
                pipeline.addLast(new WebSocketDemoHandler());
            }
        });
        // 服务器端口配置及监听
        ChannelFuture channelFuture = serverBootstrap.bind(16668).sync();
        channelFuture.addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                if (channelFuture.isSuccess()) {
                    System.out.println("监听端口 16668 成功");
                } else {
                    System.out.println("监听端口 16668 失败");
                }
            }
        });
        // 关闭通道并监听
        channelFuture.channel().closeFuture().sync();
        bossGroup.shutdownGracefully();
        workerGroup.shutdownGracefully();
    }
}

WebSocketDemoHandler业务处理器

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

/**
 * @author 李家民
 */
public class WebSocketDemoHandler extends SimpleChannelInboundHandler<WebSocketFrame> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, WebSocketFrame msg) throws Exception {
        if (msg instanceof TextWebSocketFrame) {
            // 消息接收
            String requestStr = ((TextWebSocketFrame) msg).text();
            System.out.println("我接受到的消息是：" + requestStr);
            // 消息回复
            TextWebSocketFrame textWebSocketFrame = new TextWebSocketFrame("echo");
            ctx.channel().writeAndFlush(textWebSocketFrame);
        } else {
            System.out.println("这是一个非文本消息 不做处理");
        }
    }
}

最后找一个在线WebSocket测试的网站查看效果

2.2 WebSocket相关的Netty内置处理类

在上文的案例中，我使用了TextWebSocketFrame去解析文本数据，其实还有其他数据帧格式

名称描述
BinaryWebSocketFrame二进制数据的WebSocketFrame数据帧
TextWebSocketFrame文本数据的WebSocketFrame数据帧
CloseWebSocketFrame控制帧，代表一个结束请求，包含结束的状态和结束原因
ContinuationWebSocketFrame当发送的内容多一个数据帧时，消息就会拆分为多个WebSocketFrame数据帧发送，这个类型的数据帧专用来发送剩下的内容。ContinuationWebSocketFrame可以用来发送后续的文本或者二进制数据帧
PingWebSocketFrame控制帧，对应协议报文的操作码为0x9，是WebSocket的心跳帧，由服务端发送
PongWebSocketFrame控制帧，对应协议报文的操作码为0xA，是WebSocket的心跳帧，由客户端发送

然而，在管道Pipeline上的处理器，也有相应的一些内置处理类

名称描述
WebSocketServerProtocolHandler协议升级时的处理（握手处理），另外此处理器还负责对WebSocket的三个控制帧Close\Ping\Pong进行处理
WebSocketServerProtocolHandshakeHandler协议升级时的处理（握手处理），握手完成后（连接建立），这个处理器会触发HANDSHAKE_COMPLETE的用户事件，表示握手成功
WebSocketFrameEncoder编码器，负责WebSocket数据帧编码
WebSocketFrameDecoder解码器，负责WebSocket数据帧解码

对照着上图，来看看下图的管道装配

算了，看到这里，我只想说...真难啊我丢

2.3 SpringBoot整合Netty方案

文章目录
netty-websocket-spring-boot-starter/README_zh.md at master · YeautyYE GitHub

你学废了吗

三、WebSocket客户端

因为工作原因，要写WebSocket客户端，所以回来补充了，依旧是结合SpringBoot的方式

依赖加入

<dependency>
    <groupId>org.java-websocket</groupId>
    <artifactId>Java-WebSocket</artifactId>
    <version>1.5.2</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.78</version>
</dependency>

ClientInitialized

import com.ljm.uwp.handler.WebSocketClientHandler;
import org.java_websocket.enums.ReadyState;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.concurrent.CompletableFuture;

/**
 * WebSocket UWP客户端初始化
 * @author 李家民
 */
@Component
public class ClientInitialized {
    /** 链接地址 */
    private static URI uri = null;
    /** WebSocket处理器 */
    public static WebSocketClientHandler socketClientHandler = null;
    /** 连接状态 ReadyState. NOT_YET_CONNECTED, OPEN, CLOSING, CLOSED */
    public static ReadyState connectStatus = ReadyState.NOT_YET_CONNECTED;
    /** 日志 */
    private static Logger logger = LoggerFactory.getLogger(ClientInitialized.class);
    /** 监听连接器数量 */
    private static Integer monitorNumber = 0;

    /**
     * Initial Configuration
     */
    static {
        try {
            uri = new URI("ws://127.0.0.1:16668/ws");
            socketClientHandler = new WebSocketClientHandler(uri);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * WebSocket Client connect
     * @throws URISyntaxException
     * @throws InterruptedException
     */
    @PostConstruct
    public void start() {
        logger.info("开始尝试连接 WebSocket Server...");
        socketClientHandler.connect();
    }

    /**
     * 连接状态监听
     */
    @PostConstruct
    public void connectMonitor() {
        CompletableFuture.runAsync(new Runnable() {
            @Override
            public void run() {
                if (monitorNumber < 1) {
                    monitorNumber++;
                    while (true) {
                        try {
                            if (socketClientHandler != null) {
                                // 连接状态持续监听
                                connectStatus = socketClientHandler.getReadyState();
                                if (connectStatus == ReadyState.CLOSED) {
                                    logger.error("WebSocket 服务端断开！");
                                    // 尝试重连
                                    // ...省略一万行代码
                                }
                            }
                            Thread.sleep(60000);
                        } catch (InterruptedException e) {
                            logger.error("WebSocket 监听器出现异常:" + e.getMessage());
                            e.printStackTrace();
                        }
                    }
                }
            }
        });
    }
}

WebSocketClientHandler

import org.java_websocket.client.WebSocketClient;
import org.java_websocket.handshake.ServerHandshake;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.net.URI;

/**
 * WebSocket UWP处理器
 * @author 李家民
 */
public class WebSocketClientHandler extends WebSocketClient {

    private static Logger logger = LoggerFactory.getLogger(WebSocketClientHandler.class);

    /**
     * 连接建立
     * @param serverUri WebSocket Server URI
     */
    public WebSocketClientHandler(URI serverUri) {
        super(serverUri);
    }

    /**
     * 连接打开
     * @param handshakes
     */
    @Override
    public void onOpen(ServerHandshake handshakes) {
        logger.info("连接打开:" + handshakes.getHttpStatus() + "  " + handshakes.getHttpStatusMessage());
        // 连接UWP平台的权限校验
        // ...省略十万行代码
        // ...
    }

    /**
     * 消息接收
     * @param message
     */
    @Override
    public void onMessage(String message) {
        logger.info("消息接收:" + message);
    }

    /**
     * 连接关闭
     * @param code
     * @param reason
     * @param remote
     */
    @Override
    public void onClose(int code, String reason, boolean remote) {
        logger.info("连接关闭:" + code + " " + reason + " " + remote);
    }

    /**
     * 异常
     * @param ex
     */
    @Override
    public void onError(Exception ex) {
        logger.error("onError:" + ex.getMessage());
    }
}

你学会了吗

万事如意，阖家安康

avatar
文章
阅读
粉丝