目标
- 掌握原型模式和建造者模式的应用场景
- 掌握原型模式的浅克隆和深克隆的写法
- 掌握建造者模式的基本写法
- 了解克隆是如何破坏单例的
- 了解原型模式的优缺点
- 掌握建造者模式和工厂模式的区别
原型模式的定义
- 原型模式是指原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象
- 调用者不需要知道任何创建的细节,不调用构造函数
- 属于创建型模式
原型模式的适用场景
- 类初始化消耗资源较多
- new产生的一个对象需要非常繁琐的过程(数据准备、访问权限等)
- 构造函数比较复杂
- 循环体中产生大量对象时
//创建一个接口
public interface IPrototype<T> {
T clone();
}
// 创建一个实体
public class ConcreateProtoType implements IPrototype {
private int age;
private String name;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public ConcreateProtoType clone() {
ConcreateProtoType concreateProtoType = new ConcreateProtoType();
concreateProtoType.setAge(this.age);
concreateProtoType.setName(this.name);
return concreateProtoType;
}
@Override
public String toString() {
return "ConcreateProtoType{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
}
//测试
public class Client {
public static void main(String[] args) {
ConcreateProtoType protoType = new ConcreateProtoType();
protoType.setAge(18);
protoType.setName("萧炎");
System.out.println(protoType);
//拷贝原型对象
ConcreateProtoType clone = protoType.clone();
System.out.println(clone);
}
}
打印:
ConcreateProtoType{age=18, name='萧炎'}
ConcreateProtoType{age=18, name='萧炎'}
浅克隆
//创建实例
@Data
public class ConcreateProtoType implements Cloneable {
private int age;
private String name;
private List<String> hobnies;
@Override
public ConcreateProtoType clone() {
try {
return (ConcreateProtoType) super.clone();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
@Override
public String toString() {
return "ConcreateProtoType{" +
"age=" + age +
", name='" + name + '\'' +
", hobnies=" + hobnies +
'}';
}
}
// 测试
public class Client {
public static void main(String[] args) {
ConcreateProtoType protoType = new ConcreateProtoType();
protoType.setAge(18);
protoType.setName("萧炎");
List<String> hobbies = new ArrayList<>();
hobbies.add("看电影");
hobbies.add("打游戏");
protoType.setHobnies(hobbies);
//拷贝原型对象
ConcreateProtoType clone = protoType.clone();
clone.getHobnies().add("画画");
System.out.println("原型对象:"+protoType);
System.out.println("克隆对象:"+clone);
System.out.println(protoType==clone);
System.out.println("原型对象的爱好:"+protoType.getHobnies());
System.out.println("克隆对象的爱好:"+clone.getHobnies());
System.out.println(protoType.getHobnies()==clone.getHobnies());
}
}
打印:
原型对象:ConcreateProtoType{age=18, name='萧炎', hobnies=[看电影, 打游戏, 画画]}
克隆对象:ConcreateProtoType{age=18, name='萧炎', hobnies=[看电影, 打游戏, 画画]}
false
原型对象的爱好:[看电影, 打游戏, 画画]
克隆对象的爱好:[看电影, 打游戏, 画画]
true
发现克隆的对象将原型对象改变了,原型对象被改变了 引用了同一个Hobnies的内存地址
深克隆
- 通过序列化实现深克隆
//通过序列化方式实现深克隆
//实体类
@Data
public class ConcreateProtoType implements Cloneable, Serializable {
private int age;
private String name;
private List<String> hobnies;
public ConcreateProtoType deepClone() {
try {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(this);
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
return (ConcreateProtoType) ois.readObject();
}catch (Exception e){
e.printStackTrace();
return null;
}
}
@Override
public String toString() {
return "ConcreateProtoType{" +
"age=" + age +
", name='" + name + '\'' +
", hobnies=" + hobnies +
'}';
}
}
//测试类
public class Client {
public static void main(String[] args) {
ConcreateProtoType protoType = new ConcreateProtoType();
protoType.setAge(18);
protoType.setName("萧炎");
List<String> hobbies = new ArrayList<>();
hobbies.add("看电影");
hobbies.add("打游戏");
protoType.setHobnies(hobbies);
//拷贝原型对象
ConcreateProtoType clone = protoType.deepClone();
clone.getHobnies().add("画画");
System.out.println("原型对象:"+protoType);
System.out.println("克隆对象:"+clone);
System.out.println(protoType==clone);
System.out.println("原型对象的爱好:"+protoType.getHobnies());
System.out.println("克隆对象的爱好:"+clone.getHobnies());
System.out.println(protoType.getHobnies()==clone.getHobnies());
}
}
打印:
原型对象:ConcreateProtoType{age=18, name='萧炎', hobnies=[看电影, 打游戏]}
克隆对象:ConcreateProtoType{age=18, name='萧炎', hobnies=[看电影, 打游戏, 画画]}
false
原型对象的爱好:[看电影, 打游戏]
克隆对象的爱好:[看电影, 打游戏, 画画]
false
是如何实现深克隆的呢?
跟踪 readObject()的源码最终走到如下方法中,通过反射的方式创建的一个新的实例
readObjectMethod.invoke(obj, new Object[]{ in });
- 通过JSON转换实现深克隆
//
@Data
public class ConcreateProtoType implements Cloneable, Serializable {
private int age;
private String name;
private List<String> hobnies;
//浅克隆
@Override
public ConcreateProtoType clone() {
try {
return (ConcreateProtoType) super.clone();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
//序列化
public ConcreateProtoType deepClone() {
try {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(this);
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
return (ConcreateProtoType) ois.readObject();
}catch (Exception e){
e.printStackTrace();
return null;
}
}
//通过JSON转换
public ConcreateProtoType deepCopyByJson(ConcreateProtoType obj) {
String json = JSON.toJSONString(obj);
return (ConcreateProtoType) JSON.parseObject(json, ConcreateProtoType.class);
}
@Override
public String toString() {
return "ConcreateProtoType{" +
"age=" + age +
", name='" + name + '\'' +
", hobnies=" + hobnies +
'}';
}
//测试
public class Client {
public static void main(String[] args) {
ConcreateProtoType protoType = new ConcreateProtoType();
protoType.setAge(18);
protoType.setName("萧炎");
List<String> hobbies = new ArrayList<>();
hobbies.add("看电影");
hobbies.add("打游戏");
protoType.setHobnies(hobbies);
//拷贝原型对象
// ConcreateProtoType clone = protoType.clone();
// ConcreateProtoType clone = protoType.deepClone();
ConcreateProtoType clone = protoType.deepCopyByJson(protoType);
clone.getHobnies().add("画画");
System.out.println("原型对象:"+protoType);
System.out.println("克隆对象:"+clone);
System.out.println(protoType==clone);
System.out.println("原型对象的爱好:"+protoType.getHobnies());
System.out.println("克隆对象的爱好:"+clone.getHobnies());
System.out.println(protoType.getHobnies()==clone.getHobnies());
}
}
原理:反射
单例和原型不可同时使用
单例是通过构造方法创建的
而原型不是,请往下看
//实体类
@Data
public class ConcreateProtoType implements Cloneable, Serializable {
private int age;
private String name;
private List<String> hobnies;
private ConcreateProtoType(){}
public static ConcreateProtoType concreateProtoType = new ConcreateProtoType();
public static ConcreateProtoType getInstance(){
return concreateProtoType;
}
//浅克隆
@Override
public ConcreateProtoType clone() {
try {
return (ConcreateProtoType) super.clone();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
//深克隆
public ConcreateProtoType deepClone() {
try {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(this);
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
return (ConcreateProtoType) ois.readObject();
}catch (Exception e){
e.printStackTrace();
return null;
}
}
//通过JSON转换
public ConcreateProtoType deepCopyByJson(ConcreateProtoType obj) {
String json = JSON.toJSONString(obj);
return (ConcreateProtoType) JSON.parseObject(json, ConcreateProtoType.class);
}
@Override
public String toString() {
return "ConcreateProtoType{" +
"age=" + age +
", name='" + name + '\'' +
", hobnies=" + hobnies +
'}';
}
//测试
public class Client {
public static void main(String[] args) {
ConcreateProtoType protoType = ConcreateProtoType.getInstance();
protoType.setAge(18);
protoType.setName("萧炎");
List<String> hobbies = new ArrayList<>();
hobbies.add("看电影");
hobbies.add("打游戏");
protoType.setHobnies(hobbies);
//拷贝原型对象
// ConcreateProtoType clone = protoType.clone();
// ConcreateProtoType clone = protoType.deepClone();
ConcreateProtoType clone = protoType.deepCopyByJson(protoType);
clone.getHobnies().add("画画");
System.out.println("原型对象:"+protoType);
System.out.println("克隆对象:"+clone);
System.out.println(protoType==clone);
System.out.println("原型对象的爱好:"+protoType.getHobnies());
System.out.println("克隆对象的爱好:"+clone.getHobnies());
System.out.println(protoType.getHobnies()==clone.getHobnies());
}
}
打印:
原型对象:ConcreateProtoType{age=18, name='萧炎', hobnies=[看电影, 打游戏]}
克隆对象:ConcreateProtoType{age=18, name='萧炎', hobnies=[看电影, 打游戏, 画画]}
false
原型对象的爱好:[看电影, 打游戏]
克隆对象的爱好:[看电影, 打游戏, 画画]
false
出现了两个实例--破坏了单例(自始至终只保持只有一个实例)
两个解决方法:
1.不能实现Cloneable接口
2.改造克隆方法
@Override
public ConcreateProtoType clone() {
return concreateProtoType;
}
总结:原型和单例本身就是冲突的,选择原型就不能选择单例,反之亦然
浅克隆是拷贝的引用
深克隆拷贝的是引用的值
- 深克隆在源码中的应用
1.ArrayList.clone()
2.HashMap.clone()
原型模式的优点
- 性能优良,java自带的原型模式是基于内存二进制流的拷贝,比直接new一个对象性能上提升了很多
- 可以使用深克隆方式保存对象的状态,使用原型模式将对象复制一份并将其状态保存起来,简化创建过程
原型模式的缺点
- 必须配备克隆(或者可拷贝)方法
- 当对已有类改造的时候,需要修改代码,违反了开闭原则
- 深拷贝、浅拷贝需要运用得当
建造者模式
- 建造者模式的适用场景
1.适用于创建对象需要很多步骤,但是步骤的顺序不一定固定
2.如果一个对象有非常复杂的内部结构(很多属性)
3.把复杂对象的创建和使用分离
//简单写法
//面向抽象编程 --定义简单接口
public interface IBuilder {
Course builder();
}
//定义课程类
@Data
public class Course {
private String name;
private String ppt;
private String video;
private String note;
private String homework;
@Override
public String toString() {
return "Course{" +
"name='" + name + '\'' +
", ppt='" + ppt + '\'' +
", video='" + video + '\'' +
", note='" + note + '\'' +
", homework='" + homework + '\'' +
'}';
}
}
//创建建造者
public class CourseBuilder implements IBuilder {
private Course course = new Course();
public void addName(String name){course.setName(name);}
public void addPPt(String ppt){course.setPpt(ppt);}
public void addVideo(String video){course.setVideo(video);}
public void addNote(String note){course.setNote(note);}
public void addHomework(String homework){course.setHomework(homework);}
@Override
public Course builder() {
return course;
}
}
//测试
public class Test {
public static void main(String[] args) {
CourseBuilder courseBuilder = new CourseBuilder();
courseBuilder.addName("设计模式");
courseBuilder.addHomework("课后作业");
System.out.println(courseBuilder.builder());
}
}
打印:
Course{name='设计模式', ppt='null', video='null', note='null', homework='课后作业'}
优化
//优化建造者
public class CourseBuilder implements IBuilder {
private Course course = new Course();
public CourseBuilder addName(String name){
course.setName(name);
return this;
}
public CourseBuilder addPPt(String ppt){
course.setPpt(ppt);
return this;
}
public CourseBuilder addVideo(String video){
course.setVideo(video);
return this;
}
public CourseBuilder addNote(String note){
course.setNote(note);
return this;
}
public CourseBuilder addHomework(String homework){
course.setHomework(homework);
return this;
}
@Override
public Course builder() {
return course;
}
}
//测试 链式编程
public class Test {
public static void main(String[] args) {
CourseBuilder courseBuilder = new CourseBuilder()
.addName("设计模式")
.addHomework("课后作业");
System.out.println(courseBuilder.builder());
}
}
打印:
Course{name='设计模式', ppt='null', video='null', note='null', homework='课后作业'}
建造者模式中链式编程应用的非常广泛,可以学习这种编程思想
源码应用
- StirngBuilder.append()
- Mybatis中CatchBuilder
- SqlSessionFactoryBuilder
- Spring中BeanDefinitionBuilder
建造者模式的优点
- 封装性好,创建和使用分离
- 扩展性好,建造类之间独立、一定程度上解耦
建造者模式的缺点
- 产生多余的builder对象
- 产品内部发生变化,建造者都要修改,成本较大
建造者模式和工厂模式的区别
- 建造者模式更加注重方法的调用顺序,工厂模式注重于创建对象
- 创建对象的力度不同,建造者模式创建复杂的对象,由各种复杂的部件组成,工厂模式创建出来的都一样
- 关注点:工厂模式只需要把对象创建出来就可以了,而建造者模式中不仅要创建出这个对象,还要知道这个对象由哪些部件组成
- 建造者模式根据建造过程中的顺序不一样,最终的对象部件组成也不一样