netty实现websocket服务器

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接： https://blog.csdn.net/qq_17476231/article/details/100893181

依赖

使用springboot开发，除常用starter以外还有netty-websocket-spring-boot-starter

<dependency>
		    <groupId>org.yeauty</groupId>
		    <artifactId>netty-websocket-spring-boot-starter</artifactId>
		    <version>0.8.0</version>
</dependency>

通道类

MyChannelHandlerPool
主要管理所有通道

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

/**
 * MyChannelHandlerPool
 * 通道组池，管理所有websocket连接
 */
public class MyChannelHandlerPool {

    public MyChannelHandlerPool(){}

    public static ChannelGroup channelGroup = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);

}

通道逻辑处理类

MyWebSocketHandler
主要服务端和客户端建立通道后的操作

import java.util.HashMap;
import java.util.Map;

import org.springframework.stereotype.Component;

import com.alibaba.fastjson.JSON;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.FullHttpRequest;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
@Component
public class MyWebSocketHandler extends SimpleChannelInboundHandler<TextWebSocketFrame> {

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("与客户端建立连接，通道开启！");

        //添加到channelGroup通道组
        MyChannelHandlerPool.channelGroup.add(ctx.channel());
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("与客户端断开连接，通道关闭！");
        //添加到channelGroup 通道组
        MyChannelHandlerPool.channelGroup.remove(ctx.channel());
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        //首次连接是FullHttpRequest，处理参数
        if (null != msg && msg instanceof FullHttpRequest) {
            FullHttpRequest request = (FullHttpRequest) msg;
            String uri = request.uri();

            Map paramMap=getUrlParams(uri);
            System.out.println("接收到的参数是："+JSON.toJSONString(paramMap));
            //如果url包含参数，需要处理
            if(uri.contains("?")){
                String newUri=uri.substring(0,uri.indexOf("?"));
                System.out.println(newUri);
                request.setUri(newUri);
            }

        }else if(msg instanceof TextWebSocketFrame){
            //正常的TEXT消息类型
            TextWebSocketFrame frame=(TextWebSocketFrame)msg;
            System.out.println("客户端收到服务器数据：" +frame.text());
            sendAllMessage(frame.text());
        }
        super.channelRead(ctx, msg);
    }

    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, TextWebSocketFrame textWebSocketFrame) throws Exception {

    }

    public void sendAllMessage(String message){
        //收到信息后，群发给所有channel
        MyChannelHandlerPool.channelGroup.writeAndFlush( new TextWebSocketFrame(message));
    }

    private static Map getUrlParams(String url){
        Map<String,String> map = new HashMap<>();
        url = url.replace("?",";");
        if (!url.contains(";")){
            return map;
        }
        if (url.split(";").length > 0){
            String[] arr = url.split(";")[1].split("&");
            for (String s : arr){
                String key = s.split("=")[0];
                String value = s.split("=")[1];
                map.put(key,value);
            }
            return  map;

        }else{
            return map;
        }
    }
}

服务配置类

NettyServer
对netty做常用配置

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;
import io.netty.handler.stream.ChunkedWriteHandler;

public class NettyServer {
	 private final int port;
	 
	    public NettyServer(int port) {
	        this.port = port;
	    }
	 
	    public void start() throws Exception {
	        EventLoopGroup bossGroup = new NioEventLoopGroup();
	 
	        EventLoopGroup group = new NioEventLoopGroup();
	        try {
	            ServerBootstrap sb = new ServerBootstrap();
	            sb.option(ChannelOption.SO_BACKLOG, 1024);
	            sb.group(group, bossGroup) // 绑定线程池
	                    .channel(NioServerSocketChannel.class) // 指定使用的channel
	                    .localAddress(this.port)// 绑定监听端口
	                    .childHandler(new ChannelInitializer<SocketChannel>() { // 绑定客户端连接时候触发操作
	 
	                        @Override
	                        protected void initChannel(SocketChannel ch) throws Exception {
	                            System.out.println("收到新连接");
	                            //websocket协议本身是基于http协议的，所以这边也要使用http解编码器
	                            ch.pipeline().addLast(new HttpServerCodec());
	                            //以块的方式来写的处理器
	                            ch.pipeline().addLast(new ChunkedWriteHandler());
	                            ch.pipeline().addLast(new HttpObjectAggregator(8192));
	                            ch.pipeline().addLast(new WebSocketServerProtocolHandler("/ws", null, true, 65536 * 10));
	                            ch.pipeline().addLast(new MyWebSocketHandler());
	                        }
	                    });
	            ChannelFuture cf = sb.bind().sync(); // 服务器异步创建绑定
	            System.out.println(NettyServer.class + " 启动正在监听： " + cf.channel().localAddress());
	            cf.channel().closeFuture().sync(); // 关闭服务器通道
	        } finally {
	            group.shutdownGracefully().sync(); // 释放线程池资源
	            bossGroup.shutdownGracefully().sync();
	        }
	    }
}

springboot启动类

DemoApplication
启动类（@EnableScheduling是用定时任务时的注解，不用可以忽略）

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

import com.nk.netty.NettyServer;
@SpringBootApplication
@EnableScheduling
public class DemoApplication {
	public static void main(String[] args) {
		SpringApplication.run(DemoApplication.class,args);
		try {
			new NettyServer(8000).start();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

客户端

主要是js代码

<script type="text/javascript" th:inline="javascript">
 	 var testdata;
    $(function(){ 
        var websocket = null;
        var host = document.location.host;
        //判断当前浏览器是否支持WebSocket 
        var websocket = null;  
              if('WebSocket' in window) {
                  websocket = new WebSocket("ws://服务端ip:服务端口/ws"); 
              } else if('MozWebSocket' in window) {
                  websocket = new MozWebSocket("ws://服务端ip:服务端口/ws");              
              } else {
                  websocket = new SockJS("ws://服务端ip:服务端口/ws");
              }

        //连接发生错误的回调方法 
        websocket.onerror = function() {
        };

        //连接成功建立的回调方法 
        websocket.onopen = function() {
        }

        //接收到消息的回调方法 
        websocket.onmessage = function(event) {
          console.log(event.data)
          testdata = JSON.parse(event.data)
          $(".name:eq("+testdata.id+")").text(testdata.v)
        }

        //连接关闭的回调方法 
        websocket.onclose = function() {
          setMessageInnerHTML("WebSocket连接关闭");
        }

        //监听窗口关闭事件，当窗口关闭时，主动去关闭websocket连接，防止连接还没断开就关闭窗口，server端会抛异常。 
        window.onbeforeunload = function() {
          closeWebSocket();
        }

        //关闭WebSocket连接 
        function closeWebSocket() {
          websocket.close();
        }
        
    });
</script>