Netty 权威指南之java 序列化

本章相关知识点：

相信大多数的程序员接触到的第一种序列化或者编码技术是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

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

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+"}"; 
    } 
} 

第三节：运行结果

服务端截图：

客户端截图：

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

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