创造者模式：工厂方法、抽象工厂、生成器、原型、单例

这类模式提供创建对象的机制，能够提升已有代码的灵活性和可复用性

第四节、原型模式

一、原型模式介绍


原型模式主要解决的问题就是创建重复对象，而这部分对象内容本身比较复杂，生成过程可能从库或者RPC接口中获取数据的耗时较长，因此采用克隆的方式节省时间。

二、案例场景模拟

公平性的考试需求

在保证大家的公平性一样的题目下，开始出现试题混排，正确的答案选项也混排

需要时间上机考试抽题的业务，因此在这里创建一个题库题目的场景类信息。创建：选择题，问答题。

1.场景模拟工程


在这里只模拟了两种题目，选择题和问答题。

2.场景简述

2.1 选择题
package org.levtio.demo.design;

import java.util.Map;

/**
 * @Author: LuoMingDong
 * @Date: 2023/9/20  9:40
 * @Describe: 单选题
 */
public class ChoiceQuestion {
    private String name;
    private Map<String, String> option;
    private String key;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Map<String, String> getOption() {
        return option;
    }

    public void setOption(Map<String, String> option) {
        this.option = option;
    }

    public String getKey() {
        return key;
    }

    public void setKey(String key) {
        this.key = key;
    }

    public ChoiceQuestion() {
    }

    public ChoiceQuestion(String name, Map<String, String> option, String key) {
        this.name = name;
        this.option = option;
        this.key = key;
    }
}
2.2 问答题
package org.levtio.demo.design;

/**
 * @Author: LuoMingDong
 * @Date: 2023/9/20  9:42
 * @Describe: 解答题
 */
public class AnswerQuestion {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getKey() {
        return key;
    }

    public void setKey(String key) {
        this.key = key;
    }

    private String key;

    public AnswerQuestion() {
    }

    public AnswerQuestion(String name, String key) {
        this.name = name;
        this.key = key;
    }
}

三、使用一个类实现

1.工程结构

2.代码实现

package org.levtio.demo.design;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @Author: LuoMingDong
 * @Date: 2023/9/20  10:47
 * @Describe:
 */
