java Serializable详解

最新推荐文章于 2022-07-05 01:09:25 发布

于王令

最新推荐文章于 2022-07-05 01:09:25 发布

阅读量547

点赞数 1

分类专栏： java 文章标签： java Seriazible

本文链接：https://blog.csdn.net/peiyuWang_2015/article/details/72834671

版权

java 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

1、什么是序列化和反序列化

Serialization（序列化）是一种将对象以一连串的字节描述的过程；反序列化deserialization是一种将这些字节重建成一个对象的过程。

2、什么情况下需要序列化

a）当你想把的内存中的对象保存到一个文件中或者数据库中时候；

b）当你想用套接字在网络上传送对象的时候；

c）当你想通过RMI传输对象的时候；

将需要序列化的类实现Serializable接口就可以了，Serializable接口中没有任何方法，可以理解为一个标记，即表明这个类可以序列化。

3、序列化和反序列化例子

如果我们想要序列化一个对象，首先要创建某些OutputStream(如FileOutputStream、ByteArrayOutputStream等)，然后将这些OutputStream封装在一个ObjectOutputStream中。这时候，只需要调用writeObject()方法就可以将对象序列化，并将其发送给OutputStream（对象的序列化是基于字节的，不能使用Reader和Writer等基于字符的层次结构）。而反序列的过程（即将一个序列还原成为一个对象），需要将一个InputStream(如FileInputstream、ByteArrayInputStream等)封装在ObjectInputStream内，然后调用readObject()即可。

package serizable;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class Person_Serializable implements Serializable{

	/**
	 * 序列化版本号
	 */
	private static final long serialVersionUID = 1L;
	private String name;
	//transient关键字表示在序列化是，这个变量不用加入，所有反序列化的时候，不能够获取到这个值
	private transient int age;
	public Person_Serializable(String name,int age) {
		this.name=name;
		this.age=age;
	}
	public String getName(){
		return this.name;
	}
	public int getAge(){
		return this.age;
	}
	/**
	 * 序列化当前对象到本地
	 */
	public void SerializableImpl() throws IOException{
		FileOutputStream fileOutputStream=new FileOutputStream("person.out");
		ObjectOutputStream objectOutputStream=new ObjectOutputStream(fileOutputStream);
		objectOutputStream.writeObject(this);
		objectOutputStream.flush();
		objectOutputStream.close();
		fileOutputStream.close();
	}
	/**
	 * 静态方法，将序列换的本地对象反序列化会内存中的对象
	 */
	public static  Person_Serializable ReverseSerializableImpl(String filepath) throws IOException, ClassNotFoundException{
		FileInputStream fileInputStream=new FileInputStream(filepath);
		ObjectInputStream objectInputStream=new ObjectInputStream(fileInputStream);
		Person_Serializable person_Serializable=(Person_Serializable)objectInputStream.readObject();
		objectInputStream.close();
		fileInputStream.close();
		return person_Serializable;
	}
	@Override
	public String toString() {
		return name+" age is "+age;
	}
	public static void main(String arg[]) throws IOException, ClassNotFoundException{
		Person_Serializable person=new Person_Serializable("小王", 23);
		System.out.println(person.toString());
		person.SerializableImpl();
		System.out.println(Person_Serializable.ReverseSerializableImpl("person.out").toString());
	}
}

输出：

小王 age is 23

小王 age is 0

使用了transient关键字修饰的变量，在对象序列化时不写入字节，所以反序列化的时候也无法获取到其值。

4.序列化前和序列化后的对象的关系

是 "=="还是equal？ or 是浅复制还是深复制？

答案：深复制，反序列化还原后的对象地址与原来的的地址不同

序列化前后对象的地址不同了，但是内容是一样的，而且对象中包含的引用也相同。换句话说，通过序列化操作,我们可以实现对任何可Serializable对象的”深度复制（deep copy）”——这意味着我们复制的是整个对象网，而不仅仅是基本对象及其引用。

7.静态变量能否序列化

答案是不能。因为对象的序列化是对象层级的，而静态成员是类层级的，所以静态的变量不能序列化，但是反序列化后的对象是可以访问静态成员的，因为是类层级了嘛。也就是，对象序列化保存的是对象的”状态"，即它的成员变量。由此可知，对象序列化不会关注类中的静态变量。

例子：和上面的一样，只需要看蓝色字的。

package serizable;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class Person_Serializable implements Serializable{

	/**
	 * 序列化版本号
	 */
	private static final long serialVersionUID = 1L;
	private String name;
	//transient关键字表示在序列化是，这个变量不用加入，所有反序列化的时候，不能够获取到这个值
	private transient int age;
	private static String country="中国";
	public Person_Serializable(String name,int age) {
		this.name=name;
		this.age=age;
	}
	public String getName(){
		return this.name;
	}
	public int getAge(){
		return this.age;
	}
	/**
	 * 序列化当前对象到本地
	 */
	public void SerializableImpl() throws IOException{
		FileOutputStream fileOutputStream=new FileOutputStream("person.out");
		ObjectOutputStream objectOutputStream=new ObjectOutputStream(fileOutputStream);
		objectOutputStream.writeObject(this);
		objectOutputStream.flush();
		objectOutputStream.close();
		fileOutputStream.close();
	}
	/**
	 * 静态方法，将序列换的本地对象反序列化会内存中的对象
	 */
	public static  Person_Serializable ReverseSerializableImpl(String filepath) throws IOException, ClassNotFoundException{
		FileInputStream fileInputStream=new FileInputStream(filepath);
		ObjectInputStream objectInputStream=new ObjectInputStream(fileInputStream);
		Person_Serializable person_Serializable=(Person_Serializable)objectInputStream.readObject();
		objectInputStream.close();
		fileInputStream.close();
		return person_Serializable;
	}
	@Override
	public String toString() {
		return name+" age is "+age+" country is "+country;
	}
	public static void main(String arg[]) throws IOException, ClassNotFoundException{
		Person_Serializable person=new Person_Serializable("小王", 23);
		System.out.println(person.toString());
		person.SerializableImpl();
		country="美国";
		System.out.println(Person_Serializable.ReverseSerializableImpl("person.out").toString());
	}
}

