Java序列化是指把Java对象转换为字节序列的过程；而Java反序列化是指把字节序列恢复为Java对象的过程。从而达到网络传输、本地存储的效果。
本文主要要看看JDK中使用Serializable和Externalizable接口来完成Java对象序列化，并给出部分属性序列化的几种方式，最终做出Serializable和Externalizable接口的几个方面的对比。
注：本文不讨论为什么不用第三方工具包完成序列化等~
序列化Serializable 要实现Java对象的序列化，只要将类实现Serializable或Externalizable接口即可。
采用类实现Serializable接口的序列化很简单，Java自动会将非transient修饰属性序列化到指定文件中去。
举个例子：
import java.io.Serializable; import java.util.List;
/**
-
@Type Book.java
-
@Desc
-
@author wangmengjun
-
@date 2017年12月1日 下午7:16:29
-
@version */ public class Book implements Serializable {
private static final long serialVersionUID = -6212470156629515269L;
/*书名/ private String name;
/*ISBN/ private String isbn;
/*作者/ private List authors;
/**
- @return the name */ public String getName() { return name; }
/**
- @param name the name to set */ public void setName(String name) { this.name = name; }
/**
- @return the isbn */ public String getIsbn() { return isbn; }
/**
- @param isbn the isbn to set */ public void setIsbn(String isbn) { this.isbn = isbn; }
/**
- @return the authors */ public List getAuthors() { return authors; }
/**
- @param authors the authors to set */ public void setAuthors(List authors) { this.authors = authors; }
/* (non-Javadoc)
- @see java.lang.Object#toString() */ @Override public String toString() { return "Book [name=" + name + ", isbn=" + isbn + ", authors=" + authors + "]"; }
} 然后编写一个用于序列化和反序列的小工具类，
import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream;
/**
-
@Type SerializationUtil.java
-
@Desc
-
@author wangmengjun
-
@date 2017年12月1日 下午7:23:04
-
@version */ public class SerializationUtil {
/**
- 从一个给定的文件完成反序列化 */ public static Object deserialize(String fileName) throws IOException, ClassNotFoundException { FileInputStream fis = new FileInputStream(fileName); BufferedInputStream bis = new BufferedInputStream(fis); ObjectInputStream ois = new ObjectInputStream(bis); Object obj = ois.readObject(); ois.close(); return obj; }
/**
-
将给定的对象序列化到指定的文件中去 */ public static void serialize(Object obj, String fileName) throws IOException {
FileOutputStream fos = new FileOutputStream(fileName); BufferedOutputStream bos = new BufferedOutputStream(fos); ObjectOutputStream oos = new ObjectOutputStream(bos); oos.writeObject(obj); oos.close(); } }
写个测试类，测试一下：
public class SerializableTest {
public static void main(String[] args) throws IOException, ClassNotFoundException {
Book book = new Book();
book.setIsbn("ABC123456789");
book.setName("Hello Java");
book.setAuthors(Arrays.asList("John","Eric"));
//book==>Book [name=Hello Java, isbn=ABC123456789, authors=[John, Eric]]
System.out.println("book==>" + book);
/**
* 将book对象序列化到book.temp文件中去
*/
String fileName = "book.temp";
SerializationUtil.serialize(book, fileName);
/**
* 从book.temp文件中，反序列化一个Book对象
*/
Book deserializedBook = (Book) SerializationUtil.deserialize(fileName);
//deserializedBook==>Book [name=Hello Java, isbn=ABC123456789, authors=[John, Eric]]
System.out.println("deserializedBook==>" + deserializedBook);
}
} 一个简单的示例，就完成了Book对象的序列化和反序列化。
在上述示例中，Book对象中的所有的属性都被序列化。如果里面存在部分属性，我们不想要被序列化，该如何做呢？
部分属性序列化 如果只想将部分属性进行序列化，可以采用如下几种方法：
使用transient关键字 添加writeObject和readObject方法 使用Externalizable实现 使用transient关键字 对属性添加transient关键字，可以防止该属性序列化~
如下示例中，我们不想isbn和authors属性被序列，添加上transient关键字实现一下~
public class Book implements Serializable {
private static final long serialVersionUID = -6212470156629515269L;
/** 书名 */ private String name;
/** ISBN */ private transient String isbn;
/** 作者 */ private transient List authors;
... ...
} 运行上述提到的SerializableTest.java程序，输出如下结果，我们可以看出isbn和authors的值都为null，表明这两个属性没有被序列化~
book==>Book [name=Hello Java, isbn=ABC123456789, authors=[John, Eric]] deserializedBook==>Book [name=Hello Java, isbn=null, authors=null] 添加writeObject和readObject方法 另外，我们也可以采用编写私有方法writeObject和readObject，完成部分属性的序列化。修改Book类，增加writeObject 和 readObject方法，如：
public class Book implements Serializable {
private static final long serialVersionUID = -6212470156629515269L;
/** 书名 */ private String name;
/** ISBN */ private String isbn;
/** 作者 */ private List authors;
private void writeObject(ObjectOutputStream oos) throws IOException { // oos.defaultWriteObject(); oos.writeObject(name); oos.writeObject(isbn); }
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException { // ois.defaultReadObject(); name = (String) ois.readObject(); isbn = (String) ois.readObject(); }
... ...
} 在上述示例中，我们选择序列化的属性为name和isbn，书本作者authors没有序列化~
同样，使用SerializableTest.java类测试一下，结果如下：
book==>Book [name=Hello Java, isbn=ABC123456789, authors=[John, Eric]] deserializedBook==>Book [name=Hello Java, isbn=ABC123456789, authors=null] 注意：
这里的writeObject和readObject是private的且是void的~
Java调用ObjectOutputStream类检查其是否有私有的，无返回值的writeObject方法，如果有，其会委托该方法进行对象序列化。
检查是否有合适的方法如下：
writeObjectMethod = getPrivateMethod(cl, "writeObject", new Class[] { ObjectOutputStream.class }, Void.TYPE); readObjectMethod = getPrivateMethod(cl, "readObject", new Class[] { ObjectInputStream.class }, Void.TYPE); readObjectNoDataMethod = getPrivateMethod( cl, "readObjectNoData", null, Void.TYPE); hasWriteObjectData = (writeObjectMethod != null); 使用Externalizable实现 还有一种方式，就是使用Externalizable完成部分属性的序列化。
Externalizable继承自Serializable，使用Externalizable接口需要实现writeExternal以及readExternal方法在writeExternal方法中，写入想要外部序列化的元素
public interface Externalizable extends java.io.Serializable { /**
-
The object implements the writeExternal method to save its contents
-
by calling the methods of DataOutput for its primitive values or
-
calling the writeObject method of ObjectOutput for objects, strings,
-
and arrays.
-
@serialData Overriding methods should use this tag to describe
-
the data layout of this Externalizable object. -
List the sequence of element types and, if possible, -
relate the element to a public/protected field and/or -
method of this Externalizable class. -
@param out the stream to write the object to
-
@exception IOException Includes any I/O exceptions that may occur */ void writeExternal(ObjectOutput out) throws IOException;
/**
- The object implements the readExternal method to restore its
- contents by calling the methods of DataInput for primitive
- types and readObject for objects, strings and arrays. The
- readExternal method must read the values in the same sequence
- and with the same types as were written by writeExternal.
- @param in the stream to read data from in order to restore the object
- @exception IOException if I/O errors occur
- @exception ClassNotFoundException If the class for an object being
-
restored cannot be found.
*/ void readExternal(ObjectInput in) throws IOException, ClassNotFoundException; } 修改Book类的内容，如下：
import java.io.Externalizable; import java.io.IOException; import java.io.ObjectInput; import java.io.ObjectOutput; import java.util.List;
/**
-
@Type Book.java
-
@Desc
-
@author wangmengjun
-
@date 2017年12月1日 下午7:16:29
-
@version */ public class Book implements Externalizable {
/** 书名 */ private String name;
/** ISBN */ private String isbn;
/** 作者 */ private List authors;
@Override public void writeExternal(ObjectOutput out) throws IOException { out.writeObject(name); out.writeObject(isbn); }
@Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { name = (String) in.readObject(); isbn = (String) in.readObject(); }
/**
- @return the name */ public String getName() { return name; }
/**
- @param name
-
the name to set
*/ public void setName(String name) { this.name = name; }
/**
- @return the isbn */ public String getIsbn() { return isbn; }
/**
- @param isbn
-
the isbn to set
*/ public void setIsbn(String isbn) { this.isbn = isbn; }
/**
- @return the authors */ public List getAuthors() { return authors; }
/**
- @param authors
-
the authors to set
*/ public void setAuthors(List authors) { this.authors = authors; }
/*
- (non-Javadoc)
- @see java.lang.Object#toString() */ @Override public String toString() { return "Book [name=" + name + ", isbn=" + isbn + ", authors=" + authors + "]"; }
} 同样，使用SerializableTest.java类测试一下，同样获得如下结果：
book==>Book [name=Hello Java, isbn=ABC123456789, authors=[John, Eric]] deserializedBook==>Book [name=Hello Java, isbn=ABC123456789, authors=null] Externalizable vs Serializable Externalizable和Serializable的一些比较点，如下：
【1】 Serializable 是标识接口
public interface Serializable { } 实现该接口，无需重写任何方法；
public interface Externalizable extends java.io.Serializable {
void writeExternal(ObjectOutput out) throws IOException;
void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
} Externalizable 接口继承于Serializable，实现该接口，需要重写readExternal和writeExternal方法~
【2】Serializable提供了两种方式进行对象的序列化，
采用默认序列化方式，将非transatient和非static的属性进行序列化 编写readObject和writeObject完成部分属性的序列化 Externalizable 接口的序列化，需要重写writeExternal和readExternal方法，并且在方法中编写相关的逻辑完成序列化和反序列化。
【3】Externalizable接口的实现方式一定要有默认的无参构造函数~
如果，没有无参构造函数，反序列化会报错~ 验证一下~ Book添加一个有参数的Book构造函数~
public class Book implements Externalizable {
/** 书名 */ private String name;
/** ISBN */ private String isbn;
/** 作者 */ private List authors;
public Book(String name) { this.name = name; }
... ... } 这样，序列化、反序列化之后，报no valid constructor的异常~
Exception in thread "main" java.io.InvalidClassException: Book; no valid constructor at java.io.ObjectStreamClass$ExceptionInfo.newInvalidClassException(ObjectStreamClass.java:150) at java.io.ObjectStreamClass.checkDeserialize(ObjectStreamClass.java:768) at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1772) at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1350) at java.io.ObjectInputStream.readObject(ObjectInputStream.java:370) at SerializationUtil.deserialize(SerializationUtil.java:27) at SerializableTest.main(SerializableTest.java:33)
Serializable接口实现，其采用反射机制完成内容恢复，没有一定要有无参构造函数的限制~
【4】采用Externalizable无需产生序列化ID（serialVersionUID）而Serializable接口则需要
【5】相比较Serializable, Externalizable序列化、反序列更加快速，占用相比较小的内存
在项目中，大部分的类还是推荐使用Serializable, 有些类可以使用Externalizable接口，如：
完全控制序列的流程和逻辑 需要大量的序列化和反序列化操作，而你比较关注资源和性能~ 当然，这种情况下，我们一般还会考虑第三方序列化/反序列化工具，如protobuf等进行序列化和反序列化操作~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
这个关键字的作用其实我在写java的序列化机制中曾经写过，不过那时候只是简单地认识，只要其简单的用法，没有深入的去分析。这篇文章就是去深入分析一下transient关键字。
先给出这篇文章的大致脉络
首先，介绍了transient的基本概念和基本用法、然后，介绍深入分析一下transient关键字，并介绍几个需要掌握的问题最后，来个总结
一、初识transient关键字
其实这个关键字的作用很好理解，就是简单的一句话：将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会被序列化。
概念也很好理解，下面使用代码去验证一下：
![]()
然后我们在Test中去验证一下：
![]()
从上面可以看出，在序列化SerializeUser方法中，首先创建一个序列化user类，然后将其写入到G://Test/template路径中。在反序列化DeSerializeUser方法中，首先创建一个File，然后读取G://Test/template路径中的数据。
这就是序列化和反序列化的基本实现，而且我们看一下结果，也就是被transient关键字修饰的age属性是否被序列化。
![]()
从上面的这张图可以看出，age属性变为了0，说明被transient关键字修饰之后没有被序列化。
二、深入分析transient关键字
为了更加深入的去分析transient关键字，我们需要带着几个问题去解读：
（1）transient底层实现的原理是什么？
（2）被transient关键字修饰过得变量真的不能被序列化嘛？
（3）静态变量能被序列化吗？被transient关键字修饰之后呢？
带着这些问题一个一个来解决：
1、transient底层实现原理是什么？
java的serialization提供了一个非常棒的存储对象状态的机制，说白了serialization就是把对象的状态存储到硬盘上 去，等需要的时候就可以再把它读出来使用。有些时候像银行卡号这些字段是不希望在网络上传输的，transient的作用就是把这个字段的生命周期仅存于调用者的内存中而不会写到磁盘里持久化，意思是transient修饰的age字段，他的生命周期仅仅在内存中，不会被写到磁盘中。
2、被transient关键字修饰过得变量真的不能被序列化嘛？
想要解决这个问题，首先还要再重提一下对象的序列化方式：
Java序列化提供两种方式。
一种是实现Serializable接口
另一种是实现Exteranlizable接口。 需要重写writeExternal和readExternal方法，它的效率比Serializable高一些，并且可以决定哪些属性需要序列化（即使是transient修饰的），但是对大量对象，或者重复对象，则效率低。
从上面的这两种序列化方式，我想你已经看到了，使用Exteranlizable接口实现序列化时，我们自己指定那些属性是需要序列化的，即使是transient修饰的。下面就验证一下
首先我们定义User1类：这个类是被Externalizable接口修饰的
![]()
然后我们就可以测试了
![]()
上面，代码分了两个方法，一个是序列化，一个是反序列化。里面的代码和一开始给出的差不多，只不过，User1里面少了age这个属性。
然后看一下结果：
![]()
结果基本上验证了我们的猜想，也就是说，实现了Externalizable接口，哪一个属性被序列化使我们手动去指定的，即使是transient关键字修饰也不起作用。
3、静态变量能被序列化吗？没被transient关键字修饰之后呢？
这个我可以提前先告诉结果，静态变量是不会被序列化的，即使没有transient关键字修饰。下面去验证一下，然后再解释原因。
首先，在User类中对age属性添加transient关键字和static关键字修饰。
然后，在Test类中去测试
![]()
最后，测试一下，看看结果
![]()
结果已经很明显了。现在解释一下，为什么会是这样，其实在前面已经提到过了。因为静态变量在全局区,本来流里面就没有写入静态变量,我打印静态变量当然会去全局区查找,而我们的序列化是写到磁盘上的，所以JVM查找这个静态变量的值，是从全局区查找的，而不是磁盘上。user.setAge(18);年龄改成18之后，被写到了全局区，其实就是方法区，只不过被所有的线程共享的一块空间。因此可以总结一句话：
静态变量不管是不是transient关键字修饰，都不会被序列化
三、transient关键字总结
java 的transient关键字为我们提供了便利，你只需要实现Serilizable接口，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。像银行卡、密码等等这些数据。这个需要根据业务情况了。