public class QuestionBankController {
    public String createPaper(String candidate, String number) {

        List<ChoiceQuestion> choiceQuestionList = new ArrayList<ChoiceQuestion>();
        List<AnswerQuestion> answerQuestionList = new ArrayList<AnswerQuestion>();

        Map<String, String> map01 = new HashMap<String, String>();
        map01.put("A", "JAVA2 EE");
        map01.put("B", "JAVA2 Card");
        map01.put("C", "JAVA2 ME");
        map01.put("D", "JAVA2 HE");
        map01.put("E", "JAVA2 SE");

        Map<String, String> map02 = new HashMap<String, String>();
        map02.put("A", "JAVA程序的main方法必须写在类里面");
        map02.put("B", "JAVA程序中可以有多个main方法");
        map02.put("C", "JAVA程序中类名必须与文件名一样");
        map02.put("D", "JAVA程序的main方法中如果只有一条语句，可以不用{}(大括号)括起来");

        Map<String, String> map03 = new HashMap<String, String>();
        map03.put("A", "变量由字母、下划线、数字、$符号随意组成；");
        map03.put("B", "变量不能以数字作为开头；");
        map03.put("C", "A和a在java中是同一个变量；");
        map03.put("D", "不同类型的变量，可以起相同的名字；");

        Map<String, String> map04 = new HashMap<String, String>();
        map04.put("A", "STRING");
        map04.put("B", "x3x;");
        map04.put("C", "void");
        map04.put("D", "de$f");

        Map<String, String> map05 = new HashMap<String, String>();
        map05.put("A", "31");
        map05.put("B", "0");
        map05.put("C", "1");
        map05.put("D", "2");

        choiceQuestionList.add(new ChoiceQuestion("JAVA所定义的版本中不包括", map01, "D"));
        choiceQuestionList.add(new ChoiceQuestion("下列说法正确的是", map02, "A"));
        choiceQuestionList.add(new ChoiceQuestion("变量命名规范说法正确的是", map03, "B"));
        choiceQuestionList.add(new ChoiceQuestion("以下()不是合法的标识符", map04, "C"));
        choiceQuestionList.add(new ChoiceQuestion("表达式(11+3*8)/4%3的值是", map05, "D"));
        answerQuestionList.add(new AnswerQuestion("小红马和小黑马生的小马几条腿", "4条腿"));
        answerQuestionList.add(new AnswerQuestion("铁棒打头疼还是木棒打头疼", "头最疼"));
        answerQuestionList.add(new AnswerQuestion("什么床不能睡觉", "牙床"));
        answerQuestionList.add(new AnswerQuestion("为什么好马不吃回头草", "后面的草没了"));

        // 输出结果
        StringBuilder detail = new StringBuilder("考生：" + candidate + "\r\n" +
                "考号：" + number + "\r\n" +
                "--------------------------------------------\r\n" +
                "一、选择题" + "\r\n\n");

        for (int idx = 0; idx < choiceQuestionList.size(); idx++) {
            detail.append("第").append(idx + 1).append("题：").append(choiceQuestionList.get(idx).getName()).append("\r\n");
            Map<String, String> option = choiceQuestionList.get(idx).getOption();
            for (String key : option.keySet()) {
                detail.append(key).append("：").append(option.get(key)).append("\r\n");
                ;
            }
            detail.append("答案：").append(choiceQuestionList.get(idx).getKey()).append("\r\n\n");
        }

        detail.append("二、问答题" + "\r\n\n");

        for (int idx = 0; idx < answerQuestionList.size(); idx++) {
            detail.append("第").append(idx + 1).append("题：").append(answerQuestionList.get(idx).getName()).append("\r\n");
            detail.append("答案：").append(answerQuestionList.get(idx).getKey()).append("\r\n\n");
        }

        return detail.toString();
    }
}

以上代码主要包含三部分，首先创建选择题和问答题到集合中，定义详情字符串包装结果、返回结果内容。

3.测试验证

编写测试类：

package org.levtio.demo.design.test;

import org.junit.Test;
import org.levtio.demo.design.QuestionBankController;

/**
 * @Author: LuoMingDong
 * @Date: 2023/9/20  10:49
 * @Describe:
 */
public class ApiTest {
    @Test
    public void test_QuestionBankController() {
        QuestionBankController questionBankController = new QuestionBankController();
        System.out.println(questionBankController.createPaper("lev", "1000001921032"));
        System.out.println(questionBankController.createPaper("tio", "1000001921051"));
        System.out.println(questionBankController.createPaper("eric", "1000001921987"));
    }
}

测试结果：

考生：lev
考号：1000001921032
--------------------------------------------
一、选择题

第1题：JAVA所定义的版本中不包括
A：JAVA2 EE
B：JAVA2 Card
C：JAVA2 ME
D：JAVA2 HE
E：JAVA2 SE
答案：D

第2题：下列说法正确的是
A：JAVA程序的main方法必须写在类里面
B：JAVA程序中可以有多个main方法
C：JAVA程序中类名必须与文件名一样
D：JAVA程序的main方法中如果只有一条语句，可以不用{}(大括号)括起来
答案：A

第3题：变量命名规范说法正确的是
A：变量由字母、下划线、数字、$符号随意组成；
B：变量不能以数字作为开头；
C：A和a在java中是同一个变量；
D：不同类型的变量，可以起相同的名字；
答案：B

第4题：以下()不是合法的标识符
A：STRING
B：x3x;
C：void
D：de$f
答案：C

第5题：表达式(11+3*8)/4%3的值是
A：31
B：0
C：1
D：2
答案：D

二、问答题

第1题：小红马和小黑马生的小马几条腿
答案：4条腿

第2题：铁棒打头疼还是木棒打头疼
答案：头最疼

第3题：什么床不能睡觉
答案：牙床

