18-Netty 编解码器和Handler的调用机制

最新推荐文章于 2024-04-23 10:23:30 发布
最新推荐文章于 2024-04-23 10:23:30 发布
阅读量326 收藏 1
点赞数
文章标签： netty java socket 网络协议 servlet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/flowerStream/article/details/122632599
版权

基本说明

  1. Netty的组件设计: Netty的主要组件有Channel, EventLoop, ChannelFuture, ChannelHandler, ChannelPipeline等
  2. ChannelHandler充当了处理入站和出站数据的应用程序逻辑的容器, 例如: 实现ChannelInboundHandler接口(或ChannelInboundHandlerAdapter), 你就可以接收入站事件和数据, 这些数据会被业务逻辑处理, 当要给客户端发送响应时, 也可以从ChannelInboundhandler冲刷数据, 业务逻辑通常写在一个或多个ChannelInboundHandler中,ChannelOutboundHandler原理一样, 只不过她是用来处理出站数据的
  1. ChannelPipeline提供了ChannelHandler链的容器, 以客户端应用程序为例, 例如事件的运动方向是从客户端到服务端的,那么我们称这些事件为出站, 即客户端发送给服务端的数据会通过pipeline中的一系列ChannelOutboundHandler, 并被这些Handler处理, 反之则称为入站

编码解码器

  1. 当Netty发送或者接收一个消息的时候, 就将会发生一次数据转换, 入站消息会被解码, 从字节转换为另一种格式(比如Java对象) ;如果是出站消息, 他就会被编码成字节
  2. Netty提供了一系列实用的编解码器, 他们都实现了ChannelInboundHandler或者ChannelOutboundHandler接口,在这些类中ChannelRead方法已经被重写, 以入站为例,对于每个从入站Channel读取的消息, 这个方法会被调用, 随后, 他将调用由解码器所提供的decoder()方法进行解码, 并将已经解码的字节转发给ChannelPipeline中的下一个ChannelInboundHandler

解码器 - ByteToMessageDecoder

  1. 关系继承图

  1. 由于不可能知道远程节点是否会一次性发送一个完整的消息, TCP有可能出现粘包拆包的问题, 这个类会对入站数据进行缓冲, 直到它准备好被处理
  2. 一个关于ByteToMessageDecoder实例分析

Netty的handler链调用机制

需求

  1. 使用自定义的编码器和解码器来说明Netty的handler调用机制
    1. 客户端发送long到服务器
    2. 服务器发送Long到客户端
  1. 案例演示

NettyServer

package com.dance.netty.netty.inandout;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;

public class NettyServer {

    public static void main(String[] args) throws InterruptedException {
        NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup,workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG, 128)
                    .childOption(ChannelOption.SO_KEEPALIVE, true)
                    .handler(new LoggingHandler(LogLevel.INFO))
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            // 添加自己的处理器
                            // 入站的Handler进行解码 MyByteToLongDecoder
                            pipeline.addLast("longDecoder", new MyByteToLongDecoder());
                            // 对long类型进行编码的编码器
                            pipeline.addLast("longEncoder", new MyLongToByteEncoder());
                            // 处理入站数据
                            pipeline.addLast(new NettyServerHandler());
                        }
                    });
            ChannelFuture sync = serverBootstrap.bind("127.0.0.1", 7000).sync();
            System.out.println("server is ready ......");
            sync.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

}

NettyServerHandler

package com.dance.netty.netty.inandout;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

public class NettyServerHandler extends SimpleChannelInboundHandler<Long> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Long msg) throws Exception {
        System.out.println("服务器收到来自客户端的消息 : " + msg.toString());
        // 回显客户端
        ctx.writeAndFlush(msg);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.close();
        cause.printStackTrace();
    }
}

NettyClient

package com.dance.netty.netty.inandout;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;

public class NettyClient {
    public static void main(String[] args) throws InterruptedException {
        NioEventLoopGroup eventExecutors = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(eventExecutors)
                    .channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            // 解析Long类型的解析器
                            pipeline.addLast("longDecoder", new MyByteToLongDecoder());
                            // 对long类型进行编码的编码器
                            pipeline.addLast("longEncoder", new MyLongToByteEncoder());
                            // 自己的数据处理器
                            pipeline.addLast(new NettyClientHandler());
                        }
                    });
            ChannelFuture sync = bootstrap.connect("127.0.0.1", 7000).sync();
            sync.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            eventExecutors.shutdownGracefully();
        }
    }
}

