基于Netty的IdleStateHandler实现

最新推荐文章于 2024-02-22 10:59:51 发布

福伴

最新推荐文章于 2024-02-22 10:59:51 发布

阅读量822

点赞数

原文链接：https://www.cnblogs.com/java-chen-hao/p/11453198.html

版权

什么是 IdleStateHandler

当连接的空闲时间（读或者写）太长时，将会触发一个 IdleStateEvent 事件。然后，你可以通过你的 ChannelInboundHandler 中重写 userEventTrigged 方法来处理该事件。

如何使用？

IdleStateHandler 既是出站处理器也是入站处理器，继承了 ChannelDuplexHandler 。通常在 initChannel 方法中将 IdleStateHandler 添加到 pipeline 中。然后在自己的 handler 中重写 userEventTriggered 方法，当发生空闲事件（读或者写），就会触发这个方法，并传入具体事件。
这时，你可以通过 Context 对象尝试向目标 Socekt 写入数据，并设置一个监听器，如果发送失败就关闭 Socket （Netty 准备了一个 ChannelFutureListener.CLOSE_ON_FAILURE 监听器用来实现关闭 Socket 逻辑）。
这样，就实现了一个简单的心跳服务。

源码分析

构造方法
该类有 3 个构造方法，主要对一下 4 个属性赋值：

private final boolean observeOutput;// 是否考虑出站时较慢的情况。默认值是false（不考虑）。
private final long readerIdleTimeNanos; // 读事件空闲时间，0 则禁用事件
private final long writerIdleTimeNanos;// 写事件空闲时间，0 则禁用事件
private final long allIdleTimeNanos; //读或写空闲时间，0 则禁用事件
可以分别控制读，写，读写超时的时间，单位为秒，如果是0表示不检测，所以如果全是0，则相当于没添加这个IdleStateHandler，连接是个普通的短连接。

handlerAdded 方法
IdleStateHandler是在创建IdleStateHandler实例并添加到ChannelPipeline时添加定时任务来进行定时检测的，具体在initialize(ctx)方法实现；同时在从ChannelPipeline移除或Channel关闭时，移除这个定时检测，具体在destroy()实现

复制代码
public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
if (ctx.channel().isActive() && ctx.channel().isRegistered()) {
this.initialize(ctx);
}

}

public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
this.destroy();
}
复制代码
initialize
复制代码
private void initialize(ChannelHandlerContext ctx) {
switch (state) {
case 1:
case 2:
return;
}
state = 1;
initOutputChanged(ctx);

lastReadTime = lastWriteTime = ticksInNanos();
if (readerIdleTimeNanos > 0) {
  // 这里的 schedule 方法会调用 eventLoop 的 schedule 方法，将定时任务添加进队列中
    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);
}

}
复制代码
只要给定的参数大于0，就创建一个定时任务，每个事件都创建。同时，将 state 状态设置为 1，防止重复初始化。调用 initOutputChanged 方法，初始化 “监控出站数据属性”，代码如下：

复制代码
private void initOutputChanged(ChannelHandlerContext ctx) {
if (observeOutput) {
Channel channel = ctx.channel();
Unsafe unsafe = channel.unsafe();
ChannelOutboundBuffer buf = unsafe.outboundBuffer();
// 记录了出站缓冲区相关的数据，buf 对象的 hash 码，和 buf 的剩余缓冲字节数
if (buf != null) {
lastMessageHashCode = System.identityHashCode(buf.current());
lastPendingWriteBytes = buf.totalPendingWriteBytes();
}
}
}
复制代码
读事件的 run 方法
代码如下：

复制代码
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.
    // 用于取消任务 promise
    readerIdleTimeout = schedule(ctx, this, readerIdleTimeNanos, TimeUnit.NANOSECONDS);

    boolean first = firstReaderIdleEvent;
    firstReaderIdleEvent = false;

    try {
        // 再次提交任务
        IdleStateEvent event = newIdleStateEvent(IdleState.READER_IDLE, first);
        // 触发用户 handler use
        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);
}

}
复制代码
nextDelay的初始化值为超时秒数readerIdleTimeNanos，如果检测的时候没有正在读，且计算多久没读了：nextDelay -= 当前时间 - 上次读取时间，如果小于0，说明左边的readerIdleTimeNanos小于空闲时间（当前时间 - 上次读取时间）了，则超时了
则创建IdleStateEvent事件，IdleState枚举值为READER_IDLE，然后调用channelIdle方法分发给下一个ChannelInboundHandler，通常由用户自定义一个ChannelInboundHandler来捕获并处理

