Netty 使用 EmbeddedChannel 进行单元测试

最新推荐文章于 2025-03-01 23:34:23 发布
原创 最新推荐文章于 2025-03-01 23:34:23 发布 · 3k 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Netty #EmbeddedChannel #单元测试 #Junit

本文介绍了如何在Netty中利用EmbeddedChannel对入站处理器、出站处理器及异常捕获进行单元测试，详细阐述了各个测试环节。

Netty 使用 EmbeddedChannel 进行单元测试


对于 Netty 的 ChannelHandler 进行单元测试，Netty 提供了 EmbeddedChannel 嵌入式通道来完成这一过程，主要使用该通道来测试数据的入站出站过程是否合法；
该通道提供以下常用的 API：
writeInbound 写一个入站消息到 EmbeddedChannel。 如果数据能从 EmbeddedChannel 通过 readInbound() 读到，则返回 true；
readInbound 从 EmbeddedChannel 读到入站消息。任何返回遍历整个ChannelPipeline。如果读取还没有准备，则此方法返回 null；
writeOutbound 写一个出站消息到 EmbeddedChannel。 如果数据能从 EmbeddedChannel 通过 readOutbound() 读到，则返回 true；
readOutbound 从 EmbeddedChannel 读到出站消息。任何返回遍历整个ChannelPipeline。如果读取还没有准备，则此方法返回 null；
Finish 如果从入站或者出站中能读到数据，标记 EmbeddedChannel 完成并且返回。这同时会调用 EmbeddedChannel 的关闭方法；
完整 API 见： http://netty.io/4.1/api/io/netty/channel/embedded/EmbeddedChannel.html

以下图示了 ChannelPipeline 使用 EmbeddedChannel 的方法：



入站处理器测试

以下测试一个入站解码器 FixedLengthFrameDecoder;
FixedLengthFrameDecoder
  
//用于进行测试的 Decoder，将读取的帧分隔为固定长度
public class FixedLengthFrameDecoder extends ByteToMessageDecoder {
           
           
​
    private final int frameLength;   //帧长度
​
    public FixedLengthFrameDecoder(int frameLength) {
           
           
        this.frameLength = frameLength;
    }
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
           
           
        //帧分割
        while(in.readableBytes() >= frameLength)
            out.add(in.readBytes(frameLength));

        

       

      

     

    

   

  

 



                

        

    



  


        

            

                      
                        最低0.47元/天 解锁文章
                          
                      
            

        


    



                



	

		

			

				
					
Netty学习笔记之EmbededChannel 单元测试

				
			

			

				

					qq_38767992的博客
				

				

					02-10
					
					542
					
				

			

		

		

			
				
public class FixedLengthFrameDecoder extends ByteToMessageDecoder {private final int frameLength;public FixedLengthFrameDecoder(int frameLength){if (frameLength &lt;= 0) {throw new IllegalArgumentExce...

			
		

	



                

            
              



	

		

			

				
					
Netty详解（三）：Pipeline介绍

				
			

			

				

					在都市的雨幕下找寻自我
				

				

					08-19
					
					1452
					
				

			

		

		

			
				
Pipeline是一条Netty管道流水线，一条管道需要很多Handler处理器来处理业务。Netty的业务处理器流水线ChannelPipeline是基于责任链设计模式（Chain of Responsibility）来设计的，内部是一个双向链表结构，能够支持动态地添加和删除Handler业务处理器。

			
		

	



              


  
              

                


	

		

			

				
					
Netty核心原理与基础实战（三）——详解Channel、Handler

				
			

			

				

					geminigoth的博客
				

				

					02-04
					
					1565
					
				

			

		

		

			
				
通道是Netty的核心概念之一，代表网路连接，有它负责同对端网络进行网络通信，既可以写入数据到对端，也可以从对端读取数据。AbstractChannel内部有一个pipeline属性，表示处理器的流水线。Netty在对通道进行初始化的时候，将pipiline属性初始化为DefaultChannelPipeline的实例。以上代码表明每个通道都拥有一条ChannelPipeline处理器流水线。AbstractChannel内部有一个parent父通道属性，保持通道的父通道。

			
		

	





	

		

			

				
					
Netty——EmbeddedChannel类

				
			

			

				

					吴声子夜歌的博客
				

				

					06-16
					
					2843
					
				

			

		

		

			
				
EmbeddedChannel类
Netty 提供了它所谓的 Embedded 传输，用于测试 ChannelHandler。这个传输是一种特殊的 Channel 实现— EmbeddedChannel— 的功能，这个实现提供了通过 ChannelPipeline 传播事件的简便方法。
这个想法是直截了当的:将入站数据或者出站数据写入到 EmbeddedChannel 中，然后检 查是否有任何东西到达了 ChannelPipeline 的尾端。以这种方式，你便可以确定消息是否已 经被编码或者被解码过了，以及

			
		

	



		

			
		



	

		

			

				
					
Netty 系列五（单元测试）.

				
			

			

				

