Netty 权威指南之java 序列化

梦里梦外; 2023-10-16 21:50 11阅读 0赞

本章相关知识点：

相信大多数的程序员接触到的第一种序列化或者编码技术是Java序列化，需要实现序列化的POJO对象只需要实现java.io.serlizable接口，根据实际情况生成序列ID，这个类就能通过java.io.ObjectInput 和java.io.ObjectOutput序列化和反序列化。

不需要考虑跨语言调用，对序列化性能没有苛刻的要求，Java默认写序列化机制是最好的选择，真因为如此，Java序列化虽然存在很多弊端，但是依然得到广泛的运用。

本章学习要点：

1、Netty java 序列化服务端开发

2、Netty Java序列化客户端开发

3、运行结果

第一节：Netty java 序列化服务端开发

服务端开发情景如下：Netty服务端接受到客户端的用户订购请求信息，消息定义如图下表7-1

![Center][]

服务端接受到请求信息，对客户合法性进行校验。如果合法，则构造订购成功的应答消息返回个客户端。订购应答消息如表7-2

![Center 1][]

Netty 服务端开发步骤：

1、在服务端ChannelPipline中新增解码器io.netty.handler.codec.serialization.ObjectDecoder

2、在服务端ChannelPipline 中新增解码器io.netty.handler.codec.serialization.ObjectEncoder

3、需要进行java 序列化的POJO对象必须实现java.io.serializable接口。

服务端代码

SubRespServer.java

package com.nio.server;
    
    import com.nio.handler.SubRespServerHandler;
    import io.netty.bootstrap.ServerBootstrap;
    import io.netty.channel.ChannelFuture;
    import io.netty.channel.ChannelInitializer;
    import io.netty.channel.ChannelOption;
    import io.netty.channel.EventLoopGroup;
    import io.netty.channel.nio.NioEventLoopGroup;
    import io.netty.channel.socket.SocketChannel;
    import io.netty.channel.socket.nio.NioServerSocketChannel;
    import io.netty.handler.codec.serialization.ClassResolvers;
    import io.netty.handler.codec.serialization.ObjectDecoder;
    import io.netty.handler.codec.serialization.ObjectEncoder;
    
    /**
     * Created by vixuan-008 on 2015/6/23.
     */
    public class SubRespServer {
        public static void main(String[] args)throws Exception{
            int port=15444;
            new SubRespServer().bind(port);
        }
    
        public void bind(int port)throws Exception{
            //配置服务端的NIO线程池
            EventLoopGroup bossGroup=new NioEventLoopGroup();
            EventLoopGroup workGroup=new NioEventLoopGroup();
            try{
                ServerBootstrap b=new ServerBootstrap();
                b.group(bossGroup, workGroup);
                b.channel(NioServerSocketChannel.class);
                b.option(ChannelOption.SO_BACKLOG, 100);
                b.childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
                        socketChannel.pipeline().addLast(new ObjectDecoder(1024*1024, ClassResolvers.weakCachingConcurrentResolver(this.getClass().getClassLoader())));
                        socketChannel.pipeline().addLast(new ObjectEncoder());
                        socketChannel.pipeline().addLast(new SubRespServerHandler());
    
                    }
                });
                //绑定端口，等待同步成功
                ChannelFuture f=b.bind(port).sync();
                //等待服务端关闭监听端口
                f.channel().closeFuture().sync();
    
            }finally {
                //释放线程池资源
                bossGroup.shutdownGracefully();
                workGroup.shutdownGracefully();
    
            }
    
    
        }
    }

SubRespServerHandler.java

package com.nio.handler;
    
    import com.nio.serlizable.SubscribeReq;
    import com.nio.serlizable.SubscribeResp;
    import io.netty.channel.ChannelHandlerAdapter;
    import io.netty.channel.ChannelHandlerContext;
    
    /**
     * Created by vixuan-008 on 2015/6/23.
     */
    public class SubRespServerHandler extends ChannelHandlerAdapter {
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
            SubscribeReq subscribeReq=(SubscribeReq)msg;
            if(subscribeReq.getUserName().equalsIgnoreCase("zhouzhigang")){
               System.out.println("server rceiver dats is:" + subscribeReq.toString()+"") ;
                ctx.writeAndFlush(resp(subscribeReq.getSubReqId()));
            }
        }
    
        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
            ctx.close();
        }
    
        private SubscribeResp resp(int subReqId){
            SubscribeResp resp=new SubscribeResp();
            resp.setDesc("Netty Book order success,3 day later ,send to the designated address");
            resp.setRespCode("0");
            resp.setSubReqId(subReqId);
            return  resp;
    
        }
    }

第二节：Netty Java序列化客户端开发

SubReqClient.java

