首页 文章 精选 留言 我的

Netty In Action中文版 - 第七章：编解码器Codec

2018-03-13 585

Netty In Action中文版 - 第七章：编解码器Codec

本章介绍

  • Codec，编解码器
  • Decoder，解码器
  • Encoder，编码器

Netty提供了编解码器框架，使得编写自定义的编解码器很容易，并且也很容易重用和封装。本章讨论Netty的编解码器框架以及使用。

7.1 编解码器Codec

        编写一个网络应用程序需要实现某种编解码器，编解码器的作用就是讲原始字节数据与自定义的消息对象进行互转。网络中都是以字节码的数据形式来传输数据的，服务器编码数据后发送到客户端，客户端需要对数据进行解码，因为编解码器由两部分组成：
  • Decoder(解码器)
  • Encoder(编码器)

解码器负责将消息从字节或其他序列形式转成指定的消息对象，编码器则相反；解码器负责处理“入站”数据，编码器负责处理“出站”数据。编码器和解码器的结构很简单，消息被编码后解码后会自动通过ReferenceCountUtil.release(message)释放，如果不想释放消息可以使用ReferenceCountUtil.retain(message)，这将会使引用数量增加而没有消息发布，大多数时候不需要这么做。

7.2 解码器

        Netty提供了丰富的解码器抽象基类，我们可以很容易的实现这些基类来自定义解码器。下面是解码器的一个类型：
  • 解码字节到消息
  • 解码消息到消息
  • 解码消息到字节

本章将概述不同的抽象基类，来帮助了解解码器的实现。深入了解Netty提供的解码器之前先了解解码器的作用是什么？解码器负责解码“入站”数据从一种格式到另一种格式，解码器处理入站数据是抽象ChannelInboundHandler的实现。实践中使用解码器很简单，就是将入站数据转换格式后传递到ChannelPipeline中的下一个ChannelInboundHandler进行处理；这样的处理时很灵活的，我们可以将解码器放在ChannelPipeline中，重用逻辑。

7.2.1 ByteToMessageDecoder

        通常你需要将消息从字节解码成消息或者从字节解码成其他的序列化字节。这是一个常见的任务，Netty提供了抽象基类，我们可以使用它们来实现。Netty中提供的ByteToMessageDecoder可以将字节消息解码成POJO对象，下面列出了ByteToMessageDecoder两个主要方法：
  • decode(ChannelHandlerContext, ByteBuf, List<Object>)，这个方法是唯一的一个需要自己实现的抽象方法，作用是将ByteBuf数据解码成其他形式的数据。
  • decodeLast(ChannelHandlerContext, ByteBuf, List<Object>)，实际上调用的是decode(...)。

例如服务器从某个客户端接收到一个整数值的字节码，服务器将数据读入ByteBuf并经过ChannelPipeline中的每个ChannelInboundHandler进行处理，看下图：

上图显示了从“入站”ByteBuf读取bytes后由ToIntegerDecoder进行解码，然后向解码后的消息传递到ChannelPipeline中的下一个ChannelInboundHandler。看下面ToIntegerDecoder的实现代码：

[java] view plain copy

  1. /**
  2.  * Integer解码器,ByteToMessageDecoder实现
  3.  * @author c.k
  4.  *
  5.  */
  6. public class ToIntegerDecoder extends ByteToMessageDecoder {
  8.     @Override
  9.     protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
  10.         if(in.readableBytes() >= 4){
  11.             out.add(in.readInt());
  12.         }
  13.     }
  14. }

从上面的代码可能会发现，我们需要检查ByteBuf读之前是否有足够的字节，若没有这个检查岂不更好？是的，Netty提供了这样的处理允许byte-to-message解码,在下一节讲解。除了ByteToMessageDecoder之外，Netty还提供了许多其他的解码接口。

7.2.2 ReplayingDecoder

ReplayingDecoder是byte-to-message解码的一种特殊的抽象基类，读取缓冲区的数据之前需要检查缓冲区是否有足够的字节，使用ReplayingDecoder就无需自己检查；若ByteBuf中有足够的字节，则会正常读取；若没有足够的字节则会停止解码。也正因为这样的包装使得ReplayingDecoder带有一定的局限性。

  • 不是所有的操作都被ByteBuf支持，如果调用一个不支持的操作会抛出DecoderException。
  • ByteBuf.readableBytes()大部分时间不会返回期望值

