Netty 源码分析系列（十四）Netty 编解码器

已于 2023-05-30 12:32:14 修改
阅读量1.2k 收藏 4
点赞数 1
分类专栏： netty 文章标签： java netty 后端
于 2022-03-18 11:08:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiang_wang01/article/details/123569780
版权

系列文章目录

文章目录

前言

在前面文章中，我们分别对解码器和编码器进行了讨论，其实针对编码和解码，Netty 还提供了第三种方式，那就是编解码器。编解码器顾名思义，就是结合了编码和解码功能的程序。

编解码器能够把入站和出站的数据和信息转换都放在同一个类中，对于某些场景来说显得更实用。

编解码器概述

Netty 提供了抽象的编解码器类，能把一些成对的解码器和编码器组合在一起，以此来提供对字节和消息都相同的操作。这些类实现了ChannelOutboundHandler和ChannelInboundHandler接口。

Netty 的编解码器抽象类主要有以下两种：

（1）实现从字节到消息的编解码（ByteToMessageCodec）。

（2）实现从消息到消息的编解码（MessageToMessageCodec）。

ByteToMessageCodec 抽象类

ByteToMessageCodec 抽象类用于将字节实时编码/解码为消息的编解码器，可以将其视为ByteToMessageDecoder和MessageToByteEncoder的组合。

需要注意的是，ByteToMessageCodec 的子类绝不能使用 @Sharable 进行注释。

ByteToMessageCodec 抽象类的核心源码如下：

public abstract class ByteToMessageCodec<I> extends ChannelDuplexHandler {

    private final TypeParameterMatcher outboundMsgMatcher;
    private final MessageToByteEncoder<I> encoder;

    private final ByteToMessageDecoder decoder = new ByteToMessageDecoder() {
        @Override
        public void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
            ByteToMessageCodec.this.decode(ctx, in, out);
        }

        @Override
        protected void decodeLast(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
            ByteToMessageCodec.this.decodeLast(ctx, in, out);
        }
    };

    
    protected ByteToMessageCodec() {
        this(true);
    }

   
    protected ByteToMessageCodec(Class<? extends I> outboundMessageType) {
        this(outboundMessageType, true);
    }

  
    protected ByteToMessageCodec(boolean preferDirect) {
        ensureNotSharable();
        outboundMsgMatcher = TypeParameterMatcher.find(this, ByteToMessageCodec.class, "I");
        encoder = new Encoder(preferDirect);
    }

   
    protected ByteToMessageCodec(Class<? extends I> outboundMessageType, boolean preferDirect) {
        ensureNotSharable();
        outboundMsgMatcher = TypeParameterMatcher.get(outboundMessageType);
        encoder = new Encoder(preferDirect);
    }

   
    public boolean acceptOutboundMessage(Object msg) throws Exception {
        return outboundMsgMatcher.match(msg);
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        decoder.channelRead(ctx, msg);
    }

    @Override
    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
        encoder.write(ctx, msg, promise);
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        decoder.channelReadComplete(ctx);
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        decoder.channelInactive(ctx);
    }

    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        try {
            decoder.handlerAdded(ctx);
        } finally {
            encoder.handlerAdded(ctx);
        }
    }

    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
        try {
            decoder.handlerRemoved(ctx);
        } finally {
            encoder.handlerRemoved(ctx);
        }
    }

    protected abstract void encode(ChannelHandlerContext ctx, I msg, ByteBuf out) throws Exception;

    protected abstract void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception;

    protected void decodeLast(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        if (in.isReadable()) {
            decode(ctx, in, out);
        }
    }

    private final class Encoder extends MessageToByteEncoder<I> {
        Encoder(boolean preferDirect) {
            super(preferDirect);
        }

        @Override
        public boolean acceptOutboundMessage(Object msg) throws Exception {
            return ByteToMessageCodec.this.acceptOutboundMessage(msg);
        }

        @Override
        protected void encode(ChannelHandlerContext ctx, I msg, ByteBuf out) throws Exception {
            ByteToMessageCodec.this.encode(ctx, msg, out);
        }
    }
}

在上述代码中，重点关注以下方法：

（1）decode()：这是必须要实现的抽象方法，将入站的 ByteBuf 转换为指定的消息格式，并将其转发到管道中的下一个ChannelInboundHandler。

（2）encode()：该方法是开发者需要实现的抽象方法。对于每个被编码并写入出站 ByteBuf 的消息来说，这个方法都将会被调用。

（3）decodeLast()：Netty 提供的这个默认实现只是简单地调用了decode()方法。当Channel的状态变为非活动时，这个方法将会被调用一次。可以重写该方法以提供特殊的处理。

