Springboot 整合 Netty服务的用法

QD_IT伟

于 2024-05-17 08:57:07 发布

阅读量208

点赞数 2

文章标签： spring boot 后端 java

WW_jkg

本文链接：https://blog.csdn.net/qq_41324075/article/details/138991529

版权

一、什么是Netty

1、Netty是一个Java的网络通信框架，用于快速开发可扩展的高性能网络服务器和客户端。它提供了简单而强大的抽象，使开发人员能够轻松地构建各种应用程序，包括实时通信、实时监测和大规模分布式系统。Netty的核心特点包括：异步的、事件驱动的网络编程模型、高性能、高度可定制、协议灵活、简单易用等。
2、WebSocket 的底层通常使用 Netty、Node.js、Tornado 等框架和技术实现。Netty 是一个基于 Java NIO 的异步、事件驱动的网络编程框架，被广泛用于构建高性能的网络应用程序，包括 WebSocket 服务器。在 Netty 中，可以方便地实现 WebSocket 的握手、数据传输等功能。

二、整合springboot

导入pom坐标

<dependencies>
    <!-- Spring Boot 相关依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- Netty 相关依赖 -->
    <dependency>
        <groupId>io.netty</groupId>
        <artifactId>netty-all</artifactId>
        <version>4.1.66.Final</version>
    </dependency>
</dependencies>



导入配置
public class NettyConfig {
    /**
     * 定义一个channel组，管理所有的channel
     * GlobalEventExecutor.INSTANCE 是全局的事件执行器，是一个单例
     */
    private static ChannelGroup channelGroup = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);

    /**
     * 存放用户与Chanel的对应信息，用于给指定用户发送消息
     */
    private static ConcurrentHashMap<String,Channel> userChannelMap = new ConcurrentHashMap<>();

    private NettyConfig() {}

    /**
     * 获取channel组
     * @return
     */
    public static ChannelGroup getChannelGroup() {
        return channelGroup;
    }

    /**
     * 获取用户channel map
     * @return
     */
    public static ConcurrentHashMap<String,Channel> getUserChannelMap(){
        return userChannelMap;
    }
}

netty server 服务的创建
@Component
public class NettyServer {

    private static final Logger log = LoggerFactory.getLogger(NettyServer.class);

    /**
     * webSocket协议名
     */
    private static final String WEBSOCKET_PROTOCOL = "WebSocket";

    /**
     * 端口号
     */
    @Value("${webSocket.netty.port}")
    private int port;

    /**
     * webSocket路径
     */
    @Value("${webSocket.netty.path}")
    private String webSocketPath;

    /**
     * 在Netty心跳检测中配置 - 读空闲超时时间设置
     */
    @Value("${webSocket.netty.readerIdleTime}")
    private long readerIdleTime;

    /**
     * 在Netty心跳检测中配置 - 写空闲超时时间设置
     */
    @Value("${webSocket.netty.writerIdleTime}")
    private long writerIdleTime;

    /**
     * 在Netty心跳检测中配置 - 读写空闲超时时间设置
     */
    @Value("${webSocket.netty.allIdleTime}")
    private long allIdleTime;

    @Autowired
    private WebSocketHandler webSocketHandler;

    private EventLoopGroup bossGroup;
    private EventLoopGroup workGroup;

