基本概念

• Java中創(chuàng)建對象時,一旦程序終止,創(chuàng)建的對象可能就不存在.要想使得對象能夠在程序不運行的狀態(tài)下依然能夠保存對象的信息,這時就需要用到序列化機制
• 序列化機制:
  • 一個對象可以被表示為一個字節(jié)序列,包括:
    • 對象的數(shù)據(jù)
    • 對象的類型信息
    • 存儲在對象中的數(shù)據(jù)類型
  • 將可序列化對象寫入文件后,可以從文件中讀取出來,根據(jù)對象的各種信息在內存中創(chuàng)建該對象. 這里的讀取并創(chuàng)建對象的過程就是反序列化
  • 序列化和反序列化的整個過程都是JVM獨立的.也就是說,在一個JVM中的序列化對象可以在另一個完全不同的JVM中反序列化對象
  • 一般情況下,序列化需要實現(xiàn)java.io.Serializable接口,使用ObjectInputStream和ObjectOutputStream進行對象的讀寫操作
  • 還可以實現(xiàn)java.io.Externalizable接口,進行標準的序列化或者自定義的二進制格式.用來滿足不同場景下的需求
• Java序列化場景:
  • 將Java對象的字節(jié)序列持久化到硬盤中
  • 在網絡上傳輸對象的字節(jié)序列
  • 進行遠程方法調用RMI(Remote Method Invocation)
  • JVM運行結束時,還需要使用創(chuàng)建的對象
  • 需要將創(chuàng)建的對象保存下來以便后續(xù)的傳輸
  • 使得舊JVM創(chuàng)建的對象能夠在一個新的JVM中運行
• Java序列化注意點:
  • 對象的序列化保存的是對象成員變量對象,對象的序列化不會關注類中的靜態(tài)變量
  • 類的序列化要保證類的所有屬性都是可以序列化的,如果想要某個屬性不被序列化.可以聲明為瞬時態(tài)transient

序列化

• Java對象序列化:
  • 使得可序列化的對象實現(xiàn)Serializable接口
  • 創(chuàng)建一個ObjectOutputStream輸出流
  • 調用ObjectOutputStream對象的writeObject() 方法進行輸出可序列化對象即可
• 序列化示例:

public class Person implements Serializable {
	private String name;
	private int age;

	public Person() {
		System.out.println("無參構造...");
	}

	public Person(String name, int age) {
		this.name = name;
		this.age = age;
		System.out.println("有參構造...");
	}

	@Override
	public String toString() {
		return "Person{" +
				"name='" + name + "\'" +
				", age='" + age + "\'"
				"}";
	}
}

public class SerializableTest {
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		Person person = new Person("Lily", 20);

		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Person.txt"));
		oos.writeObject(person);
		oos.close();
	}
}

反序列化

• Java對象反序列化:
  • 創(chuàng)建一個ObjectInputStream輸入流
  • 調用ObjectInputStream對象的readObject() 方法得到序列化對象

public class  DeserializableTest {
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("Person.txt"));
		Pesron person = (Person)ois.readObject(ois);
		System.out.println(person);
	}
}

• 反序列化的對象是由JVM生成的對象,而不是通過類的構造函數(shù)生成的:
  • 反序列化對象時 ,JVM中要存在對象對應的類,否則會拋出ClassNotFoundException異常
  • 如果一個可序列化的類的成員不是基本類型,而是一個引用類型時,那么這個引用類型必須實現(xiàn)Serializable接口,否則會拋出NotSerializableException異常

序列化和反序列化總結

• 實現(xiàn)Serializable接口就可以進行序列化的原因:
  • writeObject():
    • 首先會處理之前被編寫的以及不可替換的對象
    • 如果有的對象被替換了,則檢查被替換的對象
    • 最后如果對象都被替換了,則進行原始的檢查
    • 原始的檢查即檢查被替換的對象類型是否為String類型,數(shù)組類型 ,Enum類型或者實現(xiàn)了Serializable接口,符合條件就可以對檢查的對象執(zhí)行相應的序列化操作,否則將會拋出NotSerializableException異常
  • 對于序列化的機制來說,如果對同一個對象執(zhí)行多次序列化操作時,不會得到多個對象
    • 保存到磁盤的對象都有一個序列化編號,當程序試圖進行序列化時,會檢查該對象是否已經序列化
    • 只有對象從未被序列化過時,才會將此對象序列化為字節(jié)序列,如果對象已經序列化過,那么直接輸出序列化編號
    • Java序列化機制不會重復序列化同一個對象,會記錄已經序列化對象的編號,此時如果序列化了一個可變對象后,如果更改了對象的內容會再次進行序列化.如果沒有更改內容,則不會將此對象轉換為字節(jié)序列,只會保存序列化編號
