Serialization and deserialization of Java

What is the serialization and deserialization of Java? Why do I need serialization and deserialization? How do I implement the serialization and deserialization of Java? This paper focuses on these problems.

1.Java Serialization and deserialization

Java Serialization refers to the process of converting a Java object to a sequence of bytes, while Java deserialization refers to the process of reverting a sequence of bytes to a Java object.

2. Why serialization and deserialization are required

We know that when two processes communicate remotely, they can send each other various types of data, including text, pictures, audio, video, etc., which are transmitted over the network in the form of a binary sequence. So when two Java processes are communicating, can we implement the inter-process object transfer? The answer is yes. How do we do that? This requires the serialization and deserialization of Java. In other words, on the one hand, the sender needs to convert the Java object to a sequence of bytes and then transfer it over the network, on the other hand, the receiver needs to recover the Java object from the sequence of bytes.

After we have clarified why Java serialization and deserialization are needed, we naturally think of the benefits of Java serialization. The advantage of this is the persistence of data, through serialization can be permanently saved to the hard disk (usually stored in the file), the second, the use of serialization to achieve remote communication, that is, the transmission of the object's byte sequence on the network.

3. How to implement the serialization and deserialization of Java

1) Serialization API in JDK class library

Java.io.ObjectOutputStream: Represents an object output stream

Its writeobject (Object obj) method serializes the Obj object specified by the parameter and writes the resulting sequence of bytes to a target output stream.

Java.io.ObjectInputStream: Represents an object input stream

Its readobject () method reads the sequence of bytes from the source input stream, deserializes them into an object, and returns them.

2) Requirements for serialization

Only an object of a class that implements the serializable or Externalizable interface can be serialized, otherwise an exception is thrown.

3) Methods of implementing the serialization and deserialization of Java objects

Assuming a student class, its objects need to be serialized, there are three ways to do it:

Method One: If the student class implements only the serializable interface , it can be serialized and deserialized in the following way

ObjectOutputStream uses the default serialization method to serialize non-transient instance variables of the student object.

Objcetinputstream uses the default deserialization method to deserialize non-transient instance variables of the student object.

Method Two: If the student class only implements the Serializable interface, and also defines ReadObject (ObjectInputStream in) and WriteObject (Objectoutputsteam out), Serialization and deserialization are performed in the following manner.

ObjectOutputStream calls the Student object's WriteObject (ObjectOutputStream out) method to serialize.

ObjectInputStream invokes the Student object's ReadObject (ObjectInputStream in) method for deserialization.

Method Three: If the student class implements the Externalnalizable interface , and the student class must implement Readexternal (ObjectInput in) and Writeexternal ( ObjectOutput out) method, the serialization and deserialization are performed in the following manner.

ObjectOutputStream invokes the Student object's writeexternal (ObjectOutput Out) method for serialization.

ObjectInputStream invokes the Student object's readexternal (ObjectInput in) method for deserialization.

4) steps to serialize in the JDK class library

Step One: Create an object output stream that can wrap a different type of target output stream, such as a file output stream:

ObjectOutputStream out = new ObjectOutputStream (New FileOutputStream ("D:\\objectfile.obj"));

Step two: Write the object through the WriteObject () method of the object output stream:

Out.writeobject ("Hello");

Out.writeobject (New Date ());

5) steps to deserialize in the JDK class library

Step One: Create an object input stream that can wrap a different type of input stream, such as a file input stream:

ObjectInputStream in = new ObjectInputStream (New FileInputStream ("D:\\objectfile.obj"));

Step Two: Read the object through the ReadObject () method of the object output stream:

String obj1 = (string) in.readobject ();

Date Obj2 = (date) in.readobject ();

Note: In order to correctly read the data and complete the deserialization, it is necessary to ensure that the output stream writes objects to the object in the same order as the objects are read from the object input stream.

In order to better understand the Java serialization and deserialization, select the method one encoding implementation.

The student class is defined as follows:

[Java]View Plaincopy

2. Package Com.jieke.io;
4. Import java.io.Serializable;
8. /**
10. *title: Student Class
12. *description: Student class that implements the serialization interface
14. *copyright:copyright (c) 2012
16. *filename:student.java
18. * @author Wang luqing
20. * @version 1.0
22. */
24. Public class Student implements Serializable
26. {
28. private String name;
30. private char sex;
32. private int year;
34. private double GPA;
38. Public Student ()
40. {
44. }
46. Public Student (String name,char-sex,int year,double GPA)
48. {
50. this.name = name;
52. this.sex = sex;
54. this.year = year;
56. This.gpa = GPA;
58. }
62. public void SetName (String name)
64. {
66. this.name = name;
68. }
72. public void Setsex (char sex)
74. {
76. this.sex = sex;
78. }
82. public void setyear (int year)
84. {
86. this.year = year;
88. }
92. public void Setgpa (double gpa)
94. {
96. This.gpa = GPA;
98. }
102. Public String getName ()
104. {
106. return this.name;
108. }
112. public Char getsex ()
114. {
116. return This.sex;
118. }
122. public int getYear ()
124. {
126. return this.year;
128. }
132. public Double Getgpa ()
134. {
136. return This.gpa;
138. }
140. }

Serializes the object of the student class to the file O:\\java\\com\\jieke\\io\\student.txt and deserializes it from the file, displaying the result to the console. The code is as follows:

[Java]View Plaincopy

2. Import java.io.*;
6. /**
8. *title: Apply Student class
10. *description: Realizing the serialization and deserialization of student class instances
12. *copyright:copyright (c) 2012
14. *filename:usestudent.java
16. * @author Wang luqing
18. * @version 1.0
20. */
24. Public class Usestudent
26. {
28. public static void Main (string[] args)
30. {
32. Student st = New Student ("Tom",' M ',3.6);
34. File File = new file ("O:\\java\\com\\jieke\\io\\student.txt");
36. Try
38. {
40. File.createnewfile ();
42. }
44. catch (IOException e)
46. {
48. E.printstacktrace ();
50. }
52. Try
54. {
56. //student Object Serialization Process
58. FileOutputStream fos = new FileOutputStream (file);
60. ObjectOutputStream Oos = new ObjectOutputStream (FOS);
62. Oos.writeobject (ST);
64. Oos.flush ();
66. Oos.close ();
68. Fos.close ();
72. //student Object Deserialization process
74. FileInputStream FIS = new FileInputStream (file);
76. ObjectInputStream ois = new ObjectInputStream (FIS);
78. Student st1 = (Student) ois.readobject ();
80. System.out.println ("name =" + St1.getname ());
82. System.out.println ("sex =" + st1.getsex ());
84. SYSTEM.OUT.PRINTLN ("year =" + St1.getyear ());
86. SYSTEM.OUT.PRINTLN ("GPA =" + St1.getgpa ());
88. Ois.close ();
90. Fis.close ();
92. }
94. catch (classnotfoundexception e)
96. {
98. E.printstacktrace ();
100. }
102. catch (IOException e)
104. {
106. E.printstacktrace ();
108. }
110. }
112. }

The results are as follows:

Name = Tom

Sex = M

Year = 20

GPA = 3.6

Summarize:

1) Java serialization is the conversion of an object into a sequence of bytes, while the Java deserialization is the restoration of a sequence of bytes to a Java object.

2) The use of Java serialization and deserialization technology, one can achieve the persistence of data, in the MVC pattern is very useful, and the other is the object data can be remote communication.

Reprint Source: http://blog.csdn.net/wangloveall/article/details/7992448

Serialization and deserialization of Java