名詞解釋

序列化：將Java對象轉化成字節(jié)的過程

反序列化：將字節(jié)轉化成Java對象的過程

字節(jié)：1字節(jié)（byte）= 8bit，bit就是計算機認識的二進制

序列化的作用

Java對象是在Java虛擬機中使用的，一旦Java進程結束，對象就會消失，要將只有虛擬機才認識的對象，保存在磁盤中，必須將對象轉化成字節(jié)。

在RPC中的用處：序列化將對象轉換為字節(jié)流，然后通過網絡傳輸進行發(fā)送
保存對象的狀態(tài)：當Java進程需要重啟時，可以將對象序列化后保存在文件中，對象的狀態(tài)不會因為進程的關閉而丟失

如何進行序列化

基本數(shù)據類型轉為字節(jié)的思路

對于有多個字節(jié)的數(shù)據，用移位運算符，將每8位進行移位，用一個字節(jié)保存

Int類型：一個int有4個字節(jié)，可以創(chuàng)建一個長度為4的字節(jié)數(shù)組進行保存（short，long類似）
char類型：一個char有2個字節(jié)，用相應長度的字節(jié)數(shù)組保存后，反序列化時再強制轉化為char
String類型：String的值主要是一個char數(shù)組，創(chuàng)建一個大小為char數(shù)組兩倍的字節(jié)數(shù)組進行保存，反序列化時再轉化為String
Double和Float類型：過程比較復雜（沒學會），建議直接調用工具類

一個字節(jié)和其他類型的轉換工具類

import java.nio.ByteBuffer;

public class ByteUtils {

    public static byte[] short2bytes(short v) {
        byte[] b = new byte[4];
        b[1] = (byte) v;
        b[0] = (byte) (v >>> 8);
        return b;
    }

    public static byte[] String2bytes(String str){
        char[] chars = str.toCharArray();
        byte[] charByte = new byte[chars.length*2];
        for (int i = 0; i < chars.length; i++) {
            charByte[i*2] = (byte) (chars[i] >>> 8);
            charByte[i*2+1] = (byte) (chars[i]);
        }
        return charByte;
    }

    public static byte[] int2bytes(int v) {
        byte[] b = new byte[4];
        b[3] = (byte) v;
        b[2] = (byte) (v >>> 8);
        b[1] = (byte) (v >>> 16);
        b[0] = (byte) (v >>> 24);
        return b;
    }

    public static byte[] long2bytes(long v) {
        byte[] b = new byte[8];
        b[7] = (byte) v;
        b[6] = (byte) (v >>> 8);
        b[5] = (byte) (v >>> 16);
        b[4] = (byte) (v >>> 24);
        b[3] = (byte) (v >>> 32);
        b[2] = (byte) (v >>> 40);
        b[1] = (byte) (v >>> 48);
        b[0] = (byte) (v >>> 56);
        return b;
    }

    public static byte[] double2bytes(double d){
        long lValue = Double.doubleToLongBits(d);
        byte[] bytes = long2bytes(lValue);
        return bytes;
    }

    public static int bytes2Int_BE(byte[] bytes) {
        if(bytes.length < 4){
            return -1;
        }
        int iRst = (bytes[0] << 24) & 0xFF;
        iRst |= (bytes[1] << 16) & 0xFF;
        iRst |= (bytes[2] << 8) & 0xFF;
        iRst |= bytes[3] & 0xFF;
        return iRst;
    }

    public static long bytes2long(byte[] b) {
        ByteBuffer buffer = ByteBuffer.allocate(8);
        buffer.put(b, 0, b.length);
        buffer.flip();// need flip
        return buffer.getLong();
    }

    public static String bytes2String(byte[] bytes){
        char[] chars = new char[bytes.length/2];
        for (int i = 0; i < chars.length; i++) {
            chars[i] = (char) ((bytes[i*2] << 8) | bytes[i*2+1]);
        }
        return new String(chars);
    }

    public static float byte2Float(byte[] bytes){
        Integer iValue = bytes2Int_BE(bytes);
        float dValue = Float.intBitsToFloat(iValue);
        return dValue;
    }

    public static double byte2Double(byte[] bytes){
        Long lValue = bytes2long(bytes);
        double dValue = Double.longBitsToDouble(lValue);
        return dValue;
    }

}

View Code

如何序列化對象

其實序列化就是為了反序列化，保存對象之后必然要讀取對象，所以 站在反序列化的角度去研究序列化