					weixin_34343000的博客
				

				

					07-13
					
					215
					
				

			

		

		

			
				
一、概述和原理
  Netty 的单元测试，主要是对业务逻辑的 ChannelHandler 做测试（毕竟对 Bootstrap、EventLoop 这些做测试着实没有多大意义），模拟一次入站数据或者出站数据，查看数据流经 ChannelHandler 变成什么样了，以此达到测试的目的。
  Netty 的单元测试将Junit4作为测试框架，将 ...

			
		

	





	

		

			

				
					
Netty 框架学习 —— 单元测试

				
			

			

				

					低吟不作语的博客
				

				

					06-25
					
					391
					
				

			

		

		

			
				
EmbeddedChannel 概述
ChannelHandler 是 Netty 程序的关键元素，所以彻底地测试它们应该是你的开发过程中的一个标准部分，EmbeddedChannel 是 Netty 专门为改进针对 ChannelHandler 的单元测试而提供的。Netty 提供了它所谓的 Embedded 传输，这个传输是 EmbeddedChannel 的功能，提供了通过 ChannelPipeline 传播事件的简便方法
这个方法是：将入站数据或者出站数据写入到 EmbeddedChannel .

			
		

	





	

		

			

				
					
Netty实战（九）单元测试

				
			

			

				

					一起学习一起进步~
				

				

					05-29
					
					1386
					
				

			

		

		

			
				
单元测试的基本思想是：以尽可能小的区块测试代码，并且尽可能地和其他的代码模块以及运行时的依赖（如数据库和网络）相隔离。如果应用程序能通过测试验证每个单元本身都能够正常地工作，那么在出了问题时将可以更加容易地找出根本原因。ChannelHandler 是 Netty 应用程序的关键元素，所以彻底地测试它们应该是开发过程的一个标准部分。最佳实践要求你的测试不仅要能够证明实现是正确的，而且还要能够很容易地隔离那些因修改代码而突然出现的问题。这种类型的测试叫作单元测试。

			
		

	





	

		

			

				
					
【Netty】一文入门Netty开发高性能网络框架

				
			

			

				

					xiaoxualg的博客
				

				

					03-01
					
					1555
					
				

			

		

		

			
				
Netty不看重Windows上的使用，在Linux系统上，AIO的底层实现仍使用EPOLL，没有很好实现AIO，因此在性能上没有明显的优势，而且被JDK封装了一层不容易深度优化。
AIO还有个缺点是接收数据需要预先分配缓存, 而不是NIO那种需要接收时才需要分配缓存, 所以对连接数量非常大但流量小的情况, 内存浪费很多。
而且Linux上AIO不够成熟，处理回调结果速度跟不上处理需求。

			
		

	





	

		

			

				
					
EmbededChannel 单元测试

				
			

			

				

					yhs1296997148的博客
				

				

					06-09
					
					423
					
				

			

		

		

			
				
概述    前面的章节已经对 Netty 的各个组件进行了学习即使用。了解到 Netty 在使用的过程中，基本上所有的程序逻辑部分的主体都是在 ChannelHandler 中完成的，所以对 ChannelHandler 进行认真仔细的测试是很重要的一个环节了。那么，如何很好的测试 ChannelHandler 了？答案就是 EmbededChannel 。EmbededChannel    Em...

			
		

	





	

		

			

				
					
netty使用EmbeddedChannel对channel的出入站进行单元测试

				
			

			

				

					
				

				

					08-02
					
					283
					
				

			

		

		

			
				
一种特殊的Channel实现----EmbeddedChannel，它是Netty专门为改进针对ChannelHandler的单元测试而提供的。



名称
职责




writeInbound
将入站消息写到EmbeddedChannel中。如果可以通过readInbound方法从Embe...

			
		

	





	

		

			

				
					
Netty In Action中文版 - 第十章：单元测试代码

				
			

			

				

					堆码时刻
				

				

					07-30
					
					5212
					
				

			

		

		

			
				
本章介绍


单元测试
EmbeddedChannel

