java基础---->Serializable的使用

Serializable序列化的简要说明

一、 持久化的简单介绍：

　　“持久化”意味着对象的“生存时间”并不取决于程序是否正在执行——它存在或“生存”于程序的每一次调用之间。通过序列化一个对象，将其写入磁盘，以后在程序再次调用时重新恢复那个对象，就能圆满实现一种“持久”效果。

 

二、 语言里增加了对象序列化的概念后，可提供对两种主要特性的支持：

• 远程方法调用（RMI）使本来存在于其他机器的对象可以表现出好象就在本地机器上的行为。将消息发给远程对象时，需要通过对象序列化来传输参数和返回值。
• 使用一个Java Bean 时，它的状态信息通常在设计期间配置好。程序启动以后，这种状态信息必须保存下来，以便程序启动以后恢复；具体工作由对象序列化完成。

 

三、 Serializable的一些说明：

• 对象的序列化处理非常简单，只需对象实现了Serializable 接口即可（该接口仅是一个标记，没有方法）
• 序列化的对象包括基本数据类型，所有集合类以及其他许多东西，还有Class 对象
• 对象序列化不仅保存了对象的“全景图”，而且能追踪对象内包含的所有句柄并保存那些对象；接着又能对每个对象内包含的句柄进行追踪
• 使用transient关键字修饰的的变量，在序列化对象的过程中，该属性不会被序列化。

 

四、 序列化的步骤：

• 首先要创建某些OutputStream对象：OutputStream outputStream = new FileOutputStream("output.txt")
• 将其封装到ObjectOutputStream对象内：ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
• 此后只需调用writeObject()即可完成对象的序列化，并将其发送给OutputStream：objectOutputStream.writeObject(Object);
• 最后不要忘记关闭资源：objectOutputStream.close(), outputStream .close();

 

五、 反序列化的步骤：

• 首先要创建某些OutputStream对象：InputStream inputStream= new FileInputStream("output.txt")
• 将其封装到ObjectInputStream对象内：ObjectInputStream objectInputStream= new ObjectInputStream(inputStream);
• 此后只需调用writeObject()即可完成对象的反序列化：objectInputStream.readObject();
• 最后不要忘记关闭资源：objectInputStream.close()，inputStream.close();

Serializable序列化的代码实例

项目结构如下，源代码下载见huhx友情链接：

一、 首先我们建立一个Man类，实现了Serializable接口，用于Person类的测试：

 

 1 package com.huhx.model;
 2 import java.io.Serializable;
 3 
 4 public class Man implements Serializable {
 5     private static final long serialVersionUID = 1L;
 6 
 7     private String username;
 8     private String password;
 9 
10     public Man(String username, String password) {
11         this.username = username;
12         this.password = password;
13     }
14 
15     public String getUsername() {
16         return username;
17     }
18 
19     public void setUsername(String username) {
20         this.username = username;
21     }
22 
23     public String getPassword() {
24         return password;
25     }
26 
27     public void setPassword(String password) {
28         this.password = password;
29     }
30 }

 

二、 我们再建立一个Person类，用于序列化：

 1 package com.huhx.model;
 2 import java.io.Serializable;
 3 
 4 public class Person implements Serializable {
 5     private static final long serialVersionUID = 1L;
 6     
 7     private Man man;
 8     private String username;
 9     private transient int age;
10     
11     public Person() {
12         System.out.println("person constru");
13     }
14     
15     public Person(Man man, String username, int age) {
16         this.man = man;
17         this.username = username;
18         this.age = age;
19     }
20 
21     public Man getMan() {
22         return man;
23     }
24     public void setMan(Man man) {
25         this.man = man;
26     }
27     public String getUsername() {
28         return username;
29     }
30     public void setUsername(String username) {
31         this.username = username;
32     }
33     public int getAge() {
34         return age;
35     }
36     public void setAge(int age) {
37         this.age = age;
38     }
39 }

三、 编写一个包含main方法的测试类：MainTest，它的writeSerializableObject用于序列化对象：

 1 // Serializable：把对象序列化
 2 public static void writeSerializableObject() {
 3     try {
 4         Man man = new Man("huhx", "123456");
 5         Person person = new Person(man, "刘力", 21);
 6         ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("output.txt"));
 7         objectOutputStream.writeObject("string");
 8         objectOutputStream.writeObject(person);
 9         objectOutputStream.close();
10     } catch (FileNotFoundException e) {
11         e.printStackTrace();
12     } catch (IOException e) {
13         e.printStackTrace();
14     }
15 }