• 實現(xiàn)Serializable接口時可以重寫writeObject() 方法和readObject() 方法:
  • 重寫writeObject() 方法和readObject() 方法后,對象進行序列化和反序列化時,就會自動調用重寫的writeObject() 方法和readObject() 方法
• 實現(xiàn)Externalizable接口時可以重寫writeExternal() 方法和readExternal() 方法:
  • 重寫writeExternal() 方法和readExternal() 方法后,對象進行序列化和反序列化時,就會自動調用重寫的writeExternal() 方法和readExternal() 方法

自定義序列化策略

Externalizable

• 如果需要使得對象的一部分可以被序列化,另一部分數(shù)據(jù)不被序列化,此時可以自定義實現(xiàn)Externalizable接口,并且實現(xiàn)writeExternal() 和readExternal() 方法,可以在序列化和反序列化過程中自動調用來執(zhí)行一些特殊的操作
• 注意點:
  • Serializable接口實現(xiàn)的對象是與二進制的構建有關的,不會調用構造器
  • Externalizable接口實現(xiàn)的對象的所有構造函數(shù)都會被調用,所以要編寫出類的無參和有參構造函數(shù)
• 使用Externalizable自定義序列化示例:

public class CustomExternal implements Externalizable {
	
	private String name;
	
	private int code;

	public CustomExternal() {
		System.out.println("無參構造...");
	}
	
	public CustomExternal(String name, int code) {
		this.name = name;
		this.code = code;
		System.out.println("有參構造...");
	}

	@Override
	public void writeExternal(ObjectOutput out) throws IOException {
		System.out.println("執(zhí)行writeExternal()方法...");
		out.writeObject(name);
		out.writeInt(code);
	} 

	@Override
	public void readExternal(ObjectInput in) throws IOException,ClassNotFoundException {
		System.out.println("執(zhí)行readExternal()方法...");
		name = (String) in.readObject();
		code = in.readInt();
	}

	@Override
	public String toString() {
		return "類:" + name + code;
	}

	public static void main(String[] args) throws IOException, ClassNotFoundException {
		CustomExternal custom = new CustomeExternal("oxford", 666);
		System.out.println(custom);
		
		// 序列化
		ObjectOutputStream out = new ObjectOutputStream(new FileInputStream("oxford.txt"));
		System.out.println("序列化對象...");
		out.writeObject(custom);
		out.close();

		// 反序列化
		ObjectInputStream in = new ObjectInputStream(new FileInputStream("oxford.txt"));
		System.out.println("反序列化對象...");
		custom = (CustomExternal) in.readObject();
		System.out.println(custom);
		in.close();
	}
}

有參構造...
類:oxford666
序列化對象...
執(zhí)行writeExternal()方法...
反序列化對象...
無參構造...
執(zhí)行readExternal()方法...
類:oxford666 

• 使用Externalizable自定義序列化時,為了保證序列化和反序列化的正確性,需要在writeExternal() 方法中將信息寫入,并且在readExternal() 方法中恢復數(shù)據(jù)

transient

• 可以使用transient關鍵字配置一些重要的信息比如密碼等不進行序列化
  • transient關鍵字修飾的屬性不會參與到序列化過程中
  • transient關鍵字修飾的屬性在反序列化過程中,如果是引用數(shù)據(jù)類型,則返回null. 如果是基本數(shù)據(jù)類型,則返回默認值.不一定是基本數(shù)據(jù)類型序列化之前的值
• 因為實現(xiàn)Externalizable接口的對象默認情況下不會保存任何字段,所以transient關鍵字只能和Serializable對象一起使用
• transient關鍵字的使用場景:
  • 服務器端給客戶端發(fā)送序列化對象數(shù)據(jù)時,對象中存在敏感數(shù)據(jù)
  • 比如密碼字符串,在序列化時進行加密,客戶端擁有解密的密鑰,只有在客戶端進行反序列化時,才會對密碼進行讀取
  • 這時就可以對密碼字符串對象使用transient修飾,這樣可以一定程度上保證序列化對象的數(shù)據(jù)安全

