欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

Java基礎入門總結(jié)之序列化和反序列化

 更新時間：2022年02月28日 09:12:57   作者：攻城獅Chova  
序列化是一種對象持久化的手段,普遍應用在網(wǎng)絡傳輸、RMI等場景中,下面這篇文章主要給大家介紹了關于Java基礎入門總結(jié)之序列化和反序列化的相關資料,需要的朋友可以參考下

基本概念

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

序列化

  • Java對象序列化:
    • 使得可序列化的對象實現(xiàn)Serializable接口
    • 創(chuàng)建一個ObjectOutputStream輸出流
    • 調(diào)用ObjectOutputStream對象的writeObject() 方法進行輸出可序列化對象即可
  • 序列化示例:
public class Person implements Serializable {
	private String name;
	private int age;

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

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

	@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輸入流
    • 調(diào)用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生成的對象,而不是通過類的構(gòu)造函數(shù)生成的:
    • 反序列化對象時 ,JVM中要存在對象對應的類,否則會拋出ClassNotFoundException異常
    • 如果一個可序列化的類的成員不是基本類型,而是一個引用類型時,那么這個引用類型必須實現(xiàn)Serializable接口,否則會拋出NotSerializableException異常

序列化和反序列化總結(jié)

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

自定義序列化策略

Externalizable

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

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

	@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();
	}
}

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

總結(jié)

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

相關文章

最新評論