Netty -Netty心跳检测机制案例,Netty通过WebSocket编程实现服务器和客户端长链接

最新推荐文章于 2024-05-25 16:40:52 发布
最新推荐文章于 2024-05-25 16:40:52 发布
阅读量358 收藏 2
点赞数
分类专栏： 网络编程 java 文章标签： websocket netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jllion/article/details/117654302
版权

Netty心跳检测机制案例

  • 案例要求

    • 编写一个Netty心跳检测机制案例，当服务器超过3秒没有读时，就提示读空闲
    • 当服务器超过5秒没有写操作时，提示写空闲
    • 服务器超过7秒没有读或者写操作时，就提示读写空闲

  • 代码

    • HeartBeatServer

      • package com.jl.java.web.heartbeat;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import io.netty.handler.timeout.IdleStateHandler;

import java.util.concurrent.TimeUnit;

/**
 * @author jiangl
 * @version 1.0
 * @date 2021/5/25 10:32
 */
public class HeartBeatServer {

    public static void main(String[] args) {
        NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);
        NioEventLoopGroup workGroup = new NioEventLoopGroup();

        try {
            ServerBootstrap bootstrap = new ServerBootstrap();

            bootstrap.group(bossGroup,workGroup)
                    .channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG,128)
                    .childOption(ChannelOption.SO_KEEPALIVE,true)
                    //handler是bossGroup的事件
                    .handler(new LoggingHandler(LogLevel.INFO))
                    //childHandler是工作线程组 workerGroup的事件
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            /*
                             * 说明
                             * 1.IdleStateHandler 是Netty提供的处理空闲状态的处理器
                             * 2.long readerIdleTime：表示多长时间没有读，就会发送一个心跳检测包检查是否连接
                             * 3.long writerIdleTime：表示多长时间没有写，就会发送一个心跳检测包检查是否连接
                             * 4.long allIdleTime：表示多长时间没有读写，就会发送一个心跳检测包检查是否连接
                             * 5.文档说明
                             * Triggers an IdleStateEvent when a Channel has not performed read, write, or both operation for a while.
                             * 当通过在一段时间内没有发生读，写或者读写操作时，会触发一个IdleStateEvent（空闲事件）
                             * 6. 当IdleStateEvent触发后，就会传递给管道的下一个Handler去处理，通过触发下一个handler的userEventTriggered时间，在
                             * 该方法处理IdleStateEvent（读空闲，写空闲，读写空闲）
                             */
                            pipeline.addLast(new IdleStateHandler(3,5,7, TimeUnit.SECONDS));
                            //解码器
                            pipeline.addLast("decode",new StringDecoder());
                            //编码器
                            pipeline.addLast("encode",new StringEncoder());
                            //自定义的Handler
                            pipeline.addLast(new HeartBeatServerHandler());
                        }
                    });
            ChannelFuture channelFuture = bootstrap.bind(7000).sync();
            //将关闭事件同步
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            bossGroup.shutdownGracefully();
            workGroup.shutdownGracefully();
        }
    }
}

    • HeartBeatServerHandler

      • package com.jl.java.web.heartbeat;

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.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import io.netty.handler.timeout.IdleStateEvent;
import io.netty.handler.timeout.IdleStateHandler;

import java.util.concurrent.TimeUnit;

/**
 * @author jiangl
 * @version 1.0
 * @date 2021/5/25 10:32
 */
public class HeartBeatServerHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        if( evt instanceof IdleStateEvent){
            //将Evt向下转型
            IdleStateEvent idleStateEvent = (IdleStateEvent) evt;
            String eventType = null;
            switch(idleStateEvent.state() ){
                case READER_IDLE:
                    eventType = "读空闲";
                    break;
                case WRITER_IDLE:
                    eventType = "写空闲";
                    break;
                case ALL_IDLE:
                    eventType = "读写空闲";
                    break;
            }
            System.out.println(ctx.channel().remoteAddress()+"----超时时间----"+eventType);
            System.out.println("服务器做响应的处理...");
        }
    }
}

