netty权威指南学习笔记六——编解码技术之MessagePack

　　编解码技术主要应用在网络传输中，将对象比如BOJO进行编解码以利于网络中进行传输。平常我们也会将编解码说成是序列化/反序列化

　　定义：当进行远程跨进程服务调用时，需要把被传输的java对象编码为字节数组或者ByteBuffer对象。而当远程服务读取到ByteBuffer对象或者字节数组时，需要将其解码为发送时的java对象。这被称为java对象编解码技术。比如java的序列化。

　　但是，java的序列化有一定的弊端；

• 　　java序列化是java私有的协议，其他语言不支持，故而不能实现跨语言；
• 　　其次，序列化后的码流太大；
• 　　再次，序列化性能太低，耗时长。

　　因此，通常不会选择java序列化作为远程跨节点调用的编解码框架。

　　当前业界主流的编解码框架有：1）MessagePack高效的二进制序列化框架；2）Google 的Protobuf；3）Facebook的Thrift；4）JBoss Marshalliing

下面运行MessagePack的编解码

　　这个示例在权威指南上，作者并没有给出完整代码，本博主刚开始运行也没有运行出来，经过网络搜索，参考相关文章运行了出来，其中潜在存在着一些坑，运行中本博主也发现一些现象也总结出来。

　　一、首先我们需要引入相关jar包

         <dependency>
             <groupId>org.msgpack</groupId>
             <artifactId>msgpack</artifactId>
             <version>0.6.11</version>

         </dependency>
         <!-- 创建项目时已经存在，这里贴出来，但本博主不重复放包
               <dependency>
                   <groupId>org.javassist</groupId>
                   <artifactId>javassist</artifactId>
                   <version>3.22.0-GA</version>
               </dependency>
       -->

二、放上编解码代码，

坑一、一定要在继承的类后面加上泛型，这样，方法中的参数才能跟着发生变化

如过没有添加<>,则解码实现接口方法时直接生成的方法的参数如下：

编码代码

 package com.messagePack;

 import io.netty.buffer.ByteBuf;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.handler.codec.MessageToByteEncoder;
 import org.msgpack.MessagePack;

 public class MsgPackEncoder extends MessageToByteEncoder<Object> {
     @Override
     protected void encode(ChannelHandlerContext channelHandlerContext, Object o, ByteBuf byteBuf) throws Exception {
         MessagePack msgPack = new MessagePack();
 //      编码，然后转为ButyBuf传递
         byte[] bytes = msgPack.write(o);
         byteBuf.writeBytes(bytes);
     }
 }

解码代码

 package com.messagePack;

 import io.netty.buffer.ByteBuf;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.handler.codec.MessageToMessageDecoder;
 import org.msgpack.MessagePack;

 import java.util.List;

 public class MsgPackDecoder extends MessageToMessageDecoder<ByteBuf> {
     @Override
     protected void decode(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf, List<Object> list) throws Exception {
 //      获取要解码的byte数组
         final byte[] bytes;
         final int length = byteBuf.readableBytes();
         bytes = new byte[length];
         byteBuf.getBytes(byteBuf.readerIndex(),bytes,0,length);
 //      调用MessagePack 的read方法将其反序列化为Object对象
         MessagePack msgPack = new MessagePack();
         list.add(msgPack.read(bytes));
     }
 }

如果实现的接口后面没有添加泛型<ByteBuf>,则解码实现接口方法时直接生成的方法的参数如下：

  @Override
     protected void decode(ChannelHandlerContext channelHandlerContext, Object o, List list) throws Exception {

     }

不过经过实验，将接收到的Object进行转换后仍然可以，要记好netty接收和传递信息都是经过ByteBuf进行的

     @Override
     protected void decode(ChannelHandlerContext channelHandlerContext, Object o, List list) throws Exception {
         ByteBuf byteBuf = (ByteBuf) o;
 //      获取要解码的byte数组
         final byte[] bytes;
         final int length = byteBuf.readableBytes();
         bytes = new byte[length];
         byteBuf.getBytes(byteBuf.readerIndex(),bytes,0,length);
 //      调用MessagePack 的read方法将其反序列化为Object对象
         MessagePack msgPack = new MessagePack();
         list.add(msgPack.read(bytes));
     }

