Netty实现WebSocket通信案例

最新推荐文章于 2023-12-22 11:52:37 发布

JavaMrSun

最新推荐文章于 2023-12-22 11:52:37 发布

阅读量857

点赞数

分类专栏：技术杂谈

技术杂谈专栏收录该内容

38 篇文章

订阅专栏

本文介绍使用Netty开发WebSocket服务端及HTML实现客户端的过程。包括全局配置管理、核心业务处理类设计、初始化组件配置及程序启动流程。同时提供了一个简单的HTML客户端页面用于测试。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Netty开发服务端，HTML实现客户端，实现服务端与客户端的实时交互。

1.存储整个工程的全局配置：

package com.research.netty.WebSocket;

import io.netty.channel.group.ChannelGroup;
import io.netty.channel.group.DefaultChannelGroup;
import io.netty.util.concurrent.GlobalEventExecutor;

/***
 * 存储整个工程的全局配置
 */
public class NettyConfig {
    /***
     * 存储每一个客户端接入进来时的Channel对象
     */
    public  static ChannelGroup group = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
}

2.接收/处理/响应客户端websocket请求的核心业务处理类

package com.research.netty.WebSocket;

import java.util.Date;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.group.ChannelGroup;
import io.netty.channel.group.ChannelMatcher;
import io.netty.handler.codec.http.DefaultFullHttpResponse;
import io.netty.handler.codec.http.FullHttpRequest;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.netty.handler.codec.http.HttpVersion;
import io.netty.handler.codec.http.websocketx.CloseWebSocketFrame;
import io.netty.handler.codec.http.websocketx.PingWebSocketFrame;
import io.netty.handler.codec.http.websocketx.PongWebSocketFrame;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
import io.netty.handler.codec.http.websocketx.WebSocketFrame;
import io.netty.handler.codec.http.websocketx.WebSocketServerHandshaker;
import io.netty.handler.codec.http.websocketx.WebSocketServerHandshakerFactory;
import io.netty.util.CharsetUtil;

/**
 * 接收/处理/响应客户端websocket请求的核心业务处理类
 */
public class MyWebSocketHandler extends SimpleChannelInboundHandler<Object> {

    //握手
    private WebSocketServerHandshaker handshaker;
    private static final String WEB_SOCKET_URL = "ws://localhost:8888/websocket";

    //客户端与服务端创建连接的时候调用
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        NettyConfig.group.add(ctx.channel());
        System.out.println("客户端与服务端连接开启...");
    }

    //客户端与服务端断开连接的时候调用
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        NettyConfig.group.remove(ctx.channel());
        System.out.println("客户端与服务端连接关闭...");
    }

    //服务端接收客户端发送过来的数据结束之后调用
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.flush();
    }

    //工程出现异常的时候调用
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }

    //服务端处理客户端websocket请求的核心方法
    @Override
    protected void messageReceived(ChannelHandlerContext context, Object msg) throws Exception {
        //处理客户端向服务端发起http握手请求的业务
        if (msg instanceof FullHttpRequest) {
            handHttpRequest(context, (FullHttpRequest) msg);
        } else if (msg instanceof WebSocketFrame) { //处理websocket连接业务
            handWebsocketFrame(context, (WebSocketFrame) msg);
        }
    }

    /**
     * 处理客户端与服务端之前的websocket业务
     *
     * @param ctx
     * @param frame
     */
    private void handWebsocketFrame(ChannelHandlerContext ctx, WebSocketFrame frame) {
        //判断是否是关闭websocket的指令
        if (frame instanceof CloseWebSocketFrame) {
            handshaker.close(ctx.channel(), (CloseWebSocketFrame) frame.retain());
        }
        //判断是否是ping消息
        if (frame instanceof PingWebSocketFrame) {
            ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
            return;
        }

        //判断是否是二进制消息，如果是二进制消息，抛出异常（我们这个例子不支持二进制消息）
        if (!(frame instanceof TextWebSocketFrame)) {
            System.out.println("目前我们不支持二进制消息");
            throw new RuntimeException("【" + this.getClass().getName() + "】不支持消息");
        }
        //返回应答消息
        //获取客户端向服务端发送的消息
        String request = ((TextWebSocketFrame) frame).text();
        System.out.println("服务端收到客户端的消息====>>>" + request);
        TextWebSocketFrame tws = new TextWebSocketFrame(new Date().toString()
                + ctx.channel().id()
                + " ===>>> "
                + request);
        //群发，服务端向每个连接上来的客户端群发消息
        NettyConfig.group.writeAndFlush(tws);

    }

    /**
     * 处理客户端向服务端发起http握手请求的业务
     *
     * @param ctx
     * @param req
     */
    private void handHttpRequest(ChannelHandlerContext ctx, FullHttpRequest req) {
        if (!req.getDecoderResult().isSuccess()
                || !("websocket".equals(req.headers().get("Upgrade")))) {
            sendHttpResponse(ctx, req,
                    new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.BAD_REQUEST));
            return;
        }
        WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(
                WEB_SOCKET_URL, null, false);
        handshaker = wsFactory.newHandshaker(req);
        if (handshaker == null) {
            WebSocketServerHandshakerFactory.sendUnsupportedWebSocketVersionResponse(ctx.channel());
        } else {
            handshaker.handshake(ctx.channel(), req);
        }
    }

    /**
     * 服务端向客户端响应消息
     *
     * @param ctx
     * @param req
     * @param res
     */
    private void sendHttpResponse(ChannelHandlerContext ctx, FullHttpRequest req,
                                  DefaultFullHttpResponse res) {
        if (res.getStatus().code() != 200) {
            ByteBuf buf = Unpooled.copiedBuffer(res.getStatus().toString(), CharsetUtil.UTF_8);
            res.content().writeBytes(buf);
            buf.release();
        }
        //服务端向客户端发送数据
        ChannelFuture f = ctx.channel().writeAndFlush(res);
        if (res.getStatus().code() != 200) {
            f.addListener(ChannelFutureListener.CLOSE);
        }
    }
}

