The concept of Serializable serialization and deserialization of Java, the understandable interpretation of the function

Encountered this Java Serializable serialization of this interface, we may have the following problems
A, what's called serialization and deserialization
b, the effect. Why do you want to implement this Serializable interface, which is why you want to serialize
C,serialversionuid The value of this is exactly how it is set, what is the use. Some 1L, there is a long list of numbers, confusing ING.
When I first saw this keyword Serializable, it was just like all the questions.

Before dealing with this problem, you need to know a problem first, this is more important.
This serializable interface, and the related stuff, are all in Java io.

1, serialization and deserialization concepts

Serialization: The process of converting an object to a sequence of bytes is called serialization of an object.
Deserialization: The process of reverting a sequence of bytes to an object is called deserialization of the object.

The above is a professional explanation, now to some popular explanation. When the code is running, we can see a lot of objects (the debug is created),
Can be a collection of a class of objects, a lot of object data, the data,
Some of the information we want to keep him persistent, then this serialization.
is to turn these objects in memory into a sequence of byte-describing processes.
The common thing is to become a file
I do not serialize can also save the file what ah, what impact? That's what I was asking.

2, under what circumstances need serialization

When you want to save the state of an object in memory in a file or in a database;
When you want to use sockets to transfer objects on the network;
When you want to transfer objects through RMI;

(To be honest, I may have used a database of the above several)

3, how to implement serialization

Implement the Serializable interface to

The above theories are relatively simple, the actual code below to see what this serialization is capable of, as well as the resulting bug problem.

First on the object code, flying Pig. Java

2. Package Com.lxk.model;
6. import java.io.Serializable;
10. /**
12. * @author lxk on 2017/11/1
14. */
16. public class Flypig implements Serializable {
18. //private static final long serialversionuid = 1L;
20. private static String age = "269";
22. private String name;
24. private String color;
26. transient private String car;
30. //private String Addtip;
34. Public String getName() {
36. return name;
38. }
42. Public void setName(String name) {
44. this.name = name;
46. }
50. Public String getColor() {
52. return color;
54. }
58. Public void setcolor(String color) {
60. this.color = color;
62. }
66. Public String getcar() {
68. return car;
70. }
74. Public void setcar(String car) {
76. This.car = car;
78. }
82. //public String Getaddtip () {
84. //return addtip;
86. //}
88. //
90. //public void Setaddtip (String addtip) {
92. //This.addtip = Addtip;
94. //}
98. @Override
100. Public String toString() {
102. return "flypig{" +
104. "Name=" + name + ' \ ' +
106. ", color= '" + color + " \" +
108. ", car= '" + car + " \" +
110. ", age= '" + age + " \" +
112. //", addtip= '" + addtip + "\" +
114. '} ';
116. }
118. }

Note that the code for the comment is to be used in a variety of situations for a while.

Here's the main method.