        学会了使用一个或多个ChannelHandler处理接收/发送数据消息，但是如何测试它们呢？Netty提供了2个额外的类使得测试ChannelHandler变得很容易，本章讲解如何测试Netty程序。测试使用JUnit4，如果不会用可以慢慢了解。JUnit4很简单，但是功能很强大。本章将重点讲解测试已实现的Cha

			
		

	





	

		

			

				
					
netty(八）--EmbeddedChannel单元测试

				
			

			

				

					ljz2016的博客
				

				

					09-29
					
					2013
					
				

			

		

		

			
				
最佳实践要求你的测试不仅要能够证明你的实现是正确的，而且容易隔离那些因修改代码而突然出现的问题。这种类型的测试叫做单元测试。
EmbeddedChannel是netty专门改进针对ChannelHandler的单元测试而提供的。
核心方法：

数据流：


测试入站消息

...

			
		

	





	

		

			

				
					
netty如何进行单元测试

				
			

			

				

					weixin_30325071的博客
				

				

					07-17
					
					438
					
				

			

		

		

			
				
一种特殊的Channel 实现——EmbeddedChannel，它是Netty 专门为改进针对ChannelHandler 的单元测试而提供的。
将入站数据或者出站数据写入到EmbeddedChannel 中，然后检查是否有任何东西到达了ChannelPipeline 的尾端。以这种方式，你便可以确定消息是否已经被编码或者被解码过了，以及是否触发了任何的ChannelHandler 动作。
...

			
		

	





	

		

			

				
					
Netty单元测试

				
			

			

				

					大智制杖
				

				

					03-17
					
					300
					
				

			

		

		

			
				
感慨
一晃两年多了，自从刚开始给公司编写的几个网络模块，后来就没有在度使用的机会了。
讲解Netty的书籍有许多，其中《Netty实战》这本书比较经典，推荐大家用这本书入门。
概述
工欲善其事，必先利其器。
作为一个网络处理框架，如果没有脱离网络的单元测试，那么你要构建完整的一套代码，方能测试相应功能，是无法想象的。
ChannelHandler 是 Netty 应用程序的关键元素，无非就是处理输...

			
		

	





	

		

			

				
					
netty篇-单元测试

				
			

			

				

					StivenYang
				

				

					08-06
					
					229
					
				

			

		

		

			
				
netty篇-单元测试


			
		

	





	

		

			

				
					
netty(6)--单元测试

				
			

			

				

					TOPsnap的博客
				

				

					02-24
					
					702
					
				

			

		

		

			
				
netty单元测试

			
		

	





	

		

			

				
					
Netty4实战第十章：Netty应用的单元测试

				
			

			

				

					wangjinnan16的博客
				

				

					10-11
					
					3365
					
				

			

		

		

			
				
本章主要内容：



单元测试

EmbeddedChannel

			
		

	





	

		

			

				
					
Java NIO框架Netty教程(十一) 并发访问测试(上)

				
			

			

				

					jackwu_2015的博客
				

				

					07-01
					
					2053
					
				

			

		

		

			
				
之前更新了几篇关于JVM研究的文章，其实也是在做本篇文章验证的时候，跑的有点远，呵呵。回归Netty教程，这次要讲的其实是针对一个问题的研究和验证结论。另外，最近工作比较忙，所以可能会分文章更新一些阶段性的成果，而不是全部汇总更新，以免间隔过久。

起因是一个朋友，通过微博(OneCoder腾讯微博、OneCoder新浪微博、OneCoder网易微博、OneCoder搜狐微博)私信给我一个问题

			
		

	





	

		

			

				
					
Netty（7）netty提供调试的工具类：EmbeddedChannel

				
			

			

				

					учёба
				

				

					08-23
					
					694
					
				

			

		

		

			
				
可以使用这个工具类对Pipeline直接进行调试，而不需要启动客户端去调试。

			
		

	





	

		

			

				
					
netty单元测试

					
最新发布

				
			

			

				

					08-26
				

			

		

		

			
				
<think>我们希望对Netty的channelRead方法进行单元测试。channelRead方法是ChannelInboundHandlerAdapter的一个方法，当有数据读取时会被触发。在单元测试中，我们需要模拟一个ChannelHandlerContext和一个消息对象，然后调用channelRead方法，并验证其行为。

 根据引用[1]中提到的Netty内部机制，我们可以利用Netty提供的EmbeddedChannel来进行测试。EmbeddedChannel是Netty专门为单元测试提供的工具，它允许我们在不启动真实网络服务的情况下测试ChannelHandler。

 测试步骤：
 1. 创建EmbeddedChannel实例，并将待测试的Handler添加到其pipeline中。
 2. 构造测试消息（MyMessage对象）。
 3. 调用EmbeddedChannel的writeInbound方法，将消息写入，这会触发channelRead方法。
 4. 验证Handler的行为：
    - 是否打印了日志（可以通过捕获日志输出验证）
    - 是否调用了ctx.channel().close()（可以通过EmbeddedChannel的状态验证）
 5. 清理资源。

 注意：由于在channelRead方法中调用了ctx.channel().close()，我们需要检查EmbeddedChannel是否被关闭。

 另外，日志记录（log.info）可能会干扰单元测试，我们可以使用日志框架的测试支持（如SLF4J的测试实现）或者捕获日志输出。

 下面是一个示例测试代码：

 假设我们的Handler类名为MyClientHandler，代码如下：
 ```java
 public class MyClientHandler extends SimpleChannelInboundHandler<MyMessage> {
     private static final Logger log = LoggerFactory.getLogger(MyClientHandler.class);

     @Override
     protected void channelRead0(ChannelHandlerContext ctx, MyMessage msg) throws Exception {
         log.info("收到服务端{}的消息：{}", ctx.channel().remoteAddress(), msg.toString());
         ctx.channel().close();
     }
 }
 ```

 单元测试（使用JUnit和Mockito，以及Netty的EmbeddedChannel）：
 ```java
 import io.netty.channel.embedded.EmbeddedChannel;
 import org.junit.jupiter.api.Test;
 import org.slf4j.LoggerFactory;
 import ch.qos.logback.classic.Level;
 import ch.qos.logback.classic.Logger;
 import ch.qos.logback.classic.spi.ILoggingEvent;
 import ch.qos.logback.core.Appender;
 import org.mockito.ArgumentCaptor;
 import org.mockito.Captor;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;

 import static org.junit.jupiter.api.Assertions.*;
 import static org.mockito.Mockito.*;

 public class MyClientHandlerTest {

     @Mock
     private Appender<ILoggingEvent> mockAppender;

     @Captor
     private ArgumentCaptor<ILoggingEvent> captorLoggingEvent;

     @Test
     public void testChannelRead() {
         // 初始化Mockito
         MockitoAnnotations.openMocks(this);

         // 获取根Logger并添加mockAppender，以便捕获日志
         Logger root = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
         root.addAppender(mockAppender);
         root.setLevel(Level.INFO);

         // 创建EmbeddedChannel并添加Handler
         EmbeddedChannel channel = new EmbeddedChannel(new MyClientHandler());

         // 构造测试消息
         MyMessage testMsg = new MyMessage(); // 假设有合适的构造方法或setter

         // 写入入站消息，触发channelRead
         channel.writeInbound(testMsg);

         // 验证日志：捕获日志事件并检查内容
         verify(mockAppender, atLeastOnce()).doAppend(captorLoggingEvent.capture());
         ILoggingEvent loggingEvent = captorLoggingEvent.getAllValues().stream()
                 .filter(event -> event.getLevel().equals(Level.INFO))
                 .findFirst()
                 .orElse(null);
         assertNotNull(loggingEvent, "没有找到INFO级别的日志");
         assertTrue(loggingEvent.getFormattedMessage().contains("收到服务端"));

         // 验证channel是否关闭（因为Handler中调用了close）
         assertFalse(channel.isOpen(), "Channel应该被关闭");

         // 清理：移除mockAppender
         root.detachAppender(mockAppender);
     }
 }
 ```

 注意：
 1. 上述测试使用了Logback的测试方式，如果使用其他日志框架，需要相应调整。
 2. 如果不想测试日志，可以去掉日志捕获部分，只测试行为（如关闭channel）。
 3. 如果MyMessage类没有默认构造方法，需要根据实际情况构造。

 另一种简化测试（不验证日志，只验证行为）：
 ```java
 @Test
 public void testChannelReadWithoutLogging() {
     EmbeddedChannel channel = new EmbeddedChannel(new MyClientHandler());
     MyMessage testMsg = new MyMessage();
     channel.writeInbound(testMsg);
     // 验证channel是否关闭
     assertFalse(channel.isOpen());
 }
 ```

 如果日志输出是必须测试的，那么使用Mockito捕获日志事件是一种方式。另外，也可以使用内存日志（如logback-mock）或者使用System.setOut重定向标准输出（如果日志输出到控制台）来验证。

 另外，在Handler中调用了ctx.channel().close()，这会触发Channel的关闭，我们可以通过EmbeddedChannel的isOpen()方法来判断。

 问题：如果Handler中调用了ctx.channel().close()，那么EmbeddedChannel会立即关闭吗？
 答案：是的，因为EmbeddedChannel是同步执行的，所以写入消息后，Handler会立即执行，关闭操作也会立即生效。

 总结：使用EmbeddedChannel可以方便地测试Netty的Handler，包括入站和出站操作。

 相关问题：
 1. 如何测试Netty的编码器（Encoder）和解码器（Decoder）？
 2. 如何使用EmbeddedChannel测试多个Handler组成的pipeline？
 3. 如何模拟ChannelHandlerContext的其他行为（如写入出站消息）？</think>### 如何对 Netty 的 `channelRead` 方法进行单元测试

在 Netty 中进行单元测试的核心是使用 **`EmbeddedChannel`** 类（Netty 专为测试提供的工具类），结合 Mockito 等测试框架模拟依赖对象。以下是详细测试方案：

#### 一、测试环境搭建
```java
// 测试依赖
dependencies {
    testImplementation 'io.netty:netty-all:4.1.86.Final'
    testImplementation 'org.mockito:mockito-core:4.8.0'
    testImplementation 'junit:junit:4.13.2'
}
```

#### 二、核心测试步骤（使用 `EmbeddedChannel`）
```java
import io.netty.channel.embedded.EmbeddedChannel;
import org.junit.Test;

public class MyHandlerTest {

    @Test
    public void testChannelRead() {
        // 1. 创建待测试的Handler
        MyHandler handler = new MyHandler();
        
        // 2. 创建嵌入式Channel（自动绑定handler）
        EmbeddedChannel channel = new EmbeddedChannel(handler);
        
        // 3. 构造测试消息
        MyMessage testMsg = new MyMessage("TestContent");
        
        // 4. 触发channelRead事件
        channel.writeInbound(testMsg);
        
        // 5. 验证行为
        assertFalse("Channel应被关闭", channel.isOpen()); // 验证关闭
        assertEquals("应处理1条消息", 1, handler.getProcessedCount());
    }
}
```

#### 三、关键验证点
1. **消息处理验证**  
   ```java
   // 检查入站消息是否被正确消费
   assertNull("消息应被消费", channel.readInbound());
   ```

2. **日志输出验证**（使用 Mockito）  
   ```java
   @Mock
   private Logger mockLogger;

   @Test
   public void testLogOutput() {
       MyHandler handler = new MyHandler(mockLogger); // 注入mock日志
       EmbeddedChannel channel = new EmbeddedChannel(handler);
       
       channel.writeInbound(new MyMessage("test"));
       
       // 验证日志调用
       verify(mockLogger).info(contains("收到服务端"), anyString(), any(MyMessage.class));
   }
   ```

3. **关闭行为验证**  
   ```java
   // 检查是否触发closeFuture
   ChannelFuture closeFuture = channel.closeFuture();
   assertTrue("关闭应完成", closeFuture.isDone());
   ```

#### 四、处理异步操作
当 Handler 包含异步逻辑时：
```java
@Test
public void testAsyncOperation() throws InterruptedException {
    EmbeddedChannel channel = new EmbeddedChannel(new AsyncHandler());
    
    // 触发异步操作
    channel.writeInbound(new MyMessage());
    
    // 等待异步完成
    channel.runPendingTasks(); // 执行待处理任务
    
    // 验证结果
    assertTrue(channel.readOutbound() instanceof ResultMessage);
}
```

#### 五、完整测试类示例
```java
public class MyHandlerTest {
    
    @Test
    public void fullChannelReadTest() {
        // 初始化
        MyHandler handler = new MyHandler();
        EmbeddedChannel channel = new EmbeddedChannel(handler);
        
        // 执行测试
        MyMessage msg = new MyMessage("TestData");
        assertTrue(channel.writeInbound(msg));
        
        // 验证行为
        assertFalse("Channel未关闭", channel.isOpen());
        assertNull("存在未处理消息", channel.readInbound());
        
        // 验证关闭原因（若有）
        Throwable cause = channel.closeCause();
        assertNull("异常关闭", cause);
    }
}
```

#### 六、测试覆盖率提升技巧
1. **边界测试**  
   ```java
   // 测试空消息
   channel.writeInbound(Unpooled.EMPTY_BUFFER);
   ```
   
2. **异常场景**  
   ```java
   // 强制抛出异常
   channel.pipeline().fireExceptionCaught(new RuntimeException("Test"));
   assertNotNull(channel.closeCause());
   ```

3. **多消息顺序测试**  
   ```java
   channel.writeInbound(msg1, msg2, msg3);
   assertEquals(3, handler.getProcessedCount());
   ```

> **关键点**：  
> 1. 使用 `EmbeddedChannel` 模拟真实 Channel 行为[^1]  
> 2. 通过 `writeInbound()`/`readOutbound()` 控制数据流  
> 3. 结合 Mockito 验证日志等副作用  
> 4. 用 `runPendingTasks()` 处理异步逻辑

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值