Java基础(十一)--Serializable和Externalizable接口实现序列化
序列化在日常开发中经常用到，特别是涉及到网络传输的时候，例如调用第三方接口，通过一个约定好的实体进行传输，这时你必须实现序列
化，这些都是大家都了解的内容，所以文章也会讲一下序列化的高级内容。
序列化与反序列化简单认知：
我们知道，对象在不具有可达性的时候，会被GC，这些对象都是保存在堆中，而现实中，我们可能需要将对象进行持久化，并且在需要的时候
进行读取转换，这就是序列化的工作。
1、序列化：
将一个对象转换成字节流或者说是字节数组，并且可以存储或传输的形式的过程。
存储：可以把一个对象存储到文件、数据库等
网络传输：可以转化成字节或XML进行网络传输
2、反序列化：
和序列化是一个相反的过程，在需要的时候，把字节数组转化成对象。
序列化广泛应用于远程调用等所有涉及网络传输的地方
序列化相关接口：
Serializable、Externalizable、ObjectOutput、ObjectInput、ObjectOutputStream、ObjectInputStream
Serializable接口：
@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class Student implements Serializable {
private int id;
private String name;
private int sex;
private transient String addr;
}
public static void main(String[] args) throws Exception{
Student student = new Student(1001, "sam", 1, "SH");
File file = new File("D:\\a.txt");
FileOutputStream fileOutputStream = new FileOutputStream(file);
ObjectOutputStream outputStream = new ObjectOutputStream(fileOutputStream);
outputStream.writeObject(student);
outputStream.close();
ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(file));
Student student1 = (Student)inputStream.readObject();
System.out.println(student1.toString());
inputStream.close();
}
结果：
Student(id=1001, name=sam, sex=1, addr=null)
我们通过Binary Viewer查看这个二进制文件a.txt，下面二进制内容解释参考自：https://www.cnblogs.com/xrq730/p/4821958.html
第一部分：序列化文件头
1、AC ED：STREAM_MAGIC序列化协议
2、00 05：STREAM_VERSION序列化协议版本
3、73：TC_OBJECT声明这是一个新的对象
第二部分：序列化的类的描述，在这里是Student类
1、72：TC_CLASSDESC声明这里开始一个新的class
2、00 18:十进制的24，表示class名字的长度是24个字节
3、63 6F 6D ... 6E 74 20：表示的是“com.it.exception.Student”这一串字符，可以数一下确实是24个字节
4、00 00 00 00 00 00 00 01：SerialVersion，序列化ID，1
5、02：标记号，声明该对象支持序列化
6、00 03：该类所包含的域的个数为3个
第三部分：是对象中各个属性项的描述
1、49：int类型
2、00 02：十进制的2，表示字段长度
3、69 64：表示字段id
4、49：int类型
省略了sex、name属性，可以自行查看
5、74：TC_STRING，代表一个new String，用String来引用对象
第四部分：该对象父类的信息，如果没有父类就没有这部分。有父类和第2部分差不多
1、00 12：十进制的18，表示父类的长度
2、4C 6A 61 ... 6E 67 3B：“L/java/lang/String;”表示的是父类属性
3、78：TC_ENDBLOCKDATA，对象块结束的标志
4、70：TC_NULL，说明没有其他超类的标志
第五部分：输出对象的属性项的实际值，如果属性项是一个对象，这里还将序列化这个对象，规则和第2部分一样
1、00 03：十进制的3，属性的长度
2、73 61 6D：字符串"sam"，name的属性值
以上是二进制文件的解析，可以得出结论：
1、序列化之后保存的是对象的信息
2、被声明为transient的属性不会被序列化，这就是transient关键字的作用，addr字段并没有保存
所以，我们得出结论，static字段也不会被序列化，因为static变量属于类的
Externalizable接口：
public interface Externalizable extends java.io.Serializable {
void writeExternal(ObjectOutput out) throws IOException;
restored cannot be found.
void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
}
使用样例：
@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class Student implements Externalizable{
private static final long serialVersionUID = 1L;
private int id;
private String name;
private int sex;
@Override
public void writeExternal(ObjectOutput out) throws IOException {
out.writeObject(id);
out.writeObject(name);
out.writeObject(sex);
}
@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
id = (Integer)in.readObject();
name = (String)in.readObject();
sex = (Integer)in.readObject();
}
}
public class Test {
public static void main(String[] args) throws Exception{
Student student = new Student(1001, "sam", 1);
File file = new File("D:\\a.txt");
FileOutputStream fileOutputStream = new FileOutputStream(file);
ObjectOutputStream outputStream = new ObjectOutputStream(fileOutputStream);
outputStream.writeObject(student);
outputStream.close();
ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(file));
Student student1 = (Student)inputStream.readObject();
System.out.println(student1.toString());
inputStream.close();
}
}
结果：
Student(id=1001, name=sam, sex=1)
从结果看Externalizable接口同样可以实现序列化和反序列化，但是有些地方不太一样，需要注意
1、相关类必须有默认构造器，否则会抛出异常，是因为在读取对象时，会调用被序列化类的无参构造器去创建一个新的对象，然后再将被
保存对象的字段的值分别填充到新对象中。
2、需要重写writeExternal和readExternal方法，去控制序列化，并且写入字段顺序和读取顺序要保持一致，写入和读取支持多种类型，不必
一定使用object，这样不用类型转换
自定义序列化：
我们使用序列化的时候，一般情况都是使用默认的方式，而如果在一些特殊场景下我们需要进行特殊处理，例如字段加密，因为序列化是不安
全的。
@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class Student implements Serializable{
private static final long serialVersionUID = 1L;
private int id;
private String name;
private int sex;
private void writeObject(ObjectOutputStream outputStream) throws Exception {
outputStream.defaultWriteObject();
outputStream.writeBoolean(true);
}
private void readObject(ObjectInputStream inputStream) throws Exception {
inputStream.defaultReadObject();
boolean flag = inputStream.readBoolean();
System.out.println("flag: " + flag);
}
}
测试代码不变
flag: true Student(id=1001, name=sam, sex=1)
从代码上看和Externalizable接口几乎一样的，通过writeObject()和readObject()实现自定义的过程
原因：
虚拟机会首先试图调用对象里的writeObject()和readObject()，进行用户自定义的序列化和反序列化。如果没有这样的方法，那么默认调用的
是ObjectOutputStream的defaultWriteObject以及ObjectInputStream的defaultReadObject方法
我们在查看jdk集合的源码中可以看到，ArrayList、HashMap等在实现序列化的时候，都是自定义writeObject()和readObject()的
PS：虚拟机通过反射来调用writeObject()和readObject()
ArrayList序列化：
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
transient Object[] elementData; //通过数组保存集合数据
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
elementData = EMPTY_ELEMENTDATA;
s.defaultReadObject();
s.readInt(); // ignored
if (size > 0) {
ensureCapacityInternal(size);
Object[] a = elementData;
// Read in all elements in the proper order.
for (int i=0; i<size; i++) {
a[i] = s.readObject();
}
}
}
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException{
int expectedModCount = modCount;
s.defaultWriteObject();
// Write out size as capacity for behavioural compatibility with clone()
s.writeInt(size);
// Write out all elements in the proper order.
for (int i=0; i<size; i++) {
s.writeObject(elementData[i]);
}
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
}
ArrayList这样实现的目的：
ArrayList是动态数组，数组中的数据在达到阀值就会扩容，如果数组扩容后长度设为100，而里面只存放了10条数据，那就会序列化90个
null元素。为了保证在序列化的时候不会将这么多null同时进行序列化，ArrayList把元素数组设置为transient，然后通过遍历数组讲数据进行
序列化和反序列化
总结：
1、在Java中，只要一个类实现了Serializable接口，那么它就可以被序列化
2、通过ObjectOutputStream和ObjectInputStream对对象进行序列化及反序列化
3、当父类继承Serializable接口，所有子类都可以被序列化
4、子类实现了Serializable接口，如果想要父类的属性也能实现序列化，必须父类也实现Serializable 接口，否则父类中的属性不能序列
化（不报错，数据丢失），但是在子类中属性仍能正确序列化
5、如果序列化的属性是对象，则这个对象也必须实现Serializable接口，否则会报错
6、序列化并不保存静态变量
7、反序列化能否成功，要求：①.类路径相同，②.序列化ID保持一致(serialVersionUID)，否则无法成功
8、反序列化时，如果对象的属性有修改或删减，则修改的部分属性会丢失，但不会报错
5、序列化数据如果比较敏感，可以采用加密的方式，增加一定安全性
内容参考：
https://www.cnblogs.com/xrq730/p/4821958.html
http://www.importnew.com/18024.html
