netty系列之:netty中常用的對象編碼解碼器
簡介
我們在程式中除了使用常用的字元串進行數據傳遞之外，使用最多的還是JAVA對象。在JDK中，對象如果需要在網路中傳輸，必須實現Serializable介面，表示這個對象是可以被序列化的。這樣就可以調用JDK自身的對象對象方法，進行對象的讀寫。
那麼在netty中進行對象的傳遞可不可以直接使用JDK的對象序列化方法呢？如果不能的話，又應該怎麼處理呢？
今天帶大家來看看netty中提供的對象編碼器。
什麼是序列化
序列化就是將java對象按照一定的順序組織起來，用於在網路上傳輸或者寫入存儲中。而反序列化就是從網路中或者存儲中讀取存儲的對象，將其轉換成為真正的java對象。
所以序列化的目的就是為了傳輸對象，對於一些複雜的對象，我們可以使用第三方的優秀框架，比如Thrift，Protocol Buffer等，使用起來非常的方便。
JDK本身也提供了序列化的功能。要讓一個對象可序列化，則可以實現java.io.Serializable介面。
java.io.Serializable是從JDK1.1開始就有的介面，它實際上是一個marker interface，因為java.io.Serializable並沒有需要實現的介面。繼承java.io.Serializable就表明這個class對象是可以被序列化的。
@Data
@AllArgsConstructor
public class CustUser implements java.io.Serializable{
private static final long serialVersionUID = -178469307574906636L;
private String name;
private String address;
}
上面我們定義了一個CustUser可序列化對象。這個對象有兩個屬性：name和address。
接下看下怎麼序列化和反序列化：
public void testCusUser() throws IOException, ClassNotFoundException {
CustUser custUserA=new CustUser("jack","www.flydean.com");
CustUser custUserB=new CustUser("mark","www.flydean.com");
try(FileOutputStream fileOutputStream = new FileOutputStream("target/custUser.ser")){
ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
objectOutputStream.writeObject(custUserA);
objectOutputStream.writeObject(custUserB);
}
try(FileInputStream fileInputStream = new FileInputStream("target/custUser.ser")){
ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
CustUser custUser1 = (CustUser) objectInputStream.readObject();
CustUser custUser2 = (CustUser) objectInputStream.readObject();
log.info("{}",custUser1);
log.info("{}",custUser2);
}
}
上面的例子中，我們實例化了兩個CustUser對象，並使用objectOutputStream將對象寫入文件中，最後使用ObjectInputStream從文件中讀取對象。
上面是最基本的使用。需要注意的是CustUser class中有一個serialVersionUID欄位。
serialVersionUID是序列化對象的唯一標記，如果class中定義的serialVersionUID和序列化存儲中的serialVersionUID一致，則表明這兩個對象是一個對象，我們可以將存儲的對象反序列化。
如果我們沒有顯示的定義serialVersionUID，則JVM會自動根據class中的欄位，方法等資訊生成。很多時候我在看程式碼的時候，發現很多人都將serialVersionUID設置為1L，這樣做是不對的，因為他們沒有理解serialVersionUID的真正含義。
重構序列化對象
假如我們有一個序列化的對象正在使用了，但是突然我們發現這個對象好像少了一個欄位，要把他加上去，可不可以加呢？加上去之後原序列化過的對象能不能轉換成這個新的對象呢？
答案是肯定的，前提是兩個版本的serialVersionUID必須一樣。新加的欄位在反序列化之後是空值。
序列化不是加密
有很多同學在使用序列化的過程中可能會這樣想，序列化已經將對象變成了二進位文件，是不是說該對象已經被加密了呢？
這其實是序列化的一個誤區，序列化並不是加密，因為即使你序列化了，還是能從序列化之後的數據中知道你的類的結構。比如在RMI遠程調用的環境中，即使是class中的private欄位也是可以從stream流中解析出來的。
如果我們想在序列化的時候對某些欄位進行加密操作該怎麼辦呢？
這時候可以考慮在序列化對象中添加writeObject和readObject方法：
private String name;
private String address;
private int age;
private void writeObject(ObjectOutputStream stream)
throws IOException
{
//給age加密
age = age + 2;
log.info("age is {}", age);
stream.defaultWriteObject();
}
private void readObject(ObjectInputStream stream)
throws IOException, ClassNotFoundException
{
stream.defaultReadObject();
log.info("age is {}", age);
//給age解密
age = age - 2;
}
上面的例子中，我們為CustUser添加了一個age對象,並在writeObject中對age進行了加密（加2），在readObject中對age進行了解密（減2）。
注意，writeObject和readObject都是private void的方法。他們的調用是通過反射來實現的。
使用真正的加密
上面的例子， 我們只是對age欄位進行了加密，如果我們想對整個對象進行加密有沒有什麼好的處理辦法呢？
JDK為我們提供了javax.crypto.SealedObject 和java.security.SignedObject來作為對序列化對象的封裝。從而將整個序列化對象進行了加密。
還是舉個例子：
public void testCusUserSealed() throws IOException, ClassNotFoundException, NoSuchPaddingException, NoSuchAlgorithmException, IllegalBlockSizeException, BadPaddingException, InvalidAlgorithmParameterException, InvalidKeyException {
CustUser custUserA=new CustUser("jack","www.flydean.com");
Cipher enCipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
Cipher deCipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
SecretKey secretKey = new SecretKeySpec("saltkey111111111".getBytes(), "AES");
IvParameterSpec iv = new IvParameterSpec("vectorKey1111111".getBytes());
enCipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);
deCipher.init(Cipher.DECRYPT_MODE,secretKey,iv);
SealedObject sealedObject= new SealedObject(custUserA, enCipher);
try(FileOutputStream fileOutputStream = new FileOutputStream("target/custUser.ser")){
ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
objectOutputStream.writeObject(sealedObject);
}
try(FileInputStream fileInputStream = new FileInputStream("target/custUser.ser")){
ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
SealedObject custUser1 = (SealedObject) objectInputStream.readObject();
CustUser custUserV2= (CustUser) custUser1.getObject(deCipher);
log.info("{}",custUserV2);
}
}
上面的例子中，我們構建了一個SealedObject對象和相應的加密解密演算法。
SealedObject就像是一個代理，我們寫入和讀取的都是這個代理的加密對象。從而保證了在數據傳輸過程中的安全性。
使用代理
上面的SealedObject實際上就是一種代理，考慮這樣一種情況，如果class中的欄位比較多，而這些欄位都可以從其中的某一個欄位中自動生成，那麼我們其實並不需要序列化所有的欄位，我們只把那一個欄位序列化就可以了，其他的欄位可以從該欄位衍生得到。
在這個案例中，我們就需要用到序列化對象的代理功能。
首先，序列化對象需要實現writeReplace方法，表示替換成真正想要寫入的對象：
public class CustUserV3 implements java.io.Serializable{
private String name;
private String address;
private Object writeReplace()
throws java.io.ObjectStreamException
{
log.info("writeReplace {}",this);
return new CustUserV3Proxy(this);
}
}
然後在Proxy對象中，需要實現readResolve方法，用於從系列化過的數據中重構序列化對象。如下所示：
public class CustUserV3Proxy implements java.io.Serializable{
private String data;
public CustUserV3Proxy(CustUserV3 custUserV3){
data =custUserV3.getName()+ "," + custUserV3.getAddress();
}
private Object readResolve()
throws java.io.ObjectStreamException
{
String[] pieces = data.split(",");
CustUserV3 result = new CustUserV3(pieces[0], pieces[1]);
log.info("readResolve {}",result);
return result;
}
}
我們看下怎麼使用：
public void testCusUserV3() throws IOException, ClassNotFoundException {
CustUserV3 custUserA=new CustUserV3("jack","www.flydean.com");
try(FileOutputStream fileOutputStream = new FileOutputStream("target/custUser.ser")){
ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
objectOutputStream.writeObject(custUserA);
}
try(FileInputStream fileInputStream = new FileInputStream("target/custUser.ser")){
ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
CustUserV3 custUser1 = (CustUserV3) objectInputStream.readObject();
log.info("{}",custUser1);
}
}
注意，我們寫入和讀出的都是CustUserV3對象。
Serializable和Externalizable的區別
最後我們講下Externalizable和Serializable的區別。Externalizable繼承自Serializable，它需要實現兩個方法：
void writeExternal(ObjectOutput out) throws IOException;
void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
什麼時候需要用到writeExternal和readExternal呢？
使用Serializable，Java會自動為類的對象和欄位進行對象序列化，可能會佔用更多空間。而Externalizable則完全需要我們自己來控制如何寫/讀，比較麻煩，但是如果考慮性能的話，則可以使用Externalizable。
另外Serializable進行反序列化不需要執行構造函數。而Externalizable需要執行構造函數構造出對象，然後調用readExternal方法來填充對象。所以Externalizable的對象需要一個無參的構造函數。
netty中對象的傳輸
在上面的序列化一節中，我們已經知道了對於定義好的JAVA對象，我們可以通過使用ObjectOutputStream和ObjectInputStream來實現對象的讀寫工作，那麼在netty中是否也可以使用同樣的方式來進行對象的讀寫呢？
很遺憾的是，在netty中並不能直接使用JDK中的對象讀寫方法，我們需要對其進行改造。
這是因為我們需要一個通用的對象編碼和解碼器，如果使用ObjectOutputStream和ObjectInputStream，因為不同對象的結構是不一樣的，所以我們在讀取對象的時候需要知道讀取數據的對象類型才能進行完美的轉換。
而在netty中我們需要的是一種更加通用的編碼解碼器，那麼應該怎麼做呢？
還記得之前我們在講解通用的frame decoder中講過的LengthFieldBasedFrameDecoder? 通過在真實的數據前面加上數據的長度，從而達到根據數據長度進行frame區分的目的。
netty中提供的編碼解碼器名字叫做ObjectEncoder和ObjectDecoder,先來看下他們的定義：
public class ObjectEncoder extends MessageToByteEncoder<Serializable> {
public class ObjectDecoder extends LengthFieldBasedFrameDecoder {
可以看到ObjectEncoder繼承自MessageToByteEncoder，其中的泛型是Serializable，表示encoder是從可序列化的對象encode成為ByteBuf。
而ObjectDecoder正如上面我們所說的繼承自LengthFieldBasedFrameDecoder，所以可以通過一個長度欄位來區分實際要讀取對象的長度。
接下來我們詳細了解一下這兩個類是如何工作的。
ObjectEncoder
先來看ObjectEncoder是如何將一個對象序列化成為ByteBuf的。
根據LengthFieldBasedFrameDecoder的定義，我們需要一個數組來保存真實數據的長度，這裡使用的是一個4位元組的byte數組叫做LENGTH_PLACEHOLDER，如下所示：
private static final byte[] LENGTH_PLACEHOLDER = new byte[4];
我們看下它的encode方法的實現：
protected void encode(ChannelHandlerContext ctx, Serializable msg, ByteBuf out) throws Exception {
int startIdx = out.writerIndex();
ByteBufOutputStream bout = new ByteBufOutputStream(out);
ObjectOutputStream oout = null;
try {
bout.write(LENGTH_PLACEHOLDER);
oout = new CompactObjectOutputStream(bout);
oout.writeObject(msg);
oout.flush();
} finally {
if (oout != null) {
oout.close();
} else {
bout.close();
}
}
int endIdx = out.writerIndex();
out.setInt(startIdx, endIdx - startIdx - 4);
}
這裡首先創建了一個ByteBufOutputStream，然後向這個Stream中寫入4位元組的長度欄位，接著將ByteBufOutputStream封裝到CompactObjectOutputStream中。
CompactObjectOutputStream是ObjectOutputStream的子類，它重寫了writeStreamHeader和writeClassDescriptor兩個方法。
CompactObjectOutputStream將最終的數據msg寫入流中，一個encode的過程就差不多完成了。
為什麼說差不多完成了呢？因為長度欄位還是空的。
在最開始的時候，我們只是寫入了一個長度的placeholder,這個placeholder是空的，並沒有任何數據，這個數據是在最後一步out.setInt中寫入的：
out.setInt(startIdx, endIdx - startIdx - 4);
這種實現也給了我們一種思路，在我們還不知道消息的真實長度的時候，如果希望在消息之前寫入消息的長度，可以先佔個位置，等消息全部讀取完畢，知道真實的長度之後，再替換數據。
到此，對象數據已經全部編碼完畢，接下來我們看一下如何從編碼過後的數據中讀取對象。
ObjectDecoder
之前說過了ObjectDecoder繼承自LengthFieldBasedFrameDecoder,它的decode方法是這樣的：
protected Object decode(ChannelHandlerContext ctx, ByteBuf in) throws Exception {
ByteBuf frame = (ByteBuf) super.decode(ctx, in);
if (frame == null) {
return null;
}
ObjectInputStream ois = new CompactObjectInputStream(new ByteBufInputStream(frame, true), classResolver);
try {
return ois.readObject();
} finally {
ois.close();
}
}
首先調用LengthFieldBasedFrameDecoder的decode方法，根據對象的長度，讀取到真實的對象數據放到ByteBuf中。
然後通過自定義的CompactObjectInputStream從ByteBuf中讀取到真實的對象，並返回。
CompactObjectInputStream繼承自ObjectInputStream，是和CompactObjectOutputStream相反的操作。
ObjectEncoderOutputStream和ObjectDecoderInputStream
ObjectEncoder和ObjectDecoder是對象和ByteBuf之間的轉換，netty還提供了和ObjectEncoder，ObjectDecoder兼容的ObjectEncoderOutputStream和ObjectDecoderInputStream,這兩個類可以從stream中對對象編碼和解碼，並且和ObjectEncoder，ObjectDecoder完全兼容的。
總結
以上就是netty中提供的對象編碼和解碼器，大家如果希望在netty中傳遞對象，那麼netty提供的這兩個編碼解碼器是最好的選擇。
本文已收錄於 //www.flydean.com/14-8-netty-codec-object/
最通俗的解讀，最深刻的乾貨，最簡潔的教程，眾多你不知道的小技巧等你來發現！
歡迎關注我的公眾號:「程式那些事」,懂技術，更懂你！
