5.7 JDK序列化

2018-09-09 20:36:35 310 2

1 ObjectEncoder与ObjectDecoder简介

        ObjectEncoder/ObjectDecoder使用JDK序列化机制编解码,因此我们可以使用Java对象作为请求和响应参数,限制是对象必须实现Serializable。JDK序列化机制的缺点是:序列化的性能以及序列化后对象占用的字节数比较多。优点是:这是对JDK默认支持的机制,不需要引入第三方依赖。

        如果仅仅是对象序列化,字节通过网络传输后,那么在解码时,无法判断到底多少个字节可以构成一个Java对象。因此需要结合长度编码,也就是添加一个Length字段,表示序列化后的字节占用的字节数。因此ObjectEncoder/ObjectDecoder采用的通信协议如下: 

+--------+----------+
| Length |  Content |
+--------+----------+

   其中:    

  • Length:表示Content字段占用的字节数,Length本身占用的字节数我们可以指定为一个固定的值

  • Content:对象经过JDK序列化后二进制字节内容     

       乍一看,这与我们在上一节讲解的LengthFieldBasedFrameDecoder/LengthFieldPrepender采用的通信协议很类似。事实上ObjectDecoder本身就继承了LengthFieldBasedFrameDecoder。不过ObjectEncoder略有不同,其并没有继承LengthFieldPrepender,而是内部直接添加了Length字段。 

ObjectEncoder源码如下:

@Sharable
public class ObjectEncoder extends MessageToByteEncoder<Serializable> {
    private static final byte[] LENGTH_PLACEHOLDER = new byte[4];
    //当需要编码时,encode方法会被回调 
    //参数msg:就是我们需要序列化的java对象
    //参数out:我们需要将序列化后的二进制字节写到ByteBuf中
    @Override
    protected void encode(ChannelHandlerContext ctx, Serializable msg, ByteBuf out) throws Exception {
        int startIdx = out.writerIndex();
        //ByteBufOutputStream是Netty提供的输出流,数据写入其中之后,可以通过其buffer()方法会的对应的ByteBuf实例
        ByteBufOutputStream bout = new ByteBufOutputStream(out);
        //JDK序列化机制的ObjectOutputStream
        ObjectOutputStream oout = null;
        try {
            //首先占用4个字节,这就是Length字段的字节数,这只是占位符,后面为填充对象序列化后的字节数
            bout.write(LENGTH_PLACEHOLDER);
            //CompactObjectOutputStream是netty提供的类,其实现了JDK的ObjectOutputStream,顾名思义用于压缩
            //同时把bout作为其底层输出流,意味着对象序列化后的字节直接写到了bout中
            oout = new CompactObjectOutputStream(bout);
            //调用writeObject方法,即表示开始序列化
            oout.writeObject(msg);
            oout.flush();
        } finally {
            if (oout != null) {
                oout.close();
            } else {
                bout.close();
            }
        }
        int endIdx = out.writerIndex();
        //序列化完成,设置占位符的值,也就是对象序列化后的字节数量
        out.setInt(startIdx, endIdx - startIdx - 4);
    }
}

ObjectDecoder源码如下所示:

//注意ObjectDecoder继承了LengthFieldBasedFrameDecoder
public class ObjectDecoder extends LengthFieldBasedFrameDecoder {
    
    private final ClassResolver classResolver;
    public ObjectDecoder(ClassResolver classResolver) {
        this(1048576, classResolver);
    }
    //参数maxObjectSize:表示可接受的对象反序列化的最大字节数,默认为1048576 bytes,约等于1M
    //参数classResolver:由于需要将二进制字节反序列化为Java对象,需要指定一个ClassResolver来加载这个类的字节码对象
    public ObjectDecoder(int maxObjectSize, ClassResolver classResolver) {
        //调用父类LengthFieldBasedFrameDecoder构造方法,关于这几个参数的作用,参见之前章节的分析
        super(maxObjectSize, 0, 4, 0, 4);
        this.classResolver = classResolver;
    }
    //当需要解码时,decode方法会被回调
    @Override
    protected Object decode(ChannelHandlerContext ctx, ByteBuf in) throws Exception {
        //首先调用父类的decode方法进行解码,会解析出包含可解析为java对象的完整二进制字节封装到ByteBuf中,同时Length字段的4个字节会被删除
        ByteBuf frame = (ByteBuf) super.decode(ctx, in);
        if (frame == null) {
            return null;
        }
        //构造JDK ObjectInputStream实例用于解码
        ObjectInputStream ois = new CompactObjectInputStream(new ByteBufInputStream(frame, true), classResolver);
        try {
            //调用readObject方法进行解码,其返回的就是反序列化之后的Java对象
            return ois.readObject();
        } finally {
            ois.close();
        }
    }
}