三、服务端代码

 package com.messagePack;

 import io.netty.bootstrap.ServerBootstrap;
 import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelInitializer;
 import io.netty.channel.ChannelOption;
 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 EchoServer {
     public void bind(int port) throws InterruptedException {
         NioEventLoopGroup bossGroup = new NioEventLoopGroup();
         NioEventLoopGroup workGroup = new NioEventLoopGroup();
         try {
             ServerBootstrap b = new ServerBootstrap();
             b.group(bossGroup,workGroup)
                     .channel(NioServerSocketChannel.class)
                     .option(ChannelOption.SO_BACKLOG,1024)
                     .childHandler(new LoggingHandler(LogLevel.INFO))
                     .childHandler(new ChannelInitializer<SocketChannel>() {
                         @Override
                         protected void initChannel(SocketChannel socketChannel) throws Exception {
                             socketChannel.pipeline()
                                     .addLast("decoder",new MsgPackDecoder())
                                     .addLast("encoder",new MsgPackEncoder())
                                     .addLast(new EchoServerHandler());
                         }
                     });
 //          绑定端口，同步等待成功
             ChannelFuture f = b.bind(port).sync();
 //          等待服务端监听端口关闭
             f.channel().closeFuture().sync();
         } finally {
             bossGroup.shutdownGracefully();
             workGroup.shutdownGracefully();
         }
     }
     public static void main(String[] args) throws InterruptedException {
         int port = 8080;
         if(args.length>0&&args!=null){
             port = Integer.parseInt(args[0]);
         }
         new EchoServer().bind(port);

     }
 }

IO处理

 package com.messagePack;

 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelInboundHandlerAdapter;

 import java.util.List;

 public class EchoServerHandler extends ChannelInboundHandlerAdapter {
     int count;
     @Override
     public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
         System.out.println("server receive the msgpack message : "+msg+"");
         // 原路返回给客户端
         ctx.writeAndFlush(msg);
 /*        在EchoClientHandler中向服务端发送一个pojo对象，经过MessagePack编解码后，
         在EchoServerHandler中的channelRead方法中打印的msg为pojo对象的toString方法内容，
         不可以直接将msg转换为User,如果采用如下代码运行不成功*/
 /*        List<User> users = (List<User>) msg;
         System.out.println("到这里面来了,users是否为空：");
         System.out.println(users!=null);
         for(User u : users){
             System.out.println("This is"+ ++count +" times server receive client request."+u);
             ctx.write(u);
         }

         ctx.flush();*/
     }

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

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

坑二、这里的坑比较大，在上述代码注释中已经说明了，下面运行结果是注释掉以上14~16行代码，放开20~28行代码时候运行结果，结果表明收到的消息转化为User数组时候，是空的，但是后台并没有报错，不知道为什么在我的IDEA上运行不下去但是不报错

　　补充解释，这里是因为采用messagepack解码后，得到的是一个Object list列表，所以不能转化为pojo，应该用List<Object> 来接收解码后的msg，同时这个list中的object也不能转化为pojo，它或许是pojo中的具体属性

四、客户端代码

 package com.messagePack;

 import io.netty.bootstrap.Bootstrap;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
 import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelInitializer;
 import io.netty.channel.ChannelOption;
 import io.netty.channel.nio.NioEventLoopGroup;
 import io.netty.channel.socket.SocketChannel;
 import io.netty.channel.socket.nio.NioSocketChannel;
 import io.netty.handler.codec.DelimiterBasedFrameDecoder;
 import io.netty.handler.codec.string.StringDecoder;

 public class EchoClient {
     public void connection(int port,String host) throws InterruptedException {
         NioEventLoopGroup workGroup = new NioEventLoopGroup();
         try {
             Bootstrap b = new Bootstrap();
             b.group(workGroup)
                     .channel(NioSocketChannel.class)
                     .option(ChannelOption.TCP_NODELAY,true)
                     .option(ChannelOption.CONNECT_TIMEOUT_MILLIS,3000)
                     .handler(new ChannelInitializer<SocketChannel>() {
                         @Override
                         protected void initChannel(SocketChannel socketChannel) throws Exception {
                             socketChannel.pipeline().addLast("msgpack decoder",new MsgPackDecoder())
                                     .addLast("msgpack encoder",new MsgPackEncoder())
                                     .addLast(new EchoClientHandler());
 //
                         }
                     });
 //            发起异步连接操作
             ChannelFuture f = b.connect(host,port).sync();
 //                          等待客户端链路关闭
             f.channel().closeFuture().sync();
         } finally {
             workGroup.shutdownGracefully();
         }
     }
     public static void main(String[] args) throws InterruptedException {
         int port = 8080;
         if(args.length>0&&args!=null){
             System.out.println(args[0]);
             port = Integer.parseInt(args[0]);
         }
         new EchoClient().connection(port,"127.0.0.1");
     }
 }

