Netty——EmbeddedChannel类

最新推荐文章于 2024-02-04 09:30:00 发布
最新推荐文章于 2024-02-04 09:30:00 发布
阅读量2.5k 收藏 5
点赞数 1
分类专栏： Netty 文章标签： EmbeddedChannel
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cold___play/article/details/106781971
版权

EmbeddedChannel类

Netty 提供了它所谓的 Embedded 传输，用于测试 ChannelHandler。这个传输是一种特殊的 Channel 实现— EmbeddedChannel— 的功能，这个实现提供了通过 ChannelPipeline 传播事件的简便方法。

这个想法是直截了当的:将入站数据或者出站数据写入到 EmbeddedChannel 中，然后检 查是否有任何东西到达了 ChannelPipeline 的尾端。以这种方式，你便可以确定消息是否已 经被编码或者被解码过了，以及是否触发了任何的 ChannelHandler 动作。

在这里插入图片描述

入站数据由 ChannelInboundHandler 处理，代表从远程节点读取的数据。出站数据由 ChannelOutboundHandler 处理，代表将要写到远程节点的数据。根据你要测试的 ChannelHandler，你将使用*Inbound()或者*Outbound()方法对，或者兼而有之。

下图展示了使用 EmbeddedChannel 的方法，数据是如何流经 ChannelPipeline 的。 你可以使用 writeOutbound()方法将消息写到 Channel 中，并通过 ChannelPipeline 沿 着出站的方向传递。随后，你可以使用 readOutbound()方法来读取已被处理过的消息，以确 定结果是否和预期一样。类似地，对于入站数据，你需要使用 writeInbound()和 readInbound() 方法。

在这里插入图片描述
在每种情况下，消息都将会传递过 ChannelPipeline，并且被相关的 ChannelInbound- Handler 或者 ChannelOutboundHandler 处理。如果消息没有被消费，那么你可以使用 readInbound()或者 readOutbound()方法来在处理过了这些消息之后，酌情把它们从 Channel 中读出来。

使用EmbeddedChannel测试ChannelHandler

测试入站消息：
下图展示了一个简单的ByteToMessageDecoder实现。给定足够的数据，这个实现将 产生固定大小的帧。如果没有足够的数据可供读取，它将等待下一个数据块的到来，并将再次检 查是否能够产生一个新的帧。
在这里插入图片描述
这个特定的解码器将产生固定为 3 字节大小的帧。
因此，它可能会需要多个事件来提供足够的字节数以产生一个帧。最终，每个帧都会被传递给 ChannelPipeline 中的下一个 ChannelHandler。该解码器的实现，如下所示：

public class FixedLengthFrameDecoder extends ByteToMessageDecoder {
    private final int frameLength;

    public FixedLengthFrameDecoder(int frameLength) {
        if (frameLength <= 0) {
            throw new IllegalArgumentException("frameLength must be a positive integer:" + frameLength);
        }
        this.frameLength = frameLength;
    }

    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        //检查是否有足够的字节可以被读取，以生成下一个帧
        while (in.readableBytes() >= frameLength) {
            //从ByteBuf中读取一个新帧
            ByteBuf buf = in.readBytes(frameLength);
            //将该帧添加到已被解码的消息列表中
            out.add(buf);
        }
    }
}

测试FixedLengthFrameDecoder：

public class FixedLengthFrameDecoderTest {
    @Test
    public void testFrameDecoded() {
        //创建一个ByteBuf，并存储9字节
        ByteBuf buf = Unpooled.buffer();
        for (int i = 0; i < 9; i++) {
            buf.writeByte(i);
        }
        ByteBuf input = buf.duplicate();
        EmbeddedChannel channel = new EmbeddedChannel(new FixedLengthFrameDecoder(3));
        //将数据写入EmbeddedChannel
        System.out.println(channel.writeInbound(input.retain()));//true
        //标记Channel为已完成状态
        System.out.println(channel.finish());//true

        //读取所生成的消息，并且验证是否有3帧，其中每帧都为3字节
        ByteBuf read = channel.readInbound();
        System.out.println(buf.readSlice(3).equals(read));//true

        read = channel.readInbound();
        System.out.println(buf.readSlice(3).equals(read));//true
        read.release();

        read = channel.readInbound();
        System.out.println(buf.readSlice(3).equals(read));//true
        read.release();

        System.out.println(channel.readInbound() == null);//true
        buf.release();
    }

