参考:Java 实现深度复制
什么是深度复制？在Java里面，在创建一个对象，我们通常会有一个引用指向该对象，当我们通过引用变量改变对象的值（属性）时，引用是不变的，变的是内存里面的那块内存，即引用所指向的对象。一般情况下，我们将该引用赋给另一个引用变量或者作为参数传递时，传递的也只是引用，即将引用指向“复制”了一份给另一个引用变量，随后该引用变量也指向同一个对象，内存里面并没有创建一个新的对象。在某些情况下，我们需要“真正复制”对象，创建一份已知对象的copy，而不仅仅“复制”引用，用作备份也好，其他操作也好。
那么，该如何实现？
先说下思路：首先将对象序列化到流里，然后再反序列化，从流里读取出来即可。
java序列化和反序列化
- 概念
序列化：把Java对象转换为字节序列的过程。
反序列化：把字节序列恢复为Java对象的过程。 - 用途
对象的序列化主要有两种用途：
1） 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；
2） 在网络上传送对象的字节序列。 - 对象序列化
java.io.ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。只有实现了Serializable和Externalizable接口的类的对象才能被序列化。
java.io.ObjectInputStream代表对象输入流，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。
java对象序列化条件
- 实现Serializable接口
- declare a static final serialVersionUID field of type long
常用序列化方法
- 序列化
// 字节数组输出流
ByteArrayOutputStream baos = new ByteArrayOutputStream();
// 对象输出流
ObjectOutputStream oos = new ObjectOutputStream(baos);
// 串行化
oos.writeObject(new Integer(100)); //串行化整数100
2.反序列化
byte[] bytes = baos.toByteArray();
ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(bais);
Object o = ois.readObject();
实例：
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/**
*
* @author Administrator
* 深度复制
*/
public class App2 {
public static void main(String[] args) throws Exception {
/******************** 写入(串行) **********************/
// 字节数组输出流
ByteArrayOutputStream baos = new ByteArrayOutputStream();
// 对象输出流
ObjectOutputStream oos = new ObjectOutputStream(baos);
// 串行化
oos.writeObject(new Integer(100));
oos.writeObject("Hello World");
oos.writeObject(new Cat("xiaohu",18));
oos.close();
baos.close();
/******************** 读取(反串行) **********************/
byte[] bytes = baos.toByteArray();
ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(bais);
Object o = ois.readObject();
System.out.println(o);
o = ois.readObject();
System.out.println(o);
Cat cat = (Cat)ois.readObject();
System.out.println("name: "+cat.getName()+" age: "+cat.getAge());
ois.close();
bais.close();
}
}
Cat类：
import java.io.Serializable;
/**
* javaBean
*/
public class Cat implements Serializable {
private static final long serialVersionUID = 1861516170581376793L;
private String name;
private int age;
private String color ;
private int xx ;
//临时的
private transient Person owner ;
private Dog neibor ;
public Dog getNeibor() {
return neibor;
}
public void setNeibor(Dog neibor) {
this.neibor = neibor;
}
public Person getOwner() {
return owner;
}
public void setOwner(Person owner) {
this.owner = owner;
}
public int getXx() {
return xx;
}
public void setXx(int xx) {
this.xx = xx;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public Cat() {
System.out.println("()");
}
public Cat(String name, int age) {
super();
System.out.println("(1)");
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
Person类
import java.io.Serializable;
public class Person implements Serializable{
private static final long serialVersionUID = -3860831553852022224L;
private String name ;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Dog类：
package com.it18zhang.test;
import java.io.Serializable;
public class Dog implements Serializable{
private static final long serialVersionUID = 264736816365982588L;
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
总结：
- java深度复制非常实用，特别是在分布式应用当中，比如Hadoop，Spark等当中，通常采用主流的序列化框架如protobuf,avro，thrift等将数据对象进行序列化成字节数组，然后通过rpc（远程过程调用）的机制通过通信协议进行传输，从而实现分布式应用之间的通信。在节省网络带宽和磁盘io的基础上更加提高了网络传输的效率和安全性。
- 完成RPC 需要两个协议： 对象序列化协议 和 调用控制协议