四、  测试类MainTest，它的readSerializableObject用于反序列化对象：

 

 1 // Serializable：反序列化对象
 2 public static void readSerializableObject() {
 3     try {
 4         ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("output.txt"));
 5         String string = (String) objectInputStream.readObject();
 6         Person person = (Person) objectInputStream.readObject();
 7         objectInputStream.close();
 8         System.out.println(string + ", age: " + person.getAge() + ", man username: " + person.getMan().getUsername());
 9     } catch (FileNotFoundException e) {
10         e.printStackTrace();
11     } catch (Exception e) {
12         e.printStackTrace();
13     }
14 }

 

五、 在Main方法添加以上两个方法的运行，结果如下：

　　 

•  在Person类中包含Man的引用，当Person被序列化的时候，从结果可以知道Man也被序列化了
• writeObject方法可以传入String，是因为String首先是一个类，其次它也是实现了Serializable接口的
• Person类中的age字段是transient，从打印结果可以看到，序列化Person person = new Person(man, "刘力", 21)对象时，age没有进行序列化。如果transient修饰的Object类型的，那么打印的结果将会是null

 

Externalizable序列化的代码实例

首先我们看一下Externalizable的定义：继承了Serializable

 

1 public interface Externalizable extends java.io.Serializable

 

一、 同样的我们先创建一个实现了Externalizable的User类：重写里面两个方法readExternal和writeExternal

 1 package com.huhx.model;
 2 
 3 import java.io.Externalizable;
 4 import java.io.IOException;
 5 import java.io.ObjectInput;
 6 import java.io.ObjectOutput;
 7 
 8 public class User implements Externalizable {
 9     private String user;
10 
11     public String getUser() {
12         return user;
13     }
14 
15     public int getAge() {
16         return age;
17     }
18 
19     private int age;
20 
21     public User() {
22         System.out.println("user constructor.");
23     }
24 
25     public User(String user, int age) {
26         System.out.println("user constructor two.");
27         this.user = user;
28         this.age = age;
29     }
30 
31     @Override
32     public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
33         System.out.println("read external.");
34         user = (String) in.readObject();
35         age = in.readInt();
36     }
37 
38     @Override
39     public void writeExternal(ObjectOutput out) throws IOException {
40         System.out.println("write external.");
41         out.writeObject(user);
42         out.writeInt(age);
43     }
44 }

二、  在MainTest中加入方法writeExternalizableObject，用于序列化对象User

 1 // Externalizable的序列化对象
 2 public static void writeExternalizableObject() {
 3     User user = new User("huhx", 22);
 4     try {
 5         ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("Externalizable.txt"));
 6         objectOutputStream.writeObject(user);
 7         objectOutputStream.close();
 8     } catch (FileNotFoundException e) {
 9         e.printStackTrace();
10     } catch (IOException e) {
11         e.printStackTrace();
12     }
13 }

三、 在MainTest中加入方法writeExternalizableObject，用于反序列化对象User

 1 // Externalizable的反序列化对象
 2 public static void readExternalizableObject() {
 3     try {
 4         ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("Externalizable.txt"));
 5         User user = (User) objectInputStream.readObject();
 6         objectInputStream.close();
 7         System.out.println("name: " + user.getUser() + ", age: " + user.getAge());
 8     } catch (FileNotFoundException e) {
 9         e.printStackTrace();
10     } catch (Exception e) {
11         e.printStackTrace();
12     }
13 }

四、 在Main方法添加以上两个方法的运行，结果如下：

　　

• 首先User user = new User("huhx", 22);执行了User的含参构造函数
• 当执行到writeObject(user);方法时，由于User实现了Externalizable接口，所以它的writeExternal会执行，
• 在User中的readExternal方法中调用了ObjectInput的readObject方法，在这个方法中通过反射机制创建User的实例，调用了User的无参构造函数。
• 然后在readObject方法执行的时候，同样会先执行User类的readExternal方法。这个会在后续源代码分析时讲到

 

转载于:https://www.cnblogs.com/cangqinglang/p/9275662.html