    @Test
    public void testFramesDescode2() {
        ByteBuf buf = Unpooled.buffer();
        for (int i = 0; i < 9; i++) {
            buf.writeByte(i);
        }
        ByteBuf input = buf.duplicate();
        EmbeddedChannel channel = new EmbeddedChannel(new FixedLengthFrameDecoder(3));
        //返回false，因为没有一个完整的可供读取的帧
        System.out.println(channel.writeInbound(input.readBytes(2)));//false
        System.out.println(channel.writeInbound(input.readBytes(7)));//true

        System.out.println(channel.finish());//true
        ByteBuf read = channel.readInbound();
        System.out.println(buf.readSlice(3) == read);//false
        read.release();

        read = channel.readInbound();
        System.out.println(buf.readSlice(3) == read);//false
        read.release();

        read = channel.readInbound();
        System.out.println(buf.readSlice(3) == read);//false
        read.release();

        System.out.println(channel.readInbound() == null);//true
        buf.release();
    }

}

该 testFramesDecoded()方法验证了:一个包含 9 个可读字节的 ByteBuf 被解码为 3 个 ByteBuf，每个都包含了 3 字节。需要注意的是，仅通过一次对 writeInbound()方法的调 用，ByteBuf 是如何被填充了 9 个可读字节的。在此之后，通过执行 finish()方法，将 EmbeddedChannel 标记为了已完成状态。最后，通过调用 readInbound()方法，从 Embedded- Channel 中正好读取了 3 个帧和一个 null。
testFramesDecoded2()方法也是类似的，只有一处不同:入站 ByteBuf 是通过两个步 骤写入的。当 writeInbound(input.readBytes(2))被调用时，返回了 false。为什么呢? 正如同上表中所描述的，如果对 readInbound()的后续调用将会返回数据，那么 write- Inbound()方法将会返回 true。但是只有当有 3 个或者更多的字节可供读取时，FixedLengthFrameDecoder 才会产生输出。该测试剩下的部分和 testFramesDecoded()是相同的。

测试出站消息

测试出站消息的处理过程和刚才所看到的类似。在下面的例子中，我们将会展示如何使用 EmbeddedChannel 来测试一个编码器形式的 ChannelOutboundHandler，编码器是一种 将一种消息格式转换为另一种的组件。

AbsIntegerEncoder，它是 Netty 的 MessageToMessageEncoder 的一个特殊化的实现，用于将负值整数转换为绝对值。

该示例将会按照下列方式工作:

  • 持有 AbsIntegerEncoder 的 EmbeddedChannel 将会以 4 字节的负整数的形式写出站数据;
  • 编码器将从传入的 ByteBuf 中读取每个负整数，并将会调用 Math.abs()方法来获取其绝对值;
  • 编码器将会把每个负整数的绝对值写到 ChannelPipeline 中。
    在这里插入图片描述
public class AbsIntegerEncoder extends MessageToMessageEncoder<ByteBuf> {
    @Override
    protected void encode(ChannelHandlerContext ctx, ByteBuf msg, List<Object> out) throws Exception {
        while (msg.readableBytes() >= 4) {
            //从输入的ByteBuf中读取下一个整数，并且计算其绝对值
            int value = Math.abs(msg.readInt());
            //将该整数写入到编码消息的List中
            out.add(value);
        }
    }
}

测试AbsIntegerEncoder：

public class AbsIntegerEncoderTest {
    @Test
    public void testEncoded() {
        ByteBuf buf = Unpooled.buffer();
        for (int i = 1; i < 10; i++) {
            buf.writeInt(i * -1);
        }
        //创建一个EmbeddedChanel，并安装一个要测试的AbsIntegerEncoder
        EmbeddedChannel channel = new EmbeddedChannel(new AbsIntegerEncoder());
        //写入ByteBuf，调用readOutbound()方法将会产生数据
        System.out.println(channel.writeOutbound(buf));
        System.out.println(channel.finish());

        channel.readOutbound();
        for (int i = 1; i < 10; i++) {
            int temp = channel.readOutbound();
            System.out.println(temp);
        }
        System.out.println(channel.readOutbound() == null);
    }
}

