什么是对象序列化?

敢于回答这个6年前的问题，为Java新手增加了非常高级的理解

什么是序列化?

将对象转换为字节

什么是反序列化?

将字节转换回对象(反序列化)。

什么时候使用序列化?

当我们想持久化对象时。 当我们希望对象在JVM生命周期之后仍然存在时

现实世界的例子:

ATM:当账户持有人试图通过ATM从服务器取款时，提现明细等账户持有人信息将被序列化并发送到服务器，服务器将这些明细反序列化并用于操作。

在java中如何执行序列化。

1. 实现java.io.Serializable接口(标记接口，因此没有方法实现)。

2. 持久化对象:使用java.io.ObjectOutputStream类，这是一个过滤器流，它是底层字节流的包装器(将object写入文件系统或通过网络传输扁平对象并在另一端重新构建)。

• writeObject(<<instance>>) -写一个对象
• readObject() -读取一个序列化的对象

记住:

序列化对象时，只保存对象的状态，不保存对象的类文件或方法。

当你序列化一个2字节的对象时，你会看到51字节的序列化文件。

步骤如何序列化和反序列化对象。

答案:它如何转换为51字节的文件?

• 首先写入序列化流魔术数据(STREAM_MAGIC= "AC ED"和STREAM_VERSION= JVM的版本)。
• 然后，它写出与实例关联的类的元数据(类的长度、类的名称、serialVersionUID)。
• 然后它递归地写出超类的元数据，直到找到java.lang.Object。
• 然后从与实例关联的实际数据开始。
• 最后，从元数据开始将与实例关联的对象的数据写入实际内容。

你也可以检查我的Youtube视频解释

编辑:引用链接来读取。

这将回答一些常见的问题:

1. 如何不序列化类中的任何字段 答:使用transient关键字

2. 当子类被序列化时父类被序列化吗?< br > 答:不，如果父字段没有扩展Serializable接口，父字段就不会被序列化

3. 当父类被序列化时子类被序列化吗?< br > 答:是的，默认情况下子类也被序列化

4. 如何避免子类被序列化?< br > 答:a.重写writeObject和readObject方法并抛出NotSerializableException.
   

   B.你也可以在子类中标记所有暂态字段。

5. 一些系统级类，如Thread、OutputStream及其子类和Socket是不可序列化的

将文件作为Object: http://www.tutorialspoint.com/java/java_serialization.htm返回

        import java.io.*;


public class SerializeDemo
{
public static void main(String [] args)
{
Employee e = new Employee();
e.name = "Reyan Ali";
e.address = "Phokka Kuan, Ambehta Peer";
e.SSN = 11122333;
e.number = 101;


try
{
FileOutputStream fileOut =
new FileOutputStream("/tmp/employee.ser");
ObjectOutputStream out = new ObjectOutputStream(fileOut);
out.writeObject(e);
out.close();
fileOut.close();
System.out.printf("Serialized data is saved in /tmp/employee.ser");
}catch(IOException i)
{
i.printStackTrace();
}
}
}


import java.io.*;
public class DeserializeDemo
{
public static void main(String [] args)
{
Employee e = null;
try
{
FileInputStream fileIn = new FileInputStream("/tmp/employee.ser");
ObjectInputStream in = new ObjectInputStream(fileIn);
e = (Employee) in.readObject();
in.close();
fileIn.close();
}catch(IOException i)
{
i.printStackTrace();
return;
}catch(ClassNotFoundException c)
{
System.out.println("Employee class not found");
c.printStackTrace();
return;
}
System.out.println("Deserialized Employee...");
System.out.println("Name: " + e.name);
System.out.println("Address: " + e.address);
System.out.println("SSN: " + e.SSN);
System.out.println("Number: " + e.number);
}
}

我在自己的博客上说:

下面是关于序列化的详细说明:(我自己的博客)

序列化:

序列化是持久化对象状态的过程。它以字节序列的形式表示和存储。这可以存储在一个文件中。从文件中读取对象状态并恢复它的过程称为反序列化。

序列化的需求是什么?

在现代体系结构中，总是需要存储对象状态，然后再检索它。例如，在Hibernate中，要存储一个对象，我们应该使类Serializable。它所做的是，一旦对象状态以字节的形式保存，它就可以传输到另一个系统，然后该系统可以从状态中读取并检索类。对象状态可以来自数据库、不同的jvm或单独的组件。在Serialization的帮助下，我们可以检索对象状态。

代码示例及说明:

首先让我们来看看Item Class:

