大多數Java程序員接觸到的第一種序列化或者編解碼技術就是Java的默認序列化，只需要序列化的POJO對象實現java.io.Serializable接口，根據實際情況生成序列ID，這個類就能夠通過java.io.ObjectInput和java.io.ObjectOutput序列化和反序列化。
不需要考慮跨語言調用，對序列化的性能也沒有苛刻的要求時，Java默認的序列化機制是最明智的選擇之一。正因為此，雖然Java序列化機制存在着一些弊病(性能低，不能跨語言，碼流大)，卻依然得到了廣泛的應用。
開發場景設計
服務端開發的場景如下：Netty服務端接收到客戶端的用戶訂購請求消息，消息定義如表：
服務端接收到請求消息，對用戶名進行合法性校驗。如果合法，則構造訂購成功的應答消息返回給客戶端。訂購應答消息的定義如表：
使用Netty的ObjectEncoder和ObjectDecoder對訂購請求和應答消息進行序列化。
import lombok.Data; import java.io.Serializable; @Data public class SubscribeReq implements Serializable { /** * 默認的序列號ID */ private static final long serialVersionUID = 1L; private int subReqID; private String userName; private String productName; private String phoneNumber; private String address; @Override public String toString() { return "SubscribeReq [subReqID=" + subReqID + ", userName=" + userName + ", productName=" + productName + ", phoneNumber=" + phoneNumber + ", address=" + address + "]"; } } import lombok.Data; import java.io.Serializable; @Data public class SubscribeResp implements Serializable { /** * 默認序列ID */ private static final long serialVersionUID = 1L; private int subReqID; private int respCode; private String desc; @Override public String toString() { return "SubscribeResp [subReqID=" + subReqID + ", respCode=" + respCode + ", desc=" + desc + "]"; } }
Java序列化服務端示例：
使用Netty對POJO對象進行序列化的開發步驟如下。
（1）在服務端ChannelPipeline中新增解碼器io.netty.handler.codec.serialization.Object Decoder；
（2）在服務端ChannelPipeline中新增編碼器io.netty.handler.codec.serialization.Object Encoder；
（3）需要進行Java序列化的POJO對象必須實現java.io.Serializable接口。
import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.*; import io.netty.channel.nio.NioEventLoopGroup; 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; import io.netty.handler.logging.LogLevel; import io.netty.handler.logging.LoggingHandler; public class SubReqServer { public void bind(int port) throws Exception { // 配置服務端的NIO線程組 EventLoopGroup bossGroup = new NioEventLoopGroup(); EventLoopGroup workerGroup = new NioEventLoopGroup(); try { ServerBootstrap b = new ServerBootstrap(); b.group(bossGroup, workerGroup) .channel(NioServerSocketChannel.class) .option(ChannelOption.SO_BACKLOG, 100) .handler(new LoggingHandler(LogLevel.INFO)) .childHandler(new ChannelInitializer() { @Override public void initChannel(Channel ch) { ch.pipeline().addLast( //首先創建了一個新的ObjectDecoder,它負責對實現Serializable的POJO對象進行解碼 //它有多個構造函數，支持不同的ClassResolver new ObjectDecoder( //為了防止異常碼流和解碼錯位導致的內存溢出，這里將單個對象最大序列化后的字節數組長度設置為1M，作為例程它已經足夠使用。 1024 * 1024, //在此我們使用weakCachingConcurrentResolver創建線程安全的WeakReferenceMap對類加載器進行緩存， //它支持多線程並發訪問，內存不足時，會釋放緩存中的內存，防止內存泄漏。 ClassResolvers.weakCachingConcurrentResolver( this.getClass().getClassLoader()))); //新增了一個ObjectEncoder，它可以在消息發送的時候自動將實現Serializable的POJO對象進行編碼， //因此用戶無須親自對對象進行手工序列化，只需要關注自己的業務邏輯處理即可，對象序列化和反序列化都由Netty的對象編解碼器搞定。 ch.pipeline().addLast(new ObjectEncoder()); //將訂購處理handler SubReqServerHandler添加到ChannelPipeline的尾部用於業務邏輯處理， ch.pipeline().addLast(new SubReqServerHandler()); } }); // 綁定端口，同步等待成功 ChannelFuture f = b.bind(port).sync(); // 等待服務端監聽端口關閉 f.channel().closeFuture().sync(); } finally { // 優雅退出，釋放線程池資源 bossGroup.shutdownGracefully(); workerGroup.shutdownGracefully(); } } public static void main(String[] args) throws Exception { int port = 8080; if (args != null && args.length > 0) { try { port = Integer.valueOf(args[0]); } catch (NumberFormatException e) { // 采用默認值 } } new SubReqServer().bind(port); } } import io.netty.channel.ChannelHandler; import io.netty.channel.ChannelHandlerAdapter; import io.netty.channel.ChannelHandlerContext; @ChannelHandler.Sharable public class SubReqServerHandler extends ChannelHandlerAdapter { @Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { //經過解碼器handler ObjectDecoder的解碼， //SubReqServerHandler接收到的請求消息已經被自動解碼為SubscribeReq對象，可以直接使用。 SubscribeReq req = (SubscribeReq) msg; if ("Lilinfeng".equalsIgnoreCase(req.getUserName())) { System.out.println("Service accept client subscribe req : [" + req.toString() + "]"); //對訂購者的用戶名進行合法性校驗，校驗通過后打印訂購請求消息，構造訂購成功應答消息立即發送給客戶端。 ctx.writeAndFlush(resp(req.getSubReqID())); } } private SubscribeResp resp(int subReqID) { SubscribeResp resp = new SubscribeResp(); resp.setSubReqID(subReqID); resp.setRespCode(0); resp.setDesc("Netty book order succeed, 3 days later, sent to the designated address"); return resp; } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { cause.printStackTrace(); ctx.close();// 發生異常，關閉鏈路 } }
Java序列化客戶端示例：
客戶端的設計思路如下。
（1）創建客戶端的時候將Netty對象解碼器和編碼器添加到ChannelPipeline；
（2）鏈路被激活的時候構造訂購請求消息發送，為了檢驗Netty的Java序列化功能是否支持TCP粘包/拆包，客戶端一次構造10條訂購請求，最后一次性發送給服務端；
（3）客戶端訂購處理handler將接收到的訂購響應消息打印出來。
import io.netty.bootstrap.Bootstrap; import io.netty.channel.*; import io.netty.channel.nio.NioEventLoopGroup; 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; public class SubReqClient { public void connect(int port, String host) throws Exception { // 配置客戶端NIO線程組 EventLoopGroup group = new NioEventLoopGroup(); try { Bootstrap b = new Bootstrap(); b.group(group).channel(NioSocketChannel.class) .option(ChannelOption.TCP_NODELAY, true) .handler(new ChannelInitializer() { @Override public void initChannel(Channel ch) throws Exception { ch.pipeline().addLast( //我們禁止對類加載器進行緩存，它在基於OSGi的動態模塊化編程中經常使用。 //由於OSGi的bundle可以進行熱部署和熱升級，當某個bundle升級后， //它對應的類加載器也將一起升級，因此在動態模塊化編程過程中， //很少對類加載器進行緩存，因為它隨時可能會發生變化。 new ObjectDecoder(1024, ClassResolvers .cacheDisabled(this.getClass() .getClassLoader()))); ch.pipeline().addLast(new ObjectEncoder()); ch.pipeline().addLast(new SubReqClientHandler()); } }); // 發起異步連接操作 ChannelFuture f = b.connect(host, port).sync(); // 等待客戶端鏈路關閉 f.channel().closeFuture().sync(); } finally { // 優雅退出，釋放NIO線程組 group.shutdownGracefully(); } } public static void main(String[] args) throws Exception { int port = 8080; if (args != null && args.length > 0) { try { port = Integer.valueOf(args[0]); } catch (NumberFormatException e) { // 采用默認值 } } new SubReqClient().connect(port, "127.0.0.1"); } } import io.netty.channel.ChannelHandlerAdapter; import io.netty.channel.ChannelHandlerContext; public class SubReqClientHandler extends ChannelHandlerAdapter { public SubReqClientHandler() { } @Override public void channelActive(ChannelHandlerContext ctx) { //在鏈路激活的時候循環構造10條訂購請求消息，最后一次性地發送給服務端。 for (int i = 0; i < 10; i++) { ctx.write(subReq(i)); } ctx.flush(); } private SubscribeReq subReq(int i) { SubscribeReq req = new SubscribeReq(); req.setAddress("南京市江寧區方山國家地質公園"); req.setPhoneNumber("138xxxxxxxxx"); req.setProductName("Netty 權威指南"); req.setSubReqID(i); req.setUserName("Lilinfeng"); return req; } @Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { //由於對象解碼器已經對訂購請求應答消息進行了自動解碼， //因此，SubReqClientHandler接收到的消息已經是解碼成功后的訂購應答消息。 System.out.println("Receive server response : [" + msg + "]"); } @Override public void channelReadComplete(ChannelHandlerContext ctx) throws Exception { ctx.flush(); } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { cause.printStackTrace(); ctx.close(); } }
運行結果：
服務端運行結果如下:
Service accept client subscribe req : [SubscribeReq [subReqID=0, userName= Lilinfeng, productName=Netty 權威指南, phoneNumber=138xxxxxxxxx, address=南京市江寧區方山國家地質公園]]
...................................................................................
Service accept client subscribe req : [SubscribeReq [subReqID=9, userName= Lilinfeng, productName=Netty 權威指南, phoneNumber=138xxxxxxxxx, address=南京市江寧區方山國家地質公園]]
盡管客戶端一次批量發送了10條訂購請求消息，TCP會對請求消息進行粘包和拆包，但是並沒有影響最終的運行結果：服務端成功收到了10條訂購請求消息，與客戶端發送的一致。
客戶端運行結果如下:
Receive server response : [SubscribeResp [subReqID=0, respCode=0, desc=Netty book order succeed, 3 days later, sent to the designated address]]
...................................................................................
Receive server response : [SubscribeResp [subReqID=9, respCode=0, desc=Netty book order succeed, 3 days later, sent to the designated address]]
客戶端接收到了10條訂購應答消息，Netty的ObjectEncoder編碼器可以自動對訂購應答消息進行序列化，然后發送給客戶端，客戶端的ObjectDecoder對碼流進行反序列化，獲得訂購請求應答消息。