3.初始化连接时候的各个组件

package com.research.netty.WebSocket;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.stream.ChunkedWriteHandler;

/**
 * 初始化连接时候的各个组件
 */
public class MyWebSocketChannelHandler extends ChannelInitializer<SocketChannel> {

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

}

4.程序的入口，负责启动应用

package com.research.netty.WebSocket;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.Channel;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;

/**
 * 程序的入口，负责启动应用
 */
public class Main {
   public static void main(String[] args) {
      //配置服务端NIO线程组
      EventLoopGroup bossGroup = new NioEventLoopGroup();
      EventLoopGroup workGroup = new NioEventLoopGroup();
      try {
         ServerBootstrap b = new ServerBootstrap();
         b.group(bossGroup, workGroup);
         b.channel(NioServerSocketChannel.class);
         b.childHandler(new MyWebSocketChannelHandler());
         System.out.println("服务端开启等待客户端连接....");
         Channel ch = b.bind(8888).sync().channel();
         ch.closeFuture().sync();
         
      } catch (Exception e) {
         e.printStackTrace();
      }finally{
         //优雅的退出程序
         bossGroup.shutdownGracefully();
         workGroup.shutdownGracefully();
      }
   }
}

5.html

<html>
   <head>
      <meta http-equiv="Content-Type" content="text/html; charset = utf-8"/>
      <title>WebSocket客户端</title>
   <script type="text/javascript">
      var socket;
      if(!window.WebSocket){
         window.WebSocket = window.MozWebSocket;
      }

      if(window.WebSocket){
         socket = new WebSocket("ws://localhost:8888/websocket");
         socket.onmessage = function(event){
            var ta = document.getElementById('responseContent');
            ta.value += event.data + "\r\n";
         };

         socket.onopen = function(event){
            var ta = document.getElementById('responseContent');
            ta.value = "你当前的浏览器支持WebSocket,请进行后续操作\r\n";
         };

         socket.onclose = function(event){
            var ta = document.getElementById('responseContent');
            ta.value = "";
            ta.value = "WebSocket连接已经关闭\r\n";
         };
      }else{
         alert("您的浏览器不支持WebSocket");
      }

        window.onbeforeunload = function(){
            ws.close();
        }

      function send(message){
         if(!window.WebSocket){
            return;
         }
         if(socket.readyState == WebSocket.OPEN){
            socket.send(message);
         }else{
            alert("WebSocket连接没有建立成功！！");
         }
      }
   </script>
   </head>
   <body>
      <form onSubmit="return false;">
         <input type = "text" name = "message" value = ""/>
         <br/><br/>
         <input type = "button" value = "发送WebSocket请求消息" onClick = "send(this.form.message.value)"/>
         <hr color="red"/>
         <h2>客户端接收到服务端返回的应答消息</h2>
         <textarea id = "responseContent" style = "width:1024px; height:300px"></textarea>
      </form>
   </body>
</html>

---摘自慕课网netty课程