Java中序列化和反序列化

深碍√TFBOYSˉ_ 2023-09-29 15:14 116阅读 0赞

## 什么是Java序列化与反序列化？ ##

1、**序列化**：Java中的序列化机制能够**将一个实例对象信息写入到一个字节流中（只序列化对象的属性值，而不会去序列化方法），序列化后的对象可用于网络传输，或者持久化到数据库、磁盘中**。

2、反序列化：需要对象的时候，再通过字节流中的信息来重构一个相同的对象。

**3、实现序列化条件**  
1）实现接口：Serializable标识接口  
2）对象所在的类提供常量：序列版本号。  
3）要求对象的属性也是可序列化的。（基本数据类型本身是可序列化的），注意被static修饰的、transient关键字修饰的属性是不能被序列化的。

**4、代码实现**  
1、java对象Person

package ObjectInoutOutputTest;
    
    import java.io.Serializable;
    
    public class Person implements Serializable {
        
    
        /*
        1.实现接口Serializable(标识接口)
        2.当前类提供一个全局的常量：serialVersionUID
        3.除了当前的类需要实现Serializable接口外，还必须保证内部的所有属性也必须是可序列化的。
    
        ObjectOutputStrea和ObjectInputStream不能序列化static和transient修饰的成员变量
         */
        public static final long serialVersionUID = 8365573970943482803L;
        private String name;
        private int age;
        public Person(String name, int age) {
        
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    
        public Person() {
        
        }
    
        @Override
        public String toString() {
        
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

**2、序列化**

package ObjectInoutOutputTest;
    
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectOutputStream;
    
    public class xuliehua {
        
        /*
        序列化过程:将内存中的java对象保存到磁盘中或通过网络传输出去
        使用ObjectOutputStream实现
         */
        public static void main(String[] args) {
        
            ObjectOutputStream oos=null;
            try {
        
                oos = new ObjectOutputStream(new FileOutputStream("object.dat"));
    
                oos.writeObject(new String("我爱北京天安门"));
    
                oos.flush();
    
                oos.writeObject(new Person("小王",23));
                oos.flush();
    
            } catch (IOException e) {
        
                e.printStackTrace();
            }finally {
        
                if (oos != null) {
        
                    try {
        
                        oos.close();
                    } catch (IOException e) {
        
                        e.printStackTrace();
                    }
                }
            }
        }
    }

2、序列化

3、反序列化

package ObjectInoutOutputTest;
    
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.ObjectInput;
    import java.io.ObjectInputStream;
    
    public class fanxulie {
        
        /*
        反序列化：将磁盘文件中的对象还原为内存中的一个java对象
        使用ObjectInputStream
         */
        public static void main(String[] args) {
        
            ObjectInputStream ois = null;
            try {
        
                ois = new ObjectInputStream(new FileInputStream("object.dat"));
    
                Object obj = ois.readObject();
                String str = (String) obj;
    
                Person p = (Person) ois.readObject();
                System.out.println(str);
                System.out.println(p);
            } catch (IOException | ClassNotFoundException e) {
        
                e.printStackTrace();
            }finally {
        
                if (ois != null) {
        
                    try {
        
                        ois.close();
                    } catch (IOException e) {
        
                        e.printStackTrace();
                    }
                }
            }
        }
    }

**打开writeObject方法的源码看一下，发现方法中有这么一个逻辑，当要写入的对象是String、Array、Enum、Serializable类型的对象则可以正常序列化，否则会抛出NotSerializableException异常。  
这就能解释为什么Java序列化一定要实现Serializable接口了。**

/**
         * Underlying writeObject/writeUnshared implementation.
         */
        private void writeObject0(Object obj, boolean unshared)
            throws IOException
        {
        
            boolean oldMode = bout.setBlockDataMode(false);
            depth++;
            try {
        
                // 省略号。。。。。。。。。。
    
                // remaining cases
                if (obj instanceof String) {
        
                    writeString((String) obj, unshared);
                } else if (cl.isArray()) {
        
                    writeArray(obj, desc, unshared);
                } else if (obj instanceof Enum) {
        
                    writeEnum((Enum<?>) obj, desc, unshared);
                } else if (obj instanceof Serializable) {
        
                    writeOrdinaryObject(obj, desc, unshared);
                } else {
        
                    if (extendedDebugInfo) {
        
                        throw new NotSerializableException(
                            cl.getName() + "\n" + debugInfoStack.toString());
                    } else {
        
                        throw new NotSerializableException(cl.getName());
                    }
                }
            } finally {
        
                depth--;
                bout.setBlockDataMode(oldMode);
            }
        }

**5、Serializable接口**

package java.io;
    
    /**
     * @author  unascribed
     * @see java.io.ObjectOutputStream
     * @see java.io.ObjectInputStream
     * @see java.io.ObjectOutput
     * @see java.io.ObjectInput
     * @see java.io.Externalizable
     * @since   JDK1.1
     */
    public interface Serializable {
        
    }

**6、既然已经实现了Serializaable接口，为什么还要显示指定serialVersionUID的值？**  
因为序列化对象时，如果不显示的设置serialVersionUID，Java在序列化时会根据对象属性自动的生成一个serialVersionUID，再进行存储或用作网络传输。

在反序列化时，会根据对象属性自动再生成一个新的serialVersionUID，和序列化时生成的serialVersionUID进行比对，两个serialVersionUID相同则反序列化成功，否则就会抛异常。

而当显示的设置serialVersionUID后，Java在序列化和反序列化对象时，生成的serialVersionUID都为我们设定的serialVersionUID，这样就保证了反序列化的成功

**7、transient关键字**

**序列化对象时如果希望哪个属性不被序列化，则用transient关键字修饰即可。**

@Data
    public class User implements Serializable {
        
    
        private transient String name;
    
        private String age;
    }

可以看到字段name的值没有被保存到磁盘中，一旦变量被transient修饰，变量将不再是对象持久化的一部分，该变量内容在序列化后无法获得访问。

Java序列化前的结果: User(name=fufu, age=18)
    Java反序列化的结果:User(name=null, age=18)

**一个静态变量不管是否被transient修饰，均不能被序列化。 因为static修饰的属性是属于类，而非对象**