（中級篇 NettyNIO編解碼開發）第七章-java序列化

時間 2020-06-29

原文原文鏈接

相信大多數Java程序員接觸到的第一種序列化或者編解碼技術就是.Java的默認序列化，只須要序列化的POJO對象實現java.io.Serializable接口，根據實際狀況生成序列ID,
這個類就可以經過java.io.Objectlnput和java.io.ObjectOutput序列化和反序列化。
不須要考慮跨語言調用，對序列化的性能也沒有苛刻的要求時，Java默認的序列化機制是最明智的選擇之一。正由於此，雖然Java序列化機制存在着一些弊病，依然獲得了普遍的應用。
本章主要內容包括：

1。NettyJava序列化服務端開發
2。NettyJava序列化客戶端開發
3.運行Java序列化應用例程

7.1 NettyJava序列化服務端開發

服務端開發的場景以下：Netty 服務端接收到客戶端的用戶訂購請求消息，消息定義
如表7-1所示。
java

7-1 NettyJava序列化訂購請求POJO類定義程序員

  1 package lqy6_serializablePojo_127;
  2 
  3 import java.io.Serializable;
  4 /**
  5  * @author Lilinfeng
  6  * @date 2014年2月23日
  7  * @version 1.0
  8  */
  9 public class SubscribeReq implements Serializable {
 10     
 11     /**
 12      * 默認的序列號ID
 13      */
 14     private static final long serialVersionUID = 1L;
 15 
 16     private int subReqID;
 17 
 18     private String userName;
 19 
 20     private String productName;
 21 
 22     private String phoneNumber;
 23 
 24     private String address;
 25 
 26     /**
 27      * @return the subReqID
 28      */
 29     public final int getSubReqID() {
 30     return subReqID;
 31     }
 32 
 33     /**
 34      * @param subReqID
 35      *            the subReqID to set
 36      */
 37     public final void setSubReqID(int subReqID) {
 38     this.subReqID = subReqID;
 39     }
 40 
 41     /**
 42      * @return the userName
 43      */
 44     public final String getUserName() {
 45     return userName;
 46     }
 47 
 48     /**
 49      * @param userName
 50      *            the userName to set
 51      */
 52     public final void setUserName(String userName) {
 53     this.userName = userName;
 54     }
 55 
 56     /**
 57      * @return the productName
 58      */
 59     public final String getProductName() {
 60     return productName;
 61     }
 62 
 63     /**
 64      * @param productName
 65      *            the productName to set
 66      */
 67     public final void setProductName(String productName) {
 68     this.productName = productName;
 69     }
 70 
 71     /**
 72      * @return the phoneNumber
 73      */
 74     public final String getPhoneNumber() {
 75     return phoneNumber;
 76     }
 77 
 78     /**
 79      * @param phoneNumber
 80      *            the phoneNumber to set
 81      */
 82     public final void setPhoneNumber(String phoneNumber) {
 83     this.phoneNumber = phoneNumber;
 84     }
 85 
 86     /**
 87      * @return the address
 88      */
 89     public final String getAddress() {
 90     return address;
 91     }
 92 
 93     /**
 94      * @param address
 95      *            the address to set
 96      */
 97     public final void setAddress(String address) {
 98     this.address = address;
 99     }
100 
101     /*
102      * (non-Javadoc)
103      * 
104      * @see java.lang.Object#toString()
105      */
106     @Override
107     public String toString() {
108     return "SubscribeReq [subReqID=" + subReqID + ", userName=" + userName
109         + ", productName=" + productName + ", phoneNumber="
110         + phoneNumber + ", address=" + address + "]";
111     }
112 }