第4题：为什么好马不吃回头草
答案：后面的草没了


考生：tio
考号：1000001921051
--------------------------------------------
一、选择题

第1题：JAVA所定义的版本中不包括
A：JAVA2 EE
B：JAVA2 Card
C：JAVA2 ME
D：JAVA2 HE
E：JAVA2 SE
答案：D

第2题：下列说法正确的是
A：JAVA程序的main方法必须写在类里面
B：JAVA程序中可以有多个main方法
C：JAVA程序中类名必须与文件名一样
D：JAVA程序的main方法中如果只有一条语句，可以不用{}(大括号)括起来
答案：A

第3题：变量命名规范说法正确的是
A：变量由字母、下划线、数字、$符号随意组成；
B：变量不能以数字作为开头；
C：A和a在java中是同一个变量；
D：不同类型的变量，可以起相同的名字；
答案：B

第4题：以下()不是合法的标识符
A：STRING
B：x3x;
C：void
D：de$f
答案：C

第5题：表达式(11+3*8)/4%3的值是
A：31
B：0
C：1
D：2
答案：D

二、问答题

第1题：小红马和小黑马生的小马几条腿
答案：4条腿

第2题：铁棒打头疼还是木棒打头疼
答案：头最疼

第3题：什么床不能睡觉
答案：牙床

第4题：为什么好马不吃回头草
答案：后面的草没了


考生：eric
考号：1000001921987
--------------------------------------------
一、选择题

第1题：JAVA所定义的版本中不包括
A：JAVA2 EE
B：JAVA2 Card
C：JAVA2 ME
D：JAVA2 HE
E：JAVA2 SE
答案：D

第2题：下列说法正确的是
A：JAVA程序的main方法必须写在类里面
B：JAVA程序中可以有多个main方法
C：JAVA程序中类名必须与文件名一样
D：JAVA程序的main方法中如果只有一条语句，可以不用{}(大括号)括起来
答案：A

第3题：变量命名规范说法正确的是
A：变量由字母、下划线、数字、$符号随意组成；
B：变量不能以数字作为开头；
C：A和a在java中是同一个变量；
D：不同类型的变量，可以起相同的名字；
答案：B

第4题：以下()不是合法的标识符
A：STRING
B：x3x;
C：void
D：de$f
答案：C

第5题：表达式(11+3*8)/4%3的值是
A：31
B：0
C：1
D：2
答案：D

二、问答题

第1题：小红马和小黑马生的小马几条腿
答案：4条腿

第2题：铁棒打头疼还是木棒打头疼
答案：头最疼

第3题：什么床不能睡觉
答案：牙床

第4题：为什么好马不吃回头草
答案：后面的草没了

四、原型模式重构代码

原型模式主要解决的问题就是创建大量重复的类

在原型模式中所需要的非常重要的手段就是克隆，在需要用到克隆的类中都需要实现implements Cloneable接口

1.工程结构

原型模式工程结构

原型模式模型结构

  1. 工程中包括了核心的题库类QuestionBank，题库中主要负责将各个的题目进行组装最终输出试卷。
  2. 针对每一个试卷都会使用克隆的方式进行复制，复制完成后将试卷中题目以及每个题目的答案进行乱序处理。
  3. 乱序功能使用工具包：TopicRandomUtil

2.代码实现

2.1题目选项乱序操作工具包
package org.levtio.demo.design.util;

import java.util.*;

/**
 * @Author: LuoMingDong
 * @Date: 2023/9/20  11:12
 * @Describe:
 */
public class TopicRandomUtil {
    /**
     * 乱序Map元素，记录对应答案key
     * @param option 题目
     * @param key    答案
     * @return Topic 乱序后 {A=c., B=d., C=a., D=b.}
     */
    static public Topic random(Map<String, String> option, String key) {
        Set<String> keySet = option.keySet();
        ArrayList<String> keyList = new ArrayList<String>(keySet);
        Collections.shuffle(keyList);
        HashMap<String, String> optionNew = new HashMap<String, String>();
        int idx = 0;
        String keyNew = "";
        for (String next : keySet) {
            String randomKey = keyList.get(idx++);
            if (key.equals(next)) {
                keyNew = randomKey;
            }
            optionNew.put(randomKey, option.get(next));
        }
        return new Topic(optionNew, keyNew);
    }
}

