Java学习笔记（十七）——java序列化

【前面的话】

做项目总是要用到很多东西，遇到一个新的知识，并不是这个知识出来的时间短，而是对于自己来说是新的，所以就需要自己去学习，希望今后可以提高学习的效率。

这篇文章是关于Java 序列化的，选择性阅读。

【知识点】

一、什么叫序列化？

我们都知道对象是暂时保存在内存中的，不能用U盘考走了，有时为了使用介质转移对象，并且把对象的状态保持下来，就需要把对象保存下来，这个过程就叫做序列化，通俗点，就是把人的魂（对象）收伏成一个石子（可传输的介质）。

二、什么叫反序列化？

就是再把介质中的东西还原成对象，把石子还原成人的过程。

三、可能的使用情况

1. 当你想把的内存中的对象写入到硬盘的时候；

比如说你的内存不够用了，那计算机就要将内存里面的一部分对象暂时的保存到硬盘中，等到要用的时候再读入到内存中，硬盘的那部分存储空间就是所谓的虚拟内存。在比如过你要将某个特定的对象保存到文件中，我隔几天在把它拿出来用，那么这时候就要实现Serializable接口；

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

在进行java的Socket编程的时候，你有时候可能要传输某一类的对象，那么也就要实现Serializable接口；最常见的你传输一个字符串，它是JDK里面的类，也实现了Serializable接口，所以可以在网络上传输。

3. 当你想通过RMI传输对象的时候；

如果要通过远程的方法调用（RMI）去调用一个远程对象的方法，如在计算机A中调用另一台计算机B的对象的方法，那么你需要通过JNDI服务获取计算机B目标对象的引用，将对象从B传送到A，就需要实现序列化接口。

四、Serializable接口

1. Serializable接口：一个对象序列化的接口，一个类只有实现了Serializable接口，它的对象才是可序列化的。因此如果要序列化某些类的对象，这些类就必须实现Serializable接口。
2. Serializable实现代码：

 public interface Serializable {
 }

可以看出Serializable接口是一个空的接口，目的只有一个就是表示一个类的对象可以被序列化。这个标签是类可以被序列化的特性，表示这个类可以被序列化。

五、Externalizable接口

1. Externalizable接口：他是Serializable接口的子类
2. Externalizable实现代码：

 public interface Externalizable extends java.io.Serializable {
     void writeExternal(ObjectOutput out) throws IOException;
     void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
 }

六、Serializable接口和Externalizable接口区别

1. Serializable：一个对象想要被序列化，那么它的类就要实现此接口，这个对象的所有属性（包括private属性、包括其引用的对象）都可以被序列化和反序列化来保存、传递。
2. Externalizable：他是Serializable接口的子类，有时我们不希望序列化那么多，可以使用这个接口，这个接口的writeExternal()和readExternal()方法可以指定序列化哪些属性;

【学习demo And 解释】

一、Java实现序列化

      1. java.io.ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。

      2. java.io.ObjectInputStream代表对象输入流，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。

3. 对象序列化包括如下步骤：

1)创建一个对象输出流，它可以包装一个其他类型的目标输出流，如文件输出流；

2)通过对象输出流的writeObject()方法写对象。

4. 对象反序列化的步骤如下：

1)创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流；

2)通过对象输入流的readObject()方法读取对象。

5. 代码实现：

SerializableTest.java

 import java.io.*;
 import java.util.Date;

 public class SerializableTest {

     public static void main(String[] args) throws Exception {
         ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("objectFile.obj"));
         //序列化对象
         Customer customer = new Customer("阿蜜果", 24);
         out.writeObject("你好!");
         out.writeObject(new Date());
         out.writeObject(customer);//写入实现了序列化的对象
         out.writeInt(123); //写入基本类型数据
         out.close();
         //反序列化对象
         ObjectInputStream in = new ObjectInputStream(new FileInputStream("objectFile.obj"));
         System.out.println("obj1=" + (String) in.readObject());
         System.out.println("obj2=" + (Date) in.readObject());
         Customer obj3 = (Customer) in.readObject();
         System.out.println("obj3=" + obj3);
         int obj4 = in.readInt();
         System.out.println("obj4=" + obj4);
         in.close();
         }
     }
 class Customer implements Serializable {
     private String name;
     private int age;
     public Customer(String name, int age) {
         this.name = name;
         this.age = age;
         }
     public String toString() {
         return "name=" + name + ", age=" + age;
         }
     }

6. 运行结果：

 obj1=你好!
 obj2=Thu Apr 03 09:12:09 CST 2014
 obj3=name=阿蜜果, age=24
 obj4=123

