设计模式之原型模式

原型模式介绍

原型模式主要解决的是创建重复对象的问题，而这部分对象内容本身比较复杂，从数据库或者RPC框架获取相关对象数据的耗时较长，因此需要采用复制的方式节省时间。

原型模式简单使用

每个人都经历过考试，大部分情况都是在纸质的试卷上答题，随着互联网的兴起，也有一些考试改为上机考试。从时间效率和成本上看，上机考试可以大大降低哦按卷的人工成本，提高判分效率。上机考试还可以提高考试的公平性，将同样的题目混排，可以更好地降低抄袭的可能性，在这种情况下对应的答案也是混排。同样的试卷题目，如果是人工判卷，很难实现题目混排，但放在计算机上，无论是生成试卷还是判卷都能轻而易举的实现。

下面来实现这样的功能：同一张试卷、同样的题目、同样的答案，把题目和答案全部混排。

模拟场景

在模拟的场景：有选择题，解答题

选择题

package com.bestrookie.design;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Map;
/**
 * @author bestrookie
 * @date 2021/11/2 10:24 上午
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class ChoiceQuestion {
    private String name;
    private Map<String,String> option;
    private String key;

}

解答题

package com.bestrookie.design;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Map;
/**
 * @author bestrookie
 * @date 2021/11/2 10:21 上午
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class AnswerQuestion {
    private String name;
    private String key;
}

违背设计模式实现

首相想到就是一坨一坨的代码

package com.bestrookie.design;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
 * @author bestrookie
 * @date 2021/11/2 10:28 上午
 */
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>(16);
        map01.put("A","JAVA2 EE");
        map01.put("B","JAVA2 Card");
        map01.put("C","JAVA2 ME");
        map01.put("D","JAVA2 SE");
        Map<String, String> map02 = new HashMap<String, String>(16);
        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>(16);
        map03.put("A","变量由字母、下划线、数字、$符号随意组成");
        map03.put("B","变量不能以数字开头");
        map03.put("C","A和a在java中是同一个变量");
        map03.put("D","不同类型的变量，可以起相同的名字");
        Map<String, String> map04 = new HashMap<String, String>(16);
        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>(16);
        map04.put("A","31");
        map04.put("B","0");
        map04.put("C","1");
        map04.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");

        }
        detail.append("二、简答题"+"\r\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("答案："+answerQuestionList.get(idx).getKey()).append("\r\n\n");
        }
        return detail.toString();
    }
}

以上代码主要包括三部分：将选择题和问答题创建到集合中，定义详情字符串包装结果，返回结果内容。但从代码阅读上来说，这样的代码并不复杂，且更易于理解。因为就这段代码来说不是面向对象，而是面想过程，业务逻辑需要什么就直接写什么。不考虑扩展性，能跑就完事了。但是这段代码没有实现题目和答案乱序的功能，最终所有人的试卷都是一样的。如果需要增加混排题目功能，则代码时间就会非常混乱。

原型模式实现

原型主要解决的问题是创建大量的重复对象，而这里模拟的场景同样是需要给不同的考生创建相同的试卷，但在创建过程中，这些试卷的题目不应该每次都从数据库或者远程RPC接口中获取。这些操作都是非常耗时的，而且随着创建对象的增多，将严重降低创建效率。

ChoiceQuestion、AnswerQuestion被用在题库创建中；
Topic 是选项和正确答案组成的类
TopicRandomUtil 是将选项乱序
核心题库类QuestionBank主要负责将各个题目进行组装，最终输出试卷

Topic

package com.bestrookie.util;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Map;
/**
 * @author bestrookie
 * @date 2021/11/2 1:54 下午
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Topic {
    private Map<String,String> option;
    private String key;
}

TopicRandomUtil

package com.bestrookie.util;
import java.util.*;
/**
 * @author bestrookie
 * @date 2021/11/2 1:56 下午
 */
public class TopicRandomUtil {
    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>(16);
        int idx = 0;
        String newKey = "";
        for (String next : keySet) {
            String randomKey = keyList.get(idx++);
            if (key.equals(next)){
                newKey = randomKey;
            }
            optionNew.put(randomKey,option.get(next));
        }
        return new Topic(option,newKey);
    }
}

QuestionBank

package com.bestrookie;
import com.bestrookie.design.AnswerQuestion;
import com.bestrookie.design.ChoiceQuestion;
import com.bestrookie.util.Topic;
import com.bestrookie.util.TopicRandomUtil;
import lombok.Data;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Map;

/**
 * @author bestrookie
 * @date 2021/11/2 2:30 下午
 */
@Data
public class QuestionBank implements Cloneable{
    private String candidate;
    private String number;
    private ArrayList<AnswerQuestion> answerQuestionList = new ArrayList<AnswerQuestion>();
    private ArrayList<ChoiceQuestion> choiceQuestionList = new ArrayList<ChoiceQuestion>();
    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.answerQuestionList);
        Collections.shuffle(questionBank.choiceQuestionList);
        ArrayList<ChoiceQuestion> choiceQuestionList = questionBank.choiceQuestionList;
        for (ChoiceQuestion choiceQuestion : choiceQuestionList) {
            Topic random = TopicRandomUtil.random(choiceQuestion.getOption(), choiceQuestion.getKey());
            choiceQuestion.setOption(random.getOption());
            choiceQuestion.setKey(random.getKey());
        }
        return questionBank;
    }
    @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");
        }
        detail.append("二、简答题"+"\r\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("答案："+answerQuestionList.get(idx).getKey()).append("\r\n\n");
        }
        return detail.toString();
    }
}

这个类中的操作内容主要包括一下三个方面

两个append()对各项目的添加有点像在建造者模式中使用的方式-—添加装修材料
clone（）的核心是复制对象，这里的复制不仅包括对象本身，也包括两个集合。只有这样的复制才能确保在操作复制对象时不影响原对象
混排操作在list集合中有一个方法——Collections.shuffle,可以将原有集合的顺序打乱，输出一个新的顺序

InitQuestionBank

package com.bestrookie;


import com.bestrookie.design.AnswerQuestion;
import com.bestrookie.design.ChoiceQuestion;

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

/**
 * @author bestrookie
 * @date 2021/11/2 3:15 下午
 */
public class InitQuestionBank {
    private QuestionBank questionBank = new QuestionBank();
    public InitQuestionBank(){
        Map<String, String> map01 = new HashMap<String, String>(16);
        map01.put("A","JAVA2 EE");
        map01.put("B","JAVA2 Card");
        map01.put("C","JAVA2 ME");
        map01.put("D","JAVA2 SE");
        Map<String, String> map02 = new HashMap<String, String>(16);
        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>(16);
        map03.put("A","变量由字母、下划线、数字、$符号随意组成");
        map03.put("B","变量不能以数字开头");
        map03.put("C","A和a在java中是同一个变量");
        map03.put("D","不同类型的变量，可以起相同的名字");
        Map<String, String> map04 = new HashMap<String, String>(16);
        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>(16);
        map04.put("A","31");
        map04.put("B","0");
        map04.put("C","1");
        map04.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();
    }
}

总结

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