设计模式之原型模式与建造者模式

目标

• 掌握原型模式和建造者模式的应用场景
• 掌握原型模式的浅克隆和深克隆的写法
• 掌握建造者模式的基本写法
• 了解克隆是如何破坏单例的
• 了解原型模式的优缺点
• 掌握建造者模式和工厂模式的区别

原型模式的定义

• 原型模式是指原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象
• 调用者不需要知道任何创建的细节，不调用构造函数
• 属于创建型模式

原型模式的适用场景

• 类初始化消耗资源较多
• 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对象
• 产品内部发生变化，建造者都要修改，成本较大

建造者模式和工厂模式的区别

• 建造者模式更加注重方法的调用顺序，工厂模式注重于创建对象
• 创建对象的力度不同，建造者模式创建复杂的对象，由各种复杂的部件组成，工厂模式创建出来的都一样
• 关注点：工厂模式只需要把对象创建出来就可以了，而建造者模式中不仅要创建出这个对象，还要知道这个对象由哪些部件组成
• 建造者模式根据建造过程中的顺序不一样，最终的对象部件组成也不一样