输出：

小王 age is 23 country is 中国

小王 age is 0 country is 美国

5.ObjectOutputStream总writeObject()方法的实现的一部分。

。。。。。。。

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());

}

。。。。。。。。。。

从上述代码可知，如果被写对象的类型是String，或数组，或Enum，或Serializable，那么就可以对该对象进行序列化，否则将抛出NotSerializableException。

1.当一个父类实现了序列化，子类也就默认实现了序列化，因此可以不用显示的指定

2.当一个实例变量被序列化时，它所引用的其他对象也会被序列化

3.static transient关键字修饰的变量不能序列化。

serialVersionUID有什么作用？该如何使用？

serialVersionUID 是 Java 为每个序列化类产生的版本标识，可用来保证在反序列时，发送方发送的和接受方接收的是可兼容的对象。如果接收方接收的类的 serialVersionUID 与发送方发送的 serialVersionUID 不一致，进行反序列时会抛出 InvalidClassException。序列化的类可显式声明 serialVersionUID 的值，如下:

ANY-ACCESS-MODIFIER static final long serialVersionUID = 1L;

当显式定义 serialVersionUID 的值时，Java 根据类的多个方面(具体可参考 Java 序列化规范)动态生成一个默认的 serialVersionUID 。尽管这样，还是建议你在每一个序列化的类中显式指定 serialVersionUID 的值，因为不同的 jdk 编译很可能会生成不同的 serialVersionUID 默认值，进而导致在反序列化时抛出 InvalidClassExceptions 异常。所以，为了保证在不同的 jdk 编译实现中，其 serialVersionUID 的值也一致，可序列化的类必须显式指定 serialVersionUID 的值。另外，serialVersionUID 的修饰符最好是 private，因为 serialVersionUID 不能被继承，所以建议使用 private 修饰 serialVersionUID。

serialVersionUID就是控制版本是否兼容的，若我们认为修改的人是向后兼容的，则不修改serialVersionUID;反之，则提高serialVersionUID的值再回到一开始的问题，为什么ide会提示声明serialVersionUID的值呢？

因为若不显示式定义serialVersionUID的值，Java会根据类细节自动生成serialVersionUID的值，如对对类的源代码作了修改，再重新编译，新生成的类文件的serialVersionUID的取值有可能也会发生变化。类的serialVersionUID的默认值完全依赖于Java编译器的实现，对于同一个类，用不同的Java编译器编译，也有可能会导致不同的serialVersionUID。所以ide才会提示声明serialVersionUID的值。

举例说明如下: 现在尝试通过将一个类 Person 序列化到磁盘和反序列化来说明 serialVersionUID 的作用: Person 类如下:

public class Person implements Serializable {

    private static final long serialVersionUID = 1L;

    private String name;
    private Integer age;
    private String address;

    public Person() {
    }

    public Person(String name, Integer age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }


    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                '}';
    }
}

简单的测试一下：

@Test
public void testversion1L() throws Exception {
    File file = new File("person.out");
    // 序列化
    ObjectOutputStream oout = new ObjectOutputStream(new FileOutputStream(file));
    Person person = new Person("John", 21, "广州");
    oout.writeObject(person);
    oout.close();
    // 反序列化
    ObjectInputStream oin = new ObjectInputStream(new FileInputStream(file));
    Object newPerson = oin.readObject(); 
    oin.close();
    System.out.println(newPerson);
}

测试发现没有什么问题。有一天，因发展需要，需要在 Person 中增加了一个字段 email，如下:

public class Person implements Serializable {

    private static final long serialVersionUID = 1L;

    private String name;
    private Integer age;
    private String address;
    private String email;

    public Person() {
    }

     public Person(String name, Integer age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public Person(String name, Integer age, String address,String email) {
        this.name = name;
        this.age = age;
        this.address = address;
        this.email = email;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                ", email='" + email + '\'' +
                '}';
    }
}

这时我们假设和之前序列化到磁盘的 Person 类是兼容的，便不修改版本标识 serialVersionUID。再次测试如下

@Test
public void testversion1LWithExtraEmail() throws Exception {
    File file = new File("person.out");
    ObjectInputStream oin = new ObjectInputStream(new FileInputStream(file));
    Object newPerson = oin.readObject(); 
    oin.close();
    System.out.println(newPerson);
}

将以前序列化到磁盘的旧 Person 反序列化到新 Person 类时，没有任何问题。

可当我们增加 email 字段后，不作向后兼容。即放弃原来序列化到磁盘的 Person 类，这时我们可以将版本标识提高，如下:

private static final long serialVersionUID = 2L;

再次进行反序列化，则会报错，如下:

java.io.InvalidClassException:Person local class incompatible: stream classdesc serialVersionUID = 1, local class serialVersionUID = 2

谈到这里，我们大概可以清楚

于王令

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
java Serializable详解

1、什么是序列化和反序列化Serialization（序列化）是一种将对象以一连串的字节描述的过程；反序列化deserialization是一种将这些字节重建成一个对象的过程。2、什么情况下需要序列化 a）当你想把的内存中的对象保存到一个文件中或者数据库中时候；b）当你想用套接字在网络上传送对象的时候；c）当你想通过RMI传输对象的时候；将需要序列化的类实现
复制链接

扫一扫