这个工具类的操作就是将原有Map中的选型乱序操作，也就是A的选项内容给B，B的可能给C，同事记录正确答案在处理后的位置信息。

2.2克隆对象处理类
package org.levtio.demo.design;

import org.levtio.demo.design.util.Topic;
import org.levtio.demo.design.util.TopicRandomUtil;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Map;

/**
 * @Author: LuoMingDong
 * @Date: 2023/9/20  11:11
 * @Describe:
 */
public class QuestionBank implements Cloneable{
    private String candidate;
    private String number;
    private ArrayList<ChoiceQuestion> choiceQuestionList = new ArrayList<>();
    private ArrayList<AnswerQuestion> answerQuestionList = new ArrayList<>();
    public QuestionBank append(ChoiceQuestion choiceQuestion){
        choiceQuestionList.add(choiceQuestion);
        return this;
    }
    public QuestionBank append(AnswerQuestion answerQuestion){
        answerQuestionList.add(answerQuestion);
        return this;
    }
    @Override
    public Object clone() throws CloneNotSupportedException{
        QuestionBank questionBank = (QuestionBank) super.clone();
        questionBank.choiceQuestionList = (ArrayList<ChoiceQuestion>) choiceQuestionList.clone();
        questionBank.answerQuestionList = (ArrayList<AnswerQuestion>) answerQuestionList.clone();

        // 题目乱序
        Collections.shuffle(questionBank.choiceQuestionList);
        Collections.shuffle(questionBank.answerQuestionList);
        // 答案乱序
        ArrayList<ChoiceQuestion> choiceQuestionList = questionBank.choiceQuestionList;
        for (ChoiceQuestion question:
             choiceQuestionList) {
            Topic random = TopicRandomUtil.random(question.getOption(), question.getKey());
            question.setOption(random.getOption());
            question.setKey(random.getKey());
        }
        return questionBank;
    }

    public void setCandidate(String candidate) {
        this.candidate = candidate;
    }

    public void setNumber(String number) {
        this.number = number;
    }
    @Override
    public String toString(){
        StringBuilder detail = new StringBuilder("考生：" + candidate + "\r\n" +
                "考号：" + number + "\r\n" +
                "--------------------------------------------\r\n" +
                "一、选择题" + "\r\n\n");
        for (int idx = 0; idx < choiceQuestionList.size(); idx++) {
            detail.append("第").append(idx+1).append("题：").append(choiceQuestionList.get(idx).getName()).append("\r\n");
            Map<String, String> option = choiceQuestionList.get(idx).getOption();
            for (String key:
                 option.keySet()) {
                detail.append(key).append("：").append(option.get(key)).append("\r\n");
            }
            detail.append("答案：").append(choiceQuestionList.get(idx).getKey()).append("\r\n\n");
        }
        detail.append("二、问答题"+"\r\n\n");
        for (int idx = 0; idx < answerQuestionList.size(); idx++) {
            detail.append("第").append(idx + 1).append("题：").append(answerQuestionList.get(idx).getName()).append("\r\n");
            detail.append("答案：").append(answerQuestionList.get(idx).getKey()).append("\r\n\n");
        }

        return detail.toString();
    }
}

这段代码的主要操作有三个，分别是：

  1. 两个**append()**，对各项题目的添加，有点像我们在建造者模式中使用的方式，添加装修物料。
  2. **clone()**，这里的核心操作就是对对象的复制，这里的肤质不只是包括了本身，同事对两个集合也做了复制。只有这样的拷贝才能确保操作克隆对象的时候不影响原对象。
  3. 乱序操作，在list集合中有一个方法Collections.shuffle，可以将原有集合的顺序打乱，输出一个新的顺序。