下面是代码中执行的步骤。

  1. 将 4 字节的负整数写到一个新的 ByteBuf 中。
  2. 创建一个 EmbeddedChannel，并为它分配一个 AbsIntegerEncoder。
  3. 调用 EmbeddedChannel 上的 writeOutbound()方法来写入该 ByteBuf。
  4. 标记该 Channel 为已完成状态。
  5. 从 EmbeddedChannel 的出站端读取所有的整数，并验证是否只产生了绝对值。

测试异常处理：

应用程序通常需要执行比转换数据更加复杂的任务。例如，你可能需要处理格式不正确的输 入或者过量的数据。在下一个示例中，如果所读取的字节数超出了某个特定的限制，我们将会抛 出一个 TooLongFrameException。这是一种经常用来防范资源被耗尽的方法。

在下图中，最大的帧大小已经被设置为 3 字节。如果一个帧的大小超出了该限制，那么程序将 会丢弃它的字节，并抛出一个 TooLongFrameException。位于 ChannelPipeline 中的其他 ChannelHandler 可以选择在 exceptionCaught()方法中处理该异常或者忽略它:
在这里插入图片描述

//扩展ByteToMessageDecoder以将入站字节码为消息
public class FrameChunkDecoder extends ByteToMessageDecoder {
    private final int maxFrameSize;

    public FrameChunkDecoder(int maxFrameSize) {
        this.maxFrameSize = maxFrameSize;
    }

    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        int readableBytes = in.readableBytes();
        if (readableBytes > maxFrameSize) {
            //如果该帧太大，则丢弃它并抛出一个TooLongFrameException
            in.clear();
            throw new TooLongFrameException();
        }
        //否则，从ByteBuf中读取一个新的帧
        ByteBuf buf = in.readBytes(readableBytes);
        //该帧添加到解码消息的List中
        out.add(buf);
    }
}

测试FrameChunkDecoder：

public class FrameChunkDecoderTest {
    @Test
    public void testFramesDecoded() {
        ByteBuf buf = Unpooled.buffer();
        for (int i = 0; i < 9; i++) {
            buf.writeByte(i);
        }
        ByteBuf input = buf.duplicate();

        //创建一个EmbeddedChannel，并向其安装一个帧大小为3字节的FixedLengthFrameDecoder
        EmbeddedChannel channel = new EmbeddedChannel(new FrameChunkDecoder(3));

        System.out.println(channel.writeInbound(input.readBytes(2)));
        try {
            //写入一个4字节大小的帧，并捕获预期的异常
            channel.writeInbound(input.readBytes(4));
        } catch (TooLongFrameException e) {
            e.printStackTrace();
        }

        //写入剩余的2字节，会产生一个有效帧
        System.out.println(channel.writeInbound(input.readBytes(3)));//true
        System.out.println(channel.finish());

        //读取产生的消息，并且验证值
        ByteBuf read = channel.readInbound();
        System.out.println(read.equals(buf.readSlice(2)));//true
        read.release();

        read = channel.readInbound();
        System.out.println(read.equals(buf.skipBytes(4).readSlice(3)));//true
        read.release();
        buf.release();

    }
}

这里使用的try/catch块是EmbeddedChannel的一个特 殊功能。如果其中一个write*方法产生了一个受检查的Exception，那么它将会被包装在一个 RuntimeException中并抛出。这使得可以容易地测试出一个Exception是否在处理数据的 过程中已经被处理了。

