Netty心跳检测代码实例

最新推荐文章于 2023-09-08 17:14:02 发布
最新推荐文章于 2023-09-08 17:14:02 发布
阅读量402 收藏
点赞数
分类专栏： 分布式 文章标签： netty idlestate 心跳检测
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiazaizhuanyong1231/article/details/113943331
版权

1、 BIO/NIO/AIO

2、netty组件解析

3、Netty编解码&粘包拆包&心跳检测与重连&零拷贝

      Netty心跳检测代码实例

服务端

package com.weyne.io.heartbeat.server;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
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.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.handler.timeout.IdleStateHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class HeartBeatServer {

    private static final Logger LOGGER = LoggerFactory.getLogger(HeartBeatServer.class);

    public static void main(String[] args) {
        EventLoopGroup boss = new NioEventLoopGroup(1);
        EventLoopGroup work = new NioEventLoopGroup();

        ServerBootstrap bootstrap = new ServerBootstrap();

        bootstrap.group(boss, work)
                .channel(NioServerSocketChannel.class)
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        ch.pipeline().addLast("decoder", new StringDecoder());
                        ch.pipeline().addLast("encoder", new StringEncoder());
                        ch.pipeline().addLast(new IdleStateHandler(3, 0, 0));
                        ch.pipeline().addLast(new HeartBeatServerHandler());
                    }
                });
        LOGGER.info("netty server start...");

        ChannelFuture future;
        try {
            future = bootstrap.bind(8090).sync();
            future.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            work.shutdownGracefully();
            boss.shutdownGracefully();
        }

    }
}

HeartBeatServerHandler

package com.weyne.io.heartbeat.server;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
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.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.handler.timeout.IdleStateHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class HeartBeatServer {

    private static final Logger LOGGER = LoggerFactory.getLogger(HeartBeatServer.class);

    public static void main(String[] args) {
        EventLoopGroup boss = new NioEventLoopGroup(1);
        EventLoopGroup work = new NioEventLoopGroup();

        ServerBootstrap bootstrap = new ServerBootstrap();

        bootstrap.group(boss, work)
                .channel(NioServerSocketChannel.class)
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        ch.pipeline().addLast("decoder", new StringDecoder());
                        ch.pipeline().addLast("encoder", new StringEncoder());
                        ch.pipeline().addLast(new IdleStateHandler(3, 0, 0));
                        ch.pipeline().addLast(new HeartBeatServerHandler());
                    }
                });
        LOGGER.info("netty server start...");

        ChannelFuture future;
        try {
            future = bootstrap.bind(8090).sync();
            future.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            work.shutdownGracefully();
            boss.shutdownGracefully();
        }

    }
}

客户端

package com.weyne.io.heartbeat.client;

import com.weyne.io.heartbeat.server.HeartBeatServerHandler;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Random;

public class HeartBeatClient {

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

    public static void main(String[] args) {
        NioEventLoopGroup eventLoopGroup = new NioEventLoopGroup();

        Bootstrap bootstrap = new Bootstrap();

        bootstrap.group(eventLoopGroup).channel(NioSocketChannel.class)
                .handler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        ChannelPipeline pipeline = ch.pipeline();
                        pipeline.addLast("encoder" , new StringEncoder());
                        pipeline.addLast("decoder", new StringDecoder());
                        pipeline.addLast(new HeartBeatClientHandler());
                    }
                });

        logger.info("netty client start...");
        try {
            Channel channel = bootstrap.connect("127.0.0.1", 8090).sync().channel();
            String text = "Heartbeat Packet";
            Random random = new Random();
            while (channel.isActive()){
                int num = random.nextInt(10);
                logger.info(String.format("[%s]后发起心跳检测...", num));
                Thread.sleep(3 * 1000);
                channel.writeAndFlush(text);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            eventLoopGroup.shutdownGracefully();
        }
    }
}

HeartBeatClientHandler

package com.weyne.io.heartbeat.client;

import com.weyne.io.heartbeat.server.HeartBeatServerHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class HeartBeatClientHandler extends SimpleChannelInboundHandler<String> {

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

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        logger.info("client recived:"+msg);
        if (msg != null && msg.equals("idle close")){
            logger.info("服务端关闭连接，客户端关闭");
            ctx.channel().closeFuture();
        }
    }
}

