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<Object> out)

代码实现:

解码器

package com.lagou.code;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToMessageDecoder;
import io.netty.util.CharsetUtil;

import java.util.List;

/**
 * 消息解码器
 */
public class MessageDecoder extends MessageToMessageDecoder {
    @Override
    protected void decode(ChannelHandlerContext ctx, Object msg, List out) throws Exception {
        System.out.println("正在进行消息解码.....");
        ByteBuf byteBuf = (ByteBuf) msg;
        out.add(byteBuf.toString(CharsetUtil.UTF_8));  // 传递到下一个Handler
    }
}

通道读取方法:

    /**
     * 通道读取事件
     *
     * @param ctx
     * @param msg
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println("客户端发送过来的消息:" + msg);
    }

启动类:

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

3. 编码器(Encoder)

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

抽象编码器 

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

核心方法:

encode(ChannelHandlerContext ctx, String msg, List<Object> out)

代码实现:

编码器:

package com.lagou.code;

import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToMessageEncoder;
import io.netty.util.CharsetUtil;

import java.util.List;

/**
 * 消息的编码
 */
public class MessageEncoder extends MessageToMessageEncoder {
    @Override
    protected void encode(ChannelHandlerContext ctx, Object msg, List out) throws Exception {
        System.out.println("消息正在进行编码.....");
        String str = (String) msg;
        out.add(Unpooled.copiedBuffer(str, CharsetUtil.UTF_8));
    }
}

消息发送:

 @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        // ctx.writeAndFlush(Unpooled.copiedBuffer("你好呀，我是Netty客户端", CharsetUtil.UTF_8));
        ChannelFuture future = ctx.writeAndFlush("你好呀，我是Netty客户端");
        future.addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                if (future.isSuccess()) {
                    System.out.println("数据发送成功");
                } else {
                    System.out.println("数据发送失败");
                }
            }
        });
    }

启动类

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

4. 编码解码器Codec

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

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

代码实现:

package com.lagou.code;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToMessageCodec;
import io.netty.util.CharsetUtil;

import java.util.List;

/**
 * 消息编解码器
 */
public class MessageCodec extends MessageToMessageCodec {
    /**
     * 编码
     *
     * @param channelHandlerContext
     * @param o
     * @param list
     * @throws Exception
     */
    @Override
    protected void encode(ChannelHandlerContext ctx, Object msg, List out) throws Exception {
        System.out.println("消息正在进行编码.....");
        String str = (String) msg;
        out.add(Unpooled.copiedBuffer(str, CharsetUtil.UTF_8));
    }

    /**
     * 解码
     *
     * @param channelHandlerContext
     * @param o
     * @param list
     * @throws Exception
     */
    @Override
    protected void decode(ChannelHandlerContext ctx, Object msg, List out) throws Exception {
        System.out.println("正在进行消息解码.....");
        ByteBuf byteBuf = (ByteBuf) msg;
        out.add(byteBuf.toString(CharsetUtil.UTF_8));  // 传递到下一个Handler
    }
}

启动类:

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

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

3、客户端完整代码示例

package com.lagou.code;

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

/**
 * Netty客户端
 */
public class NettyClient {
    public static void main(String[] args) throws InterruptedException {
      //  1. 创建线程组
        EventLoopGroup group = new NioEventLoopGroup();
      //  2. 创建客户端启动助手
        Bootstrap bootstrap = new Bootstrap();
      //  3. 设置线程组
        bootstrap.group(group)
                .channel(NioSocketChannel.class) //  4. 设置客户端通道实现为NIO
                .handler(new ChannelInitializer<SocketChannel>() { //  5. 创建一个通道初始化对象
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        /* // 添加解码器
                        ch.pipeline().addLast("messageDecoder", new MessageDecoder());
                        // 添加编码器
                        ch.pipeline().addLast("messageEncoder", new MessageEncoder()); */
                        // 添加编解码器
                        ch.pipeline().addLast("", new MessageCodec());
                        //  6. 向pipeline中添加自定义业务处理handler
                        ch.pipeline().addLast(new NettyClientHandler());
                    }
                });
      //  7. 启动客户端,等待连接服务端,同时将异步改为同步
        ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 9999).sync();
        //  8. 关闭通道和关闭连接池
        channelFuture.channel().closeFuture().sync();
        group.shutdownGracefully();
    }
}

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