Netty通过WebSocket编程实现服务器和客户端长链接

  • 案例要求

    • HTTP协议是无状态的，浏览器和服务器间的请求响应一次，下一次会重新创建连接
    • 要求：实现基于websocket的长链接的全双工的交互
    • 改变http协议多次请求的约束，实现长链接，服务器可以发送消息给浏览器
    • 客户端浏览器和服务器端会相互感知，比如服务器关闭了，浏览器会感知，同样浏览器关闭了，服务器会感知

  • 代码

    • MyServer

      • package com.jl.java.web.websocket;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.ChannelPipeline;
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.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import io.netty.handler.stream.ChunkedWriteHandler;

/**
 * @author jiangl
 * @version 1.0
 * @date 2021/5/25 21:54
 */
public class MyServer {
    public static void main(String[] args) {
        NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);
        NioEventLoopGroup workGroup = new NioEventLoopGroup();

        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap()
                    .group(bossGroup,workGroup)
                    .channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG,128)
                    .option(ChannelOption.SO_KEEPALIVE,true)
                    .handler(new LoggingHandler(LogLevel.INFO))
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            //因为基于http协议，使用http的编码和解码器
                            pipeline.addLast("decoder",new HttpServerCodec());
                            //是以块方式写，添加ChunkedWriteHandler处理器
                            pipeline.addLast("encoder",new ChunkedWriteHandler());
                            /*
                             * HttpObjectAggregator说明
                             * 1.http数据在传输过程中是分段，HttpObjectAggregator，就是可以将多个段聚合
                             * 2.当浏览器发送大量数据时，就会发出多次http请求
                             */
                            pipeline.addLast(new HttpObjectAggregator(8192));
                            /*
                             * WebSocketServerProtocolHandler说明
                             * 1.对应WebSocket，它的数据是以 帧（Frame）形式传递
                             * 2.WebSocketFrame 有六个子类
                             * 3.浏览器请求时，ws://localhost:7000/hello
                             * 4.WebSocketServerProtocolHandler 核心功能将Http协议升级为ws协议 即ws协议（保持长链接）
                             */
                            pipeline.addLast(new WebSocketServerProtocolHandler("/hello"));
                            //添加自定义的handler事件，专门处理浏览器请求，处理业务逻辑
                            pipeline.addLast(new MyTextWebSocketFrameHandler());

                        }
                    });
            ChannelFuture channelFuture = serverBootstrap.bind(8080).sync();
            channelFuture.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            bossGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }
}

    • MyTextWebSocketFrameHandler

      • package com.jl.java.web.websocket;

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

import java.time.LocalDateTime;

/**
 * @author jiangl
 * @version 1.0
 * @date 2021/5/26 10:10
 */
public class MyTextWebSocketFrameHandler extends SimpleChannelInboundHandler<TextWebSocketFrame> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, TextWebSocketFrame msg) throws Exception {
        System.out.println("服务器端收到消息"+msg.text());
        //回复
        ctx.channel().writeAndFlush(new TextWebSocketFrame("服务器时间："+ LocalDateTime.now()+" "+msg.text()));
    }

    /**
     * 当web客户端连接后，触发方法
     * @param ctx
     * @throws Exception
     */
    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        //id表示唯一的值，LongText 是唯一的 shortText不是唯一的
        System.out.println("handlerAdded 被调用："+ctx.channel().id().asLongText());
        System.out.println("handlerAdded 被调用："+ctx.channel().id().asShortText());
    }

    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
        System.out.println("handlerRemoved 被调用"+ctx.channel().id().asLongText());
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        System.out.println("异常发生 "+cause.getMessage());
        ctx.close();//关闭连接
    }
}

    • html

      • <!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <script type="application/javascript">
        var socket;
        if(window.WebSocket){
            socket = new WebSocket("ws://localhost:8080/hello");
            //相当于channelRead,ev接收服务端返回的消息
            socket.onmessage = function (ev){
                var rt = document.getElementById("responseText");
                rt.value = rt.value + "\n" +ev.data;
            }
            //相当于连接开启
            socket.onopen = function (ev){
                var rt = document.getElementById("responseText");
                rt.value = "连接开始...." + "\n";
            }
            //连接关闭
            socket.onclose = function(ev){
                var rt = document.getElementById("responseText");
                rt.value = rt.value + "\n" +"连接关闭....";
            }
        }else{
            alert("当前浏览器不支持webSocket");
        }

        //发送消息
        function send(message){
            if(!window.socket){
                return;
            }
            if(socket.readyState == WebSocket.OPEN){
                //通过Socket发送消息
                socket.send(message);
            }else{
                alert("连接没有开启")
            }
        }

    </script>
    <form onsubmit="return false">
        <textarea id="message" style="height: 300px;width: 300px"></textarea>
        <input type="button" value="发送消息" onclick="send(this.form.message.value)">
        <textarea id="responseText" style="height: 300px;width: 300px"></textarea>
        <input type="button" value="清空内容" onclick="document.getElementById('responseText').value = ''">
    </form>