IO处理类

 package com.messagePack;

 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelInboundHandlerAdapter;

 public class EchoClientHandler extends ChannelInboundHandlerAdapter {
     private int count;

     @Override
     public void channelActive(ChannelHandlerContext ctx) throws Exception {
        /* User user = getUser();
         ctx.writeAndFlush(user);*/
         User[] users = getUsers();
         for(User u : users){
             ctx.write(u);
         }
         ctx.flush();
     }

     @Override
     public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
         System.out.println("this is client receive msg【  "+ ++count +"  】times:【"+msg+"】");
        if(count<5){ //控制运行次数，因为不加这个控制直接调用下面代码的话，客户端和服务端会形成闭环循环，一直运行
         ctx.write(msg);
         }
     }

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

     @Override
     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
         ctx.close();
     }
     private User[] getUsers(){
         User[] users = new User[5];
         for(int i=0;i<5;i++){
             User user = new User();
             user.setId(String.valueOf(i));
             user.setAge(18+i);
             user.setName("张元"+i);
             user.setSex("男"+String.valueOf(i*2));
             users[i]=user;
         }
         return users;
     }

     private User getUser(){
             User user = new User();
             user.setId("11");
             user.setAge(18);
             user.setName("张元");
             user.setSex("男");
         return user;
     }
 }

五、User代码

坑三、要传输的javabean一定要加上注解@message

 package com.messagePack;

 import org.msgpack.annotation.Message;

 @Message
 public class User {
     private String name;
     private int age;
     private String id;
     private String sex;

     public int getAge() {
         return age;
     }

     public void setAge(int age) {
         this.age = age;
     }

     public String getId() {
         return id;
     }

     public void setId(String id) {
         this.id = id;
     }

     public String getSex() {
         return sex;
     }

     public void setSex(String sex) {
         this.sex = sex;
     }

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     @Override
     public String toString() {
         return "User{" +
                 "name='" + name + '\'' +
                 ", age=" + age +
                 ", id='" + id + '\'' +
                 ", sex='" + sex + '\'' +
                 '}';
     }
 }

六、运行结果

客户端

服务端

七、上面运行的结果发现打印的数据都完全一样，这是因为没有考虑粘包/半包的处理，还不能正常工作，下面我们利用Netty的LengthFieldPrepender和LengthFieldBasedFrameDecoder,来解决上述问题，这里只需要对客户端和服务端添加相关的处理类就可以了，改动代码如下：

客户端

 .handler(new ChannelInitializer<SocketChannel>() {
                         @Override
                         protected void initChannel(SocketChannel socketChannel) throws Exception {
                             socketChannel.pipeline()
                                     .addLast("frameDecoder",new LengthFieldBasedFrameDecoder(65535,
                                             0,4,0,4))
                                     .addLast("msgpack decoder",new MsgPackDecoder())
                                     .addLast("frameEncoder",new LengthFieldPrepender(4))
                                     .addLast("msgpack encoder",new MsgPackEncoder())
                                     .addLast(new EchoClientHandler());
 //
                         }
                     });

服务端

  .childHandler(new ChannelInitializer<SocketChannel>() {
                         @Override
                         protected void initChannel(SocketChannel socketChannel) throws Exception {
                             socketChannel.pipeline()
                                     .addLast("framDecoder",new LengthFieldBasedFrameDecoder(65535,
                                             0,4,0,4))
                                     .addLast("decoder",new MsgPackDecoder())
                                     .addLast("frameEncoder",new LengthFieldPrepender(4))
                                     .addLast("encoder",new MsgPackEncoder())
                                     .addLast(new EchoServerHandler());
                         }
                     });

其实两者改动的地方完全一样，下面看一下运行效果

客户端

服务端

这次运行结果显示的是0~5的数据，但是遗憾的是不知道为什么有重复了一下，而且之重复了部分的运行，暂时不理会。以后应用多了可能就明白了。或者有路过的朋友知道的留个言，谢谢！