• Netty编解码器

    1、Java的编解码

            编码（Encode）称为序列化， 它将对象序列化为字节数组，用于网络传输、数据持久化或者其它用途。

            解码（Decode）称为反序列化，它把从网络、磁盘等读取的字节数组还原成原始对象（通常是原始对象的拷贝），以方便后续的业务逻辑操作。

            java序列化对象只需要实现java.io.Serializable接口并生成序列化ID，这个类就能够通过java.io.ObjectInput和java.io.ObjectOutput序列化和反序列化。 

            Java序列化目的：1.网络传输。2.对象持久化。

            Java序列化缺点：1.无法跨语言。 2.序列化后码流太大。3.序列化性能太低。

            Java序列化仅仅是Java编解码技术的一种，由于它的种种缺陷，衍生出了多种编解码技术和框架，这些编解码框架实现消息的高效序列化。

    2、Netty编解码器

    1. 概念

            在网络应用中需要实现某种编解码器，将原始字节数据与自定义的消息对象进行互相转换。网络中都是以字节码的数据形式来传输数据的，服务器编码数据后发送到客户端，客户端需要对数据进行解码。

            对于Netty而言，编解码器由两部分组成：编码器、解码器。

    • 解码器：负责将消息从字节或其他序列形式转成指定的消息对象。
    • 编码器：将消息对象转成字节或其他序列形式在网络上传输。

            Netty 的编（解）码器实现了 ChannelHandlerAdapter，也是一种特殊的 ChannelHandler，所以依赖于 ChannelPipeline，可以将多个编（解）码器链接在一起，以实现复杂的转换逻辑。

    Netty里面的编解码： 解码器：负责处理“入站 InboundHandler”数据。 编码器：负责“出站OutboundHandler” 数据。

    2. 解码器(Decoder)

            解码器负责 解码“入站”数据从一种格式到另一种格式，解码器处理入站数据是抽象ChannelInboundHandler的实现。需要将解码器放在ChannelPipeline中。对于解码器，Netty中主要提供了抽象基类ByteToMessageDecoder和MessageToMessageDecoder

    抽象解码器 

    • ByteToMessageDecoder: 用于将字节转为消息，需要检查缓冲区是否有足够的字节
    • ReplayingDecoder: 继承ByteToMessageDecoder，不需要检查缓冲区是否有足够的字节,但是 ReplayingDecoder速度略慢于ByteToMessageDecoder,同时不是所有的ByteBuf都支持。项目复杂性高则使用ReplayingDecoder，否则使用ByteToMessageDecoder
    • MessageToMessageDecoder: 用于从一种消息解码为另外一种消息（例如POJO到POJO）

    核心方法:

    decode(ChannelHandlerContext ctx, ByteBuf msg, List out) 

    代码实现:
     

    解码器
     

    1. package com.lagou.code;
    2.  
    3. import io.netty.buffer.ByteBuf;
    4. import io.netty.channel.ChannelHandlerContext;
    5. import io.netty.handler.codec.MessageToMessageDecoder;
    6. import io.netty.util.CharsetUtil;
    7.  
    8. import java.util.List;
    9.  
    10. /**
    11.  * 消息解码器
    12.  */
    13. public class MessageDecoder extends MessageToMessageDecoder {
    14.     @Override
    15.     protected void decode(ChannelHandlerContext ctx, Object msg, List out) throws Exception {
    16.         System.out.println("正在进行消息解码.....");
    17.         ByteBuf byteBuf = (ByteBuf) msg;
    18.         out.add(byteBuf.toString(CharsetUtil.UTF_8));  // 传递到下一个Handler
    19.     }
    20. }
     

    通道读取方法:
     

    1.     /**
    2.      * 通道读取事件
    3.      *
    4.      * @param ctx
    5.      * @param msg
    6.      * @throws Exception
    7.      */
    8.     @Override
    9.     public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
    10.         System.out.println("客户端发送过来的消息:" + msg);
    11.     }
     

    启动类:
     

    1. protected void initChannel(SocketChannel ch) throws Exception {
    2. //8. 向pipeline中添加自定义业务处理handler
    3.     ch.pipeline().addLast(new MessageDecoder());//添加解码器
    4.     ch.pipeline().addLast(new NettyServerHandler());
    5. }
     

    3. 编码器(Encoder)
     

            与ByteToMessageDecoder和MessageToMessageDecoder相对应，Netty提供了对应的编码器实现MessageToByteEncoder和MessageToMessageEncoder，二者都实现ChannelOutboundHandler接口。
     

     

    抽象编码器 
     

    • MessageToByteEncoder: 将消息转化成字节
    • MessageToMessageEncoder: 用于从一种消息编码为另外一种消息（例如POJO到POJO）
    

    核心方法:
     

     
 
    encode(ChannelHandlerContext ctx, String msg, List out)
     
 

    代码实现:
     

    编码器:
     

    1. package com.lagou.code;
    2.  
    3. import io.netty.buffer.Unpooled;
    4. import io.netty.channel.ChannelHandlerContext;
    5. import io.netty.handler.codec.MessageToMessageEncoder;
    6. import io.netty.util.CharsetUtil;
    7.  
    8. import java.util.List;
    9.  
    10. /**
    11.  * 消息的编码
    12.  */
    13. public class MessageEncoder extends MessageToMessageEncoder {
    14.     @Override
    15.     protected void encode(ChannelHandlerContext ctx, Object msg, List out) throws Exception {
    16.         System.out.println("消息正在进行编码.....");
    17.         String str = (String) msg;
    18.         out.add(Unpooled.copiedBuffer(str, CharsetUtil.UTF_8));
    19.     }
    20. }
     

    消息发送:
     

    1.  @Override
    2.     public void channelActive(ChannelHandlerContext ctx) throws Exception {
    3.         // ctx.writeAndFlush(Unpooled.copiedBuffer("你好呀，我是Netty客户端", CharsetUtil.UTF_8));
    4.         ChannelFuture future = ctx.writeAndFlush("你好呀，我是Netty客户端");
    5.         future.addListener(new ChannelFutureListener() {
    6.             @Override
    7.             public void operationComplete(ChannelFuture future) throws Exception {
    8.                 if (future.isSuccess()) {
    9.                     System.out.println("数据发送成功");
    10.                 } else {
    11.                     System.out.println("数据发送失败");
    12.                 }
    13.             }
    14.         });
    15.     }
     

    启动类
     

    1. @Override
    2. protected void initChannel(SocketChannel ch) throws Exception {
    3.     //6. 向pipeline中添加自定义业务处理handler
    4.     ch.pipeline().addLast(new MessageDecoder());//添加解码器
    5.     ch.pipeline().addLast(new MessageEncoder());//添加编码器
    6.     ch.pipeline().addLast(new NettyClientHandler());
    7. }
     

    4. 编码解码器Codec
     

            编码解码器: 同时具有编码与解码功能，特点同时实现了ChannelInboundHandler和ChannelOutboundHandler接口，因此在数据输入和输出时都能进行处理。
     

     

    Netty提供提供了一个ChannelDuplexHandler适配器类,编码解码器的抽象基类ByteToMessageCodec ,MessageToMessageCodec都继承与此类. 
     

    代码实现:
     

    1. package com.lagou.code;
    2.  
    3. import io.netty.buffer.ByteBuf;
    4. import io.netty.buffer.Unpooled;
    5. import io.netty.channel.ChannelHandlerContext;
    6. import io.netty.handler.codec.MessageToMessageCodec;
    7. import io.netty.util.CharsetUtil;
    8.  
    9. import java.util.List;
    10.  
    11. /**
    12.  * 消息编解码器
    13.  */
    14. public class MessageCodec extends MessageToMessageCodec {
    15.     /**
    16.      * 编码
    17.      *
    18.      * @param channelHandlerContext
    19.      * @param o
    20.      * @param list
    21.      * @throws Exception
    22.      */
    23.     @Override
    24.     protected void encode(ChannelHandlerContext ctx, Object msg, List out) throws Exception {
    25.         System.out.println("消息正在进行编码.....");
    26.         String str = (String) msg;
    27.         out.add(Unpooled.copiedBuffer(str, CharsetUtil.UTF_8));
    28.     }
    29.  
    30.     /**
    31.      * 解码
    32.      *
    33.      * @param channelHandlerContext
    34.      * @param o
    35.      * @param list
    36.      * @throws Exception
    37.      */
    38.     @Override
    39.     protected void decode(ChannelHandlerContext ctx, Object msg, List out) throws Exception {
    40.         System.out.println("正在进行消息解码.....");
    41.         ByteBuf byteBuf = (ByteBuf) msg;
    42.         out.add(byteBuf.toString(CharsetUtil.UTF_8));  // 传递到下一个Handler
    43.     }
    44. }
     

    启动类:
     

    1. protected void initChannel(SocketChannel ch) throws Exception {
    2.     //8. 向pipeline中添加自定义业务处理handler
    3.     ch.pipeline().addLast(new MessageCoder());//添加编解码器
    4.     ch.pipeline().addLast(new NettyServerHandler());
    5. }
     

    注意：编解码器handler一定要定义在业务处理handler的前面
     

     

    3、客户端完整代码示例
     

    1. package com.lagou.code;
    2.  
    3. import io.netty.bootstrap.Bootstrap;
    4. import io.netty.channel.ChannelFuture;
    5. import io.netty.channel.ChannelInitializer;
    6. import io.netty.channel.EventLoopGroup;
    7. import io.netty.channel.nio.NioEventLoopGroup;
    8. import io.netty.channel.socket.SocketChannel;
    9. import io.netty.channel.socket.nio.NioSocketChannel;
    10.  
    11. /**
    12.  * Netty客户端
    13.  */
    14. public class NettyClient {
    15.     public static void main(String[] args) throws InterruptedException {
    16.       //  1. 创建线程组
    17.         EventLoopGroup group = new NioEventLoopGroup();
    18.       //  2. 创建客户端启动助手
    19.         Bootstrap bootstrap = new Bootstrap();
    20.       //  3. 设置线程组
    21.         bootstrap.group(group)
    22.                 .channel(NioSocketChannel.class) //  4. 设置客户端通道实现为NIO
    23.                 .handler(new ChannelInitializer() { //  5. 创建一个通道初始化对象
    24.                     @Override
    25.                     protected void initChannel(SocketChannel ch) throws Exception {
    26.                         /* // 添加解码器
    27.                         ch.pipeline().addLast("messageDecoder", new MessageDecoder());
    28.                         // 添加编码器
    29.                         ch.pipeline().addLast("messageEncoder", new MessageEncoder()); */
    30.                         // 添加编解码器
    31.                         ch.pipeline().addLast("", new MessageCodec());
    32.                         //  6. 向pipeline中添加自定义业务处理handler
    33.                         ch.pipeline().addLast(new NettyClientHandler());
    34.                     }
    35.                 });
    36.       //  7. 启动客户端,等待连接服务端,同时将异步改为同步
    37.         ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 9999).sync();
    38.         //  8. 关闭通道和关闭连接池
    39.         channelFuture.channel().closeFuture().sync();
    40.         group.shutdownGracefully();
    41.     }
    42. }
     

    注：服务端与之类似，省略。
    
                
                    
                

                
  • 

                    相关阅读:
    
                    
台湾飞凌FM8PB513B单片机提供单片机方案开发 产品设计                            
    
协议类型（总结为主，非详细）                            
    
Pr怎么消除人声？三个方法解决！                            
    
RabbitMQ小结                            
    
Java项目：SSM汽车维修预约平台                            
    
【Linux】《Linux命令行与shell脚本编程大全 (第4版) 》笔记-Chapter5-理解 shell                            
    
最大流的算法 Algorithm for Maximum Flow                            
    
Spring面试题（2022）                            
    
y85.第四章 Prometheus大厂监控体系及实战 -- prometheus告警机制进阶、pushgateway和prometheus存储(十六)                            
    
[附源码]Python计算机毕业设计钓鱼爱好者交流平台                            
    
                        
                
    • 
                
  • 
                    原文地址：https://blog.csdn.net/weixin_52851967/article/details/126116192
                
    •