在介绍序列化之前,首先要知道以下几个概念:
非持久化:对于存在 JVM(Java 虚拟机)的对象,其内部的状态只能保持在内存中,一旦 JVM 停止工作,内部的状态也就消失了,所以它是非持久化的。
持久化:如果想要永久的保存对象(即持久化),通常的作法是将其保存到文件或数据库。
序列化:在 Java 中想要实现对象的持久化,就需要将其序列化,通过序列化,可以很容易的将 JVM 中的活动对象转换成字节数组(流)进行存储。
反序列化:将文件或数据库中的字节数组(流)转换成 JVM的活动对象。
在 Java 中,类可以通过实现 Serializable、Externalizable 接口来序列化。
类一旦实现了 Serializable 接口,表示它可以被序列化。
具体的序列化/反序列化操作则需要通过对象流(ObjectOutputStream /ObjectInputStream )实现。
下面来看具体的例子:
class Person implements Serializable { private String name; private int age; public Person(String name ,int age){ this.name = name; this.age =age; } public String getName() { return name; } public int getAge() { return age; } @Override public String toString() { return "name is " + name + " , age is " + age; } }public class Test { private final static String TEMPFILE = "E:" + File.separator + "test.txt"; public static void main(String[] args) { Person person = new Person("test",100); write(person); // 关键 -> 序列化之后重新对对象进行赋值 person = new Person("hello",999); read(person); // 输出结果: // name is test , age is 100,序列化成功 // 反序列化成功,name is test , age is 100 } // 通过 ObjectOutputStream 进行对象的序列化操作 private static void write(Person person) { try { ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(TEMPFILE)); oos.writeObject(person); oos.close(); System.out.println(person+",序列化成功"); } catch (Exception e) { e.printStackTrace(); } } // 通过 ObjectInputStream 进行对象的反序列化操作 private static void read(Person person) { try { ObjectInputStream ois = new ObjectInputStream(new FileInputStream(TEMPFILE)); person = (Person) ois.readObject(); ois.close(); System.out.println("反序列化成功.,"+person); } catch (Exception e) { e.printStackTrace(); } } }
观察输出结果,我们在对象序列化之后重新对其赋值,而通过反序列化的结果依然与对象序列化之前的值一致,这也间接证明对象被永久的存储下来,实现了持久化。
序列化失败,有两种情况:不想被序列化、无法被序列化。
在类中,被关键字 transient、static 修饰的成员变量,表示自己不想被序列化。它会导致局部序列化失败。
在类中,存在成员变量是 Thead 类型,则该类无法被序列化,它的影响是整体的。
下面来看这几种情况:
但凡变量被其修饰时,表示该参数是瞬态的,不想被序列化(不是无法序列化)。
// 序列化过程、调用过程与上述例子一致,省略代码... // 这里只对内部类 Person 的 age 属性进行修改class Person implements Serializable { // 用 transient 修该变量 private transient int age; // 省略部分代码...} // 调用后的输出结果: // name is test , age is 100,序列化成功 // 反序列化成功.,name is test , age is 0
观察输出结果,发现序列化之前 age 的是 100,而通过反序列化读取的 age 为 0。
int 类型的参数初始值为 0,这也正说明了该参数没有被序列化。
但凡被其修饰的变量代表全局变量,访问全局变量时可以不依靠类对象。而序列化的操作是为了保存对象。正是由于这一特性与序列化的矛盾,导致全局变量默认不被序列化(不是无法序列化)。
// 序列化过程、调用过程与上述例子一致,省略代码... // 这里只对内部类 Person 的 name 属性进行修改class Person implements Serializable { // 用 static 修该变量 private static String name; // 省略部分代码...} // 输出结果: // name is test , age is 100,序列化成功//反序列化成功.,name is hello , age is 100
观察输出结果,发现 name 的值为 hello,不是序列化之前的 test。
前后值不一样说明其没有被序列化。又因为 static 的特性是与类有关,该变量序列化操作之后被重新赋值了,导致其值不是 null,而是 hello。
如果对象的成员变量含有 Thread 类型,是无法被序列化的。
// 序列化过程、调用过程与上述例子一致,省略代码... // 这里只对内部类 Person 的 name 属性进行修改class Person implements Serializable { //新增成员变量 private Thread myThread = new Thread(); //省略部分代码...} // 输出结果(抛出异常): // Caused by: java.io.NotSerializableException: java.lang.Thread
上面介绍了序列化失败的情况,那如果某些情况非要实现序列化呢(比如一定要实现全局变量的序列化)。那么需要在类中自定义序列化/反序列化过程,来看下面这个例子:
// 序列化操作代码与上面一致... // 这里只对内部类 Person 的属性进行修改。class Person implements Serializable { private static String name; private transient int age; // 自定义序列化操作 private void writeObject(ObjectOutputStream out) throws IOException{ out.defaultWriteObject(); out.writeObject(name); out.writeInt(age); } // 自定义反序列化操作 private void readObject(ObjectInputStream in) throws IOException,ClassNotFoundException{ in.defaultReadObject(); name = (String) in.readObject(); age = in.readInt(); } // 省略部分代码...} // 输出结果: // name is test , age is 100,序列化成功 // 反序列化成功,name is test , age is 100
类通过实现 Externalizable接口,也表示它可以被序列化,但它有两个限制:
接口强制实现了writeExternal 和 readExternal 方法用于自定义序列化与反序列化过程。
要求该类中必须含有无参构造函数。
同时由于它的序列化过程是定义在公共方法中的,所以不安全。
来看下面的例子:
// 序列化操作代码与上面一致,这里只对内部类 Person 的进行修改。 class Person implements Externalizable { private static String name; private transient int age; // 重点 ->必须有无参构造函数 public Person(){ } public Person(String name ,int age){ this.name = name; this.age =age; } public String getName() { return name; } public int getAge() { return age; } @Override public String toString() { return "name is " + name + " , age is " + age; } // 实现接口的方法 @Override public void writeExternal(ObjectOutput out) throws IOException { out.writeObject(name); out.writeInt(age); } // 实现接口的方法 @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { name = (String) in.readObject(); age = in.readInt(); } } // 输出结果: // name is test , age is 100,序列化成功 // 反序列化成功,name is test , age is 100
serialVersionUID,即序列化版本号。
它的作用是:在序列化时保持版本的兼容性,即在版本升级时反序列化仍保持对象的唯一性。
对于生成 serialVersionUID,共有两种方式:
一种是固定值:1L
一种是经过 JVM 计算,不同的 JVM 采取的计算算法可能不同。
对于采用 JVM 生成的方式,它具有以下特点:
若对象的代码保持不变时,多次生成的serialVersionUID也是不变的。
当对方法进行修改时,serialVersionUID**不变**。
当对对象的属性进行修改时,重新生成的serialVersionUID**会发生变化**。
因此说明序列化是作用于对象属性上的。
下面通过实例来探究下 serialVersionUID 的具体作用:
首先我们对对象进行序列化操作(这里取消了反序列化的操作)
// 序列化操作代码与上面例子一致...// 这里取消了反序列化的操作public static void main(String[] args) { Person person = new Person("test",100); write(person); person = new Person("java", 200); //read(person);}
然后新增一个对象的属性,再进行反序列化操作
// 省略部分代码,与上面的代码一致...class Person implements Serializable { private String name; private age; //新增成员变量 private int phone; //省略部分代码... } }public static void main(String[] args) { Person person = new Person("test",100); //write(person); person = new Person("java", 200); read(person); }// 输出结果(抛出异常):// java.io.InvalidClassException: Person;
观察代码,在序列化对象并没有添加 serialVersionUID 的情况,在对象序列化之后如果改变了对象的属性,反序列化就会抛出异常。如果对象添加了 serialVersionUID 就不会出现这种情况,这里就不验证了。
以上就是13.Java 基础 - 序列化的内容,更多相关内容请关注PHP中文网(www.php.cn)!