public class Item implements Serializable{


/**
*  This is the Serializable class
*/
private static final long serialVersionUID = 475918891428093041L;
private Long itemId;
private String itemName;
private transient Double itemCostPrice;
public Item(Long itemId, String itemName, Double itemCostPrice) {
super();
this.itemId = itemId;
this.itemName = itemName;
this.itemCostPrice = itemCostPrice;
}


public Long getItemId() {
return itemId;
}


@Override
public String toString() {
return "Item [itemId=" + itemId + ", itemName=" + itemName + ", itemCostPrice=" + itemCostPrice + "]";
}




public void setItemId(Long itemId) {
this.itemId = itemId;
}


public String getItemName() {
return itemName;
}
public void setItemName(String itemName) {
this.itemName = itemName;
}


public Double getItemCostPrice() {
return itemCostPrice;
}


public void setItemCostPrice(Double itemCostPrice) {
this.itemCostPrice = itemCostPrice;
}
}

在上面的代码中，可以看到项类实现了可序列化的。

这是使类可序列化的接口。

现在我们可以看到一个名为serialVersionUID的变量被初始化为Long变量。这个数字是由编译器根据类的状态和类属性计算出来的。这个数字将帮助jvm在从文件中读取对象的状态时识别对象的状态。

为此，我们可以看看官方的Oracle文档:

序列化运行时与每个可序列化类a相关联 版本号，称为serialVersionUID，在 反序列化验证发送方和接收方是否序列化 对象为该对象加载了与之兼容的类 关于序列化。类的类 对象的serialVersionUID与 对应的发送方类，则反序列化将导致 InvalidClassException。可序列化类可以声明自己的类 serialVersionUID通过声明一个名为 "serialVersionUID"必须是静态的，final的，long类型: ANY-ACCESS-MODIFIER static final long serialVersionUID = 42L;如果一个 serializable类没有显式声明serialVersionUID， 然后序列化运行时将计算一个默认值 类的各个方面的serialVersionUID值 类，如Java(TM)对象序列化中所述 规范。然而，强烈建议所有 可序列化类显式声明serialVersionUID值，因为 默认的serialVersionUID计算对类非常敏感 细节可能因编译器实现而异 从而导致意外的invalidclassexception 反序列化。因此，为了保证一致的serialVersionUID 值跨不同的Java编译器实现，一个可序列化的 类必须声明显式的serialVersionUID值。它也是 强烈建议显式的serialVersionUID声明使用 私有修饰符，因为这样的声明只适用于 立即声明类——serialVersionUID字段则不是

如果你注意到，我们使用的另一个关键字是瞬态。

如果字段不可序列化，则必须将其标记为transient。在这里，我们将itemCostPrice标记为transient，并且不希望它被写入文件中

现在让我们看看如何在文件中写入对象的状态，然后从那里读取它。