2.4初始化试卷数据
package org.levtio.demo.design;

import java.util.HashMap;
import java.util.Map;

/**
 * @Author: LuoMingDong
 * @Date: 2023/9/20  11:45
 * @Describe:
 */
public class QuestionBankController {
    private QuestionBank questionBank = new QuestionBank();

    public QuestionBankController() {

        Map<String, String> map01 = new HashMap<String, String>();
        map01.put("A", "JAVA2 EE");
        map01.put("B", "JAVA2 Card");
        map01.put("C", "JAVA2 ME");
        map01.put("D", "JAVA2 HE");
        map01.put("E", "JAVA2 SE");

        Map<String, String> map02 = new HashMap<String, String>();
        map02.put("A", "JAVA程序的main方法必须写在类里面");
        map02.put("B", "JAVA程序中可以有多个main方法");
        map02.put("C", "JAVA程序中类名必须与文件名一样");
        map02.put("D", "JAVA程序的main方法中如果只有一条语句，可以不用{}(大括号)括起来");

        Map<String, String> map03 = new HashMap<String, String>();
        map03.put("A", "变量由字母、下划线、数字、$符号随意组成；");
        map03.put("B", "变量不能以数字作为开头；");
        map03.put("C", "A和a在java中是同一个变量；");
        map03.put("D", "不同类型的变量，可以起相同的名字；");

        Map<String, String> map04 = new HashMap<String, String>();
        map04.put("A", "STRING");
        map04.put("B", "x3x;");
        map04.put("C", "void");
        map04.put("D", "de$f");

        Map<String, String> map05 = new HashMap<String, String>();
        map05.put("A", "31");
        map05.put("B", "0");
        map05.put("C", "1");
        map05.put("D", "2");

        questionBank.append(new ChoiceQuestion("JAVA所定义的版本中不包括", map01, "D"))
                .append(new ChoiceQuestion("下列说法正确的是", map02, "A"))
                .append(new ChoiceQuestion("变量命名规范说法正确的是", map03, "B"))
                .append(new ChoiceQuestion("以下()不是合法的标识符",map04, "C"))
                .append(new ChoiceQuestion("表达式(11+3*8)/4%3的值是", map05, "D"))
                .append(new AnswerQuestion("小红马和小黑马生的小马几条腿", "4条腿"))
                .append(new AnswerQuestion("铁棒打头疼还是木棒打头疼", "头最疼"))
                .append(new AnswerQuestion("什么床不能睡觉", "牙床"))
                .append(new AnswerQuestion("为什么好马不吃回头草", "后面的草没了"));
    }

    public String createPaper(String candidate, String number) throws CloneNotSupportedException {
        QuestionBank questionBankClone = (QuestionBank) questionBank.clone();
        questionBankClone.setCandidate(candidate);
        questionBankClone.setNumber(number);
        return questionBankClone.toString();
    }
}
  1. 主要提供对试卷内容的模式初始化操作。
  2. 创建的时候使用克隆方式

3.测试验证

编写测试类：

package org.levtio.demo.design.test;

import org.junit.Test;
import org.levtio.demo.design.QuestionBankController;

/**
 * @Author: LuoMingDong
 * @Date: 2023/9/20  11:48
 * @Describe:
 */
public class ApiTest {
    @Test
    public void test_QuestionBank() throws CloneNotSupportedException {
        QuestionBankController questionBankController = new QuestionBankController();
        System.out.println(questionBankController.createPaper("花花", "1000001921032"));
        System.out.println(questionBankController.createPaper("豆豆", "1000001921051"));
        System.out.println(questionBankController.createPaper("大宝", "1000001921987"));
    }
}

测试结果：

考生：lev
考号：1000001921032
--------------------------------------------
一、选择题

第1题：以下()不是合法的标识符
A：de$f
B：void
C：STRING
D：x3x;
答案：B

第2题：JAVA所定义的版本中不包括
A：JAVA2 HE
B：JAVA2 SE
C：JAVA2 EE
D：JAVA2 ME
E：JAVA2 Card
答案：A