得到一串字節(jié)流之后，要如何轉換成對象

要通過反射創(chuàng)建對象，首先要知道對象的類名稱，然后調用類的默認構造函數(shù)
要識別類名稱，得知道類名稱是由哪些字節(jié)轉換的
要有一個值存放類名稱的字節(jié)長度，長度前最好放一個標記
給對象的字段賦值，各種類型都不一樣，需要識別
需要數(shù)據類型的字節(jié)長度，根據長度去識別字節(jié)數(shù)組中的一部分
將字節(jié)轉換成指定的數(shù)據類型
通過反射給對象的字段賦值

序列化的代碼實現(xiàn)如下

這里沒有將對象的類型寫入字節(jié)數(shù)組，因為反序列化的方法會傳入一個class參數(shù)，可以直接構造對象

 1 public static byte[] serialize(Object object) throws IllegalAccessException, ClassNotFoundException {
 2         
 3         // 對象序列化后的字節(jié)數(shù)組
 4         byte[] objectByte = new byte[1024];
 5         // 通過移動的下標變量不斷往數(shù)組添加數(shù)據
 6         int index = 0;
 7         // 標記后面的字節(jié)可以轉化成對象
 8         objectByte[index] = SerializationNum.SERIALIZATION_OBJECT_NUM;
 9         
10         Class clazz = object.getClass();
11         // 遍歷所有字段，將字段的值轉化為字節(jié)
12         Field[] fields = clazz.getDeclaredFields();
13         // 一開始的標記占了一個位置
14         int len = 1;
15         for (Field field : fields) {
16 
17             // 將private屬性設置為可訪問
18             field.setAccessible(true);
19 
20             // 每次移動下標,給后面的數(shù)據騰地方
21             index += len;
22             // 不同的類型，不同的轉化方式
23             Class fieldClass = field.getType();
24             // 每種類型對應一個標記
25             byte magicNum = SerializationNum.getNum(fieldClass);
26 
27             byte[] valueByte = new byte[0];
28             switch (magicNum){
29                 case SerializationNum.INTEGER_NUM:
30                     // 反射獲取值
31                     Integer iValue = (Integer) field.get(object);
32                     // int類型是4個字節(jié)
33                     len = 4;
34                     // 轉化成一個長度為4的字節(jié)數(shù)組
35                     valueByte = ByteUtils.int2bytes(iValue);
36                     break;
37 
38                 case SerializationNum.LONG_NUM:
39                     long longValue = field.getLong(object);
40                     len = 8;
41                    valueByte = ByteUtils.long2bytes(longValue);
42                     break;
43 
44                 case SerializationNum.STRING_NUM:
45                     String sValue = (String) field.get(object);
46                     valueByte = ByteUtils.String2bytes(sValue);
47                     len = valueByte.length;
48                     break;
49 
50                 default:
51                     break;
52             }
53             // 將類型和長度都添加字節(jié)數(shù)組中
54             objectByte[index++] = magicNum;
55             objectByte[index++] = (byte) len;
56             // 轉化后的字節(jié)復制到對象字節(jié)數(shù)組
57             System.arraycopy(valueByte,0,objectByte,index,len);
58         }
59 
60         index += len;
61         // 對象已經整個被轉化完畢的標記
62         objectByte[index] = SerializationNum.FINISH_NUM;
63 
64         return objectByte;
65     }