</body>
</html>

Shacoray
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【项目实战】基于netty-websocket-spring-boot-starter实现WebSocket服务器长链接处理
本本本添哥
03-09 2646
项目中需要建立客户端与服务端之间的长链接，首先就考虑用WebSocket，再来SpringBoot原来整合WebSocket方式并不高效，因此找到了netty-websocket-spring-boot-starter 这款脚手架，它能让我们在SpringBoot中使用Netty来开发WebSocket服务器，并像spring-websocket的注解开发一样简单。
Netty通过WebSocket编程实现服务器和客户端长连接.zip
11-13
在本示例"Netty通过WebSocket编程实现服务器和客户端长连接"中，我们将深入探讨如何利用Netty这一高性能的Java网络应用框架来构建WebSocket服务。 Netty是一个异步事件驱动的网络应用框架，适用于开发高并发、高...
Netty学习----心跳检测机制和WebSocket编程实现服务器和客户端长连接案例（含源码）
https://juejin.cn/user/4248168663101239/posts
02-04 1284
心跳检测机制和WebSocket编程实现服务器和客户端长连接案例一. 心跳检测机制案例二. WebSocket编程实现服务器和客户端长连接案例 一. 心跳检测机制案例 MyServer 服务端 package com.xizi.netty_heartBeat; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelInitiali
基于Netty实现WebSocket客户端
最新发布
u013771019的专栏
05-25 1207
握手事件是在自定义的Handler中实现的，这里为了方便使用CountDownLatch，使用了匿名内部类SimpleChannelInboundHandler的方式。这里我们不手动进行握手，由Netty通过WebSocketClientProtocolHandler进行握手，但是我们要知道何时握手完成了。测试的时候，我们可以看到，当客户端发送ping的时候，服务端会自动回pong，这个是有Netty实现的服务端自带的心跳机制。】，测试用的WebSocket服务端也是用Netty实现的，参考【
十一、Netty 通过 WebSocket 编程实现服务器和客户端长连接
猿小许的博客
11-09 671
一、 什么是Websocket? 1、websocket技术应用场景 使用java技术快速学习一个简单的在线聊天室系统，该系统具备很强的扩展性，可以根据业务需要，制作在线客服系统、web版的微信、QQ即时通信系统等，使用较为流行的技术，采用积木式的编程思路。 web领域的实时推送技术，也被称为Realtime技术，这种技术要达到的目的是绕过用户不需要刷新浏览器就可以获得实时更新。他有着广泛的应用前景，比如在线聊天室，在线客服系统、评论系统、WebIM等。 2、websocket协议概述 webSocket
Netty 通过WebSocket编程实现服务器和客户端长连接
努力学习，努力爱你！
09-09 489
利用WebSocketServerProtocolHandler 进行实现 其原理是利用101状态码讲http协议转换为websocket协议。//相当于channelReado ev收到服务器端会送的消息。//判断当前浏览器支不支持 websocket。//先判断webSocket是否创建好了。"当前浏览器不支持websocket"如有问题，欢迎指正！
Netty应用——通过WebSocket编程实现服务器和客户端长连接（十八）
prince~home
02-13 357
客户端浏览器和服务器端会相互感知，比如服务器关闭了，浏览器会感知，同样浏览器关闭了，服务器会感知。Http协议是无状态的，浏览器和服务器间的请求响应一次，下一次会重新创建连接。p协议多次请求的约束，实现长连接了， 服务器可以发送消息给浏览器。要求:实现基于webSocket的长连接的全双工的交互。
Netty通过WebSocket编程实现服务器和客户端长连接
qq_36609994的博客
03-25 621
1、编写服务端 public class MyServer { public static void main(String[] args) { EventLoopGroup boss = new NioEventLoopGroup(); EventLoopGroup worker = new NioEventLoopGroup(); try...
Netty 通过 WebSocket 编程实现服务器和客户端长连接
Mr.xie1024的博客
01-25 213
实例要求： Http 协议是无状态的，浏览器和服务器间的请求响应一次，下一次会重新创建连接。 要求：实现基于 WebSocket 的长连接的全双工的交互 改变 Http 协议多次请求的约束，实现长连接了，服务器可以发送消息给浏览器 客户端浏览器和服务器端会相互感知，比如服务器关闭了，浏览器会感知，同样浏览器关闭了，服务器会感知 MyServer import com.atguigu.netty.heartbeat.MyServerHandler; import io.netty.bootstrap.Se
netty基础_06.Netty 通过 WebSocket 编程实现服务器和客户端长连接
07-10 297
实例要求： MyTextWebSocketFrameHandler hello.html 可以看到并不是发一次数据，连接就关闭了，而是可以继续发送。
Netty学习笔记 8 Netty 通过WebSocket编程实现服务器和客户端长连接
zyzy123321的博客
07-27 143
通过WebSocket编程实现服务器和客户端长连接 MyServer package com.my.netty.websocket; import com.atguigu.netty.heartbeat.MyServerHandler; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelInitializer; import
netty-socketio：在Java上实现的Socket.IO服务器。 实时Java框架
02-03
该项目是服务器的开源Java实现。 基于服务器框架。 结帐 根据Apache License 2.0许可。 产品特点 支持0.7 ... 0.9.16 （ netty -socketio 1.6.6）和1.0+ （netty-socketio最新版本）版本 支持XHR轮询传输 支持...
netty+websocket实现心跳和断线重连
03-06
综上所述，通过 Netty 实现 WebSocket 服务，并结合心跳检测和断线重连机制，我们可以构建出健壮、可靠的实时通信系统。在实际项目中，还需要根据业务需求进行调整和优化，确保系统的稳定性和用户体验。
netty-websocket.zip
08-12
标题中的"Netty-WebSocket.zip"表明这是一个与Netty框架和WebSocket协议相关的项目或示例代码。Netty是一个高性能、异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。而WebSocket是...
netty-spring-boot-starter:Netty与Spring Boot集成
03-19
netty-spring-boot-starter 基于Netty的Spring Boot Starter工程。 介绍 支持TCP长连接消息转发到Spring容器 支持自定义消息枚举类（ CommandController ， CommandMapping ） 支持自定义通信协议解析（ ...
Java针对不同文件加水印
J三石的博客
03-10 3483
背景 需求需要对不同文件加水印，例如：jpg，png，pdf，word 由于不同文件不同的方式，所以进行逐个功能开发 调研 图片文件（jpg,png,e.g.)：通过ImageIO PDF：1.itextpdf 2.pdfbox Word：1.通过Free Spire for Doc 2.apache poi 分析 对比 图片文件，最好选择就是通过ImageIO，ImageIO为Java的自带工具类javax.imageio.ImageIO PDF下 itext官网url：https://it
记录服务器上，不定时出现io.lettuce.core.RedisCommandTimeoutException: Command timed out after xxx millisecond(s)
J三石的博客
04-25 2984
记录服务器上，不定时出现io.lettuce.core.RedisCommandTimeoutException: Command timed out after 12 millisecond(s) 日志 org.springframework.data.redis.RedisConnectionFailureException: Unable to connect to Redis; nested exception is org.springframework.data.redis.connec
JAVA 使用web3j接入以太坊（一）
J三石的博客
09-09 2514
第一步先创建maven项目，在项目的pom文件依赖中添加web3j <dependency> <groupId>org.web3j</groupId> <artifactId>core</artifactId> <version>4.2.0</version> </dependency>...
netty-websocket-spring-boot-starter使用案例
06-01
netty-websocket-spring-boot-starter是一个基于Netty实现的WebSocket框架，可以方便地在Spring Boot应用中集成WebSocket功能。使用该框架可以快速构建实时通信、消息推送等功能。 下面是一个使用netty-websocket-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值