什么是原型模式
原型模式是一个创建型的模式。原型二字表明了改模式应该有一个样板实例，用户从这个样板对象中复制一个内部属性一致的对象，这个过程也就是我们称的“克隆”。被复制的实例就是我们所称的“原型”，这个原型是可定制的。原型模式多用于创建复杂的或者构造耗时的实例，因为这种情况下，复制一个已经存在的实例可使程序运行更高效。关键就是两个字：克隆
对象克隆简介
对象克隆，说白了，就是将已实例化的对象复制一个出来，有个别同学就要问了，字节new 出来或者用反射创建一个实例出来不就好了吗？ 干嘛要克隆？ 当然你可以new也可以反射，但是你new出来的对象都是空的，我们克隆是是将已有内容的对象复制一个一模一样的出来，比如我们看看下面这个复制对象的案例；
-
// 实例化对象
-
StudentInfo studentInfo =
new StudentInfo();
-
studentInfo.setName(
"张三");
-
studentInfo.setAge(
16);
-
studentInfo.setHeight(
149);
-
studentInfo.setLoginName(zhangsan);
-
studentInfo.setStatus(
1);
-
studentInfo.setAddress(
"广东省深圳市南山区深圳湾一号3栋28楼2802房");
-
.......
-
studentInfo.setN(
"N");
// 第N个对象
-
-
// 复制对象
-
StudentInfo copyInfo =
new StudentInfo();
-
copyInfo.setName(studentInfo.getName());
-
copyInfo.setAge(studentInfo.getAge());
-
copyInfo.setHeight(studentInfo.getHeight());
-
copyInfo.setLoginName(studentInfo.getLoginName());
-
copyInfo.setStatus(studentInfo.getStatus());
-
copyInfo.setAddress(studentInfo.getAddress());
-
........
-
copyInfo.setN(studentInfo.getN());
// 设置第N个对象
以上的复制对象方式是可行的，但是需要每个都重新赋值一遍，太麻烦啦，而且如果对象太多的话，你不得写好多代码，维护起来也麻烦得多，
原型模式使用场景
- 类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等，通过原型拷贝避免这些消耗
- 通过new产生的一个对象需要非常繁琐的数据准备或者权限，这时可以使用原型模式。
- 一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用，即保护性拷贝。
什么时候要用到对象拷贝
Spring默认是单例模式的，但如果在类上面加上 @Scope("prototype") 注解，就表明这个对象是原型模式，它的低层其实就是拷贝了一个容器中的对象实现的；
-
@Service
-
@Scope("prototype")
-
public
class StudentService {
-
}
让我们看看java API里面一个用到了克隆对象的方法 java.util.Date:
-
/**
-
* Return a copy of this object.
-
*/
-
public
Object
clone() {
-
Date d =
null;
-
try {
-
d = (Date)super.
clone();
-
if (cdate !=
null) {
-
d.cdate = (BaseCalendar.Date) cdate.
clone();
-
}
-
}
catch (CloneNotSupportedException e) {}
// Won't happen
-
return d;
-
}
爱学习的童鞋发问：“介绍完了对象拷贝，那如果需要实现对象拷贝的话，有哪些方式呢？” ，首先，这是个好问题， 让我们把掌声送给这位童鞋，这可问到点子上了，对象拷贝啊一共有3种方式，分别为
- 浅拷贝
- 深拷贝
- 序列化深拷贝
接下来我们一个个地介绍它们的作用
拷贝引用 （不算拷贝，只是共用指针而已）
有个聪明的同学马上就想出来了一个法子，并且站起来大声说：“脑师，我想到了，是不是这样的啊，（接着在电脑面前对着键盘一顿输出），先是画出一个流程图，然后敲了一段代码，这也太简单了吧， 我很聪明吧？嘿嘿”； 先看看这位童鞋画的图吧！
让我们在看看这位聪明的同学写的代码吧！
-
public static void main(String[] args) {
-
-
Student zhangsan =
new Student(
new StudentInfo(
"张三",
15));
-
System.out.println(
"引用拷贝前张三的地址："+zhangsan);
-
-
Student copy = zhangsan;
// 拷贝对象
-
System.out.println(
"引用拷贝后张三的地址："+copy);
-
-
// 将名称改为李四
-
System.out.println(
"将名称改为李四");
-
zhangsan.getInfo().setName(
"李四");
-
-
System.out.println(
"获取名称："+copy.getInfo().getName());
-
}
可是运行之后，结果是这样的：
-
引用拷贝前张三的地址：
com
.clone
.Student
@66d3c617
-
引用拷贝后张三的地址：com.clone.Student@
66d3c617
-
将名称改为李四
-
获取名称：李四
这样也没错，算是实现了拷贝对象，但注意看后面的，我把名称改为李四， 复制的对象也跟着改了；原来啊，虽然用了2个对象，但是呢，我们可以看到打印的toString() 的内存地址是一样的，所以本质上，虽然看上去复制了一个对象出来，其实本质上它们共用了一个引用，引向同一块内存地址；改了其中一个，另一个也会跟着改；
1、浅拷贝
当然，我们还有另一种方式可以实现克隆后的对象会使用不同的地址，就是用 clone 的方式，Object 是所有类的父类，这个类有个方法叫做clone() 方法， 这个方法就是用来克隆用的，使用这个方法后，会为我们拷贝一份基本类型，但是不拷贝引用类型，这2个引用类型也是指向同一块内存地址的； 所以，浅拷贝只会拷贝基本数据类型，不会拷贝引用类型，基本数据类型会分配一块新的内存地址来存储，引用类型用的是同一块内存地址
注意：使用clone() 方法必须先实现 Cloneable 接口，否则会报错；
我们看看代码是怎么实现的吧
-
package com.clone;
-
import java.util.ArrayList;
-
/**
-
* 深拷贝
-
*/
-
public
class ShallowCopy {
-
-
public static void main(String[] args) throws Exception {
-
ArrayList<String> subjectList =
new ArrayList<>();
-
subjectList.add(
"数学");
-
subjectList.add(
"语文");
-
Student zhangsan =
new Student(
"张三",
15, subjectList);
-
Object clone = zhangsan.clone();
-
System.out.println(
"深拷贝前张三的地址：" + zhangsan);
-
System.out.println(
"深拷贝后张三的地址：" + clone);
-
-
Student student = (Student) clone;
-
-
// 将名称改为李四
-
System.out.println(
"将深拷贝后的名称改为李四，科目增加体育");
-
student.setName(
"李四");
-
student.getSubjectList().add(
"体育");
-
-
System.out.println(
"获取深拷贝修改后名称：" + student.getName());
-
System.out.println(
"获取深拷贝修改后科目：" + student.getSubjectList());
-
-
System.out.println(
"获取深拷贝前名称：" + zhangsan.getName());
-
System.out.println(
"获取深拷贝前科目：" + zhangsan.getSubjectList());
-
}
-
}
-
-
// 学生类
-
class Student implements Cloneable {
// 实现Serializable 接口
-
// 名称
-
private String name;
-
// 年龄，基本数据类型
-
private
int age;
-
// 科目列表 ，引用类型
-
private ArrayList<String> subjectList;
-
-
public Student(String name, int age, ArrayList<String> subjectList) {
-
this.name = name;
-
this.age = age;
-
this.subjectList = subjectList;
-
}
-
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; }
-
public ArrayList<String> getSubjectList() {
return subjectList; }
-
public void setSubjectList(ArrayList<String> subjectList) {
this.subjectList = subjectList; }
-
-
@Override
-
protected Object clone() throws CloneNotSupportedException {
-
Object clone =
super.clone();
// 浅拷贝
-
Student student = (Student) clone;
-
return student;
-
}
-
}
-
-
打印结果
-
深拷贝前张三的地址：
com
.clone
.Student@
66d3c617
-
深拷贝后张三的地址：
com
.clone
.Student@
63947c6b
-
将深拷贝后的名称改为李四，科目增加体育
-
获取深拷贝修改后名称：李四
-
获取深拷贝修改后科目：
[数学, 语文, 体育]
-
获取深拷贝前名称：张三 (因为拷贝了一份新的基本数据类型，所以修改后不会影响原对象)
-
获取深拷贝前科目：
[数学, 语文, 体育] （引用对象未拷贝，修改后原对象的科目也跟着变化）
这下我们就可以看到，这里2个对象打印的内存地址已经不一样了，并且将张三改为李四，克隆对象也不受影响；
2、深拷贝
在浅克隆中，对象的成员变量是基本数据类型（Integer 、Float、Char、Long 、Double、Short、Boolean、Byte、包括String ），但如果对象的成员变量也是一个对象,就需要把这个成员变量对象也克隆一份出来，如果不克隆对象类型的成员变量，那么它们本质上的数据还是指向同一块地址，所以我们既要克隆对象，也要克隆这个对象的成员变量；深拷贝会拷贝整个对象，会分配一块新的内存地址来存储数据
实现代码
-
package com.clone;
-
import java.util.ArrayList;
-
/**
-
* 深拷贝
-
*/
-
public
class DeepCopy {
-
-
public static void main(String[] args) throws Exception {
-
ArrayList<String> subjectList =
new ArrayList<>();
-
subjectList.add(
"数学");
-
subjectList.add(
"语文");
-
Student zhangsan =
new Student(
"张三",
15, subjectList);
-
Object clone = zhangsan.clone();
-
System.out.println(
"深拷贝前张三的地址：" + zhangsan);
-
System.out.println(
"深拷贝后张三的地址：" + clone);
-
-
Student student = (Student) clone;
-
-
// 将名称改为李四
-
System.out.println(
"将深拷贝后的名称改为李四，科目增加体育");
-
student.setName(
"李四");
-
student.getSubjectList().add(
"体育");
-
-
System.out.println(
"获取深拷贝修改后名称：" + student.getName());
-
System.out.println(
"获取深拷贝修改后科目：" + student.getSubjectList());
-
-
System.out.println(
"获取深拷贝前名称：" + zhangsan.getName());
-
System.out.println(
"获取深拷贝前科目：" + zhangsan.getSubjectList());
-
}
-
}
-
-
// 学生类
-
class Student implements Cloneable {
// 实现Serializable 接口
-
// 名称
-
private String name;
-
// 年龄，基本数据类型
-
private
int age;
-
// 科目列表 ，引用类型
-
private ArrayList<String> subjectList;
-
-
public Student(String name, int age, ArrayList<String> subjectList) {
-
this.name = name;
-
this.age = age;
-
this.subjectList = subjectList;
-
}
-
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; }
-
public ArrayList<String> getSubjectList() {
return subjectList; }
-
public void setSubjectList(ArrayList<String> subjectList) {
this.subjectList = subjectList; }
-
-
@Override
-
protected Object clone() throws CloneNotSupportedException {
-
Object clone =
super.clone();
// 浅拷贝
-
Student student = (Student) clone;
-
student.subjectList = (ArrayList<String>)
this.subjectList.clone();
// 深拷贝
-
return student;
-
}
-
}
-
-
打印结果
-
深拷贝前张三的地址：
com
.clone
.Student
@66d3c617
-
深拷贝后张三的地址：com.clone.Student@
63947c6b
-
将深拷贝后的名称改为李四，科目增加体育
-
获取深拷贝修改后名称：李四
-
获取深拷贝修改后科目：[数学, 语文, 体育]
-
获取深拷贝前名称：张三
-
获取深拷贝前科目：[数学, 语文]
3、序列化深拷贝（解决多层克隆问题）
如果引用类型里面还包含很多引用类型，或者内层引用类型的类里面又包含引用类型，如果每个对象都去实现Cloneable 接口并重写clone方法的话，就会很麻烦。就像这种格式的对象：
这时我们可以用序列化的方式来实现对象的深克隆；序列化我们在学习javase基础的时候就已经学过了，用起来也是非常简单，只需要实现 Serializable 接口即可，通过 下面的代码例子可以看到，使用了更少的代码，并且不需要重写clone方法也可以实现对象深拷贝；
-
package com.clone;
-
import java.io.*;
-
import java.util.ArrayList;
-
import java.util.List;
-
-
/**
-
* 克隆对象--深拷贝--序列化拷贝
-
*/
-
public
class SerialCloneObject {
-
-
public static void main(String[] args) throws Exception {
-
List<String> subjectList =
new ArrayList<>();
-
subjectList.add(
"数学");
-
subjectList.add(
"语文");
-
Student zhangsan =
new Student(
"张三",
15,subjectList);
-
System.out.println(
"序列化前张三的地址："+zhangsan);
-
-
// 序列化
-
ByteArrayOutputStream byteArrayOutputStream = serialObject(zhangsan);
-
-
// 反序列化
-
Object o = deserialObject(byteArrayOutputStream);
-
-
// 打印结果
-
System.out.println(
"序列化后张三的地址："+o);
-
-
Student student = (Student) o;
-
-
//修改名称不会影响到深拷贝的对象
-
System.out.println(
"将反序列化后的名称修改为：李四，并添加科目：体育");
-
student.setName(
"李四");
-
student.getSubjectList().add(
"体育");
-
System.out.println(
"反序列化修改后的张三名称："+student.getName());
-
System.out.println(
"反序列化修改后的张三科目："+student.getSubjectList());
-
System.out.println(
"未序列化的张三科目："+zhangsan.getSubjectList());
-
}
-
-
// 序列化
-
private static ByteArrayOutputStream serialObject(Object object) throws IOException {
-
ByteArrayOutputStream byteArrayOutputStream =
new ByteArrayOutputStream();
-
ObjectOutputStream out =
new ObjectOutputStream(byteArrayOutputStream);
-
out.writeObject(object);
-
// 关闭流
-
byteArrayOutputStream.close();
-
out.close();
-
return byteArrayOutputStream;
-
}
-
-
// 反序列化
-
private static Object deserialObject(ByteArrayOutputStream byteArrayOutputStream) throws IOException, ClassNotFoundException {
-
ByteArrayInputStream byteArrayInputStream =
new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
-
ObjectInputStream in =
new ObjectInputStream(byteArrayInputStream);
-
Object o = in.readObject();
-
-
// 关闭流
-
byteArrayInputStream.close();
-
in.close();
-
return o;
-
}
-
}
-
// 学生类
-
class Student implements Serializable {
// 实现Serializable 接口
-
// 名称
-
private String name;
-
// 年龄，基本数据类型
-
private
int age;
-
// 科目列表 ，引用类型
-
private List<String> subjectList;
-
-
public Student(String name,int age,List<String > subjectList){
-
this.name = name;
-
this.age = age;
-
this.subjectList = subjectList;
-
}
-
-
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; }
-
public List<String> getSubjectList() {
return subjectList; }
-
public void setSubjectList(List<String> subjectList) {
this.subjectList = subjectList; }
-
}
-
-
-
打印结果
-
序列化前张三的地址：
com
.clone
.Student
@66d3c617
-
序列化后张三的地址：com.clone.Student@
1ddc4ec2
-
将反序列化后的名称修改为：李四，并添加科目：体育
-
反序列化修改后的张三名称：李四
-
反序列化修改后的张三科目：[数学, 语文, 体育]
-
未序列化的张三科目：[数学, 语文]
转载：https://blog.csdn.net/qq_27184497/article/details/116610550
查看评论