    /**
     * 启动
     *
     * @throws InterruptedException
     */
    private void start() throws InterruptedException {
        bossGroup = new NioEventLoopGroup();
        workGroup = new NioEventLoopGroup();
        ServerBootstrap bootstrap = new ServerBootstrap();
        // bossGroup辅助客户端的tcp连接请求, workGroup负责与客户端之前的读写操作
        bootstrap.group(bossGroup, workGroup);
        // 设置NIO类型的channel
        bootstrap.channel(NioServerSocketChannel.class);
        // 设置监听端口
        bootstrap.localAddress(new InetSocketAddress(port));
        // 连接到达时会创建一个通道
        bootstrap.childHandler(new ChannelInitializer<SocketChannel>() {

            @Override
            protected void initChannel(SocketChannel ch) throws Exception {
                // 心跳检测(一般情况第一个设置,如果超时了,则会调用userEventTriggered方法,且会告诉你超时的类型)
                ch.pipeline().addLast(new IdleStateHandler(readerIdleTime, writerIdleTime, allIdleTime, TimeUnit.MINUTES));
                // 流水线管理通道中的处理程序（Handler），用来处理业务
                // webSocket协议本身是基于http协议的，所以这边也要使用http编解码器
                ch.pipeline().addLast(new HttpServerCodec());
                ch.pipeline().addLast(new ObjectEncoder());
                // 以块的方式来写的处理器
                ch.pipeline().addLast(new ChunkedWriteHandler());
                /*
                    说明：
                    1、http数据在传输过程中是分段的，HttpObjectAggregator可以将多个段聚合
                    2、这就是为什么，当浏览器发送大量数据时，就会发送多次http请求
                 */
                ch.pipeline().addLast(new HttpObjectAggregator(8192));
                /*
                    说明：
                    1、对应webSocket，它的数据是以帧（frame）的形式传递
                    2、浏览器请求时 ws://localhost:58080/xxx 表示请求的uri
                    3、核心功能是将http协议升级为ws协议，保持长连接
                */
                ch.pipeline().addLast(new WebSocketServerProtocolHandler(webSocketPath, WEBSOCKET_PROTOCOL, true, 65536 * 10));
                // 自定义的handler，处理业务逻辑
                ch.pipeline().addLast(webSocketHandler);
            }
        });
        // 配置完成，开始绑定server，通过调用sync同步方法阻塞直到绑定成功
        ChannelFuture channelFuture = bootstrap.bind().sync();
        log.info("Server started and listen on:{}", channelFuture.channel().localAddress());
        // 对关闭通道进行监听
        channelFuture.channel().closeFuture().sync();
    }

    /**
     * 释放资源
     *
     * @throws InterruptedException
     */
    @PreDestroy
    public void destroy() throws InterruptedException {
        if (bossGroup != null) {
            bossGroup.shutdownGracefully().sync();
        }
        if (workGroup != null) {
            workGroup.shutdownGracefully().sync();
        }
    }