源码解读：

pipeline加入IdleStateHandler心跳连接核心组件，查看该类，继承了ChannelDuplexHandler，该类不仅继承了ChannelInboundHandlerAdapter，还实现了ChannelOutboundHandler，也就是入站和出站的数据流都需要经过这个handler。

/**
 * {@link ChannelHandler} implementation which represents a combination out of a {@link ChannelInboundHandler} and
 * the {@link ChannelOutboundHandler}.
 *
 * It is a good starting point if your {@link ChannelHandler} implementation needs to intercept operations and also
 * state updates.
 */
public class ChannelDuplexHandler extends ChannelInboundHandlerAdapter implements ChannelOutboundHandler {
    ... ...
}

查看IdleStateHandler的channelActive方法，关键在于initialize(ctx)

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        // This method will be invoked only if this handler was added
        // before channelActive() event is fired.  If a user adds this handler
        // after the channelActive() event, initialize() will be called by beforeAdd().
        initialize(ctx);
        super.channelActive(ctx);
    }

接着在该方法中，根据IdleState实现不同的读/写/读写超时task

    private void initialize(ChannelHandlerContext ctx) {
        // Avoid the case where destroy() is called before scheduling timeouts.
        // See: https://github.com/netty/netty/issues/143
        switch (state) {
        case 1:
        case 2:
            return;
        }

        state = 1;
        initOutputChanged(ctx);

        lastReadTime = lastWriteTime = ticksInNanos();
        if (readerIdleTimeNanos > 0) {
            readerIdleTimeout = schedule(ctx, new ReaderIdleTimeoutTask(ctx),
                    readerIdleTimeNanos, TimeUnit.NANOSECONDS);
        }
        if (writerIdleTimeNanos > 0) {
            writerIdleTimeout = schedule(ctx, new WriterIdleTimeoutTask(ctx),
                    writerIdleTimeNanos, TimeUnit.NANOSECONDS);
        }
        if (allIdleTimeNanos > 0) {
            allIdleTimeout = schedule(ctx, new AllIdleTimeoutTask(ctx),
                    allIdleTimeNanos, TimeUnit.NANOSECONDS);
        }
    }

继续跟到ReaderIdleTimeoutTask，该类最后实现的是Runnable，看run()方法，关键在于channelIdle(ctx, event);将channel和IdleState传递下去

private final class ReaderIdleTimeoutTask extends AbstractIdleTask {

        ReaderIdleTimeoutTask(ChannelHandlerContext ctx) {
            super(ctx);
        }

        @Override
        protected void run(ChannelHandlerContext ctx) {
            long nextDelay = readerIdleTimeNanos;
            if (!reading) {
                nextDelay -= ticksInNanos() - lastReadTime;
            }

            if (nextDelay <= 0) {
                // Reader is idle - set a new timeout and notify the callback.
                readerIdleTimeout = schedule(ctx, this, readerIdleTimeNanos, TimeUnit.NANOSECONDS);

                boolean first = firstReaderIdleEvent;
                firstReaderIdleEvent = false;

                try {
                    IdleStateEvent event = newIdleStateEvent(IdleState.READER_IDLE, first);
                    channelIdle(ctx, event);
                } catch (Throwable t) {
                    ctx.fireExceptionCaught(t);
                }
            } else {
                // Read occurred before the timeout - set a new timeout with shorter delay.
                readerIdleTimeout = schedule(ctx, this, nextDelay, TimeUnit.NANOSECONDS);
            }
        }
    }

继续下去看到ctx.fireUserEventTriggered(evt);看到fire，就要联想到这是执行到pipeline中的下个channel了，而本例中的下一个channel是HeartBeatServerHandler，所以直接到HeartBeatServerHandler.userEventTriggered了。

    protected void channelIdle(ChannelHandlerContext ctx, IdleStateEvent evt) throws Exception {
        ctx.fireUserEventTriggered(evt);
    }