靜態(tài)變量

• 序列化時不會序列化靜態(tài)變量
  • 靜態(tài)變量屬于類的狀態(tài),序列化中保存的是對象,也就是類的實例的狀態(tài)
  • 序列化操作的是序列化中對象,也就是類的實例的狀態(tài),靜態(tài)變量屬于類的狀態(tài).所以序列化時不會對靜態(tài)變量進行序列化

序列化ID

• Java虛擬機進行反序列化:
  • 兩個類的類路徑和功能代碼一致
  • 兩個類的序列化ID,也就是serialVersionUID一致
• 功能代碼一致:
  • 序列化的類和反序列化的類所實現(xiàn)的功能和功能相關的代碼是一樣的
  • 示例:
    • 客戶端A將類對象序列化客戶端B, 客戶端B進行反序列化
    • 這時要求A和B都有這樣的一個類文件,功能代碼一致,并且都實現(xiàn)了Serializable接口
• serialVersionUID的兩種生成方式:
  • 默認值 1L
  • 通過類名,接口名和方法名以及屬性隨機生成的一個不重復的long類型的值
• 在序列化ID, 即serialVersionUID相同的情況下,即使序列化對象的序列化屬性修改,序列化對象也可以進行反序列化.因此如果只是修改了方法或者修改了靜態(tài)變量或transient變量,只要不修改序列化ID, 那么反序列化就不會受到影響
• 顯式聲明序列化ID, 即serialVersionUID的場景:
  • 如果需要類的不同版本對序列化兼容,要確保類的不同版本具有相同的serialVersionUID
  • 如果不需要類的不同版本對序列化兼容,要確保類的不同版本具有不同的serialVersionUID
  • 序列化一個類的實例后,如果修改一個字段或者增加一個字段,如果沒有設置類的serialVersionUID, 就會導致無法反序列化舊的實例,會在反序列化時拋出異常
  • 序列化類添加SerialVersionUID后,如果修改一個字段或者增加一個字段,反序列化舊的實例時,修改的或者增加的字段的值會設置為初始化的值

破壞單例