    /**
     * 初始化(新线程开启)
     */
    @PostConstruct()
    public void init() {
        //需要开启一个新的线程来执行netty server 服务器
        new Thread(() -> {
            try {
                start();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}


webdocket服务的创建
@Component
@ChannelHandler.Sharable
public class WebSocketHandler extends SimpleChannelInboundHandler<TextWebSocketFrame> {

    private static final Logger log = LoggerFactory.getLogger(WebSocketHandler.class);

    /**
     * 一旦连接,第一个被执行
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        log.info("handlerAdded 被调用" + ctx.channel().id().asLongText());
        // 添加到channelGroup 通道组
        NettyConfig.getChannelGroup().add(ctx.channel());
    }

    /**
     * 读取数据
     */
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, TextWebSocketFrame msg) throws Exception {
        // 获取用户ID,关联channel
        /*InetSocketAddress inSocket = (InetSocketAddress) ctx.channel().remoteAddress();
        String clientIp = inSocket.getAddress().getHostAddress();*/
        if (!StringUtils.isBlank(msg.text())) {
            try {

                ReceiveMsg receiveMsg = JSON.parseObject(msg.text(), ReceiveMsg.class);
                String uid = receiveMsg.getUserId();
                String command = receiveMsg.getCommand();
                String hyNbbh = receiveMsg.getHyNbbh();
                String ytNbbh = receiveMsg.getYtNbbh();
                String appId = receiveMsg.getAppId();
                if (StringUtils.isBlank(uid)) {
                    ReturnMsg returnMsg = new ReturnMsg();
                    returnMsg.setSuccess(false).setErrmsg("用户ID不能为空!");
                    ctx.channel().writeAndFlush(new TextWebSocketFrame(JSONObject.toJSONString(returnMsg)));
                    return;
                }
                // 当用户ID已存入通道内,则不进行写入,只有第一次建立连接时才会存入,其他情况发送uid则为心跳需求
                if (StringUtils.isBlank(hyNbbh)) {
                    //首页等
                    uid = ctx.channel().id().asLongText() + "_" + uid + "_Home";
                } else {
                    //会议讨论页面
                    uid = ctx.channel().id().asLongText() + "_" + uid + "_" + hyNbbh;
                }
                log.info("服务器收到消息：{}", msg.text());
                if (!NettyConfig.getUserChannelMap().containsKey(uid)) {
                    log.info("服务器收到消息：{}", msg.text());
                    NettyConfig.getUserChannelMap().put(uid, ctx.channel());//新用户上线

                    // 将用户ID作为自定义属性加入到channel中，方便随时channel中获取用户ID
                    // 回复消息
                    //ctx.channel().writeAndFlush(new TextWebSocketFrame("服务器连接成功！"));
                } else {
                    log.info("服务器收到消息：{}", msg.text());
                }
                if (StringUtils.isNotBlank(command)) {
                    if (command.equals(CommandEnum.HY_USERONLINE.getText())) {
                        pushService().updateSdry(receiveMsg, "1", false);//更新实到人员
                    }
                    //广播用户在线信息
                    if (command.equals(CommandEnum.HY_SMS.getText())) {
                        pushService().pushMsgToTlry(receiveMsg, false);
                    } else {
                        pushService().pushMsgToTlry(receiveMsg, true);
                    }
                }
            } catch (Exception e) {
                ReturnMsg returnMsg = new ReturnMsg();
                returnMsg.setSuccess(false).setErrmsg("解析收到数据时发生错误：" + e);
                ctx.channel().writeAndFlush(new TextWebSocketFrame(JSONObject.toJSONString(returnMsg)));
            }

        }

    }

    /**
     * 移除通道及关联用户
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
        log.info("handlerRemoved 被调用" + ctx.channel().id().asLongText());
        // 删除通道
        NettyConfig.getChannelGroup().remove(ctx.channel());
        removeUserId(ctx);
    }

    /**
     * 异常处理
     *
     * @param ctx
     * @param cause
     * @throws Exception
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        log.info("异常：{}", cause.getMessage());
        // 删除通道
        NettyConfig.getChannelGroup().remove(ctx.channel());
        removeUserId(ctx);
        ctx.close();
    }

    /**
     * 心跳检测相关方法 - 会主动调用handlerRemoved
     *
     * @param ctx
     * @param evt
     * @throws Exception
     */
    @Override
    public void userEventTriggered(final ChannelHandlerContext ctx, Object evt) throws Exception {
        if (evt instanceof IdleStateEvent) {
            IdleStateEvent event = (IdleStateEvent) evt;
            if (event.state() == IdleState.ALL_IDLE) {
                //清除超时会话
                /*ChannelFuture writeAndFlush = ctx.writeAndFlush("you will close");
                writeAndFlush.addListener(new ChannelFutureListener() {

                    @Override
                    public void operationComplete(ChannelFuture future) throws Exception {
                       // ctx.channel().close();
                    }
                });*/
            }
        } else {
            super.userEventTriggered(ctx, evt);
        }
    }

    /**
     * channelInactive
     * channel 通道 Inactive 不活跃的
     * 当客户端主动断开服务端的链接后，这个通道就是不活跃的。也就是说客户端与服务端的关闭了通信通道并且不可以传输数据
     *
     * @param ctx
     */
    @Override
    public void channelInactive(ChannelHandlerContext ctx) {
        //getThis().pushMsgToAll("设备消息：----发现一个设备主动离线；设备的IP地址为"+clientIp);
        NettyConfig.getChannelGroup().remove(ctx.channel());
        removeUserId(ctx);
        ctx.close();
    }

    /**
     * 删除用户与channel的对应关系
     *
     * @param ctx
     */
    private void removeUserId(ChannelHandlerContext ctx) {
        /*ctx.channel().id().asLongText();
        AttributeKey<String> key = AttributeKey.valueOf("userId");*/
        String userId = ctx.channel().id().asLongText();

        if (!StringUtils.isBlank(userId) && NettyConfig.getUserChannelMap() != null && NettyConfig.getUserChannelMap().size() > 0) {
            NettyConfig.getUserChannelMap().forEach((key, v) -> {
                String id = v.id().asLongText();
                if (userId.equals(id)) {
                    NettyConfig.getUserChannelMap().remove(key);
                    log.info("删除用户与channel的对应关系,uid：{}", userId);
                    ReceiveMsg receiveMsg = new ReceiveMsg();
                    String[] s = key.split("_");
                    receiveMsg.setCommand(CommandEnum.HY_USEROFLINE.getText()).setHyNbbh(s[2]).setUserId(s[1]);
                    pushService().updateSdry(receiveMsg, "0", true);
                    pushService().pushMsgToTlry(receiveMsg, true);
                }
            });

        }
    }

    private PushService pushService() {
        PushService pushService = ApplicationContextUtil.getBean("pushService", PushService.class);
        return pushService;
    }

    private PushHomeService pushHomeService() {
        PushHomeService pushHomeService = ApplicationContextUtil.getBean("pushHomeService", PushHomeService.class);
        return pushHomeService;
    }
}