java序列化深克隆_如何在内存序列化中使用Java深克隆对象

骑猪看日落 2023-02-25 07:01 47阅读 0赞

java序列化深克隆

在我以前的文章中，我解释了[深度克隆][Link 1]和[浅层克隆之间][Link 1]的[区别][Link 1] ， [以及复制构造函数][Link 2]和[防御性复制方法][Link 3]比默认的Java克隆[如何][Link 2]更好。

使用[复制构造函数][Link 2]和[防御性复制方法][Link 3]进行的[Java对象克隆][Link 1]当然具有某些优势，但是我们必须显式编写一些代码才能在所有这些方法中实现深度克隆。 而且，仍然有可能我们会错过某些东西并且不会得到深克隆的对象。

正如[在Java中创建对象的5种不同方式中][Java_5]所讨论的那样，反序列化序列化对象会创建一个状态与序列化对象相同的新对象。 因此，与上述克隆方法类似，我们也可以使用对象[序列化和反序列化][Link 4]来实现深度克隆功能，并且通过这种方法，我们不必担心或编写用于深度克隆的代码，默认情况下会得到它。

但是，使用序列化克隆对象会带来一些性能开销，如果我们只需要克隆对象并且不需要将其持久保存在文件中以备将来使用，则可以通过使用**内存中序列化**来改进它。

我们将使用以下`Employee`类作为示例，其`name` ，  
作为状态的`doj`和`skills` ，对于深度克隆，我们无需担心code> name字段，因为它是一个String对象，默认情况下所有  
[弦在本质上是不变的][Link 5] 。

*您可以在《 [如何在Java中创建不可变的类》][Java]以及《 [为什么String是不可变的和Final》][Link 5]上阅读有关不可变性的更多信息。*

Employee class implements Serializable { 
         private static final long serialVersionUID = 2L; 
         private String name; 
         private LocalDate doj; 
         private List<String> skills; 
         public Employee(String name, LocalDate doj, List<String> skills) { 
             this .name = name; 
             this .doj = doj; 
             this .skills = skills; 
         } 
         public String getName() { return name; } name; } 
         public LocalDate getDoj() { return doj; } doj; } 
         public List<String> getSkills() { return skills; } skills; } 
         // Method to deep clone a object using in memory serialization 
         public Employee deepClone() throws IOException, ClassNotFoundException { 
             // First serializing the object and its state to memory using ByteArrayOutputStream instead of FileOutputStream. 
             ByteArrayOutputStream bos = new ByteArrayOutputStream(); 
             ObjectOutputStream out = new ObjectOutputStream(bos); 
             out.writeObject( this ); 
             // And then deserializing it from memory using ByteArrayOutputStream instead of FileInputStream. 
             // Deserialization process will create a new object with the same state as in the serialized object, 
             ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray()); 
             ObjectInputStream in = new ObjectInputStream(bis); 
             return (Employee) in.readObject(); 
         } 
         @Override 
         public String toString() { 
             return String.format( "Employee{name='%s', doj=%s, skills=%s}" , name, doj, skills); 
         } 
         @Override 
         public boolean equals(Object o) { 
             if ( this == o) return true ; 
             if (o == null || getClass() != o.getClass()) return false ; 
             Employee employee = (Employee) o; 
             return Objects.equals(name, employee.name) && 
                 Objects.equals(doj, employee.doj) && 
                 Objects.equals(skills, employee.skills); 
         } 
         @Override 
         public int hashCode() { 
             return Objects.hash(name, doj, skills); 
         }  }

为了深度克隆`Employee`类的对象，我提供了一个  
`deepClone()`方法，通过使用将对象序列化到内存  
`ByteArrayOutputStream`而不是`FileOutputStream`并使用`ByteArrayInputStream`而不是`FileInputStream`将其反序列化。 在这里，我们将对象序列化为字节，然后再次将其从字节反序列化为对象。

![format_png][]

Employee类实现`Serializable`接口来实现序列化，这有其自身的劣势，我们可以[通过使用Externalizable接口][Externalizable]来自[定义序列化过程][Externalizable]来克服其中的某些劣势。