NettyClientHandler

package com.dance.netty.netty.inandout;

import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

import java.nio.charset.StandardCharsets;

public class NettyClientHandler extends SimpleChannelInboundHandler<Long> {
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        // 发送消息到服务器
        // 正常数据
        ctx.writeAndFlush(1234567890L);

        /*
         * 分析:
         *  1. "qwerqwerqwerqwer" 是16个字节
         *  2. 该处理器的前一个Handler是MyLongToByteEncoder
         *  3. MyLongToByteEncoder 的父类是 MessageToByteEncoder
         *  4. MessageToByteEncoder 类中 有一个模板方法, 里面调用了我们自己实现的encode方法, 因为是模板方法所以里面有逻辑(重要),分析一下
         *  @Override
            public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
                ByteBuf buf = null;
                try {
                * // 重点: 判断 消息是否和当前的编码器匹配 如果匹配才往下走
                    if (acceptOutboundMessage(msg)) {
                        @SuppressWarnings("unchecked")
                        * // 转换消息类型为定义类型
                        I cast = (I) msg;
                        * // 构造成 ByteBuf
                        buf = allocateBuffer(ctx, cast, preferDirect);
                        try {
                        * // 重点: 调用我们自己实现的encode方法 传入case, 也就是我们发送的数据
                            encode(ctx, cast, buf);
                        } finally {
                            ReferenceCountUtil.release(cast);
                        }

                        if (buf.isReadable()) {
                            ctx.write(buf, promise);
                        } else {
                            buf.release();
                            ctx.write(Unpooled.EMPTY_BUFFER, promise);
                        }
                        buf = null;
                    } else {
                    * // 重点: 不匹配直接发送, 不走encode方法
                        ctx.write(msg, promise);
                    }
                } catch (EncoderException e) {
                    throw e;
                } catch (Throwable e) {
                    throw new EncoderException(e);
                } finally {
                    if (buf != null) {
                        buf.release();
                    }
                }
            }
            * 5. 因此我们在编写Encoder的时候, 要注意 传入的数据类型要和Encode的处理类型一致
         */
        // 其他类型数据
//        ctx.writeAndFlush(Unpooled.copiedBuffer("qwerqwerqwerqwer", StandardCharsets.UTF_8));
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Long msg) throws Exception {
        System.out.println("客户端接收来自服务器的消息: " + msg.toString());
    }
}

MyByteToLongDecoder

package com.dance.netty.netty.inandout;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;

import java.util.List;

/**
 * 自定义解码器
 */
public class MyByteToLongDecoder extends ByteToMessageDecoder {
    /**
     * 解码方法 会根据接收到的数据被调用多次 直到确定没有新的元素被添加到 List中
     * 或者ByteBuf没有更多的可读字节为止
     * 如果List out 不为空 就会将list的内容传递给下一个ChannelInboundHandler进行处理 该方法也会被调用多次
     * @param ctx 上下文对象
     * @param in 入站的ByteBuf
     * @param out 输出给下一个调用链的数据容器
     * @throws Exception
     */
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        // 应为这个是一个Long的解码器, 所以只处理Long类型的数据
        // 默认Long是8个字节
        if(in.readableBytes() >= 8){
            out.add(in.readLong());
        }else{
            // TODO 不够一个Long的数据, 不处理
        }
    }
}

MyLongToByteEncoder

package com.dance.netty.netty.inandout;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;
import io.netty.handler.codec.MessageToByteEncoder;

import java.util.List;

/**
 * 自定义编码器
 */
public class MyLongToByteEncoder extends MessageToByteEncoder<Long> {
    /**
     * 编码方法
     * @param ctx 上下文
     * @param msg 消息
     * @param out 输出给下一个编码器的ByteBuf
     * @throws Exception 异常
     */
    @Override
    protected void encode(ChannelHandlerContext ctx, Long msg, ByteBuf out) throws Exception {
        if(msg != null){
            out.writeLong(msg);
        }
    }
}
  1. 测试 执行结果

