【README】
- 1, 为啥要序列化或序列化的意义?
- 2,系统间调用的报文格式,大多数是Json字符串(或字节数组);接收方接收json;
- 3,但当系统调用如RMI,客户端请求服务器获取一个 javabean对象的状态信息,而不是json格式,这个时候 json格式就不合适了;当然了,在发送时我们可以 把 javabean的状态信息的属性转为json;接收时把json对象转为 javabean;很显然,这样太复杂了,而且不利于维护,一旦 javabean的属性做修改,需要改的代码太多;
- 4,基于此, 序列化出现了,序列化可以把对象信息转换为字节数组,保存到媒介中(如磁盘,内存,或传输到网络),后续需要用到的时候,可以直接把字节数组反序列化为java对象,而不需要做其他操作;也可以理解为是 java对象持久化;
- 这可以解决 系统调用间 javabean对象信息传输的问题;即请求前,把对象序列化为字节数组;接收时,把字节数组反序列化(直接解析)为java bean对象(而不需要其他格式转换);
- 5,序列化的另一个用途是 用于java对象的深拷贝;
【补充1】本文给出了3种实现序列化的方式,包括
- 1种自动方式(实现 Serializable 接口);
- 2种手动方式(分别实现 Externalizable, Serializable 接口);
【补充2】自动实现与手动实现
- 自动实现: 程序员无需自定义字段序列化策略,由 java底层默认实现;
- 手动实现:程序员需要自定义自定序列化策略,哪些需要序列化,哪些不需要;
【1】java序列化实现
1)java序列化定义: 把那些实现了 Serializable 接口的对象转换成一个字节序列;并能够在以后把这个字节 序列完全恢复到原来的对象;实现对 javabean状态的持久化;
2)如何理解持久性? 持久性意味着一个对象的生命周期并不取决于 程序是否在执行;就像数据库的持久化一样;但一个对象可以存在于 程序的调用之间,如远程方法调用 RMI;
3)通过序列化可以把java对象以字节格式保存到磁盘,内存,网络流上面;在以后需要的时候,把序列化后的字节恢复(或反序列化)成原来的 javabean的状态;
【2】 序列化实现
【2.1】实现 Serializable 接口自动实现序列化
javabean序列化
/*** @Description 实现Serializable自动实现序列化与反序列化* @author xiao tang* @version 1.0.0* @createTime 2021年11月20日*/
public class AutoSerializableClass implements Serializable {String name;Date date;Map<String, String> configs;// transient 表示不序列化agetransient int age;public AutoSerializableClass(String name) {this(name, Collections.emptyMap(), new Date(), 18);}public AutoSerializableClass(String name, Map<String, String> configs) {this(name, configs, new Date(), 18);}public AutoSerializableClass(String name, Map<String, String> configs, Date date, int age) {this.name = name;this.configs = configs;this.date = date;this.age = age;}public String getName() {return name;}public Map<String, String> getConfigs() {return configs;}/*** @description 基于序列化的深度拷贝* @return AutoSerializableClass* @author xiao tang* @date 2021/11/20*/public AutoSerializableClass deepClone() throws Exception {ByteArrayOutputStream buf = new ByteArrayOutputStream();// 把流放在 tyr资源块中,程序结束java会自动关闭流资源try (ObjectOutputStream outputStream = new ObjectOutputStream(buf)) {outputStream.writeObject(this);}try (ObjectInputStream inputStream = new ObjectInputStream(new ByteArrayInputStream(buf.toByteArray()))) {return (AutoSerializableClass) inputStream.readObject();}} @Overridepublic String toString() {return "AutoSerializableClass{" +"name='" + name + '\'' +", date=" + date +", configs=" + configs +", age=" + age +'}';}
}
【2.1.1】序列化到磁盘与反序列
public static String path = "d://temp//";
/*** @description 测试用例-把 AutoSerializableClass 对象序列化到磁盘* @author xiao tang* @date 2021/11/20*/public static void main(String[] args) throws IOException, ClassNotFoundException {// 把 AutoSerializableClass 对象序列化到磁盘ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(path + "my01.out"));outputStream.writeObject(new AutoSerializableClass("zhangsan"));outputStream.close();// 从磁盘读取序列化对象ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(path + "my01.out"));AutoSerializableClass objParsed = (AutoSerializableClass) objectInputStream.readObject();System.out.println(objParsed.getName()); // zhangsan}
【2.1.2】深度拷贝
/** * @description 测试用例-基于 Serializable接口自动实现序列化的深度拷贝* @author xiao tang* @date 2021/11/20 */public static void main(String[] args) throws Exception {Map<String, String> configs = new HashMap<>();configs.put("k1", "v1");AutoSerializableClass lisi = new AutoSerializableClass("lisi", configs);// 深度拷贝到lisi2 和 lisi3AutoSerializableClass lisi2 = lisi.deepClone();AutoSerializableClass lisi3 = lisi.deepClone();// 为lisi2添加配置lisi2.getConfigs().put("k2", "v2");System.out.println("\n lisi2==="); // configs={k1=v1, k2=v2}, age=0System.out.println(lisi2);System.out.println("\n lisi3==="); // configs={k1=v1}, age=0System.out.println(lisi3);// 为lisi3添加配置lisi3.getConfigs().put("k3", "v3");System.out.println("\n lisi2==="); // configs={k1=v1, k2=v2}, age=0System.out.println(lisi2);System.out.println("\n lisi3==="); // configs={k1=v1, k3=v3}, age=0 System.out.println(lisi3);}
lisi2===
AutoSerializableClass{name='lisi', date=Sat Nov 20 21:43:50 CST 2021, configs={k1=v1, k2=v2}, age=0}lisi3===
AutoSerializableClass{name='lisi', date=Sat Nov 20 21:43:50 CST 2021, configs={k1=v1}, age=0}lisi2===
AutoSerializableClass{name='lisi', date=Sat Nov 20 21:43:50 CST 2021, configs={k1=v1, k2=v2}, age=0}lisi3===
AutoSerializableClass{name='lisi', date=Sat Nov 20 21:43:50 CST 2021, configs={k1=v1, k3=v3}, age=0}
【代码解说】
- 1,可以看到 lisi2 lisi3 是独立的两个对象,且反序列化后,lisi2,lisi3 定义的 configs 不是同一个 ;
- 2,age 本身初始化为18,但这里为0,是因为 age 被修改为 transient,表示不序列该字段,故age取int默认值0;
- 3,接口 Serializable 没有任何方法,仅一个标识接口而已;
【2.2】实现 Externalizable 接口手动实现序列化
1,Externalizable接口继承自 Serializable, 有2个方法需要实现;
2,这两个方法 writeExternal 和 readExternal 方法 会分别在序列化和反序列化还原的过程中被自动调用,以便执行一些特殊操作(对某些字段进行序列化与反序列化,某些不进行如账号密码,private字段不序列化等) ;如 我们可以对age 字段进行序列化和反序列化,即便age被 transient 修饰;
public interface Externalizable extends java.io.Serializable {void writeExternal(ObjectOutput out) throws IOException; void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
}
3,Externalizable 实现类
/*** @Description 实现Externalizable手动实现序列化与反序列化* @author xiao tang* @version 1.0.0* @createTime 2021年11月20日*/
public class ManualExternalizableClass implements Externalizable {String name;Date date;Map<String, String> configs;// transient 表示不序列化agetransient int age;public ManualExternalizableClass(){}public ManualExternalizableClass(String name) {this(name, new Date(), new HashMap<String, String>(), 18);}public ManualExternalizableClass(String name, Date date, Map<String, String> configs, int age) {this.name = name;this.date = date;this.configs = configs;this.age = age;}/** * @description 序列化过程自动调用* @param out 序列化书写流* @author xiao tang* @date 2021/11/20 */@Overridepublic void writeExternal(ObjectOutput out) throws IOException {out.writeObject(name);out.writeObject(date);out.writeInt(age);}/** * @description 反序列化过程自动调用* @param in 反序列化读入流* @author xiao tang* @date 2021/11/20 */@Overridepublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {this.name = String.valueOf(in.readObject());this.date = (Date) in.readObject();this.age = in.readInt();}/*** @description 深度拷贝 ManualExternalizableClass* @return MyExternalizableClass对象* @author xiao tang* @date 2021/11/20*/public ManualExternalizableClass deepClone() throws Exception {ByteArrayOutputStream buf = new ByteArrayOutputStream();try (ObjectOutputStream outputStream = new ObjectOutputStream(buf)) {outputStream.writeObject(this);}try (ObjectInputStream inputStream = new ObjectInputStream(new ByteArrayInputStream(buf.toByteArray()))) {return (ManualExternalizableClass) inputStream.readObject();}}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return "ManualExternalizableClass{" +"name='" + name + '\'' +", date=" + date +", configs=" + configs +", age=" + age +'}';}
}
【2.2.1】 测试用例,对 Externalizable 对象进行深拷贝
/*** @Description 测试用例-实现Externalizable手动实现序列化与反序列化* @author xiao tang* @version 1.0.0* @createTime 2021年11月20日*/
public class ManualExternalizableClassTest {public static void main(String[] args) throws Exception {ManualExternalizableClass obj = new ManualExternalizableClass("zhangsan");// 深度拷贝ManualExternalizableClass newObj = obj.deepClone();newObj.setAge(19); // 对新对象的age赋值,不影响老对象System.out.println("obj = " + obj); // age=18System.out.println("newObj = " + newObj); // age=19}
}
obj = MyExternalizableClass{name='zhangsan', date=Sat Nov 20 20:32:15 CST 2021, configs={}, age=18}
newObj = MyExternalizableClass{name='zhangsan', date=Sat Nov 20 20:32:15 CST 2021, configs=null, age=19}
【代码解说】
- 1,上述javabean MyExternalizableClass实现了 Externalizable 接口的方法 writeExternal() ,序列化字段name,date, age;实现了方法 readExternal(),反序列化字段 name, date, age;即便age 被 transient 修饰,但我们还可以序列化;
- 2,这种方式的序列化,需要指定序列化的字段,本文定义为 手动序列化方式;
【2.3】实现Serializable手动实现序列化
1)序列化javabean
/*** @Description 实现 Serializable 手动实现序列化与反序列化* @author xiao tang* @version 1.0.0* @createTime 2021年11月20日*/
public class ManualSerializableClass implements Serializable {String name;Date date;Map<String, String> configs;// transient 表示不序列化agetransient int age;public ManualSerializableClass(String name) {this(name, new HashMap<>(), new Date(), 18);}public ManualSerializableClass(String name, Map<String, String> configs) {this(name, configs, new Date(), 18);}public ManualSerializableClass(String name, Map<String, String> configs, Date date, int age) {this.name = name;this.configs = configs;this.date = date;this.age = age;}public String getName() {return name;}public Map<String, String> getConfigs() {return configs;}/** * @description 序列化过程自动调用(注意这里并不是重写 Serializable接口方法,即便没有重写,序列化过程也会自动调用,算是java一个缺陷,from thingking-in-java)* @param outputStream 书写流* @author xiao tang* @date 2021/11/20 */private void writeObject(ObjectOutputStream outputStream) throws IOException {outputStream.defaultWriteObject(); // 先调用默认序列化方式outputStream.writeInt(age); // 把age 进行手动序列化}/** * @description 反序列化过程自动调用(注意这里并不是重写 Serializable接口方法,即便没有重写,反序列化过程也会自动调用,算是java一个缺陷,from thingking-in-java)* @param inputStream 读入流* @author xiao tang* @date 2021/11/20 */private void readObject(ObjectInputStream inputStream) throws IOException, ClassNotFoundException {inputStream.defaultReadObject(); // 先调用默认反序列化方式age = inputStream.readInt(); // 把 age 手动反序列化}/*** @description 基于序列化的深度拷贝* @return AutoSerializableClass* @author xiao tang* @date 2021/11/20*/public ManualSerializableClass deepClone() throws Exception {ByteArrayOutputStream buf = new ByteArrayOutputStream();try (ObjectOutputStream outputStream = new ObjectOutputStream(buf)) {outputStream.writeObject(this);}try (ObjectInputStream inputStream = new ObjectInputStream(new ByteArrayInputStream(buf.toByteArray()))) {return (ManualSerializableClass) inputStream.readObject();}}@Overridepublic String toString() {return "AutoSerializableClass{" +"name='" + name + '\'' +", date=" + date +", configs=" + configs +", age=" + age +'}';}
}
2)测试用例
/*** @Description 测试用例-实现 Serializable 手动实现序列化与反序列化* @author xiao tang* @version 1.0.0* @createTime 2021年11月20日*/
public class ManualSerializableClassTest {public static void main(String[] args) throws Exception {ManualSerializableClass oldObj = new ManualSerializableClass("zhangsan");ManualSerializableClass newObj = oldObj.deepClone();newObj.getConfigs().put("newK", "newV");System.out.println("oldObj=" + oldObj); // configs={}, age=18System.out.println("newObj=" + newObj); // configs={newK=newV}, age=18}
}
oldObj=MySerializableClass{name='zhangsan', date=Sat Nov 20 21:06:37 CST 2021, configs={}, age=18}
newObj=MySerializableClass{name='zhangsan', date=Sat Nov 20 21:06:37 CST 2021, configs={newK=newV}, age=18}
【小结】