侧边栏壁纸
博主头像
qingtian博主等级

喜欢是一件细水流长的事,是永不疲惫的双向奔赴~!

  • 累计撰写 85 篇文章
  • 累计创建 40 个标签
  • 累计收到 0 条评论

设计模式之原型模式

qingtian
2020-11-05 / 0 评论 / 0 点赞 / 405 阅读 / 15,975 字 / 正在检测是否收录...
温馨提示:
本文最后更新于 2020-12-31,若内容或图片失效,请留言反馈。部分素材来自网络,若不小心影响到您的利益,请联系我们删除。

设计模式之原型模式

来源自《重学Java设计模式》链接提取码:ytc3

原型模式

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

案例场景模拟

思考为了保证考试的公平性,现采取将题库中的题进行试题混排的需求,该如何完成?

因为需要实现一个上机考试抽题的服务,因此在这里建造一个题库题目的场景类信息,用于创建;选择题问答题

选择题

/**
 * 单选题
 */
public class ChoiceQuestion {

    private String name;                 // 题目
    private Map<String, String> option;  // 选项;A、B、C、D
    private String key;                  // 答案;B

    public ChoiceQuestion() {
    }

    public ChoiceQuestion(String name, Map<String, String> option, String key) {
        this.name = name;
        this.option = option;
        this.key = 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 class AnswerQuestion {

    private String name;  // 问题
    private String key;   // 答案

    public AnswerQuestion() {
    }

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

    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;
    }
}

面向过程,不使用设计模式解决:

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();
    }

}

测试使用:

public class ApiTest {

    @Test
    public void test_QuestionBankController() {
        QuestionBankController questionBankController = new QuestionBankController();
        System.out.println(questionBankController.createPaper("花花", "1000001921032"));
        System.out.println(questionBankController.createPaper("豆豆", "1000001921051"));
        System.out.println(questionBankController.createPaper("大宝", "1000001921987"));
    }

}

result

考生:花花
考号: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题:为什么好马不吃回头草
答案:后面的草没了


考生:豆豆
考号: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题:为什么好马不吃回头草
答案:后面的草没了


考生:大宝
考号: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题:为什么好马不吃回头草
答案:后面的草没了

可以看见我们并未实现乱序的目的!

而且以上代码非常难以扩展,随着题目的不断增加以及乱序功能的补充,都会让这段代码变得越来越混乱。

使用原型模式重构代码

原型模式主要解决的问题就是创建大量重复的类,而我们模拟的场景就需要给不同的用户都创建相同的试卷,但这些试卷的题目不便于每次都从库中获取,甚至有时候需要从远程的RPC中获取。这样都是非常耗时的,而且随着创建对象的增多将严重影响效率。

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

原型模式结构模型

2020-11-05_113845

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

代码实现

工具类TopicRandomUtil

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);
    }

}

克隆对象处理类

public class QuestionBank implements Cloneable {

    private String candidate; // 考生
    private String number;    // 考号

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

    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();
    }

}

这里的主要操作内容有三个,分别是;

  • 两个append(),对各项题目的添加,有点像我们在建造者模式中使用的方式,添加装修物料。
  • clone(),这里的核心操作就是对对象的复制,这里的复制不只是包括了本身,同时对两个集合也做了复制。只有这样的拷贝才能确保在操作克隆对象的时候不影响原对象。
  • 乱序操作,在list集合中有一个方法,Collection.shuffle,可以将原有集合的顺序打乱,输出一个新的顺序。在这里我们使用此方法对题目进行乱序操作。

初始化试卷数据

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();
    }

}
  • 对外部提供创建试卷的方法,在创建的过程中使用的是克隆的方式;(QuestionBank) questionBank.clone();,并最终返回试卷信息。

测试验证

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"));
    }

}

result

考生:花花
考号:1000001921032
--------------------------------------------
一、选择题

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

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

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

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

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

二、问答题

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

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

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

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


考生:豆豆
考号:1000001921051
--------------------------------------------
一、选择题

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

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

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

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

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

二、问答题

第1题:什么床不能睡觉
答案:牙床

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

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

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


考生:大宝
考号:1000001921987
--------------------------------------------
一、选择题

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

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

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

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

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

二、问答题

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

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

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

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

总结

  • 以上的实际场景模拟了原型模式在开发中的重构的作用。但是原型模式的使用频率确实不是很高。如果有一些特殊场景需要用到,也可以按照此设计模式进行优化。
  • 另外原型模式的优点包括;便于通过克隆方式创建复杂对象、也可以避免重复做初始化操作、不需要与类中所属的其他类耦合等。但也有一些缺点如果对象中包括了循环引用的克隆,以及类中深度使用对象的克隆,都会是此模式变得异常麻烦。
  • 设计模式是一整套的思想,在不同的场景合理的运用可以提升整体的架构的质量。永远不要想着去硬凑设计模式。否则将会引起过度设计。以及在承接业务反复变化的需求时造成浪费的开发和维护成本。
  • 初期是代码的优化,中期是设计模式的使用,后期是把控全局服务的搭建。
0

评论区