那是怎么指定下一个handler的呢？我们继续看ctx.fireUserEventTriggered(evt);看findContextInbound(MASK_USER_EVENT_TRIGGERED)是找到当前ChannelHandlerContext的下一个handle，直到什么条件才最终完成赋值，这块先不管，主要是ctx = ctx.next赋值下一个handlerContext为当前ctx 。源码如下：

    private AbstractChannelHandlerContext findContextInbound(int mask) {
        AbstractChannelHandlerContext ctx = this;
        EventExecutor currentExecutor = executor();
        do {
            ctx = ctx.next;
        } while (skipContext(ctx, currentExecutor, mask, MASK_ONLY_INBOUND));
        return ctx;
    }

再看invokeUserEventTriggered(findContextInbound(MASK_USER_EVENT_TRIGGERED), event);是反射初始化类，然后执行方法userEventTriggered

    static void invokeUserEventTriggered(final AbstractChannelHandlerContext next, final Object event) {
        ObjectUtil.checkNotNull(event, "event");
        EventExecutor executor = next.executor();
        if (executor.inEventLoop()) {
            next.invokeUserEventTriggered(event);
        } else {
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    next.invokeUserEventTriggered(event);
                }
            });
        }
    }
    private void invokeUserEventTriggered(Object event) {
        if (invokeHandler()) {
            try {
                ((ChannelInboundHandler) handler()).userEventTriggered(this, event);
            } catch (Throwable t) {
                invokeExceptionCaught(t);
            }
        } else {
            fireUserEventTriggered(event);
        }
    }

 

