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的数据，但是遗憾的是不知道为什么有重复了一下，而且之重复了部分的运行，暂时不理会。以后应用多了可能就明白了。或者有路过的朋友知道的留个言，谢谢！