如果你能忍受上面列出的限制，相比ByteToMessageDecoder，你可能更喜欢ReplayingDecoder。在满足需求的情况下推荐使用ByteToMessageDecoder，因为它的处理比较简单，没有ReplayingDecoder实现的那么复杂。ReplayingDecoder继承与ByteToMessageDecoder，所以他们提供的接口是相同的。下面代码是ReplayingDecoder的实现：

[java] view plain copy

  1. /**
  2.  * Integer解码器,ReplayingDecoder实现
  3.  * @author c.k
  4.  *
  5.  */
  6. public class ToIntegerReplayingDecoder extends ReplayingDecoder<Void> {
  8.     @Override
  9.     protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
  10.         out.add(in.readInt());
  11.     }
  12. }

当从接收的数据ByteBuf读取integer，若没有足够的字节可读，decode(...)会停止解码，若有足够的字节可读，则会读取数据添加到List列表中。使用ReplayingDecoder或ByteToMessageDecoder是个人喜好的问题，Netty提供了这两种实现，选择哪一个都可以。

        上面讲了byte-to-message的解码实现方式，那message-to-message该如何实现呢？Netty提供了MessageToMessageDecoder抽象类。

7.2.3 MessageToMessageDecoder

        将消息对象转成消息对象可是使用MessageToMessageDecoder，它是一个抽象类，需要我们自己实现其decode(...)。message-to-message同上面讲的byte-to-message的处理机制一样，看下图：
看下面的实现代码：

[java] view plain copy

  1. /**
  2.  * 将接收的Integer消息转成String类型，MessageToMessageDecoder实现
  3.  * @author c.k
  4.  *
  5.  */
  6. public class IntegerToStringDecoder extends MessageToMessageDecoder<Integer> {
  8.     @Override
  9.     protected void decode(ChannelHandlerContext ctx, Integer msg, List<Object> out) throws Exception {
  10.         out.add(String.valueOf(msg));
  11.     }
  12. }

7.2.4 解码器总结

        解码器是用来处理入站数据，Netty提供了很多解码器的实现，可以根据需求详细了解。那我们发送数据需要将数据编码，Netty中也提供了编码器的支持。下一节将讲解如何实现编码器。

7.3 编码器

        Netty提供了一些基类，我们可以很简单的编码器。同样的，编码器有下面两种类型：
  • 消息对象编码成消息对象
  • 消息对象编码成字节码

相对解码器，编码器少了一个byte-to-byte的类型，因为出站数据这样做没有意义。编码器的作用就是将处理好的数据转成字节码以便在网络中传输。对照上面列出的两种编码器类型，Netty也分别提供了两个抽象类：MessageToByteEncoder和MessageToMessageEncoder。下面是类关系图：

7.3.1 MessageToByteEncoder

        MessageToByteEncoder是抽象类，我们自定义一个继承MessageToByteEncoder的编码器只需要实现其提供的encode(...)方法。其工作流程如下图：
实现代码如下：

[java] view plain copy

  1. /**
  2.  * 编码器，将Integer值编码成byte[]，MessageToByteEncoder实现
  3.  * @author c.k
  4.  *
  5.  */
  6. public class IntegerToByteEncoder extends MessageToByteEncoder<Integer> {
  7.     @Override
  8.     protected void encode(ChannelHandlerContext ctx, Integer msg, ByteBuf out) throws Exception {
  9.         out.writeInt(msg);
  10.     }
  11. }

7.3.2 MessageToMessageEncoder

需要将消息编码成其他的消息时可以使用Netty提供的MessageToMessageEncoder抽象类来实现。例如将Integer编码成String，其工作流程如下图：

代码实现如下：

[java] view plain copy

  1. /**
  2.  * 编码器，将Integer编码成String，MessageToMessageEncoder实现
  3.  * @author c.k
  4.  *
  5.  */
  6. public class IntegerToStringEncoder extends MessageToMessageEncoder<Integer> {
  8.     @Override
  9.     protected void encode(ChannelHandlerContext ctx, Integer msg, List<Object> out) throws Exception {
  10.         out.add(String.valueOf(msg));
  11.     }
  12. }

