社区 学习 工具库 休闲
搜索
简体中文
首页 > Java > java教程 > 正文

13.Java 基础 - 序列化

黄舟
发布： 2017-02-27 10:53:47
原创
1111 人浏览过


基本概念


在介绍序列化之前，首先要知道以下几个概念：

  • 非持久化：对于存在 JVM（Java 虚拟机）的对象，其内部的状态只能保持在内存中，一旦 JVM 停止工作，内部的状态也就消失了，所以它是非持久化的。

  • 持久化：如果想要永久的保存对象（即持久化），通常的作法是将其保存到文件或数据库。

  • 序列化：在 Java 中想要实现对象的持久化，就需要将其序列化，通过序列化，可以很容易的将 JVM 中的活动对象转换成字节数组（流）进行存储。

  • 反序列化：将文件或数据库中的字节数组（流）转换成 JVM的活动对象。

在 Java 中，类可以通过实现 Serializable、Externalizable 接口来序列化。

Serializable

类一旦实现了 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 类型，则该类无法被序列化，它的影响是整体的。

下面来看这几种情况：

1.transient

但凡变量被其修饰时，表示该参数是瞬态的，不想被序列化（不是无法序列化）。

// 序列化过程、调用过程与上述例子一致，省略代码...
// 这里只对内部类 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，这也正说明了该参数没有被序列化。

2.static

但凡被其修饰的变量代表全局变量，访问全局变量时可以不依靠类对象。而序列化的操作是为了保存对象。正是由于这一特性与序列化的矛盾，导致全局变量默认不被序列化（不是无法序列化）。

// 序列化过程、调用过程与上述例子一致，省略代码...
// 这里只对内部类 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。

3.Thread

如果对象的成员变量含有 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

类通过实现 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

1.概念

serialVersionUID，即序列化版本号。

它的作用是：在序列化时保持版本的兼容性，即在版本升级时反序列化仍保持对象的唯一性。

对于生成 serialVersionUID，共有两种方式：

  • 一种是固定值：1L

  • 一种是经过 JVM 计算，不同的 JVM 采取的计算算法可能不同。

对于采用 JVM 生成的方式，它具有以下特点：

  • 若对象的代码保持不变时，多次生成的serialVersionUID也是不变的。

  • 当对方法进行修改时，serialVersionUID**不变**。

  • 当对对象的属性进行修改时，重新生成的serialVersionUID**会发生变化**。

因此说明序列化是作用于对象属性上的。

2.实例

下面通过实例来探究下 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）！


相关标签：
Java ，序列化
来源：php.cn
上一篇：12.Java 基础 - 通配符 下一篇：14.Java 基础 - 参数传递
本站声明
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系admin@php.cn
作者最新文章
最新问题
动态修改Javafx中的内联CSS样式 我试图在应用程序最大化时更改窗格的背景图像。我的背景是使用内嵌css设置的。我为样式设置了两个不同的变量和一个if语句。但是，我没有运气让它改变样式。StringcssStyle=...
来自于 2024-04-06 20:57:16
0
1
487
如何使用其 SKU'连接”多个产品？ 我想根据WooCommerce的SKU合并两个或多个产品的库存。示例：（共享相同库存的两种产品）透明手机壳iPhone11-SKU12345个性化iPhone11手机壳-SKU56...
来自于 2024-04-05 08:53:52
0
1
3478
如果一列为空，如何对 SQL 结果进行排序？ 我对查询结果的排序有疑问。我有3列需要排序：ORDERBYlevelDESC,logoDESC,bNameASC我想先通过DESC订购最高“级别”，这很有效。之后，我想订购“徽标”...
来自于 2024-04-05 00:39:32
0
1
317
选择 SUM 时控制相邻列的顺序 当您通过SUM选择时，返回的数据会分组到单个记录中，这很好。下面的查询正确返回总和，但相邻列的值似乎始终来自最早的记录。有什么办法可以控制相邻列的顺序吗？例如，返回总和并返回最新行...
来自于 2024-04-04 23:26:33
0
1
402
CommandText属性初始化问题 我正在尝试使用C#控制台应用程序同时将数据实现到2个（后来是3个）表中。我想在表“用户”中实现名字、姓氏和用户ID，用户ID将自动递增。同样的userID也应该与porilfeID...
来自于 2024-04-04 22:43:24
0
1
385
相关专题
更多>
热门推荐
热门教程
更多>
相关教程
热门推荐
最新课程
最新下载
更多>
网站特效
网站源码
网站素材
前端模板