• 除了反射可以破壞單例模式外,序列化和反序列化后會得到一個新的對象,也可以破壞單例模式
• 序列化和反序列化破壞單例模式:
  • 反序列化時,使用ObjectInputStream對象中的readObject() 方法
  • readObject() 的方法中調用readObject0() 方法

      public final Object readObject()
        throws IOException, ClassNotFoundException
    {
        if (enableOverride) {
            return readObjectOverride();
        }
        
        int outerHandle = passHandle;
        try {
            Object obj = readObject0(false);
            handles.markDependency(outerHandle, passHandle);
            ClassNotFoundException ex = handles.lookupException(passHandle);
            if (ex != null) {
                throw ex;
            }
            if (depth == 0) {
                vlist.doCallbacks();
            }
            return obj;
        } finally {
            passHandle = outerHandle;
            if (closed && depth == 0) {
                clear();
            }
        }
    }

  • readObject0() 方法中會返回一個checkResolve(readOrdinaryObject(unshared))

      private Object readObject0(boolean unshared) throws IOException {
        boolean oldMode = bin.getBlockDataMode();
        if (oldMode) {
            int remain = bin.currentBlockRemaining();
            if (remain > 0) {
                throw new OptionalDataException(remain);
            } else if (defaultDataEnd) {
                throw new OptionalDataException(true);
            }
            bin.setBlockDataMode(false);
        }
  
        byte tc;
        while ((tc = bin.peekByte()) == TC_RESET) {
            bin.readByte();
            handleReset();
        }
  
        depth++;
        totalObjectRefs++;
        try {
            switch (tc) {
                case TC_NULL:
                    return readNull();
  
                case TC_REFERENCE:
                    return readHandle(unshared);
  
                case TC_CLASS:
                    return readClass(unshared);
  
                case TC_CLASSDESC:
                case TC_PROXYCLASSDESC:
                    return readClassDesc(unshared);
  
                case TC_STRING:
                case TC_LONGSTRING:
                    return checkResolve(readString(unshared));
  
                case TC_ARRAY:
                    return checkResolve(readArray(unshared));
  
                case TC_ENUM:
                    return checkResolve(readEnum(unshared));
  
                case TC_OBJECT:
                    return checkResolve(readOrdinaryObject(unshared));
  
                case TC_EXCEPTION:
                    IOException ex = readFatalException();
                    throw new WriteAbortedException("writing aborted", ex);
  
                case TC_BLOCKDATA:
                case TC_BLOCKDATALONG:
                    if (oldMode) {
                        bin.setBlockDataMode(true);
                        bin.peek();             
                        throw new OptionalDataException(
                            bin.currentBlockRemaining());
                    } else {
                        throw new StreamCorruptedException(
                            "unexpected block data");
                    }
  
                case TC_ENDBLOCKDATA:
                    if (oldMode) {
                        throw new OptionalDataException(true);
                    } else {
                        throw new StreamCorruptedException(
                            "unexpected end of block data");
                    }
  
                default:
                    throw new StreamCorruptedException(
                        String.format("invalid type code: %02X", tc));
            }
        } finally {
            depth--;
            bin.setBlockDataMode(oldMode);
        }
    }

  • readOrdinaryObject() 方法用于讀取并返回普通對象. 這里的普通對象不包括String, Class, ObjectStreamClass, 數(shù)組或者枚舉常量這些對象

  private Object readOrdinaryObject(boolean unshared)
        throws IOException
    {
        if (bin.readByte() != TC_OBJECT) {
            throw new InternalError();
        }
  
        ObjectStreamClass desc = readClassDesc(false);
        desc.checkDeserialize();
  
        Class<?> cl = desc.forClass();
        if (cl == String.class || cl == Class.class
                || cl == ObjectStreamClass.class) {
            throw new InvalidClassException("invalid class descriptor");
        }
  
        Object obj;
        try {
            obj = desc.isInstantiable() ? desc.newInstance() : null;
        } catch (Exception ex) {
            throw (IOException) new InvalidClassException(
                desc.forClass().getName(),
                "unable to create instance").initCause(ex);
        }
  
        passHandle = handles.assign(unshared ? unsharedMarker : obj);
        ClassNotFoundException resolveEx = desc.getResolveException();
        if (resolveEx != null) {
            handles.markException(passHandle, resolveEx);
        }
  
        if (desc.isExternalizable()) {
            readExternalData((Externalizable) obj, desc);
        } else {
            readSerialData(obj, desc);
        }
  
        handles.finish(passHandle);
  
        if (obj != null &&
            handles.lookupException(passHandle) == null &&
            desc.hasReadResolveMethod())
        {
            Object rep = desc.invokeReadResolve(obj);
            if (unshared && rep.getClass().isArray()) {
                rep = cloneArray(rep);
            }
            if (rep != obj) {
                // Filter the replacement object
                if (rep != null) {
                    if (rep.getClass().isArray()) {
                        filterCheck(rep.getClass(), Array.getLength(rep));
                    } else {
                        filterCheck(rep.getClass(), -1);
                    }
                }
                handles.setObject(passHandle, obj = rep);
            }
        }
  
        return obj;
    }

  • isInstantiable() 方法表示如果一個實現(xiàn)了Serializable接口或者Externalizable接口的類可以在運行時實例化,那么該方法就返回true
  • 如果可以在運行時序列化,就會調用desc.newInstance() 方法使用反射的方式調用無參構造方法新建一個對象,創(chuàng)建一個類的新的實例
    • 如果類實現(xiàn)的是Serializable接口,就調用第一個不可進行序列化超類的無參構造方法數(shù)創(chuàng)建新的實例
    • 如果類實現(xiàn)的Externalizable接口,就調用公共的無參構造方法創(chuàng)建新的實例
• 因為序列化過程中會通過反射調用無參構造函數(shù)創(chuàng)建一個新的對象,所以序列化會破壞單例模式
• 為了防止序列化破壞單例模式,可以在Singleton.java中添加readResolve() 方法并且指定要返回的對象的生成策略
  • 因為readOrdinaryObject() 方法源碼中的hasResolveMethod() 表示如果實現(xiàn)了Serializable或者Externalizable接口的類中包含readResolve() 方法就返回true
  • invokeReadResolve() 方法會通過反射的方式調用要被反序列化的類的readResolve() 方法

總結

到此這篇關于Java基礎入門之序列化和反序列化的文章就介紹到這了,更多相關Java序列化和反序列化內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！