第3题：下列说法正确的是
A：JAVA程序的main方法中如果只有一条语句，可以不用{}(大括号)括起来
B：JAVA程序中类名必须与文件名一样
C：JAVA程序的main方法必须写在类里面
D：JAVA程序中可以有多个main方法
答案：C

第4题：表达式(11+3*8)/4%3的值是
A：0
B：2
C：31
D：1
答案：B

第5题：变量命名规范说法正确的是
A：变量由字母、下划线、数字、$符号随意组成；
B：变量不能以数字作为开头；
C：A和a在java中是同一个变量；
D：不同类型的变量，可以起相同的名字；
答案：B

二、问答题

第1题：小红马和小黑马生的小马几条腿
答案：4条腿

第2题：什么床不能睡觉
答案：牙床

第3题：铁棒打头疼还是木棒打头疼
答案：头最疼

第4题：为什么好马不吃回头草
答案：后面的草没了


考生：tio
考号：1000001921051
--------------------------------------------
一、选择题

第1题：以下()不是合法的标识符
A：STRING
B：de$f
C：x3x;
D：void
答案：D

第2题：表达式(11+3*8)/4%3的值是
A：31
B：1
C：0
D：2
答案：D

第3题：下列说法正确的是
A：JAVA程序的main方法中如果只有一条语句，可以不用{}(大括号)括起来
B：JAVA程序中可以有多个main方法
C：JAVA程序的main方法必须写在类里面
D：JAVA程序中类名必须与文件名一样
答案：C

第4题：JAVA所定义的版本中不包括
A：JAVA2 HE
B：JAVA2 SE
C：JAVA2 ME
D：JAVA2 EE
E：JAVA2 Card
答案：A

第5题：变量命名规范说法正确的是
A：A和a在java中是同一个变量；
B：变量不能以数字作为开头；
C：变量由字母、下划线、数字、$符号随意组成；
D：不同类型的变量，可以起相同的名字；
答案：B

二、问答题

第1题：小红马和小黑马生的小马几条腿
答案：4条腿

第2题：什么床不能睡觉
答案：牙床

第3题：铁棒打头疼还是木棒打头疼
答案：头最疼

第4题：为什么好马不吃回头草
答案：后面的草没了


考生：eric
考号：1000001921987
--------------------------------------------
一、选择题

第1题：变量命名规范说法正确的是
A：A和a在java中是同一个变量；
B：变量由字母、下划线、数字、$符号随意组成；
C：变量不能以数字作为开头；
D：不同类型的变量，可以起相同的名字；
答案：C

第2题：下列说法正确的是
A：JAVA程序的main方法中如果只有一条语句，可以不用{}(大括号)括起来
B：JAVA程序中类名必须与文件名一样
C：JAVA程序中可以有多个main方法
D：JAVA程序的main方法必须写在类里面
答案：D

第3题：以下()不是合法的标识符
A：STRING
B：void
C：de$f
D：x3x;
答案：B

第4题：JAVA所定义的版本中不包括
A：JAVA2 EE
B：JAVA2 SE
C：JAVA2 HE
D：JAVA2 Card
E：JAVA2 ME
答案：C

第5题：表达式(11+3*8)/4%3的值是
A：0
B：2
C：31
D：1
答案：B

二、问答题

第1题：铁棒打头疼还是木棒打头疼
答案：头最疼

第2题：为什么好马不吃回头草
答案：后面的草没了

第3题：什么床不能睡觉
答案：牙床

第4题：小红马和小黑马生的小马几条腿
答案：4条腿

选择题乱排序功能也实现了。

五、总结

  1. 原型模式的使用频率不是很高。
  2. 优点：便于通过克隆方式创建复杂对象，也可以避免重复做初始化操作，不需要与类中所属的其他类耦合等。
  3. 缺点：如果对象中包括了循环引用的克隆，以及类中深度使用对象的克隆，都会使此模式变的异常麻烦