Java的序列化和反序列化

最新推荐文章于 2021-06-23 19:53:24 发布

咖啡不加冰和糖

最新推荐文章于 2021-06-23 19:53:24 发布

阅读量157

点赞数

分类专栏： java基础文章标签： java

转载请注明出处

本文链接：https://blog.csdn.net/weixin_42096624/article/details/104902442

版权

java基础专栏收录该内容

33 篇文章 0 订阅

订阅专栏

本节，我们来分析对象的序列化和反序列化。从以下几个方面来进行分析：

为什么要进行序列化？
什么是序列化与反序列化？
如何实现序列化和反序列化？
序列化和反序列化要注意什么问题？如何进行解决？
为什么实现了Serializable接口就可以序列化？

为什么要进行序列化？

将Java对象状态信息存储在硬盘或数据库中；
通过网络传输Java对象，所以序列化Java类。
通过RMI传输对象的时候；

什么是序列化和反序列化？

序列化：将 Java对象状态信息 转化为 二进制字节流 的过程。
反序列化：将 二进制字节流 转化为 Java对象 的过程。

如何实现序列化和反序列化？

Java中，只要一个类实现了Serializable接口，或者该类中所有成员变量都是可序列化的，那么这个类是可序列化的。
代码：
user.java

package els;

import java.io.Serializable;

public class User implements Serializable{
	private String name;
	private int age;
	public static String sex = "男";//static修饰的变量不会被序列化
	public int aaa;
	private transient String birthday;//transient修饰的变量不会被序列化
	public User(){};
	public User(String name, int age,String birthday) {
		this.name = name;
		this.age = age;
		this.birthday = birthday;
	}
	
	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 String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	
	public String getBirthday() {
		return this.birthday;
	}
	public void setBirthday(String birthday) {
		this.birthday = birthday;
	}
	@Override
	public String toString() {
		return "user [name=" + name + ", age=" + age + ", sex=" + sex +" , birthday=" + birthday + "]";
	}	
}

SerializationTest.java

public class SerializationTest {
package els;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SerializationTest {
	
	private ObjectInputStream in = null;
	private ObjectOutputStream out = null;
	
	public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
		SerializationTest s = new SerializationTest();
		s.serializeUser();//序列化      1
		s.deSerializeUser();//反序列化   2
	} 
	
	//序列化对象
	public void serializeUser() throws FileNotFoundException, IOException{
		User user = new User("张三",18,"男");
		out = new ObjectOutputStream(new FileOutputStream(new File("C:/Users/狗尾巴草/Desktop/User123.txt")));
		out.writeObject(user);
		System.out.println("User对象序列化成功！");
		out.close();
	}
	//反序列化对象
	public void deSerializeUser() throws FileNotFoundException, IOException, ClassNotFoundException{
		User.sex = "女";
		in = new ObjectInputStream(new FileInputStream(new File("C:/Users/狗尾巴草/Desktop/User123.txt")));
		User user = (User) in.readObject();
		System.out.println("User对象反序列化成功！");
		System.out.println(user);
		out.close();
	}
}

运行程序，结果如下：
在这里插入图片描述
由此来看如果要对对象进行存储或者传输，就要对对象进行序列化。

序列化和反序列化要注意什么问题？如何进行解决？

序列化一个不能序列化的对象，会引发java.io.NotSerializableExceptionjava.io.NotSerializableException异常；
static 成员变量不能被序列化(程序中反序列化后sex为女)；
可以使用Transient 修饰不需要序列化的** 成员变量**（只能修饰成员变量）；
关于SerialVersionUID：

为什么提出SerialVersionUID？
有这样一种情况：将2处注释，运行完毕，再将1处注释，然后给User类添加一个成员变量，
运行后发现返序列化产生异常：java.io.InvalidClassException:XXXX: stream
classdesc serialVersionUID = 5938141070329258997, local class serialVersionUID
= 1357382093675737652。
由此可知，SerialVersionUID是为了解决序列化后被序列化的类被修改的问题。

序列化时Java序列化机制根据类，接口和变量为类生成一个序列化版本号serialVersionUID，并将该serialVersionUID存储在字节流中，当进行反序列化的时候，JVM会将该序列号和实体类中（有可能已经被修改）的serialVersionUID进行比较，如果不等（类被修改），则抛异常。

所以我们一般显示的设置一个版本号，这样即使修改了实体类，反序列化也不会有异常。
如HashMap源码中的private static final long serialVersionUID = 362498820763181265L;

2.关于设置serialVersionUID：
一是默认的1L，比如：private static final long serialVersionUID = 1L;
二是利用Java中serialver工具找到该对象的serialVersionUID；

为什么实现了Serializable接口就可以序列化？

Serializable接口中什么都没有，那么为什么实现了该接口的对象就可以序列化呢？
我们从源码入手，根据上面的例子，执行下面一句代码：

out = new ObjectOutputStream(new FileOutputStream(new File("C:/Users/狗尾巴草/Desktop/User123.txt")));

在eclipse中用Ctrl+鼠标左键点击ObjectOutputStream，跳转到ObjectOutputStream的writeObject()：

 public final void writeObject(Object obj) throws IOException {
        if (enableOverride) {
            writeObjectOverride(obj);
            return;
        }
        try {
            writeObject0(obj, false);
        } catch (IOException ex) {
            if (depth == 0) {
                writeFatalException(ex);
            }
            throw ex;
        }
    }

enableOverride是该类的boolean类型的成员变量，未赋值时为false；则其实是调用writeObject0(obj, false); 该方法中有这么一段代码：

private void writeObject0(Object obj, boolean unshared)
        throws IOException
    {
            ....
            // 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());
                }
            }
    }
    ....