备案控制台
开发者社区 开发与运维 文章 正文

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

2018-03-14 1982
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Netty In Action中文版 - 第七章：编解码器Codec 本章介绍 Codec，编解码器 Decoder，解码器 Encoder，编码器 Netty提供了编解码器框架，使得编写自定义的编解码器很容易，并且也很容易重用和封装。

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
文章标签：
Java
编解码
API
测试技术
流计算
关键词：
Netty编解码器
Netty codec
Netty中文版
Netty action
Netty action中文版
优惠券发放
目录
相关文章
岁岁种桃花儿
|
5月前
|
存储 编解码 Java
Netty使用篇：自定义编解码器
Netty使用篇：自定义编解码器
岁岁种桃花儿
62 0
岁岁种桃花儿
|
5月前
|
设计模式 JSON 编解码
Netty使用篇：编解码器
Netty使用篇：编解码器
岁岁种桃花儿
46 0
TiMi先生
|
10月前
|
移动开发 安全 前端开发
Netty实战（十二）预置的ChannelHandler和编解码器（二）
HTTPS、WebSocket的添加使用和大型数据写入以及几种常见的序列化)
TiMi先生
60 0
TiMi先生
|
10月前
|
安全 Java 关系型数据库
Netty实战（十一）预置的ChannelHandler和编解码器（一）
作为一个通讯框架，通讯数据的安全性也是不可或缺的一部分。一般常见的像TLS/SSL这样的安全协议我们都应该熟悉。 我们在访问安全网站时都遇到过这些协议，但是它们也可用于其他不是基于HTTP的应用程序，如安全SMTP（SMTPS）邮件服务器甚至是关系型数据库系统。
TiMi先生
100 0
TiMi先生
|
10月前
|
容器
Netty实战（十）编解码器框架
网络只将数据看作是原始的字节序列。但我们的应用程序则会把这些字节组织成有意义的信息。在数据和网络字节流之间做相互转换是最常见的编程任务之一。例如，我们可能需要处理标准的格式或者协议（如 FTP 或 Telnet）、实现一种由第三方定义的专有二进制协议，或者扩展一种由自己的组织创建的遗留的消息格式。将应用程序的数据转换为网络格式，以及将网络格式转换为应用程序的数据的组件分别叫作编码器和解码器，同时具有这两种功能的单一组件叫作编解码器。
TiMi先生
64 0
王老狮
|
安全 Java 关系型数据库
高性能IO框架Netty五 - Netty内置的编解码器
高性能IO框架Netty五 - Netty内置的编解码器
王老狮
98 0
kunfire
|
缓存 移动开发 网络协议
第 8 章 Netty 编解码器和 Handler 调用机制
第 8 章 Netty 编解码器和 Handler 调用机制
kunfire
137 0
六脉神剑.
|
网络协议 算法
小六六学Netty系列之编解码器和handler的调用机制（下）
前言 文本已收录至我的GitHub仓库，欢迎Star：github.com/bin39232820… 种一棵树最好的时间是十年前，其次是现在
六脉神剑.
132 0
六脉神剑.
|
存储 编解码 网络协议
小六六学Netty系列之编解码器和handler的调用机制（上）
前言 文本已收录至我的GitHub仓库，欢迎Star：github.com/bin39232820… 种一棵树最好的时间是十年前，其次是现在
六脉神剑.
207 0
xleesf
|
编解码 缓存 安全
【Netty】ChannelHandler和codec
前面学习了Netty的codec框架，下面接着学习ChannelHandler与codec之间的关联。
xleesf
105 0
【Netty】ChannelHandler和codec