package com.nio.client;
    
    import com.nio.handler.SubReqServerHandler;
    import io.netty.channel.ChannelFuture;
    import io.netty.channel.ChannelInitializer;
    import io.netty.channel.ChannelOption;
    import io.netty.channel.EventLoopGroup;
    import io.netty.channel.nio.NioEventLoopGroup;
    import io.netty.channel.socket.SocketChannel;
    
    import io.netty.channel.socket.nio.NioSocketChannel;
    
    import io.netty.handler.codec.serialization.ClassResolvers;
    import io.netty.handler.codec.serialization.ObjectDecoder;
    import io.netty.handler.codec.serialization.ObjectEncoder;
    
    /**
     * Created by vixuan-008 on 2015/6/23.
     */
    public class SubReqClient {
        public static void main(String[] args)throws Exception{
            int port=15444;
            new SubReqClient().bind(port, "127.0.0.1");
        }
        public void bind(int port,String host)throws Exception{
            //配置客户端NIO线程池
            EventLoopGroup workGroup=new NioEventLoopGroup();
            try{
                io.netty.bootstrap.Bootstrap b=new io.netty.bootstrap.Bootstrap();
                b.group(workGroup);
                b.channel(NioSocketChannel.class);
                b.option(ChannelOption.TCP_NODELAY,true);
                b.handler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
    
                        socketChannel.pipeline().addLast(new ObjectDecoder(1024, ClassResolvers.weakCachingConcurrentResolver(this.getClass().getClassLoader())));
                        socketChannel.pipeline().addLast(new ObjectEncoder());
                        socketChannel.pipeline().addLast(new SubReqServerHandler());
                    }
                });
                //发起异步连接操作
                ChannelFuture f=b.connect(host,port).sync();
                //等待客户端链路关闭
                f.channel().closeFuture().sync();
    
            }finally {
                //释放NIO 线程组
                workGroup.shutdownGracefully();
    
            }
    
    
        }
    }

SubReqServerHandler.java

package com.nio.handler;
    
    import com.nio.serlizable.SubscribeReq;
    import io.netty.channel.ChannelHandlerAdapter;
    import io.netty.channel.ChannelHandlerContext;
    
    /**
     * Created by vixuan-008 on 2015/6/23.
     */
    public class SubReqServerHandler extends ChannelHandlerAdapter {
        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {
          for(int i=0;i<10;i++){
              ctx.write(subReq(i));
          }
            ctx.flush();
        }
    
        public SubscribeReq subReq(int i){
            SubscribeReq req=new SubscribeReq();
            req.setAddress("湖南长沙雨花区西子一间");
            req.setPhoneNumber("1877498****");
            req.setUserName("zhouzhigang");
            req.setSubReqId(i);
            req.setProductName("java 开发指南");
            return req;
        }
    
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
            System.out.println("Receiver message is:"+msg);
        }
    
        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
           ctx.close();
        }
    
        @Override
        public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
           ctx.flush();
        }
    }

相关实体类POJO补充：

SubscribeReq.java

package com.nio.serlizable;
    
    /**
     * Created by vixuan-008 on 2015/6/23.
     */
    public class SubscribeReq implements java.io.Serializable {
        private static final long serialVersionUID=1L;
    
        private int subReqId;
        private String userName;
        private String productName;
        private String phoneNumber;
        private String address;
    
        public int getSubReqId() {
            return subReqId;
        }
    
        public void setSubReqId(int subReqId) {
            this.subReqId = subReqId;
        }
    
        public String getUserName() {
            return userName;
        }
    
        public void setUserName(String userName) {
            this.userName = userName;
        }
    
        public String getProductName() {
            return productName;
        }
    
        public void setProductName(String productName) {
            this.productName = productName;
        }
    
        public String getPhoneNumber() {
            return phoneNumber;
        }
    
        public void setPhoneNumber(String phoneNumber) {
            this.phoneNumber = phoneNumber;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        @Override
        public String toString() {
            return "SubscribeReq:{subReqId:"+subReqId+",userName:"+userName+",productName:"+productName+",phoneNumber:"+phoneNumber+",address:"+address+"}";
        }
    }

SubscribeResp.java

package com.nio.serlizable;
    
    /**
     * Created by vixuan-008 on 2015/6/23.
     */
    public class SubscribeResp implements java.io.Serializable {
        private static final long serialVersionUID=1L;
    
        private int subReqId;
        private String respCode;
        private String desc;
    
        public int getSubReqId() {
            return subReqId;
        }
    
        public void setSubReqId(int subReqId) {
            this.subReqId = subReqId;
        }
    
        public String getRespCode() {
            return respCode;
        }
    
        public void setRespCode(String respCode) {
            this.respCode = respCode;
        }
    
        public String getDesc() {
            return desc;
        }
    
        public void setDesc(String desc) {
            this.desc = desc;
        }
    
        @Override
        public String toString() {
            return "SubscribeResp:{subReqId:"+subReqId+",respCode:"+respCode+",desc:"+desc+"}";
        }
    }

第三节：运行结果

服务端截图：

![Center 2][]

客户端截图：

![Center 3][]

总结：本章节重点介绍如何使用Netty 提供的ObjectEncoed编码器和ObjectDecode 解码器实现对普通POJO的序列化。通过订书Demo，我们学习了服务端和客户端的开发，并且模拟TCP的粘包和拆包场景，对运行结果进行了相关分析。

通过使用Netty的Java序列化编解码handler,用户通过短短的几行代码，就能完成POJO的序列化和反序列化。在业务处理handler中，用户只需要将精力聚焦业务逻辑的实现上，不需要关心底层代码的实现，这极大的提高开发效率。

[Center]: https://img-blog.csdn.net/20150623155440197?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvemhvdXpoaXdlbmdhbmc=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
[Center 1]: https://img-blog.csdn.net/20150623155718300?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvemhvdXpoaXdlbmdhbmc=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
[Center 2]: https://img-blog.csdn.net/20150623170025102?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvemhvdXpoaXdlbmdhbmc=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
[Center 3]: https://img-blog.csdn.net/20150623170052718?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvemhvdXpoaXdlbmdhbmc=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center