我们可以在下面的测试中运行，以了解我们的克隆方法是深层克隆还是浅层克隆，此处所有`==`操作将返回false（因为两个对象是分开的），而所有`equals`将返回true（因为两者具有相同的内容）。

public static void main(String[] args) throws IOException, ClassNotFoundException { 
      Employee emp = new Employee( "Naresh Joshi" , LocalDate.now(), Arrays.asList( "Java" , "Scala" , "Spring" )); 
      System.out.println( "Employee object: " + emp); 
      // Deep cloning `emp` object by using our `deepClone` method. 
      Employee clonedEmp = emp.deepClone(); 
      System.out.println( "Cloned employee object: " + clonedEmp); 
      System.out.println(); 
      // All of this will print false because both objects are separate. 
      System.out.println(emp == clonedEmp); 
      System.out.println(emp.getDoj() == clonedEmp.getDoj()); 
      System.out.println(emp.getSkills() == clonedEmp.getSkills()); 
      System.out.println(); 
      // All of this will print true because `clonedEmp` is a deep clone of `emp` and both have the same content. 
      System.out.println(Objects.equals(emp, clonedEmp)); 
      System.out.println(Objects.equals(emp.getDoj(), clonedEmp.getDoj())); 
      System.out.println(Objects.equals(emp.getSkills(), clonedEmp.getSkills()));  }

我们知道反序列化过程每次都会创建一个新对象，如果我们必须使我们的类单身，那将是不好的。 这就是为什么我们需要覆盖和禁用单例类的序列化，这可以通过提供writeReplace和readResolve方法来实现。

与序列化类似，Java克隆也不能与单例模式一起使用，这就是为什么我们也需要覆盖和禁用它。 我们可以通过实现克隆的方式来做到这一点，以便它要么抛出  
`CloneNotSupportedException`或每次都返回相同的实例。

*您可以在[Java Cloning][]和[Java][Java Cloning]上阅读有关Java克隆和序列化的更多信息。*   
 *[Java序列化][Java 1]主题。*   
  
您可以在此找到本文的完整源代码。  
[Github存储库][Github] ，请随时提供宝贵的反馈。

> 翻译自: [https://www.javacodegeeks.com/2019/08/deep-clone-using-java-memory-serialization.html][https_www.javacodegeeks.com_2019_08_deep-clone-using-java-memory-serialization.html]

java序列化深克隆

[Link 1]: https://www.programmingmitra.com/2016/11/Java-Cloning-Types-of-Cloning-Shallow-Deep-in-Details-with-Example.html
[Link 2]: https://www.programmingmitra.com/2017/01/Java-cloning-copy-constructor-versus-Object-clone-or-cloning.html
[Link 3]: https://www.programmingmitra.com/2017/01/java-cloning-why-copy-constructors-are-not-sufficient-or-good.html
[Java_5]: https://www.programmingmitra.com/2016/05/different-ways-to-create-objects-in-java-with-example.html
[Link 4]: https://www.programmingmitra.com/2019/08/what-is-serialization-everything-about-java-serialization-explained-with-example.html
[Link 5]: https://www.programmingmitra.com/2018/02/why-string-is-immutable-and-final-in-java.html
[Java]: https://www.programmingmitra.com/2018/02/how-to-create-immutable-class-in-java.html
[format_png]: /images/20230209/4b7b5f4cb90946dfb29ffbe5d5228080.png
[Externalizable]: https://www.programmingmitra.com/2019/08/how-to-customize-serialization-in-java-by-using-externalizable-interface.html
[Java Cloning]: https://www.programmingmitra.com/search/label/Java%20Cloning
[Java 1]: https://www.programmingmitra.com/search/label/Serialization
[Github]: https://github.com/njnareshjoshi/exercises/blob/master/src/org/programming/mitra/exercises/DeepCloningUsingSerializationExample.java
[https_www.javacodegeeks.com_2019_08_deep-clone-using-java-memory-serialization.html]: https://www.javacodegeeks.com/2019/08/deep-clone-using-java-memory-serialization.html