Server

一月 18, 2022 12:05:45 上午 io.netty.handler.logging.LoggingHandler channelRegistered
信息: [id: 0x1a8323fa] REGISTERED
一月 18, 2022 12:05:45 上午 io.netty.handler.logging.LoggingHandler bind
信息: [id: 0x1a8323fa] BIND: /127.0.0.1:7000
一月 18, 2022 12:05:45 上午 io.netty.handler.logging.LoggingHandler channelActive
信息: [id: 0x1a8323fa, L:/127.0.0.1:7000] ACTIVE
server is ready ......
一月 18, 2022 12:05:50 上午 io.netty.handler.logging.LoggingHandler channelRead
信息: [id: 0x1a8323fa, L:/127.0.0.1:7000] READ: [id: 0xac268da1, L:/127.0.0.1:7000 - R:/127.0.0.1:55730]
一月 18, 2022 12:05:50 上午 io.netty.handler.logging.LoggingHandler channelReadComplete
信息: [id: 0x1a8323fa, L:/127.0.0.1:7000] READ COMPLETE
服务器收到来自客户端的消息 : 1234567890

Client

客户端接收来自服务器的消息: 1234567890
  1. 调用图

  1. 结论
    1. 不论解码器Handler还是编码器Handler即接收的消息类型必须与待处理的消息类型一致, 否则该Handle不会被执行
    2. 在解码器 进行数据解码时, 需要判断 缓冲区(ByteBuf)的数据是否足够, 否则接收到的结果会与期望结果可能不一致

解码器 - ReplayingDecoder

  1. public abstract class ReplayingDecoder<S> extends ByteToMessgaeDecoder
  2. ReplayingDecoder 扩展了 ByteToMessageDecoder类, 使用这个类 我们不必调用readableBytes()方法 参数 S 指定了用户状态管理的类型, 其中Void代表不需要状态管理
  1. 应用实例: 使用ReplayingDecoder编写解码器, 对前面的案例进行简化[案例演示]
package com.dance.netty.netty.inandout;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;
import io.netty.handler.codec.ReplayingDecoder;

import java.util.List;

/**
 * 自定义解码器
 */
public class MyByteToLongDecoder2 extends ReplayingDecoder<Void> {

    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        // 应为这个是一个Long的解码器, 所以只处理Long类型的数据
        // 默认Long是8个字节
//        if(in.readableBytes() >= 8){
        // 不需要判断数据是否够读取 ,内部会进行处理判断
        out.add(in.readLong());
//        }else{
//            // TODO 不够一个Long的数据, 不处理
//        }
    }
}
  1. ReplayingDecoder使用方便, 但是它有一些局限性:
    1. 并不是所有的ByteBuf操作都被支持, 如果调用了一个不被支持的方法, 将会抛出一个UnsupportedOperationExeception
    2. ReplayingDecoder 在某些情况下可能稍慢于ByteToMessageDecoder, 例如:网络缓慢并且消息格式复杂时, 消息会被拆成多个碎片,速度变慢

其他解码器

其他解码器

  1. LineBasedFrameDecoder : 这个类在Netty内部也有使用, 它使用行尾控制字符(\n 或者 \r\n) 作为分隔符来解析数据
  2. DelimiterBasedFrameDecoder: 使用自定义的特殊字符作为消息的分隔符
  1. HttpObjectDecoder : 一个Http数据的解码器
  2. LengthFieldBasedFrameDecoder : 通过指定长度来标识整包消息, 这样就可以自动处理黏包和半包消息

其他编码器