7.4 编解码器

实际编码中，一般会将编码和解码操作封装太一个类中，解码处理“入站”数据，编码处理“出站”数据。知道了编码和解码器，对于下面的情况不会感觉惊讶：

  • byte-to-message编码和解码
  • message-to-message编码和解码

如果确定需要在ChannelPipeline中使用编码器和解码器，需要更好的使用一个抽象的编解码器。同样，使用编解码器的时候，不可能只删除解码器或编码器而离开ChannelPipeline导致某种不一致的状态。使用编解码器将强制性的要么都在ChannelPipeline，要么都不在ChannelPipeline。

        考虑到这一点，我们在下面几节将更深入的分析Netty提供的编解码抽象类。

7.4.1 byte-to-byte编解码器

        Netty4较之前的版本，其结构有很大的变化，在Netty4中实现byte-to-byte提供了2个类：ByteArrayEncoder和ByteArrayDecoder。这两个类用来处理字节到字节的编码和解码。下面是这两个类的源码，一看就知道是如何处理的：

[java] view plain copy

  1. public class ByteArrayDecoder extends MessageToMessageDecoder<ByteBuf> {
  2.     @Override
  3.     protected void decode(ChannelHandlerContext ctx, ByteBuf msg, List<Object> out) throws Exception {
  4.          // copy the ByteBuf content to a byte array
  5.         byte[] array = new byte[msg.readableBytes()];
  6.         msg.getBytes(0, array);
  8.         out.add(array);
  9.     }
  10. }

[java] view plain copy

  1. @Sharable
  2. public class ByteArrayEncoder extends MessageToMessageEncoder<byte[]> {
  3.     @Override
  4.     protected void encode(ChannelHandlerContext ctx, byte[] msg, List<Object> out) throws Exception {
  5.         out.add(Unpooled.wrappedBuffer(msg));
  6.     }
  7. }

7.4.2 ByteToMessageCodec

ByteToMessageCodec用来处理byte-to-message和message-to-byte。如果想要解码字节消息成POJO或编码POJO消息成字节，对于这种情况，ByteToMessageCodec<I>是一个不错的选择。ByteToMessageCodec是一种组合，其等同于ByteToMessageDecoder和MessageToByteEncoder的组合。MessageToByteEncoder是个抽象类，其中有2个方法需要我们自己实现：

  • encode(ChannelHandlerContext, I, ByteBuf)，编码
  • decode(ChannelHandlerContext, ByteBuf, List<Object>)，解码

7.4.3 MessageToMessageCodec

        MessageToMessageCodec用于message-to-message的编码和解码，可以看成是MessageToMessageDecoder和MessageToMessageEncoder的组合体。MessageToMessageCodec是抽象类，其中有2个方法需要我们自己实现：
  • encode(ChannelHandlerContext, OUTBOUND_IN, List<Object>)
  • decode(ChannelHandlerContext, INBOUND_IN, List<Object>)

但是，这种编解码器能有用吗？

        有许多用例，最常见的就是需要将消息从一个API转到另一个API。这种情况下需要自定义API或旧的API使用另一种消息类型。下面的代码显示了在WebSocket框架APIs之间转换消息：