二、Java实现序列化的时候使用关键字

      1. transient是Java语言的关键字，用来表示一个域不是该对象序列化的一部分。当一个对象被序列化的时候，transient型变量的值不包括在序列化的表示中，然而非transient型的变量是被包括进去的。

2. demo代码

其中Password定义为transient型，在输出的时候，就会不被序列化。输出null。

SerializableTest.java

 import java.io.*; 

 public class SerializableTest {
     public static void main(String args[]) {
         testObjectSeri();
         testObjectInSeri();
     }
     /**
      * 对象序列化测试
      */
     public static void testObjectSeri() {
         Person person = new Person("熔岩", "341022225562156", "lavasoft");
         FileOutputStream fos = null;
         ObjectOutputStream oos = null;
         try {
             fos = new FileOutputStream("person.dat");
             oos = new ObjectOutputStream(fos);
             oos.writeObject(person);
         } catch (FileNotFoundException e) {
             System.out.println("找不到指定的文件！");
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         } finally {
             try {
                 oos.flush();
                 oos.close();
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
     }
     /**
      * 对象反序列化测试
      */
     public static void testObjectInSeri() {
         FileInputStream fis = null;
         ObjectInputStream ois = null;
         Person person = null;
         try {
             fis = new FileInputStream("person.dat");
             ois = new ObjectInputStream(fis);
             person = (Person) ois.readObject();
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         } catch (ClassNotFoundException e) {
             e.printStackTrace();
         } finally {
             try {
                 ois.close();
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
         System.out.println(person.toString());
     }
 }
 /**
 * 测试序列化所用的类
 */
 class Person implements Serializable {
     private String username;
     private String cardNumber;
     private transient String password;
     public Person(String username, String cardNumber, String password) {
         this.username = username;
         this.cardNumber = cardNumber;
         this.password = password;
     }
     public String getUsername() {
         return username;
     }
     public void setUsername(String username) {
         this.username = username;
     }
     public String getCardNumber() {
         return cardNumber;
     }
     public void setCardNumber(String cardNumber) {
         this.cardNumber = cardNumber;
     }
     public String getPassword() {
         return password;
     }
     public void setPassword(String password) {
         this.password = password;
     }
     public String toString() {
         StringBuffer sb = new StringBuffer(this.getClass().getName());
         sb.append("[");
         sb.append("\n\t");
         sb.append("username=" + this.username);
         sb.append("\n\t");
         sb.append("cardNumber=" + this.cardNumber);
         sb.append("\n\t");
         sb.append("password=" + this.password);
         sb.append("]");
         return sb.toString();
     }
 }

4. 运行结果：

 Person[
     username=熔岩
     cardNumber=341022225562156
     password=null]

【几个问题】

一、序列化版本serialVersionUID

1. serialVersionUID作用：

序列化时为了保持版本的兼容性，即在版本升级时反序列化仍保持对象的唯一性。

类的serialVersionUID的默认值完全依赖于Java编译器的实现，对于同一个类，用不同的Java编译器编译，有可能会导致不同的serialVersionUID，也有可能相同。为了提高serialVersionUID的独立性和确定性，强烈建议在一个可序列化类中显示的定义serialVersionUID，为它赋予明确的值。显式地定义serialVersionUID有两种用途：

1)在某些场合，希望类的不同版本对序列化兼容，因此需要确保类的不同版本具有相同的serialVersionUID；

2)在某些场合，不希望类的不同版本对序列化兼容，因此需要确保类的不同版本具有不同的serialVersionUID。

2. 有两种生成方式：

一个是默认的1L，比如：private static final long serialVersionUID = 1L;

一个是根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段，比如：

private static final long serialVersionUID = xxxxL;

当你一个类实现了Serializable接口，如果没有定义serialVersionUID，Eclipse会提供这个 ，提示功能告诉你去定义 。在Eclipse中点击类中warning的图标一下，Eclipse就会自动给定两种生成的方式。如果不想定义它，在Eclipse的设置中也 可以把它关掉的，设置如下：

Window ==> Preferences ==> Java ==> Compiler ==> Error/Warnings ==> Potential programming problems

将Serializable class without serialVersionUID的warning改成ignore即可。

二、其他说明：

1. 基本类型的数据可以直接序列化
2. 对象要被序列化，它的类必须要实现Serializable接口;如果一个类中有引用类型的实例变量，这个引用类型也要实现Serializable接口。

      如果不想让引用类实现Serializable接口，并且让本类成功序列化也可以，使用transient关键字。

【参考资料】

1. Serializable 作用
2. Java对象的序列化和反序列化实践
3. java.io 序列化 总结(一)---Serializable 和 Externalizable 的区别与联系

【后面的话】

随波逐流虽易，努力生活不易，且行且珍惜。

——TT