吴声子夜歌
关注
专栏目录
Netty 使用 EmbeddedChannel 进行单元测试
Al_assad的博客
03-07 2913
Netty 使用 EmbeddedChannel 进行单元测试对于 Netty 的 ChannelHandler 进行单元测试，Netty 提供了 EmbeddedChannel 嵌入式通道来完成这一过程，主要使用该通道来测试数据的入站出站过程是否合法；该通道提供以下常用的 API：writeInbound 写一个入站消息到 EmbeddedChannel。 如果数据能从 EmbeddedChan...
Netty学习笔记之EmbededChannel 单元测试
qq_38767992的博客
02-10 487
public class FixedLengthFrameDecoder extends ByteToMessageDecoder {private final int frameLength;public FixedLengthFrameDecoder(int frameLength){if (frameLength &lt;= 0) {throw new IllegalArgumentExce...
Netty（7）netty提供调试的工具类：EmbeddedChannel
учёба
08-23 577
可以使用这个工具类对Pipeline直接进行调试，而不需要启动客户端去调试。
netty使用EmbeddedChannel对channel的出入站进行单元测试
08-02 239
一种特殊的Channel实现----EmbeddedChannel，它是Netty专门为改进针对ChannelHandler的单元测试而提供的。 名称 职责 writeInbound 将入站消息写到EmbeddedChannel中。如果可以通过readInbound方法从Embe...
netty(八）--EmbeddedChannel单元测试
ljz2016的博客
09-29 1915
最佳实践要求你的测试不仅要能够证明你的实现是正确的，而且容易隔离那些因修改代码而突然出现的问题。这种类型的测试叫做单元测试。 EmbeddedChannel是netty专门改进针对ChannelHandler的单元测试而提供的。 核心方法： 数据流： 测试入站消息 ...
【Netty】如何防范资源被耗尽？测试工具 EmbeddedChannel
qfzhangwei的专栏
06-08 294
EmbeddedChannel 测试工具： coding import com.google.common.base.Objects; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import io.netty.channel.ChannelHandlerContext; import io.netty.c...
Netty学习4——传输
TomWu的博客
06-04 240
传输1.传输API    传输API的核心是interface Channnel，它被用于所有的I/O操作。    每个Channel都将会被分配一个ChannelPipeline和ChannelConfig。ChannelConfig包含了该Channel的所有配置设置，并且支持热更新。由于支持热更新。由于特定的传输可能具有独特的设置，所以它可能会实现一个ChannelConfig的子类型。  ...
初识Netty原理(三)——解码和编码
monkey-jie的博客
01-05 873
在Netty底层读入的是ByteBuf二进制数据，在实际开发中，需要将它解码为Java的POJO对象，处理完业务后，需要将Java的POJO对象编码为ByteBuf二进制数据放进通道中进行传输。这里就需要使用到Netty的解码器和编码器。 Decoder原理和使用 原理 Netty中的解码器都直接或间接地实现了入站处理适配器，所以在使用时，直接继承解码器就行，而不需要再去实现处理适配器。 在继承解...
Netty实战（四）Netty的传输
一起学习一起进步~
05-17 533
但是，并不是所有的操作系统都支持这一特性。如果为了用于非阻塞 I/O 而重新实现这个简单的应用程序，都需要一次完全的重写的话，那么不难想象，移植真正复杂的应用程序需要付出什么样的努力。虽然这保证了 Netty 的非阻塞 API 可以在任何平台上使用，但它也包含了相应的限制，因为 JDK为了在所有系统上提供相同的功能，必须做出妥协。ps：Netty 的 Channel 实现是线程安全的，因此你可以存储一个到 Channel 的引用，并且每当你需要向远程节点写数据时，都可以使用它，即使当时许多线程都在使用它。
netty学习笔记
qq_38777662的博客
08-12 730
io.netty PART1 Netty——异步和事件驱动 1.netty概述 Netty 是一款异步的事件驱动的网络应用程序框架，支持快速地开发可维护的高性能的面向协议的服务器和客户端。 在网络编程领域，Netty是Java的卓越框架。它驾驭了Java高级API的能力，并将其隐藏在一个易于使用的API之后。Netty使你可以专注于自己真正感兴趣的——你的应用程序的独一无二的价值。 2.netty特性  非阻塞网络调用使得我们可以不必等待一个操作的完成。完全异步的 I/O 正是基于这个特性构建的，并且
Netty简介
weixin_46120888的博客
05-01 1216
文章目录1.什么是Netty?2.一个简单地Netty程序3.Netty执行流程简析3.1服务端准备工作3.2客户端准备工作3.3交互过程4.一些概念的再明确5. EventLoop组件5.1 EventLoop用法5.1.1执行普通任务5.1.2 执行定时任务5.2 eventLoop分工细化5.3源码分析——不同工人之间如何交接6.Channel6.1 ChannelFuture6.1.1 sync()同步处理结果6.1.2 addListener异步处理结果6.1.3 close存在的问题7.在net
EmbededChannel 单元测试
yhs1296997148的博客
06-09 352
概述    前面的章节已经对 Netty 的各个组件进行了学习即使用。了解到 Netty 在使用的过程中，基本上所有的程序逻辑部分的主体都是在 ChannelHandler 中完成的，所以对 ChannelHandler 进行认真仔细的测试是很重要的一个环节了。那么，如何很好的测试 ChannelHandler 了？答案就是 EmbededChannel 。EmbededChannel    Em...
Netty_Day3_netty入门-EmbeddedChannel
weixin_43899452的博客
02-21 255
EmbeddedChannel可以用于测试各个handler，通过其构造函数按顺序传入需要测试handler，然后调用对应的Inbound和Outbound方法即可 public class TestEmbeddedChannel { public static void main(String[] args) { ChannelInboundHandlerAdapter h1 = new ChannelInboundHandlerAdapter() { @O
JAVA(8)-EmbeddedChannel-encode-decode
aggie4628的专栏
07-08 192
数据在网络上传输时都是0，1。数据编码是必然面对的。本文给出了test基本步骤示例。我的感受，改一步测一点。编码：encode 消息体转换成字节数组 解码：decode 字节数组转换成消息体 编码：encode 消息体转换成字节数组 1.建立管道 2.添加编码器 3.在管道里创建一个空间 4.把内容写入管道 5.验证读出来，判断内存值和期望值 //消息转成字节数组 @...
Netty核心原理与基础实战（三）——详解Channel、Handler
最新发布
geminigoth的博客
02-04 1267
通道是Netty的核心概念之一，代表网路连接，有它负责同对端网络进行网络通信，既可以写入数据到对端，也可以从对端读取数据。AbstractChannel内部有一个pipeline属性，表示处理器的流水线。Netty在对通道进行初始化的时候，将pipiline属性初始化为DefaultChannelPipeline的实例。以上代码表明每个通道都拥有一条ChannelPipeline处理器流水线。AbstractChannel内部有一个parent父通道属性，保持通道的父通道。
Netty专栏 （二）——— Netty的重要组件介绍与传输
热门推荐
thinking_fioa的博客
06-05 1万+
  @author 鲁伟林 记录《Netty 实战》中各章节学习过程，写下一些自己的思考和总结，帮助使用Netty框架的开发技术人员们，能够有所得，避免踩坑。 本博客目录结构将严格按照书本《Netty 实战》，省略与Netty无关的内容，可能出现跳小章节。 本博客中涉及的完整代码： GitHub地址: https://github.com/thinkingfioa/netty-learning...
基于Netty实现自定义消息通信协议（协议设计及解析应用实战）
qq_42986622的博客
11-20 2451
所谓的协议，是由语法、语义、时序这三个要素组成的一种规范，通信双方按照该协议规范来实现网络数据传输，这样通信双方才能实现数据正常通信和解析。 由于不同的中间件在功能方面有一定差异，所以其实应该是没有一种标准化协议来满足不同差异化需求，因此很多中间件都会定义自己的通信协议，另外通信协议可以解决粘包和拆包问题。 在本篇文章中，我们来实现一个自定义消息协议。 自定义协议的要素 自定义协议，那这个协议必须要有组成的元素， 魔数：用来判断数据包的有效性 版本号：可以支持协议升级 序列
Netty实战（九）单元测试
一起学习一起进步~
05-29 1234
单元测试的基本思想是：以尽可能小的区块测试代码，并且尽可能地和其他的代码模块以及运行时的依赖（如数据库和网络）相隔离。如果应用程序能通过测试验证每个单元本身都能够正常地工作，那么在出了问题时将可以更加容易地找出根本原因。ChannelHandler 是 Netty 应用程序的关键元素，所以彻底地测试它们应该是开发过程的一个标准部分。最佳实践要求你的测试不仅要能够证明实现是正确的，而且还要能够很容易地隔离那些因修改代码而突然出现的问题。这种类型的测试叫作单元测试。
Netty kqueue传输类中英API文档合辑
资源摘要信息: "Netty是一个高性能的异步事件驱动的网络应用框架，它可以帮助开发者快速地开发可维护的高性能协议服务器和客户端。在当前版本中，我们提供了针对kqueue的网络传输类库支持，kqueue是FreeBSD操作系统...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值