[java] view plain copy

  1. package netty.in.action;
  3. import java.util.List;
  5. import io.netty.buffer.ByteBuf;
  6. import io.netty.channel.ChannelHandlerContext;
  7. import io.netty.channel.ChannelHandler.Sharable;
  8. import io.netty.handler.codec.MessageToMessageCodec;
  9. import io.netty.handler.codec.http.websocketx.BinaryWebSocketFrame;
  10. import io.netty.handler.codec.http.websocketx.CloseWebSocketFrame;
  11. import io.netty.handler.codec.http.websocketx.ContinuationWebSocketFrame;
  12. import io.netty.handler.codec.http.websocketx.PingWebSocketFrame;
  13. import io.netty.handler.codec.http.websocketx.PongWebSocketFrame;
  14. import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
  15. import io.netty.handler.codec.http.websocketx.WebSocketFrame;
  17. @Sharable
  18. public class WebSocketConvertHandler extends
  19.         MessageToMessageCodec<WebSocketFrame, WebSocketConvertHandler.MyWebSocketFrame> {
  21.     public static final WebSocketConvertHandler INSTANCE = new WebSocketConvertHandler();
  23.     @Override
  24.     protected void encode(ChannelHandlerContext ctx, MyWebSocketFrame msg, List<Object> out) throws Exception {
  25.         switch (msg.getType()) {
  26.         case BINARY:
  27.             out.add(new BinaryWebSocketFrame(msg.getData()));
  28.             break;
  29.         case CLOSE:
  30.             out.add(new CloseWebSocketFrame(true, 0, msg.getData()));
  31.             break;
  32.         case PING:
  33.             out.add(new PingWebSocketFrame(msg.getData()));
  34.             break;
  35.         case PONG:
  36.             out.add(new PongWebSocketFrame(msg.getData()));
  37.             break;
  38.         case TEXT:
  39.             out.add(new TextWebSocketFrame(msg.getData()));
  40.             break;
  41.         case CONTINUATION:
  42.             out.add(new ContinuationWebSocketFrame(msg.getData()));
  43.             break;
  44.         default:
  45.             throw new IllegalStateException("Unsupported websocket msg " + msg);
  46.         }
  47.     }
  49.     @Override
  50.     protected void decode(ChannelHandlerContext ctx, WebSocketFrame msg, List<Object> out) throws Exception {
  51.         if (msg instanceof BinaryWebSocketFrame) {
  52.             out.add(new MyWebSocketFrame(MyWebSocketFrame.FrameType.BINARY, msg.content().copy()));
  53.             return;
  54.         }
  55.         if (msg instanceof CloseWebSocketFrame) {
  56.             out.add(new MyWebSocketFrame(MyWebSocketFrame.FrameType.CLOSE, msg.content().copy()));
  57.             return;
  58.         }
  59.         if (msg instanceof PingWebSocketFrame) {
  60.             out.add(new MyWebSocketFrame(MyWebSocketFrame.FrameType.PING, msg.content().copy()));
  61.             return;
  62.         }
  63.         if (msg instanceof PongWebSocketFrame) {
  64.             out.add(new MyWebSocketFrame(MyWebSocketFrame.FrameType.PONG, msg.content().copy()));
  65.             return;
  66.         }
  67.         if (msg instanceof TextWebSocketFrame) {
  68.             out.add(new MyWebSocketFrame(MyWebSocketFrame.FrameType.TEXT, msg.content().copy()));
  69.             return;
  70.         }
  71.         if (msg instanceof ContinuationWebSocketFrame) {
  72.             out.add(new MyWebSocketFrame(MyWebSocketFrame.FrameType.CONTINUATION, msg.content().copy()));
  73.             return;
  74.         }
  75.         throw new IllegalStateException("Unsupported websocket msg " + msg);
  76.     }
  78.     public static final class MyWebSocketFrame {
  79.         public enum FrameType {
  80.             BINARY, CLOSE, PING, PONG, TEXT, CONTINUATION
  81.         }
  83.         private final FrameType type;
  84.         private final ByteBuf data;
  86.         public MyWebSocketFrame(FrameType type, ByteBuf data) {
  87.             this.type = type;
  88.             this.data = data;
  89.         }
  91.         public FrameType getType() {
  92.             return type;
  93.         }
  95.         public ByteBuf getData() {
  96.             return data;
  97.         }
  99.     }
  100. }

7.5 其他编解码方式

使用编解码器来充当编码器和解码器的组合失去了单独使用编码器或解码器的灵活性，编解码器是要么都有要么都没有。你可能想知道是否有解决这个僵化问题的方式，还可以让编码器和解码器在ChannelPipeline中作为一个逻辑单元。幸运的是，Netty提供了一种解决方案，使用CombinedChannelDuplexHandler。虽然这个类不是编解码器API的一部分，但是它经常被用来简历一个编解码器。

7.5.1 CombinedChannelDuplexHandler

        如何使用CombinedChannelDuplexHandler来结合解码器和编码器呢？下面我们从两个简单的例子看了解。

[java] view plain copy

  1. /**
  2.  * 解码器，将byte转成char
  3.  * @author c.k
  4.  *
  5.  */
  6. public class ByteToCharDecoder extends ByteToMessageDecoder {
  8.     @Override
  9.     protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
  10.         while(in.readableBytes() >= 2){
  11.             out.add(Character.valueOf(in.readChar()));
  12.         }
  13.     }
  15. }