下面我们通过实际案例来演示ObjectEncoder与ObjectDecoder的使用。

2 使用案例

首先我们分别编写两个Java对象Request/Response分别表示请求和响应。 

public class Request implements Serializable{
    private String request;
    private Date requestTime;
    //setters getters and toString
}
public class Response implements Serializable{
    private String response;
    private Date responseTime;
    //setters getters and toString
}


  接着我们编写Client端代码:

public class JdkSerializerClient {
    public static void main(String[] args) throws Exception {
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap(); // (1)
            b.group(workerGroup); // (2)
            b.channel(NioSocketChannel.class); // (3)
            b.option(ChannelOption.SO_KEEPALIVE, true); // (4)
            b.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                public void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new ObjectEncoder());
                    ch.pipeline().addLast(new ObjectDecoder(new ClassResolver() {
                        public Class<?> resolve(String className) throws ClassNotFoundException {
                            return Class.forName(className);
                        }
                    }));
                    ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                        // 在于server建立连接后,即发送请求报文
                        public void channelActive(ChannelHandlerContext ctx) {
                            Request request = new Request();
                            request.setRequest("i am request!");
                            request.setRequestTime(new Date());
                            ctx.writeAndFlush(request);
                        }
                        //接受服务端的响应
                        @Override
                        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                            Response response= (Response) msg;
                            System.out.println("receive response:"+response);
                        }
                    });
                }
            });
            // Start the client.
            ChannelFuture f = b.connect("127.0.0.1", 8080).sync(); // (5)
            // Wait until the connection is closed.
            f.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
        }
    }
}

        由于client既要发送Java对象Request作为请求,又要接受服务端响应的Response对象,因此在ChannelPipeline中,我们同时添加了ObjectDecoder和ObjectEncoder。

        另外我们自定义了一个ChannelInboundHandler,在连接建立时,其channelActive方法会被回调,我们在这个方法中构造一个Request对象发送,通过ObjectEncoder进行编码。服务端会返回一个Response对象,此时channelRead方法会被回调,由于已经经过ObjectDecoder解码,因此可以直接转换为Reponse对象,然后打印。

server端: 

public class JdkSerializerServer {
    public static void main(String[] args) throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup(); // (1)
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap(); // (2)
            b.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class) // (3)
                    .childHandler(new ChannelInitializer<SocketChannel>() { // (4)
                        @Override
                        public void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new ObjectEncoder());
                            ch.pipeline().addLast(new ObjectDecoder(new ClassResolver() {
                                public Class<?> resolve(String className) throws ClassNotFoundException {
                                    return Class.forName(className);
                                }
                            }));
                            // 自定义这个ChannelInboundHandler打印拆包后的结果
                            ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                                @Override
                                public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                                    Request request= (Request) msg;
                                    System.out.println("receive request:"+request);
                                    Response response = new Response();
                                    response.setResponse("response to:"+request.getRequest());
                                    response.setResponseTime(new Date());
                                    ctx.writeAndFlush(response);
                                }
                            });
                        }
                    });
            // Bind and start to accept incoming connections.
            ChannelFuture f = b.bind(8080).sync(); // (7)
            System.out.println("JdkSerializerServer Started on 8080...");
            f.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }
}

Server端与Client端分析类似,这里不再赘述。

先后启动Server端与Client端,在Server端控制台我们将看到: 

JdkSerializerServer Started on 8080...
receive request:Request{request='i am request!', requestTime=2018-9-9 18:47:30}

在Client端控制台我们将看到:

receive response:Response{response='response to:i am request!', responseTime=2018-9-9 18:48:36}

到此,我们的案例完成。Request和Response都编码、解码成功了。

3 总结

    把ObjectEncoder/ObjectDecoder作为序列化/反序列化入门是非常合适的,因为其足够简单。同时通过这个案例,我们也发现了,通信协议中必须包含了一个Length字段,用于表示对象序列化后的字节数。事实上,这种模式也可以套用到我们接下来要介绍的其他序列化框架中。