SubscribeReq是個普通的JOJO對象，須要強調的有兩點。
(1）第9行實現Serializable接口；
(2）第14行自動生成默認的序列化ID；

下面繼續看訂購應答POJO類。
NettyJava序列化訂購應答POJO類定義編程

package lqy6_serializablePojo_127;

import java.io.Serializable;

/**
 * @author Lilinfeng
 * @date 2014年2月23日
 * @version 1.0
 */
public class SubscribeResp implements Serializable {

    /**
     * 默認序列ID
     */
    private static final long serialVersionUID = 1L;

    private int subReqID;

    private int respCode;

    private String desc;

    /**
     * @return the subReqID
     */
    public final int getSubReqID() {
    return subReqID;
    }

    /**
     * @param subReqID
     *            the subReqID to set
     */
    public final void setSubReqID(int subReqID) {
    this.subReqID = subReqID;
    }

    /**
     * @return the respCode
     */
    public final int getRespCode() {
    return respCode;
    }

    /**
     * @param respCode
     *            the respCode to set
     */
    public final void setRespCode(int respCode) {
    this.respCode = respCode;
    }

    /**
     * @return the desc
     */
    public final String getDesc() {
    return desc;
    }

    /**
     * @param desc
     *            the desc to set
     */
    public final void setDesc(String desc) {
    this.desc = desc;
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
    return "SubscribeResp [subReqID=" + subReqID + ", respCode=" + respCode
        + ", desc=" + desc + "]";
    }

}

NettyJava序列化訂購服務端主函數SubReqServerbootstrap

 1 package lqy6_serializableNetty_127;
 2 
 3 import io.netty.bootstrap.ServerBootstrap;
 4 import io.netty.channel.ChannelFuture;
 5 import io.netty.channel.ChannelInitializer;
 6 import io.netty.channel.ChannelOption;
 7 import io.netty.channel.EventLoopGroup;
 8 import io.netty.channel.nio.NioEventLoopGroup;
 9 import io.netty.channel.socket.SocketChannel;
10 import io.netty.channel.socket.nio.NioServerSocketChannel;
11 import io.netty.handler.codec.serialization.ClassResolvers;
12 import io.netty.handler.codec.serialization.ObjectDecoder;
13 import io.netty.handler.codec.serialization.ObjectEncoder;
14 import io.netty.handler.logging.LogLevel;
15 import io.netty.handler.logging.LoggingHandler;
16 
17 /**
18  * @author lilinfeng
19  * @date 2014年2月14日
20  * @version 1.0
21  */
22 public class SubReqServer {
23     public void bind(int port) throws Exception {
24     // 配置服務端的NIO線程組
25     EventLoopGroup bossGroup = new NioEventLoopGroup();
26     EventLoopGroup workerGroup = new NioEventLoopGroup();
27     try {
28         ServerBootstrap b = new ServerBootstrap();
29         b.group(bossGroup, workerGroup)
30             .channel(NioServerSocketChannel.class)
31             .option(ChannelOption.SO_BACKLOG, 100)
32             .handler(new LoggingHandler(LogLevel.INFO))
33             .childHandler(new ChannelInitializer<SocketChannel>() {
34             @Override
35             public void initChannel(SocketChannel ch) {
36                 ch.pipeline()
37                     .addLast(
38                         new ObjectDecoder(
39                             1024 * 1024,
40                             ClassResolvers
41                                 .weakCachingConcurrentResolver(this .getClass()
42                                     .getClassLoader())));
43                 ch.pipeline().addLast(new ObjectEncoder());
44                 ch.pipeline().addLast(new SubReqServerHandler());
45             }
46             });
47 
48         // 綁定端口，同步等待成功
49         ChannelFuture f = b.bind(port).sync();
50 
51         // 等待服務端監聽端口關閉
52         f.channel().closeFuture().sync();
53     } finally {
54         // 優雅退出，釋放線程池資源
55         bossGroup.shutdownGracefully();
56         workerGroup.shutdownGracefully();
57     }
58     }
59 
60     public static void main(String[] args) throws Exception {
61     int port = 8080;
62     if (args != null && args.length > 0) {
63         try {
64         port = Integer.valueOf(args[0]);
65         } catch (NumberFormatException e) {
66         // 採用默認值
67         }
68     }
69     new SubReqServer().bind(port);
70     }
71 }

從35行開始進行分析。首先建立了一個新的ObjectDecoder，它負責對實現Serializable的POJ0對象進行解碼，它有多個構造函數，支持不一樣的ClassResolver，在此咱們使用weakCachingConcurrentResolver建立線程安全的WeakReferenceMap對類加載器進行緩存，它支持多線程併發訪問，當虛擬機內存不足時，會釋放緩存中的內存，防止內存泄漏。爲了防止異常碼流和解碼錯位致使的內存溢出，這裏將單個對象最大序列化後的字節數組長度設置爲IM，做爲例程它已經足夠使用。數組

第43行新增了一個ObjectEncoder，它能夠在消息發送的時候自動將實現Serializable的POJO對象進行編碼，所以用戶無須親自對對象進行手工序列化，只須要關注本身的業務應輯處理便可，對象序列化和反序列化都由Netty的對象編解碼器搞定。緩存

第44行將訂購處理SubReqServerHandler添加到ChannelPipeline的尾部用於業務邏輯處理，安全

下面咱們看下SubReqServerHandler是如何實現的。多線程

 1 package lqy6_serializableNetty_127;
 2 
 3 import io.netty.channel.ChannelHandler.Sharable;
 4 import io.netty.channel.ChannelHandlerAdapter;
 5 import io.netty.channel.ChannelHandlerContext;
 6 import lqy6_serializablePojo_127.SubscribeReq;
 7 import lqy6_serializablePojo_127.SubscribeResp;
 8 
 9 /**
10  * @author lilinfeng
11  * @date 2014年2月14日
12  * @version 1.0
13  */
14 @Sharable
15 public class SubReqServerHandler extends ChannelHandlerAdapter {
16 
17     @Override
18     public void channelRead(ChannelHandlerContext ctx, Object msg)
19         throws Exception {
20     SubscribeReq req = (SubscribeReq) msg;
21     if ("Lilinfeng".equalsIgnoreCase(req.getUserName())) {
22         System.out.println("Service accept client subscrib req : ["
23             + req.toString() + "]");
24         ctx.writeAndFlush(resp(req.getSubReqID()));
25     }
26     }
27 
28     private SubscribeResp resp(int subReqID) {
29     SubscribeResp resp = new SubscribeResp();
30     resp.setSubReqID(subReqID);
31     resp.setRespCode(0);
32     resp.setDesc("Netty book order succeed, 3 days later, sent to the designated address");
33     return resp;
34     }
35 
36     @Override
37     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
38     cause.printStackTrace();
39     ctx.close();// 發生異常，關閉鏈路
40     }
41 }

通過解碼器handlerObjectDecoder的解碼，SubReqServerHandler 接收到的請求消息已經被自動解碼爲SubscribeReq對象，能夠直接使用。併發

第21行對訂購者的用戶名進行合法性校驗，校驗經過後打印訂購請求消息，構造訂購成功應答消息當即發送給客戶端。異步

下面繼續進行產品訂購客戶端的開發

7.2 Java序列化Netty客戶端開發

客戶端的設計思路以下。

(1）建立客戶端的時候將Netty對象解碼器和編碼器添加到ChannelPipeline;
(2）鏈路被激活的時候構造訂購請求消息發送，爲了檢驗Netty的Java序列化功能是否支持TCP粘包／拆包，客戶端一次構造10條訂購請求，最後一次性發送給服務端：
(3）客戶端訂購處理handle將接收到的訂購響應消息打印出來。面咱們具體看下客戶端的代碼實現。

客戶踹開發例程

7-5 NettyJava序列化產品訂購客戶端

 1 package lqy6_serializableNetty_127;
 2 
 3 import io.netty.bootstrap.Bootstrap;
 4 import io.netty.channel.ChannelFuture;
 5 import io.netty.channel.ChannelInitializer;
 6 import io.netty.channel.ChannelOption;
 7 import io.netty.channel.EventLoopGroup;
 8 import io.netty.channel.nio.NioEventLoopGroup;
 9 import io.netty.channel.socket.SocketChannel;
10 import io.netty.channel.socket.nio.NioSocketChannel;
11 import io.netty.handler.codec.serialization.ClassResolvers;
12 import io.netty.handler.codec.serialization.ObjectDecoder;
13 import io.netty.handler.codec.serialization.ObjectEncoder;
14 
15 /**
16  * @author lilinfeng
17  * @date 2014年2月14日
18  * @version 1.0
19  */
20 public class SubReqClient {
21     public void connect(int port, String host) throws Exception {
22     // 配置客戶端NIO線程組
23     EventLoopGroup group = new NioEventLoopGroup();
24     try {
25         Bootstrap b = new Bootstrap();
26         b.group(group).channel(NioSocketChannel.class)
27             .option(ChannelOption.TCP_NODELAY, true)
28             .handler(new ChannelInitializer<SocketChannel>() {
29             @Override
30             public void initChannel(SocketChannel ch)
31                 throws Exception {
32                 ch.pipeline().addLast(
33                     new ObjectDecoder(1024, ClassResolvers
34                         .cacheDisabled(this.getClass() .
35                                 getClassLoader())));
36                 ch.pipeline().addLast(new ObjectEncoder());
37                 ch.pipeline().addLast(new SubReqClientHandler());
38             }
39             });
40 
41         // 發起異步鏈接操做
42         ChannelFuture f = b.connect(host, port).sync();
43 
44         // 當代客戶端鏈路關閉
45         f.channel().closeFuture().sync();
46     } finally {
47         // 優雅退出，釋放NIO線程組
48         group.shutdownGracefully();
49     }
50     }
51 
52     /**
53      * @param args
54      * @throws Exception
55      */
56     public static void main(String[] args) throws Exception {
57     int port = 8080;
58     if (args != null && args.length > 0) {
59         try {
60         port = Integer.valueOf(args[0]);
61         } catch (NumberFormatException e) {
62         // 採用默認值
63         }
64     }
65     new SubReqClient().connect(port, "127.0.0.1");
66     }
67 }

第32行，咱們禁止對類加載器進行緩存，它在基於OSGi的動態模塊化編程中常常使用。因爲OSGi的bundle能夠進行熱部署和熱升級，當某個bundle升級後，它對應的類加載器也將一塊兒升級，所以在動態模塊化編程過程當中，不多對類加載器進行緩存，由於它隨時可能會發生變化

下面繼續看下SubReqClientHandler的實現。

 1 package lqy6_serializableNetty_127;
 2 
 3 import io.netty.channel.ChannelHandlerAdapter;
 4 import io.netty.channel.ChannelHandlerContext;
 5 import lqy6_serializablePojo_127.SubscribeReq;
 6 
 7 
 8 /**
 9  * @author lilinfeng
10  * @date 2014年2月14日
11  * @version 1.0
12  */
13 public class SubReqClientHandler extends ChannelHandlerAdapter {
14     /**
15      * Creates a client-side handler.
16      */
17     public SubReqClientHandler() {
18     }
19 
20     @Override
21     public void channelActive(ChannelHandlerContext ctx) {
22     for (int i = 0; i < 10; i++) {
23         ctx.write(subReq(i));
24     }
25     ctx.flush();
26     }
27 
28     private SubscribeReq subReq(int i) {
29     SubscribeReq req = new SubscribeReq();
30     req.setAddress("南京市雨花臺區軟件大道101號華爲基地");
31     req.setPhoneNumber("138xxxxxxxxx");
32     req.setProductName("Netty 最佳實踐和原理分析");
33     req.setSubReqID(i);
34     req.setUserName("Lilinfeng");
35     return req;
36     }
37 
38     @Override
39     public void channelRead(ChannelHandlerContext ctx, Object msg)
40         throws Exception {
41     System.out.println("Receive server response : [" + msg + "]");
42     }
43 
44     @Override
45     public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
46     ctx.flush();
47     }
48 
49     @Override
50     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
51     cause.printStackTrace();
52     ctx.close();
53     }
54 }

第22~25行，在鏈路激活的時候循環構造10條訂購請求消息，最後一次性地發送給服務端。因爲對象解碼器已經對訂購請求應答消息進行了自動解碼，此，SubReqClientHandler接收到的消息已是解碼成功後的訂購應答消息。

下面的小節將執行咱們前面開發的訂購請求客戶端和服務端，看下執行結果是否符合設計預期。

7.3 運行結果

運行Java例程

首先運行服務端，而後運行客戶端，運行結果以下。服務端運行結果以下。

 1 Service accept client subscrib req : [SubscribeReq [subReqID=0, userName=Lilinfeng, productName=Netty 最佳實踐和原理分析, phoneNumber=138xxxxxxxxx, address=南京市雨花臺區軟件大道101號華爲基地]]
 2 Service accept client subscrib req : [SubscribeReq [subReqID=1, userName=Lilinfeng, productName=Netty 最佳實踐和原理分析, phoneNumber=138xxxxxxxxx, address=南京市雨花臺區軟件大道101號華爲基地]]
 3 Service accept client subscrib req : [SubscribeReq [subReqID=2, userName=Lilinfeng, productName=Netty 最佳實踐和原理分析, phoneNumber=138xxxxxxxxx, address=南京市雨花臺區軟件大道101號華爲基地]]
 4 Service accept client subscrib req : [SubscribeReq [subReqID=3, userName=Lilinfeng, productName=Netty 最佳實踐和原理分析, phoneNumber=138xxxxxxxxx, address=南京市雨花臺區軟件大道101號華爲基地]]
 5 Service accept client subscrib req : [SubscribeReq [subReqID=4, userName=Lilinfeng, productName=Netty 最佳實踐和原理分析, phoneNumber=138xxxxxxxxx, address=南京市雨花臺區軟件大道101號華爲基地]]
 6 Service accept client subscrib req : [SubscribeReq [subReqID=5, userName=Lilinfeng, productName=Netty 最佳實踐和原理分析, phoneNumber=138xxxxxxxxx, address=南京市雨花臺區軟件大道101號華爲基地]]
 7 Service accept client subscrib req : [SubscribeReq [subReqID=6, userName=Lilinfeng, productName=Netty 最佳實踐和原理分析, phoneNumber=138xxxxxxxxx, address=南京市雨花臺區軟件大道101號華爲基地]]
 8 Service accept client subscrib req : [SubscribeReq [subReqID=7, userName=Lilinfeng, productName=Netty 最佳實踐和原理分析, phoneNumber=138xxxxxxxxx, address=南京市雨花臺區軟件大道101號華爲基地]]
 9 Service accept client subscrib req : [SubscribeReq [subReqID=8, userName=Lilinfeng, productName=Netty 最佳實踐和原理分析, phoneNumber=138xxxxxxxxx, address=南京市雨花臺區軟件大道101號華爲基地]]
10 Service accept client subscrib req : [SubscribeReq [subReqID=9, userName=Lilinfeng, productName=Netty 最佳實踐和原理分析, phoneNumber=138xxxxxxxxx, address=南京市雨花臺區軟件大道101號華爲基地]]

儘管客戶端一次批量發送了10條訂購請求消息，TCP會對請求消息進行粘包和拆包，可是並無影響最終的運行結果：服務端成功收到了10條訂購請求消息，與客戶端發淫的一致。
客戶端運行結果以下。

 1 Receive server response : [SubscribeResp [subReqID=0, respCode=0, desc=Netty book order succeed, 3 days later, sent to the designated address]]
 2 Receive server response : [SubscribeResp [subReqID=1, respCode=0, desc=Netty book order succeed, 3 days later, sent to the designated address]]
 3 Receive server response : [SubscribeResp [subReqID=2, respCode=0, desc=Netty book order succeed, 3 days later, sent to the designated address]]
 4 Receive server response : [SubscribeResp [subReqID=3, respCode=0, desc=Netty book order succeed, 3 days later, sent to the designated address]]
 5 Receive server response : [SubscribeResp [subReqID=4, respCode=0, desc=Netty book order succeed, 3 days later, sent to the designated address]]
 6 Receive server response : [SubscribeResp [subReqID=5, respCode=0, desc=Netty book order succeed, 3 days later, sent to the designated address]]
 7 Receive server response : [SubscribeResp [subReqID=6, respCode=0, desc=Netty book order succeed, 3 days later, sent to the designated address]]
 8 Receive server response : [SubscribeResp [subReqID=7, respCode=0, desc=Netty book order succeed, 3 days later, sent to the designated address]]
 9 Receive server response : [SubscribeResp [subReqID=8, respCode=0, desc=Netty book order succeed, 3 days later, sent to the designated address]]
10 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對碼流進行反序列化，得到訂購請求應答消息。

總結本章介紹瞭如何利用Netty提供的ObjectEncoder編碼器和ObjectDecoder解碼器實現對普邊POJO對象的序列化。經過訂購圖書例程，咱們學習了服務端和客戶端的開發，而且模擬了TCP粘包／拆包場景，對運行結果進行了分析。經過使用Netty的Java序列化編解碼handler，用戶經過短短的幾行代碼，就能完成POJO的序列化和反序列化。在業務處理ba:ndler中，用戶只須要將精力聚焦在業務邏輯的實現上F不須要關心底層的編解碼細節，這極大地提高了開發效率。下一章咱們繼續學習谷歌的Protob時，看在Netty 中如何使用Protob•uf 實現對POJO對象的自動編解碼。