2. Package com.lxk.test;
6. import Com.lxk.model.FlyPig;
10. import java.io.*;
14. /**
16. * Serialization Test
18. *
20. * @author lxk on 2017/11/1
22. */
24. public class serializabletest {
26. Public static void main(string[] args) throws Exception {
28. Serializeflypig ();
30. Flypig Flypig = Deserializeflypig ();
32. System.out.println (Flypig.tostring ());
36. }
40. /**
42. * Serialization
44. */
46. private static void Serializeflypig() throws IOException {
48. Flypig Flypig = new Flypig ();
50. Flypig.setcolor ("Black");
52. Flypig.setname ("Naruto");
54. Flypig.setcar ("0000");
56. ///ObjectOutputStream object output stream, storing Flypig object in the FlyPig.txt file of e-drive, complete serialization of the Flypig object
58. ObjectOutputStream Oos = new ObjectOutputStream (NewFileOutputStream (new File ("D:/flypig.txt" ));
60. Oos.writeobject (Flypig);
62. System.out.println ("Flypig object serialization succeeded!") ");
64. Oos.close ();
66. }
70. /**
72. * Deserialization
74. */
76. private static Flypig deserializeflypig() throws Exception {
78. ObjectInputStream ois = new ObjectInputStream (NewFileInputStream (new File ("D:/flypig.txt" ));
80. Flypig person = (Flypig) ois.readobject ();
82. System.out.println ("Flypig object deserialization succeeded!") ");
84. return person;
86. }
88. }

A brief description of the above 2 classes that manipulate the file stream

ObjectOutputStream represents the 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.

ObjectInputStream represents the object input stream:

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

How to see the operation of the actual situation.

The first kind: Come up on these code, do not move, direct run, look at the effect.

The actual running result, he will generate a file in D:/flypig.txt.

From the results of the operation, see:

1, he implements serialization and deserialization of objects.

Properties that are modified by 2,transient are not serialized. I set the Audi four-lap car missing and became null. My God.

3, you don't have to rush to say that this static variable age is also serialized. This one has to be tested separately.

Second: In order to verify that this static property can be serialized and deserialized, you can do the following.

1. Public static void main(string[] args) throws Exception {
2. Serializeflypig ();
3. //flypig Flypig = Deserializeflypig ();
4. //system.out.println (flypig.tostring ());
5. }

When this is over, it means that you are serializing objects to a file first. This object is static variable.

Now change the value of age in the Flypig class to 26.

Then, look inside the run code and execute the result.

You can see that just 269 of the serialization is not read out. But just modified 26, if possible, should be covered by this 26, is 269.

So, come to the conclusion that this statically static property, he does not serialize.

The third type: demonstrating the role and usage of the Serialversionuid

The most violent modification, directly removes the interface of the model class implementation. The subsequent serialization and deserialization methods are then executed. Direct error.

Throw exception: Notserializableexception

This is too violent, it is not recommended to do so.

Then there is the same thing as the above, which first executes the serialization method separately. Generate files.
Then, open the property Addtip, and after that, perform the deserialization method again, to see the phenomenon.

Throw exception: Invalidclassexception details are as follows.

InvalidClassException:com.lxk.model.FlyPig;
Local class Incompatible:
Stream Classdesc Serialversionuid =-3983502914954951240,
Local class Serialversionuid = 7565838717623951575

Explain:

Because I have no definite assignment to this serialversionuid in the model, but Java is automatically assigned to me,

This value is calculated in relation to the properties of this model.

When I kept it, that is, when I serialized it, there was no such addtip attribute at that time,

So, the auto-generated serialversionuid this value,

When I deserialized the Java automatically generated this serialversionuid value is different, he throws an exception.

(You can also reverse, with ID to serialize, and then, no ID to deserialize.) is the same problem. ）

Again, is the first serialization, this time, the private static final long serialversionuid = 1L; The comment for this line of code opens. The Addtip attribute is commented out first

After serialization, the property is opened and then deserialized. See what happens.

This time, code execution OK, everything is fine. Good.

What this phenomenon means to us:

Old iron, the meaning is relatively large, first of all, if you do not know what the serialization is to do, in case he really like the beginning of the database, socket transmission, RMI transmission. Although I do not know what this is to do. You have a model bean implemented this interface, you did not write this serialversionuid then in the later expansion, there may be a bug that does not know the old data, then do not fry it. Recall the above error situation. Think about all the scary, this pot who comes back?

So, there is a theory, that is, in the implementation of this serializable interface, it is necessary to give this serialversionuid assignment, is such a problem.

This explains why the Eclipse editor will need to add a value for this ID when we have just started coding, after implementing this interface. And it's a long list of numbers you don't know how to get.

The following explains how the value of this serialversionuid is set to OK.

First of all, you can not use your own to assign value, Java will give you value, but this will appear above the bug, very insecure, so, you have to manually.

So, how do I assign a value, eclipse may automatically assign you a long list of numbers. This is not necessary.

Can be simply assigned to a 1L, this is OK. This ensures that the code is consistent when the deserialization succeeds.

The values of different serialversionuid will affect the deserialization, that is, the reading of the data, you write 1L, pay attention to the larger. The computer is not case-sensitive, but, as the audience, we are to distinguish between 1 and L, so say, this value, idle nothing to move, or a version upgrade, the old data is incompatible, you do not know where the problem is ...

The following is a description of the interface Serializable from the JDK API documentation
Class by implementing the Java.io.Serializable interface to enable its serialization functionality. A
class that does not implement this interface will not be able to serialize or deserialize any of its states. The
all the subtypes of a serializable class are themselves serializable. Because implementing an interface is also indirectly equivalent to inheritance. The
serialization interface has no methods or fields and is used only to identify the semantics of serialization.

Description of the Serialversionuid
Serialization runtime is associated with each serializable class using a version number called Serialversionuid. The sequence number is used during deserialization to verify that the sender and receiver of the serialized object have loaded a serialized-compatible class for the object. If the serialversionuid of the object's class that the recipient loads differs from the version number of the corresponding sender's class, deserialization will cause invalidclassexception. A serializable class can explicitly declare its own serialversionuid by declaring a field named "Serialversionuid", which must be a static (static), final (final) long field:

If the serializable class does not explicitly declare Serialversionuid, the serialization runtime calculates the default Serialversionuid value for the class based on the various aspects of the class, as described in the Java (TM) object serialization specification. However, it is strongly recommended that all serializable classes explicitly declare the SERIALVERSIONUID value because the calculation of the default Serialversionuid has a high sensitivity to the details of the class and may vary widely depending on the compiler implementation. This can lead to unexpected invalidclassexception during deserialization. Therefore, to ensure consistency of serialversionuid values across different Java compilers, the serialization class must declare an explicit SERIALVERSIONUID value. It is also strongly recommended to use the private modifier to display the declaration Serialversionuid, if possible, because such a declaration applies only to the direct declaration class-The Serialversionuid field is not useful as an inherited member. An array class cannot declare an explicit serialversionuid, so they always have a default computed value, but the array class does not have the requirement to match the Serialversionuid value

78544505

The concept of Serializable serialization and deserialization of Java, the understandable interpretation of the function