总的来说，每次读取操作都会记录一个时间，定时任务时间到了，会计算当前时间和最后一次读的时间的间隔，如果间隔超过了设置的时间，就触发 UserEventTriggered 方法。就是这么简单。

写事件的 run 方法
写任务的逻辑基本和读任务的逻辑一样，唯一不同的就是有一个针对出站较慢数据的判断。

if (hasOutputChanged(ctx, first)) {
return;
}
如果这个方法返回 true，就不执行触发事件操作了，即使时间到了。看看该方法实现：

复制代码
private boolean hasOutputChanged(ChannelHandlerContext ctx, boolean first) {
if (observeOutput) {
// 如果最后一次写的时间和上一次记录的时间不一样，说明写操作进行过了，则更新此值
if (lastChangeCheckTimeStamp != lastWriteTime) {
lastChangeCheckTimeStamp = lastWriteTime;
// 但如果，在这个方法的调用间隙修改的，就仍然不触发事件
if (!first) { // #firstWriterIdleEvent or #firstAllIdleEvent
return true;
}
}
Channel channel = ctx.channel();
Unsafe unsafe = channel.unsafe();
ChannelOutboundBuffer buf = unsafe.outboundBuffer();
// 如果出站区有数据
if (buf != null) {
// 拿到出站缓冲区的对象 hashcode
int messageHashCode = System.identityHashCode(buf.current());
// 拿到这个缓冲区的所有字节
long pendingWriteBytes = buf.totalPendingWriteBytes();
// 如果和之前的不相等，或者字节数不同，说明，输出有变化，将 “最后一个缓冲区引用” 和 “剩余字节数” 刷新
if (messageHashCode != lastMessageHashCode || pendingWriteBytes != lastPendingWriteBytes) {
lastMessageHashCode = messageHashCode;
lastPendingWriteBytes = pendingWriteBytes;
// 如果写操作没有进行过，则任务写的慢，不触发空闲事件
if (!first) {
return true;
}
}
}
}
return false;
}
复制代码
如果用户没有设置了需要观察出站情况。就返回 false，继续执行事件。
反之，继续向下，如果最后一次写的时间和上一次记录的时间不一样，说明写操作刚刚做过了，则更新此值，但仍然需要判断这个 first 的值，如果这个值还是 false，说明在这个写事件是在两个方法调用间隙完成的 / 或者是第一次访问这个方法，就仍然不触发事件。
如果不满足上面的条件，就取出缓冲区对象，如果缓冲区没对象了，说明没有发生写的很慢的事件，就触发空闲事件。反之，记录当前缓冲区对象的 hashcode 和剩余字节数，再和之前的比较，如果任意一个不相等，说明数据在变化，或者说数据在慢慢的写出去。那么就更新这两个值，留在下一次判断。
继续判断 first ，如果是 fasle，说明这是第二次调用，就不用触发空闲事件了。
所有事件的 run 方法
这个类叫做 AllIdleTimeoutTask ，表示这个监控着所有的事件。当读写事件发生时，都会记录。代码逻辑和写事件的的基本一致，除了这里：

复制代码
long nextDelay = allIdleTimeNanos;
if (!reading) {
// 当前时间减去最后一次写或读的时间，若大于0，说明超时了
nextDelay -= ticksInNanos() - Math.max(lastReadTime, lastWriteTime);
}
复制代码
这里的时间计算是取读写事件中的最大值来的。然后像写事件一样，判断是否发生了写的慢的情况。最后调用 ctx.fireUserEventTriggered(evt) 方法。

通常这个使用的是最多的。构造方法一般是：

pipeline.addLast(new IdleStateHandler(0, 0, 30, TimeUnit.SECONDS));
深圳网站建设www.sz886.com

福伴

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
基于Netty的IdleStateHandler实现

什么是 IdleStateHandler当连接的空闲时间（读或者写）太长时，将会触发一个 IdleStateEvent 事件。然后，你可以通过你的 ChannelInboundHandler 中重写 userEventTrigged 方法来处理该事件。如何使用？IdleStateHandler 既是出站处理器也是入站处理器，继承了 ChannelDuplexHandler 。通常在 init...
复制链接

扫一扫