MessageToMessageCodec 抽象类

MessageToMessageCodec 抽象类用于将消息实时编码/解码为消息的编解码器，可以将其视为MessageToMessageDecoder和MessageToMessageEncoder`的组合。

MessageToMessageCodec 抽象类的核心源码如下：

public abstract class MessageToMessageCodec<INBOUND_IN, OUTBOUND_IN> extends ChannelDuplexHandler {

    private final MessageToMessageEncoder<Object> encoder = new MessageToMessageEncoder<Object>() {

        @Override
        public boolean acceptOutboundMessage(Object msg) throws Exception {
            return MessageToMessageCodec.this.acceptOutboundMessage(msg);
        }

        @Override
        @SuppressWarnings("unchecked")
        protected void encode(ChannelHandlerContext ctx, Object msg, List<Object> out) throws Exception {
            MessageToMessageCodec.this.encode(ctx, (OUTBOUND_IN) msg, out);
        }
    };

    private final MessageToMessageDecoder<Object> decoder = new MessageToMessageDecoder<Object>() {

        @Override
        public boolean acceptInboundMessage(Object msg) throws Exception {
            return MessageToMessageCodec.this.acceptInboundMessage(msg);
        }

        @Override
        @SuppressWarnings("unchecked")
        protected void decode(ChannelHandlerContext ctx, Object msg, List<Object> out) throws Exception {
            MessageToMessageCodec.this.decode(ctx, (INBOUND_IN) msg, out);
        }
    };

    private final TypeParameterMatcher inboundMsgMatcher;
    private final TypeParameterMatcher outboundMsgMatcher;

    protected MessageToMessageCodec() {
        inboundMsgMatcher = TypeParameterMatcher.find(this, MessageToMessageCodec.class, "INBOUND_IN");
        outboundMsgMatcher = TypeParameterMatcher.find(this, MessageToMessageCodec.class, "OUTBOUND_IN");
    }

 
    protected MessageToMessageCodec(
            Class<? extends INBOUND_IN> inboundMessageType, Class<? extends OUTBOUND_IN> outboundMessageType) {
        inboundMsgMatcher = TypeParameterMatcher.get(inboundMessageType);
        outboundMsgMatcher = TypeParameterMatcher.get(outboundMessageType);
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        decoder.channelRead(ctx, msg);
    }

    @Override
    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
        encoder.write(ctx, msg, promise);
    }

    public boolean acceptInboundMessage(Object msg) throws Exception {
        return inboundMsgMatcher.match(msg);
    }

    public boolean acceptOutboundMessage(Object msg) throws Exception {
        return outboundMsgMatcher.match(msg);
    }

    protected abstract void encode(ChannelHandlerContext ctx, OUTBOUND_IN msg, List<Object> out)
            throws Exception;

    protected abstract void decode(ChannelHandlerContext ctx, INBOUND_IN msg, List<Object> out)
            throws Exception;
}

在上述代码中，重点关注以下几个方法：

（1）decode()：这是必须要实现的抽象方法，将入站消息（INBOUND_IN类型）解码为消息，这些消息将转发到ChannelPipeline中的下一个ChannelInboundHandler。

（2）encode()：该方法是开发者需要实现的抽象方法。将出站消息（OUTBOUND_IN类型）编码为消息，然后将消息转发到ChannelPipeline中的下一个ChannelOutboundHandler。

请注意，如果消息是ReferenceCounted类型，则需要对刚刚通过的消息调用ReferenceCounted.ratain()。这个调用是必须的，因为MessageToMessageCodec将在编码/解码的消息上调用ReferenceCounted.ralease()。

以下是 MessageToMessageCodec 的示例，将 Integer 解码为 Long，然后将 Long 编码为 Integer。

public class NumberCodec extends MessageToMessageCodec<Integer,Long> {

    @Override
    protected void decode(ChannelHandlerContext ctx, Integer msg, List<Object> out) throws Exception {
            out.add(msg.longValue());
    }

    @Override
    protected void encode(ChannelHandlerContext ctx, Long msg, List<Object> out) throws Exception {
            out.add(msg.intValue())
    }
}

ChannelDuplexHandler 类

观察ByteToMessageCodec和MessageToMessageCodec 的源码，发现他们都继承自ChannelDuplexHandler 类。ChannelDuplexHandler 类是ChannelHandler的一个实现，表示 ChannelInboundHandler和 ChannelOutboundHandler的组合。如果ChannelHandler的实现需要拦截操作及状态更新，则这个 ChannelDuplexHandler 类会是一个很好的起点。

public class ChannelDuplexHandler extends ChannelInboundHandlerAdapter implements ChannelOutboundHandler {...}

CombinedChannelDuplexHandler 类

CombinedChannelDuplexHandler 类是 ChannelDuplexHandler 类的子类，用于将ChannelInboundHandler和 ChannelOutboundHandler组合到一个ChannelHandler中去。

在前面的文章示例中，编码器和解码器都是分开实现的。在不动现有代码的基础上，可以使用CombinedChannelDuplexHandler 类轻松实现一个编解码器，唯一要做的就是通过 CombinedChannelDuplexHandler 类来对解码器和编码器进行组合。

例如，有一个解码器ByteToCharDecoder，代码如下：

public class ByteToCharDecoder extends ByteToMessageDecoder {

    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        if(in.readableBytes() >= 2){
            out.add(in.readChar());
        }
    }
}

ByteToCharDecoder用于从 ByteBuf 中提取 2 个字节长度的字符，并将它们作为 char 写入到 List 中，将会被自动装箱为 Character 对象。

编码器 CharToByteEncoder的代码如下：

public class CharToByteEncoder extends MessageToByteEncoder<Character> {

    @Override
    protected void encode(ChannelHandlerContext ctx, Character msg, ByteBuf out) throws Exception {
        out.writeChar(msg);
    }
}

CharToByteEncoder 编码 char 消息到 ByteBuf。

现在有了编码器和解码器了，需要将它们组成一个编解码器。CombinedByteCharCodec代码如下：

public class CombinedByteCharCodec extends CombinedChannelDuplexHandler<ByteToCharDecoder, CharToByteEncoder> {

    public CombinedByteCharCodec(){
        super(new ByteToCharDecoder(),new CharToByteEncoder());
    }

}

CombinedByteCharCodec的参数是解码器和编码器，通过父类的构造器函数使它们结合起来。用上述方式组合编码器和解码器，使程序更简单、更灵活，避免编写多个编解码器类。

当然，是否使用CombinedByteCharCodec取决于具体的项目风格，没有绝对的好坏。

总结

通过以上对于编解码器的分析，相信小伙伴们对于编码器、解码器以及编解码器都有所了解了，下节我们就自己来实现一个自定义的编解码器。

初念初恋
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
93个netty高并发教学视频下载.txt
07-17
85_Netty编解码器剖析与入站出站处理器详解；86_Netty自定义编解码器与TCP粘包拆包问题；87_Netty编解码器执行流程深入分析；88_ReplayingDecoder源码分析与特性解读；89_Netty常见且重要编解码器详解；90_TCP粘包与...
精通并发与netty 无加密视频
04-13
第85讲：Netty编解码器剖析与入站出站处理器详解 第86讲：Netty自定义编解码器与TCP粘包拆包问题 第87讲：Netty编解码器执行流程深入分析 第88讲：ReplayingDecoder源码分析与特性解读 第89讲：Netty常见且重要...
Netty in action—codec框架
日积月累，天道酬勤
09-19 777
什么是codec每个网络应用程序必须定义在机器之间传输的原始字节如何被解析然后转换为目标程序的数据格式。该转换逻辑由编解码器(codec,编码解码器，下文中我直接用codec表示)处理，codec由编码器和编码器组成，每个编码器或解码器负责将字节流从一种格式转换到另一种格式。那么该如何区分编码器和解码器呢？将消息视为具有特定含义的字节的结构化序列-数据。 编码器将该消息转换成适合于传输的格式（很可能
解码器和编码器结合
学而不思则忘
05-29 552
1. ByteToMessageCodec编解码器 这是一个抽象类，继承它，就等同于继承了ByteToMessageDecoder解码器和MessageToByteEncoder编码器这两个基类。 有两个方法需要去实现： 编码方法：encode(...) 解码方法：decode(...) // 示例 public class Byte2IntegerCodec extends ByteToMessageCodec<Integer> { @Override public voi
Netty源码深度解析
最新发布
weixin_41338970的博客
02-03 764
最后做一个小的总结，下图是我在网上，充分说明了Netty框架的运行模式，它是基于Reactor模型的主从架构：需要创建两个线程组EventLoopGroup，即bossGroup和workerGroup，一般bossGroup设置的线程组中线程的数量为1(也可以设置>1，如果这样设置的话，就需要绑定其他的端口，设置几个，绑定几个端口)，workerGroup设置的线程组是多个，不设置默认创建的线程数量为 CPU核心数×2。今天，聊一聊Netty源码。因此，Netty使用。
io.netty学习（十五）Netty 编解码器
码灵的博客
06-27 1573
在前面文章中，我们分别对解码器和编码器进行了讨论。其实针对编码和解码，Netty 还提供了第三种方式，那就是编解码器。编解码器顾名思义，就是结合了编码和解码功能的程序。编解码器能够把入站和出站的数据和信息转换都放在同一个类中，对于某些场景来说显得更实用。Netty 提供了抽象的编解码器类，能把一些成对的解码器和编码器组合在一起，以此来提供对字节和消息都相同的操作。这些类实现了和接口。Netty 的编解码器抽象类主要有以下两种：（1）实现从字节到消息的编解码（（2）实现从消息到消息的编解码（
Netty 核心源码解析
weixin_41385912的博客
12-09 9407
Netty 第一讲：Netty 架构与原理本文是《Netty 三讲》的第二讲：Netty 核心源码解析（部分），大纲如下：前言1. Netty 服务端启动过程源码剖析1.1. 执行 ne...
Netty之编解码技术(四)
青鸟飞鱼
02-01 7277
通常我们习惯将编码（Encode）称为序列化（serialization），它将对象序列化为字节数组，用于网络传输、数据持久化或者其它用途。反之，解码（Decode）称为反序列化（deserialization），它把从网络、磁盘等读取的字节数组还原成原始对象（通常是原始对象的拷贝），以方便后续的业务逻辑操作。Java序列化相信大多数Java程序员接触到的第一种序列化或者编解码技术就是Java默认...
Netty 编解码器详解
Charge8的博客
05-05 5126
Netty 编解码器详解
精通并发与netty视频教程(2018)视频教程
12-24
85_Netty编解码器剖析与入站出站处理器详解 86_Netty自定义编解码器与TCP粘包拆包问题 87_Netty编解码器执行流程深入分析 88_ReplayingDecoder源码分析与特性解读 89_Netty常见且重要编解码器详解 90_TCP粘包与拆包...
精通并发与 netty 视频教程(2018)视频教程
04-17
85_Netty编解码器剖析与入站出站处理器详解 86_Netty自定义编解码器与TCP粘包拆包问题 87_Netty编解码器执行流程深入分析 88_ReplayingDecoder源码分析与特性解读 89_Netty常见且重要编解码器详解 90_TCP粘包与拆包...
netty: ByteToMessageCodec的用法
amadeus_liu2的博客
01-24 406
三、编写netty TCP服务器，并在ChannelPipeline中加入上述两个handler。一、创建ByteToMessageCodec的子类并重写encode和decode方法。二、编写一个简单的ChannelInboundHandlerAdapter。
Netty 源码解析（上）
黄裳博客
04-21 1696
netty源码解析
Netty核心技术十--Netty 核心源码剖析
qq_31745863的博客
07-11 735
每当ServerSocket创建一个新的连接，就会创建一个Socket，对应的就是目标客户端。每一个新创建的Socket 都将会分配一个全新的 ChanneIPipeline(以下简称 pipeline)每一个ChannelPipeline内部都含有多个ChannelHandlerContext(以下简称 Context)他们一起组成了双向链表，这些Context 用于包装我们调用addLast 方法时添加的ChannelHandler (以下简称handler)关系图。
Netty源码解读
专注基础架构领域
04-23 889
2、调用服务端NioServerSocketChannel的pipeline，将客户端的NioSocketChannel作为参数传过去，最终会调用到ServerBootstrapAcceptor，将NioSocketChannel注册到workGroup上。2、当有客户端连接时，通过NioServerSocketChannel的accept()得到每个客户端的NioSocketChannel，将其注册到selector上，对客户端OP_READ操作感兴趣。
netty源码分析
qq_39203337的博客
09-13 3328
netty源码解析
Netty源码浅析
DaHuangXiao的博客
06-28 516
前言 到目前为止，已经看了不少框架的源码了，但如何对源码做笔记并写博客，不同框架适合的做笔记方式也不同 对于Netty框架而言，我认为以对比学习+回答问题的方式来浅析源码会好一些，因为Netty本质上也就是基于NIO的一个非阻塞网络编程框架，那么本篇笔记就对比一个简单的NIO非阻塞网络编程，看看Netty是如何实现的 流程解析 看Netty源码主要就是去看其如何实现Reactor模式的，关于Reactor的演变，在《初识Netty》中我做了对比，不进行赘述 本节主要比较一下NIO的传统非阻塞方式与Netty
netty 源码分析
10-12
对于想要深入了解 netty 的开发者来说，必须要对 netty 的源码进行深入分析和研究。 netty 源码分析的主要内容包括：netty 的整体架构、核心组件的实现、网络协议的支持、线程模型的设计等方面。在分析 netty 源码...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值