public class SerializationExample {


public static void main(String[] args){
serialize();
deserialize();
}


public static void serialize(){


Item item = new Item(1L,"Pen", 12.55);
System.out.println("Before Serialization" + item);


FileOutputStream fileOut;
try {
fileOut = new FileOutputStream("/tmp/item.ser");
ObjectOutputStream out = new ObjectOutputStream(fileOut);
out.writeObject(item);
out.close();
fileOut.close();
System.out.println("Serialized data is saved in /tmp/item.ser");
} catch (FileNotFoundException e) {


e.printStackTrace();
} catch (IOException e) {


e.printStackTrace();
}
}


public static void deserialize(){
Item item;


try {
FileInputStream fileIn = new FileInputStream("/tmp/item.ser");
ObjectInputStream in = new ObjectInputStream(fileIn);
item = (Item) in.readObject();
System.out.println("Serialized data is read from /tmp/item.ser");
System.out.println("After Deserialization" + item);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}

在上面的例子中，我们可以看到一个对象的序列化和反序列化。

为此我们使用了两个类。为了序列化对象，我们使用了ObjectOutputStream。我们已经使用writeObject方法将对象写入文件。

对于反序列化，我们使用ObjectInputStream从文件中读取对象。它使用readObject从文件中读取对象数据。

上述代码的输出如下所示:

Before SerializationItem [itemId=1, itemName=Pen, itemCostPrice=12.55]
Serialized data is saved in /tmp/item.ser
After DeserializationItem [itemId=1, itemName=Pen, itemCostPrice=null]

注意，来自反序列化对象的itemCostPrice是零，因为它没有被写入。

在本文的第一部分中，我们已经讨论了Java序列化的基础知识。

现在让我们深入讨论它以及它是如何工作的。

首先让我们从serialversionuid。开始

serialVersionUID在Serializable类中用作版本控制。

如果您没有显式地声明serialVersionUID, JVM将根据Serializable类的各种属性自动为您声明。

Java的计算serialversionuid的算法(在这里阅读更多细节)

1. 类名。
   2. 类修饰符写为32位整数。
   3. 按名称排序的每个接口的名称。
   4. 对于按字段名排序的类的每个字段(私有静态和私有瞬态字段除外):字段名。的 写为32位整数的字段的修饰符。描述符 这个领域。李< / >
   5. 如果存在类初始化式，则写出以下内容:方法的名称，。
   6. 方法的修饰符:java.lang.reflect.Modifier。STATIC，写为32位整数。
   7. 方法的描述符()V。
   8. 对于每个按方法名和签名排序的非私有构造函数:方法名，。的修饰符 方法编写为32位整数。方法的描述符。李< / >
   9. 对于每个按方法名和签名排序的非私有方法:方法名。方法的修饰符写为 32位整数。
   方法的描述符
   10. sha -1算法在DataOutputStream产生的字节流上执行，生成5个32位的值sha[0..4]。的 对象的第一个和第二个32位值组合成哈希值 SHA-1消息摘要。如果结果是消息摘要，则为五 32位的单词H0 H1 H2 H3 H4，是一个由五个int值命名的数组 Sha，哈希值计算如下:
   李< / ol > < / >

    long hash = ((sha[0] >>> 24) & 0xFF) |
>            ((sha[0] >>> 16) & 0xFF) << 8 |
>            ((sha[0] >>> 8) & 0xFF) << 16 |
>            ((sha[0] >>> 0) & 0xFF) << 24 |
>            ((sha[1] >>> 24) & 0xFF) << 32 |
>            ((sha[1] >>> 16) & 0xFF) << 40 |
>            ((sha[1] >>> 8) & 0xFF) << 48 |
>        ((sha[1] >>> 0) & 0xFF) << 56;

Java的序列化算法

对象序列化的算法说明如下:
1. 它写出与实例关联的类的元数据 2. 它递归地写出超类的描述，直到找到java . lang . object.
3.一旦它完成了元数据信息的写入，它就开始处理与实例关联的实际数据。但这一次，它 从最上面的超类开始 4. 它递归地写入与实例相关的数据，从最小的超类开始写入派生最多的类

要记住的事情:

1. 类中的静态字段不能序列化。

   public class A implements Serializable{
   String s;
   static String staticString = "I won't be serializable";
   }
   

2. If the serialversionuid is different in the read class it will throw a InvalidClassException exception.

3. If a class implements serializable then all its sub classes will also be serializable.

   public class A implements Serializable {....};
   
   
   public class B extends A{...} //also Serializable
   

4. If a class has a reference of another class, all the references must be Serializable otherwise serialization process will not be performed. In such case, NotSerializableException is thrown at runtime.

Eg:

public class B{
String s,
A a; // class A needs to be serializable i.e. it must implement Serializable
}

|*|序列化一个类:将一个对象转换为字节和字节返回到对象(反序列化)

class NamCls implements Serializable
{
int NumVar;
String NamVar;
}

|=>对象序列化是将对象的状态转换为字节蒸汽的过程

• |->当您希望对象在JVM生命周期之外仍然存在时实现
• |->序列化对象可以存储在数据库中
• |->可序列化对象不能被人类读取和理解，因此我们可以实现安全性

|=>对象-反序列化是获取对象状态并将其存储到对象(java.lang.Object)的过程

在存储它的状态之前，它检查input-file/network中的serialVersionUID和.class文件中的serialVersionUID是否相同 如果没有抛出java.io.InvalidClassException.
. nbspIf not throw java.io.InvalidClassException.
. nbspIf not throw

只有当Java对象的类或其任何超类
时，该对象才可序列化

• 实现java.io.Serializable接口或
  
• 它的子接口java.io.Externalizable.
  

|=>类中的静态字段不能序列化

class NamCls implements Serializable
{
int NumVar;
static String NamVar = "I won't be serializable";;
}

|=>如果你不想序列化一个类的变量，使用transient关键字

class NamCls implements Serializable
{
int NumVar;
transient String NamVar;
}

|=>如果一个类实现了序列化，那么它的所有子类也都是可序列化的

|=>如果一个类有另一个类的引用，所有的引用必须是Serializable，否则序列化过程将不会执行。在这种情况下，
NotSerializableException将在运行时抛出。

我将提供一个类比，以潜在地帮助巩固对象序列化/反序列化的概念目的/实用性。

我想象< em >对象序列化/反序列化< / em >在试图移动一个物体通过雨水沟的上下文中。对象本质上被“分解”或序列化分解为自身的更模块化的版本——在本例中是字节序列——以便有效地通过介质。在计算的意义上，我们可以将字节通过排水沟的路径视为类似于字节通过网络的路径。我们正在改变我们的对象，以符合更理想的运输方式或格式。序列化的对象通常存储在二进制文件中，以后可以对该文件进行读、写或同时进行读、写。

也许一旦我们的对象能够作为分解的字节序列通过drain，我们可能希望将对象的表示形式作为二进制数据存储在数据库或硬盘驱动器中。不过，主要的要点是，通过序列化/反序列化，我们可以选择让对象在序列化后保持二进制形式，或者通过执行反序列化来“检索”对象的原始形式。

在Java中，使用Serialization和Externalisation接口也可以实现同样的功能