[java] view plain copy

  1. /**
  2.  * 编码器，将char转成byte
  3.  * @author Administrator
  4.  *
  5.  */
  6. public class CharToByteEncoder extends MessageToByteEncoder<Character> {
  8.     @Override
  9.     protected void encode(ChannelHandlerContext ctx, Character msg, ByteBuf out) throws Exception {
  10.         out.writeChar(msg);
  11.     }
  12. }

[java] view plain copy

  1. /**
  2.  * 继承CombinedChannelDuplexHandler，用于绑定解码器和编码器
  3.  * @author c.k
  4.  *
  5.  */
  6. public class CharCodec extends CombinedChannelDuplexHandler<ByteToCharDecoder, CharToByteEncoder> {
  7.     public CharCodec(){
  8.         super(new ByteToCharDecoder(), new CharToByteEncoder());
  9.     }
  10. }

从上面代码可以看出，使用CombinedChannelDuplexHandler绑定解码器和编码器很容易实现，比使用*Codec更灵活。

Netty还提供了其他的协议支持，放在io.netty.handler.codec包下，如：
  • Google的protobuf，在io.netty.handler.codec.protobuf包下
  • Google的SPDY协议
  • RTSP(Real Time Streaming Protocol，实时流传输协议)，在io.netty.handler.codec.rtsp包下
  • SCTP(Stream Control Transmission Protocol，流控制传输协议)，在io.netty.handler.codec.sctp包下
  • ......
原文地址http://www.bieryun.com/2168.html
上一篇 下一篇
优秀的个人博客,低调大师

微信关注我们

原文链接：https://yq.aliyun.com/articles/538165

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

Netty In Action中文版 - 第八章：附带的ChannelHandler和Codec

Netty In Action中文版 - 第八章：附带的ChannelHandler和Codec 本章介绍 使用SSL/TLS创建安全的Netty程序 使用Netty创建HTTP/HTTPS程序 处理空闲连接和超时 解码分隔符和基于长度的协议 写大数据 序列化数据 上一章讲解了如何创建自己的编解码器，我们现在可以用上一章的知识来编写自己的编解码器。不过Netty提供了一些标准的ChannelHandler和Codec。Netty提供了很多协议的支持，所以我们不必自己发明轮子。Netty提供的这些实现可以解决我们的大部分需求。本章讲解Netty中使用SSL/TLS编写安全的应用程序，编写HTTP协议服务器，以及使用如WebSocket或Google的SPDY协议来使HTTP服务获得更好的性能；这些都是很常见的应用，本章还会介绍数据压缩，在数据量比较大的时候，压缩数据是很有必要的。 8.1 使用SSL/TLS创建安全的Netty程序 通信数据在网络上传输一般是不安全的，因为传输的数据可以发送纯文本或二进制的数据，很容易被破解。我们很有必要对网络上的数据进行加密。SSL和TLS是众所周...
2018-03-13
735
下一篇

相关文章

发表评论

资源下载

更多资源
Spring

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

时间: 2025-12-17 大小: 5MB 下载: 1次
Rocky Linux

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

时间: 2026-04-12 大小: 1.42GB 下载: 4次
Sublime Text

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。

时间: 2025-12-03 大小: 9.84MB 下载: 39次
WebStorm

WebStorm

WebStorm 是jetbrains公司旗下一款JavaScript 开发工具。目前已经被广大中国JS开发者誉为“Web前端开发神器”、“最强大的HTML5编辑器”、“最智能的JavaScript IDE”等。与IntelliJ IDEA同源，继承了IntelliJ IDEA强大的JS部分的功能。

时间: 2025-12-13 大小: 249.54MB 下载: 22次
手机查看

扫码在手机上查看文章

扫描二维码，手机阅读更方便

热门标签
DeepSeek Jdk25 OpenAi HarmonyOS6 Nacos3 SpringBoot4 SpringCloud Docker Kubernetes Service Mesh Redis Gemini3 Rocky10

欢迎您来访！

登录后，您将获得更多功能！
热门文章
联系我们

有任何问题或合作意向欢迎联系我们

Email: 99873273@qq.com

QQ: 99873273

用户登录
用户注册