Netty应用(十) 之 自定义编解码器 & 自定义通信协议

目录

25.自定义编解码器

25.1 自定义编解码器编码

25.2 自定义编解码器的总结和补充

26.自定义通信协议

26.1 关于通信协议的关注点

26.2 自定义通信协议的格式

26.3 编解码

---

25.自定义编解码器

有了上面这个大体框架的流程之后，我们来聊一个非常特殊的：

比如我们在客户端想把字符串"10-20"经过编码后转为long类型，然后转为二进制存储到ByteBuf中，通过网络IO发出去，服务端接收到ByteBuf后，解码为long类型

那么在netty中是没有这么个编解码器的，所以我们需要自己去实现这个编解码器。在框架中，你要扩展自定义一个组件也好，功能也罢，需要遵循它们的规范，也就是继承它的一些接口或者实现它的一些实现类。比如：spring中的Event那个事件通知。

你自定义的东西只有实现别的规范，这样才能被框架体系发现你自定义的类，进而你自定义的东西才能和框架融为一体，融为一体后才能实现你的功能，框架才会调用你。

而对于编码器，我们需要继承的是MessageToByteEncoder，对于解码器，我们需要继承的是ByteToMessageDecoder。然后在pipline中生效，这就是它的逻辑。

于是基于这个逻辑来实现我们的自定义编解码器

25.1 自定义编解码器编码

需求：

1.我们在客户端发送一个字符串"10~20"，这样的数据，然后我们希望发送出去的时候是以分隔符为界限，发出去两个long类型的数据

2.服务端接收到之后把数据从ByteBuf中取出来

需求分析：

这就是需要一组编解码器，编码器把字符串分隔开，然后转为两个long发出去

解码器把接收到的ByteBuf数据拿到手，解码转为long类型处理

具体实现如下：

• 客户端实现

package com.messi.netty_core_02.netty10;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.logging.LoggingHandler;

import java.net.InetSocketAddress;

public class MyNettyClient {


    public static void main(String[] args) throws InterruptedException {
        Bootstrap bootstrap = new Bootstrap();
        bootstrap.channel(NioSocketChannel.class);
        NioEventLoopGroup group = new NioEventLoopGroup();
        bootstrap.group(group);

        bootstrap.handler(new ChannelInitializer() {
            @Override
            protected void initChannel(NioSocketChannel ch) throws Exception {
                ChannelPipeline pipeline = ch.pipeline();
                //日志输出的编码器
                pipeline.addLast(new LoggingHandler());
                //我们自定义的编码器
                pipeline.addLast(new MyLong2ByteEncoder());
            }
        });

        Channel channel = bootstrap.connect(new InetSocketAddress(8000)).sync().channel();
        channel.writeAndFlush("10-20");
        group.shutdownGracefully();
    }



}

package com.messi.netty_core_02.netty10;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteEncoder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MyLong2ByteEncoder extends MessageToByteEncoder {

    private static final Logger log = LoggerFactory.getLogger(MyLong2ByteEncoder.class);

    /**
     *
     * @param ctx           上下文对象
     * @param msg           等待编码的数据
     * @param out           编码后的数据为二进制字节流格式，都存储到out中交给Netty，netty负责把ByteBuf数据交给socket缓冲区
     *                      socket缓冲区会把数据交给网络IO通信发给服务端
     * @throws Exception
     */
    @Override
    protected void encode(ChannelHandlerContext ctx, String msg, ByteBuf out) throws Exception {
        log.info("MyLong2ByteEncoder.encode start ~~~ ") ;
        if (msg == null) {
            return;
        }
        String[] msgs = msg.split("-");
        for (String message : msgs) {
            long longMsg = Long.parseLong(message);
            //每一个long类型的数据都在ByteBuf中占用8字节的大小空间
            out.writeLong(longMsg);
        }
    }
}

• 服务端实现

package com.messi.netty_core_02.netty10;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.logging.LoggingHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MyNettyServer {

    private static final Logger log = LoggerFactory.getLogger(MyNettyServer.class);

    public static void main(String[] args) {
        ServerBootstrap serverBootstrap = new ServerBootstrap();

        serverBootstrap.group(new NioEventLoopGroup(1),new NioEventLoopGroup(8));
        DefaultEventLoopGroup defaultEventLoopGroup = new DefaultEventLoopGroup();
        serverBootstrap.channel(NioServerSocketChannel.class);
        serverBootstrap.childHandler(new ChannelInitializer() {
            @Override
            protected void initChannel(NioSocketChannel ch) throws Exception {
                ChannelPipeline pipeline = ch.pipeline();
                pipeline.addLast(new LoggingHandler());
                pipeline.addLast(new MyByte2LongDecoder());
                pipeline.addLast(defaultEventLoopGroup,new ChannelInboundHandlerAdapter(){
                    @Override
                    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                        if(msg instanceof Long) {
                            Long data = (Long) msg;
                            log.info("得到的客户端输入为：{}",data) ;
                        }
                    }
                });
            }
        });

        serverBootstrap.bind(8000);
    }

}

package com.messi.netty_core_02.netty10;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;

public class MyByte2LongDecoder extends ByteToMessageDecoder {

    private static final Logger log = LoggerFactory.getLogger(MyByte2LongDecoder.class);

    /**
     *
     * @param ctx          上下文对象
     * @param in           网络IO传输过来的数据，存储到ByteBuf类型的in中
     * @param out          解码处理完后，把每一个"Message"都存储到out这一集合中，便于后续Netty遍历该out集合进行执行pipeline流水线的Handler操作
     *                     Netty是以消息Message为单位进行处理数据的，有多少Message，就执行多少次pipeline
     *                     ---->
     *                     如果字节数不超过滑动窗口，socket缓冲区，ByteBuf缓冲区，客户端只发一次数据即可，为什么服务端能划分出多个Message呢？
     *                     原因很简单：每调用一次decode进行处理ByteBuf，那么就会封装成一个Message。
     *                     如果服务端一次没有处理完ByteBuf，那么会进行第二次调用decode方法的处理，则第二次处理ByteBuf，则又会生成一个新的Message
     *                     以此类推，直到ByteBuf中的数据都处理完。
     *                     调用n次decode方法，处理ByteBuf n次，存储n个Message到out集合中
     *                     ---->
     *                     啥时候意味着ByteBuf中的数据都处理完？
     *                     其实还是指针的移动，思考一下之前NIO的各种指针，当读指针到达limit指针边界后就意味着ByteBuf处理完毕
     * @throws Exception
     */
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List