【netty】 io.netty.handler.codec.TooLongFrameException
九师兄
05-11 2万+
背景 做netty权威指南的私有协议开发，案例报错如 io.netty.handler.codec.TooLongFrameException: Adjusted frame length exceeds 1048576: 795898487 - discarded at io.netty.handler.codec.LengthFieldBasedFrameDecoder.fail(Lengt...
io.netty学习（四）ChannelHandler
码灵的博客
06-20 1342
先简略了解一下和的概念。想象一个流水线车间。当组件从流水线头部进入，穿越流水线，流水线上的工人按顺序对组件进行加工，到达流水线尾部时商品组装完成。可以将当做流水线，当做流水线工人。源头的组件当做event，如readwrite等等。本篇文章我们先来讲讲的相关知识，下面进入正文吧。以上就是关于的分析，相信你对也有一定的了解，下期我们再来分析的源码。
Handler源码分析之Message类型
qq_27246079的博客
03-22 537
队头是同步消息时，就是正常取出，比如将m1取出了，m2就成了队头，就这样取当取到m3时发现这个msg.target=null,就知道m3是一个屏障消息，取到它代表后面跟着一个急需处理的异步消息(UI刷新消息)，那么就会一直往后找直到遍历到m5时发现它是异步消息，那就赶紧把m5先取出并分发它去执行UI刷新的逻辑（这里对应MessageQueue的next()方法中的逻辑），还记得上面mTraversalRunnable吗？所以，当分发了异步消息后，在取下一个消息前，这个屏障消息就被移除了。
一起学Netty（三）之 SimpleChannelInboundHandler
热门推荐
z69183787的专栏
10-31 2万+
其实Netty的知识点还是很零碎的，比如这个SimpleChannelInboundHandler这个类，在《Netty in Action》该书中的原版的Hello world的demo的客户端就是使用的SimpleChannelInboundHandler来作为处理器的，我本来也是使用这个类作为我处理类的，但是做一个新手，这个类还是让我走了一点弯路，我们可以看到SimpleChannelInb
Dubbo报错：io.netty.handler.codec.EncoderException: java.lang.IllegalStateException: Serialized class
枫陵的博客
03-25 7696
报错详情： 在dubbo整合SpringSecurity时，需要使用HttpServletRequest获取信息，代码如下： 结果执行后，查看结果，发现报错，报错信息如下： io.netty.handler.codec.EncoderException: java.lang.IllegalStateException: Serialized class org.springframework.security.web.firewall.StrictHttpFirewall$StrictFirewa
03-04-10-Netty编解码的艺术1
08-04
无论是内置的编解码器，如ByteToMessageDecoder和MessageToByteEncoder，还是用户自定义的编码器，都是Netty高效通信的关键组成部分。 通过本章的学习，读者将深入理解Netty如何处理网络通信中的数据问题，并掌握...
Netty 系列之编解码器和 handler 的调用机制
AS011x的博客
09-12 484
编写网络应用程序时，因为数据在网络中传输的都是二进制字节码数据，在发送数据时就需要编码，接收数据时就需要解码codec(编解码器) 的组成部分有两个：decoder(解码器)和 encoder(编码器)。encoder 负责把业务数据转换成字节码数据，decoder 负责把字节码数据转换成业务数据Protobuf 是 Google 发布的开源项目，全称 Google Protocol Buffers，是一种轻便高效的结构化数据存储格式，可以用于结构化数据串行化，或者说序列化。
Netty入门（四） --- 编码和解码，Netty的handler调用机制，TCP粘包和拆包原理和解决
化身强盗的博客
01-25 1101
文章目录七、Google Protobuf7.1 编码和解码简介7.2 Netty本身的编解码机制和问题分析7.3 Protobuf基本介绍7.4 Protobuf发送单对象7.5 Protobuf发送多对象八、Netty编解码器和handler调用机制8.1 基本说明8.2 编解码器基本原理8.3 Netty的handler链调用机制8.4 一些简单的解码器8.4.1 ByteToMessageDecoder 解码器8.4.2 ReplayingDecoder解码器8.4.3 其他的编解码器九、TCP粘包
Netty——Handler链调用机制及编解码器
weixin_43415481的博客
05-11 811
JAVA后端开发知识总结（持续更新…） Netty——Handler链调用机制及编解码器 文章目录Netty——Handler链调用机制及编解码器一、Netty的入站和出站机制1.1 概述1.2 Handler 编解码器1.2.1 ByteToMessageDecoder1.2.2 ReplayingDecoder1.2.3 HttpObjectDecoder二、Handler链调用机制2.1 服务端2.2 客户端2.3 结果 一、Netty的入站和出站机制 1.1 概述   ChannelHand.
learning-netty
11-18
`HttpServerCodec`是Netty提供的HTTP编解码器，用于处理HTTP请求和响应。 ### Netty的代码结构 Netty的源码组织非常有序，主要包括以下几个部分： #### common `io.netty.util`包提供了基础的工具类和实用函数。 ...
三. Netty 进阶
weixin_46633487的博客
04-30 481
三. Netty 进阶 笔记源于视频:https://www.bilibili.com/video/BV1py4y1E7oA?p=54&spm_id_from=pageDriver 1. 粘包与半包 1.1 粘包现象 服务端代码 public class HelloWorldServer { static final Logger log = LoggerFactory.getLogger(HelloWorldServer.class); void start() {
Netty 中的 handler 和 Pipeline
rickiyang的博客
05-23 978
上一节我们讲了 Netty 的启动流程，从启动流程入手分析了 Reactor 模型的第一步：channel 如何绑定 Selector。然后讲到了 EventLoop 在启动的时候发挥了什么作用。整个启动类我们从头到尾过了一遍，今天我们来解决上节遗留的问题：Selector 如何将请求交给对应的 handler处理。 1. handler 的初始化 还是先从启动类入手： ServerBootstrap server = new ServerBootstrap().group(bossGroup,workGr
【Netty】使用Netty实现自己的通信协议
最新发布
Zhangsama1的博客
04-23 9184
netty实现自己的通信协议
Netty专栏 （ 八 ）——— ChannelHandler动态添加-动态编排案例分享
thinking_fioa的博客
08-19 1万+
Netty-Small-Demo @author 鲁伟林 子项目Netty-Small-Demo介绍诸多使用Netty的小案例。如: ChannelHandler动态编排、AttributeMap的使用或ChannelPrimise等诸多Netty提供的特性。 非常欢迎同学们fork或者留言，一起交流技术。 本博客中涉及的完整代码： GitHub地址: https://github.com/t...
架构设计：系统间通信（6）——IO通信模型和Netty 上篇
JAVA入门中
10-05 2万+
下面的两篇文章我们将会在您已经理解原生的JAVA NIO框架的基础上，向您介绍Netty的原理和使用。讲解Netty并不是我们这个系列“系统间通信”的内容重点。目的是通过讲解IO通信模型、JAVA对各种通信模型的支持、上层的Netty/MINA封装，可以让大家深刻理解“系统间通信”中一个重要要素——信息如何传递。
Netty之Handler详解与实战
HaSaKing的博客
02-27 2198
在Netty中，Handler是实现网络应用逻辑的核心。它提供了一系列回调方法，例如处理接收到的数据、异常处理、连接活动等。Netty通过ChannelPipeline来管理Handler，可以想象为一个Handler链，数据在这个链上流动，每个Handler对数据进行处理后，可以传递给链上的下一个Handler，这种机制极大地提高了处理流程的灵活性和可定制性。
Netty 服务器客户端，发送自定义消息
...
03-30 2万+
Netty 5 的包 服务器，四个java文件 1            SubReqServer.java package com.test.netty; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.cha
Netty源码解析6-ChannelHandler实例之LoggingHandler
微信搜：import_bigdata，大数据领域硬核原创作者
02-23 893
请戳GitHub原文: https://github.com/wangzhiwubigdata/God-Of-BigData 更多文章关注：多线程/集合/分布式/Netty/NIO/RPC Java高级特性增强-集合 Java高级特性增强-多线程 Java高级特性增强-Synchronized Java高级特性增强-volatile Java高级特性增强-并发集合框架 Java高级特性增...
一起学Netty（十二）之 Netty心跳简单Demo
z69183787的专栏
10-31 9577
前面简单地了解了一下IdleStateHandler，我们现在写一个简单的心跳demo： 1）服务器端每隔5秒检测服务器端的读超时，如果5秒没有接受到客户端的写请求，也就说服务器端5秒没有收到读事件，则视为一次超时 2）如果超时二次则说明连接处于不活跃的状态，关闭ServerChannel 3）客户端每隔4秒发送一些写请求，这个请求相当于一次心跳包，告之服务器端：客户端仍旧活着
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值