反序列化過程實現(xiàn)

 1 public static Object deserialize(byte[] bytes,Class clazz) throws InstantiationException, IllegalAccessException {
 2 
 3         int index = 0;
 4         // 識別首部，確保是能夠反序列化成對象的字節(jié)
 5         if (bytes[index] != SerializationNum.SERIALIZATION_OBJECT_NUM) {
 6             return null;
 7         }
 8 
 9         // 使用默認構造方法
10         Object obj = clazz.newInstance();
11         // 跳過最開始的魔數(shù)
12         byte len = 1;
13 
14         // 一個個給對象的字段賦值
15         for (Field declaredField : clazz.getDeclaredFields()) {
16             declaredField.setAccessible(true);
17             // 每次移動下標
18             index += len;
19 
20             // 不同的類型，不同的轉化方式
21             Class fieldClass = declaredField.getType();
22 
23             byte magicNum = SerializationNum.getNum(fieldClass);
24 
25             // 防止數(shù)組越界
26             if (index >= bytes.length || bytes[index] != magicNum){
27                 continue;
28             }
29 
30             Object value = null;
31             // 先獲取需要的字節(jié)長度
32              len = bytes[++index];
33             // 創(chuàng)建一個新數(shù)組去作為方法參數(shù)，如果不采用這種傳參方式，也許能節(jié)約這個空間
34             byte[] srcBytes = new byte[len];
35             System.arraycopy(bytes,++index,srcBytes,0,len);
36 
37             switch (magicNum){
38                 case SerializationNum.INTEGER_NUM:
39 
40                     value = ByteUtils.bytes2Int_BE(srcBytes);
41                     break;
42 
43                 case SerializationNum.LONG_NUM:
44 
45                     value = ByteUtils.bytes2long(srcBytes);
46                     break;
47 
48                 case SerializationNum.STRING_NUM:
49 
50                    value = ByteUtils.bytes2String(srcBytes);
51                    break;
52 
53                 case SerializationNum.DOUBLE_NUM:
54                     value = ByteUtils.byte2Double(srcBytes);
55                     break;
56 
57                 default:
58                     break;
59             }
60             // 將值賦給對象
61             declaredField.set(obj,value);
62         }
63         return obj;
64     }

對各種基本數(shù)據類型進行特殊標記的工具類

public class SerializationNum {

    public static final byte BOOLEAN_NUM = 0x01;
    public static final byte SHORT_NUM = 0x02;
    public static final byte INTEGER_NUM = 0x03;
    public static final byte LONG_NUM = 0x04;
    public static final byte CHAR_NUM = 0x05;
    public static final byte FLOAT_NUM = 0x06;
    public static final byte DOUBLE_NUM = 0x07;
    public static final byte STRING_NUM = 0x08;
    public static final byte OBJECT_NUM = 0x09;
    public static final byte SERIALIZATION_OBJECT_NUM = 0x10;
    public static final byte FINISH_NUM = 0x30;

    public static byte getNum(Class clazz){
        if (clazz == String.class) {
            return STRING_NUM;
        }
        if (clazz == Integer.class) {

            return INTEGER_NUM;
        }
        if (clazz == Double.class) {

            return DOUBLE_NUM;
        }
        if (clazz == Boolean.class) {
            return BOOLEAN_NUM;
        }
        if (clazz == Float.class) {

            return FINISH_NUM;
        }
        if (clazz == Long.class) {

            return LONG_NUM;
        }

        return 0x77;
    }

}

View Code

測試代碼

 1 public static void main(String[] args) throws IOException {
 2         Entity entity = new Entity();
 3 
 4         entity.setName("name");
 5         entity.setNum(5);
 6         entity.setId(5L);
 7         entity.setMoney(100.55);
 8         
 9         try {
10             System.out.println("可以將對象序列號后的字節(jié)重新反序列化成對象");
11            byte[] objByte = serialize(entity);
12             Entity entity1 = (Entity) deserialize(objByte,Entity.class);
13             System.out.println(entity1);
14 
15 
16             System.out.println("保存在文件的字節(jié)，取出來后也可以反序列成對象");
17             FileOutputStream outputStream = new FileOutputStream("text.out");
18             FileInputStream inputStream = new FileInputStream("text.out");
19             byte[] fileBytes = new byte[1024];
20 
21             outputStream.write(objByte);
22             inputStream.read(fileBytes);
23 
24             Entity entity2 = (Entity) deserialize(fileBytes,Entity.class);
25             System.out.println(entity2);
26 
27         } catch (IllegalAccessException | ClassNotFoundException | InstantiationException e) {
28             System.out.println("類不能被構造");
29             e.printStackTrace();
30         }
31 
32     }

測試結果：

Java：對一個對象序列化和反序列化的簡單實現(xiàn)

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av

Java：對一個對象序列化和反序列化的簡單實現(xiàn)

Java：對一個對象序列化和反序列化的簡單實現(xiàn)

名詞解釋

序列化的作用

如何進行序列化

基本數(shù)據類型轉為字節(jié)的思路

如何序列化對象

相關閱讀更多精彩內容

友情鏈接更多精彩內容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九 欧美,1769亚洲,黄色成人av

Java：對一個對象序列化和反序列化的簡單實現(xiàn)

名詞解釋

序列化的作用

如何進行序列化

基本數(shù)據類型轉為字節(jié)的思路

如何序列化對象

相關閱讀更多精彩內容

友情鏈接更多精彩內容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av