Rcfee
关注
专栏目录
Netty学习（五）—IdleStateHandler心跳机制
tuzhenyu的博客
11-21 7万+
Netty学习（五）—IdleStateHandler心跳机制 Netty的IdleStateHandler心跳机制主要是用来检测远端是否存活，如果不存活或活跃则对空闲Socket连接进行处理避免资源的浪费； 个人主页：tuzhenyu’s page 原文地址：Netty学习（五）—IdleStateHandler心跳机制 (0)基础 心跳机制 心跳是在
物联网之java实现（springboot + netty + 心跳，附完整源码）
06-16
本实例主要探讨如何利用Java、Spring Boot和Netty来创建一个带有心跳机制的物联网系统，并提供完整的源代码供参考。 **Java在物联网中的角色** Java作为跨平台的编程语言，拥有广泛的应用场景，特别是在物联网(IoT)...
一起学Netty（十一）之 Netty心跳之IdleStateHandler
热门推荐
BazingaLyncc
05-14 2万+
Netty提供了对心跳机制的天然支持，心跳可以检测远程端是否存活，或者活跃 今天我们就一起初识一下Netty4的心跳机制 Netty4.0提供了一个类，名为IdleStateHandler，这个类可以对三种类型的心跳检测 这个类的构造参数是这样的： 前三个的参数解释如下： 1）readerIdleTime：为读超时时间（即测试端一定时间内未接受到被测试端消
netty 中 IdleStateHandler
cgj296645438的博客
06-05 822
IdleStateHandler 空闲状态处理器，是用来检测当前Handler的ChannelRead()的空闲时间。 构造方法如下 public IdleStateHandler( long readerIdleTime, long writerIdleTime, long allIdleTime, TimeUnit unit) { ...
netty-IdleStateHandler
老猿说说专栏
10-12 140
IdleStateHandler public class IdleStateHandler extends ChannelDuplexHandler { // Not create a new ChannelFutureListener per write operation to reduce GC pressure. private final ChannelFutureL...
netty的IdleStateHandler
stephen830
08-19 337
netty的IdleStateHandler   网络连接中，处理Idle事件是很常见的，一般情况下，客户端与服务端在指定时间内没有任何读写请求，就会认为连接 是idle的。此时，客户端需要向服务端发送ping消息，来维持服务端与客户端的链接。那么怎么判断客户端在指定时间里没有任何读写请求呢？netty 中为我们提供一个特别好用的IdleStateHandler来干这个苦差事！请看下面代码...
netty代码demo.rar
04-25
- **心跳机制**：实现客户端与服务器之间的定期心跳检测，确保连接的有效性。 - **多路复用**：展示如何在一个Channel上处理多个并发连接。 - **编解码器**：自定义的编码和解码器，用于将复杂的数据结构转换为字节...
netty:netty 实例
06-13
这个实例很可能是 Netty 框架的一个源码仓库，名为 "netty-master"，通常包含了 Netty 的核心组件、示例代码、测试用例以及相关的文档。 在深入探讨 Netty 的知识点之前，先来理解一下什么是框架。框架是一种半成品...
netty-代码.zip
11-05
8. **心跳机制与空闲检测**：Netty 支持自定义心跳包和空闲检测策略，用于保持长连接的活跃性，防止因网络延迟或异常导致的通信中断。 在“netty-demo”项目中，你可能会看到以下示例： - **基本的TCP服务端和...
Java高并发编程代码（Netty NIO 实例）
05-12
8. **心跳机制**: 在游戏服务器中，为了检测连接状态和保持连接活跃，通常会实现心跳包的发送和接收。 9. **编解码器**: 自定义的编码器和解码器，用于将业务对象转换成可传输的字节流，以及将接收到的字节流还原成...
DotNetty系列三：编码解码器,IdleStateHandler心跳机制,群发,项目代码
02-23
https://blog.csdn.net/qq_34719168/article/details/87893803 博文项目源代码
java 心跳代码
12-18
java 心跳代码，一个简单的例子，希望对大家有帮助
心跳检查和思路代码
01-16
心跳检测的思路及代码 外网服务端保存内网服务端会话的有效性以及平台上监控所有内网的网络状况,模仿心跳机制实现,这里在做一点叙述,关于思路和具体实现.
Netty心跳检测之IdleStateHandler
qq_36851469的博客
08-24 344
protected void initChannel(SocketChannel ch) throws Exception { // 初始化时，IdleStateHandler 加入到pipeline时，会初始化一个任务加入到队列中，并且记录当前时间微妙 // 线程遍历队列，当执行到的该IdleStateHandler对应的任务时，通过当前时间与过期时间比较，如果小于0说明超时，会调用ServerIdleStateTrigger // 执行相应的逻辑，比如断开客户端连接 ch.pipeli
Netty入门案例——Netty实现心跳检测
秃了也弱了
04-20 471
【代码】Netty入门案例——Netty实现心跳检测。
Netty自带的心跳机制——IdleStateHandler
moneywenxue的博客
10-20 1万+
一、前言 Netty提供了对心跳机制的天然支持，心跳可以检测远程端是否存活，或者活跃。 今天我们就一起初识一下Netty4的心跳机制。Netty4.0提供了一个类，名为IdleStateHandler，这个类可以对三种类型的心跳检测。 二、项目中的应用 上述是项目中应用到的心跳机制关键代码，主要步骤： 在pipeline中添加IdleStateHandler； 在IdleStateHandler后面再添加IdleHandler，这个handler是我们自定义的，后面会再分析...
Netty源码解析-IdleStateHandler
恐龙弟旺仔的博客
12-30 2097
前言： 心跳机制广泛运用在我们的应用平台中。对于连接到应用服务的客户端，服务端有必要对长时间没有请求的客户端连接进行清理，以避免连接过多。这就需要服务端有空闲连接检测机制。 而针对客户端而言，如果长时间未请求数据，为避免被服务端清理连接，就需要间歇性的发送心跳请求。 在Netty中，针对以上需求，已经有现成的Handler可供使用，这就是本文要介绍的IdleStateHandler。 1.IdleStateHandler的使用 1.1 服务端检测长时间未请求的客户端 我们在服务端可以使用Id
Netty源码剖析之IdleStateHandler空闲检测机制
最新发布
李哈zzz的博客
09-08 651
在各种论坛上，笔者看到大部分的博客都是把netty的IdleStateHandler说成心跳机制，而笔者认为这并不是心跳机制，仅仅是跟心跳机制比较相似，并且IdleStateHandler能做的并不仅仅只有"心跳机制"，笔者认为叫做空闲检测机制比较适合。为什么说叫做空闲检测机制比较合适呢？因为netty是封装了NIO，而提及IO无非就是输入输出，换种方式说无非就是读和写。
netty的读写空闲检测-IdleStateHandler
流火
04-28 1446
netty的读写空闲检测-IdleStateHandler
netty实现心跳检测
06-02
在 Netty 中，实现心跳检测可以使用 IdleStateHandler 类。这个类是一个 ChannelHandler，可以在一段时间内检测 Channel 是否有读或写事件发生，如果超时没有发生事件，就会触发一个 IdleStateEvent 事件。我们可以...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值