设计模式实战：原型模式实现场景对象的复制

/**
 * 场景超类
 * @author daijiyong
 */
abstract public class AbstractScene implements Cloneable, Serializable {
    /**
     * 场景名字
     */
    public SceneNameCode sceneNameCode;
    /**
     * 当前场景的匹配词
     */
    protected LinkedList<SceneMatchWord> matchWords;
    public AbstractScene() {
    }
    public AbstractScene(SceneNameCode sceneNameCode) {
        this.sceneNameCode = sceneNameCode;
    }
    /**
     * 对外统一处理操作，子类进行重写
     */
    public abstract String deal(String userInput);
    /**
     * 初始化操作，子类进行重写
     */
    protected abstract void init();
    /**
     * 根据用户输入与当前场景进行匹配
     *
     * @param userInput 用户输入内容
     * @return 匹配结果
     */
    public Boolean match(String userInput) {
        // TODO
        //  根据用户的输入进行匹配
        //  匹配成功则返回true，失败则返回false
        for (SceneMatchWord smw : matchWords) {
            if (smw.match(userInput)) {
                return true;
            }
        }
        return false;
    }
    /**
     * 深克隆
     *
     * @return 克隆结果
     */
    @Override
    public AbstractScene clone() {
        AbstractScene clone = null;
        try {
            clone = (AbstractScene) super.clone();
            ByteArrayOutputStream bo = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bo);
            oos.writeObject(this);
            ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
            ObjectInputStream oi = new ObjectInputStream(bi);
            clone = (AbstractScene) oi.readObject();
        } catch (IOException | ClassNotFoundException | CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return clone;
    }
}

public class NumberReverseQueryScene extends AbstractScene {
    public NumberReverseQueryScene(SceneNameCode sceneNameCode) {
        super(sceneNameCode);
        init();
    }
    @Override
    public String deal(String userInput) {
        // TODO
        //  当前场景对用户输入的具体实现
        //  并返回结果
        return String.format("%s处理用户的输入内容%s\n", sceneNameCode.getName(), userInput);
    }
    /**
     * 初始化当前场景数据
     */
    @Override
    public void init() {
        // 初始化匹配内容
        matchWords = new LinkedList<>();
        //5个或5个以上数字，不含字母，非1非0开头号码
        matchWords.add(new SceneMatchWord(Pattern.compile("[2-9]\\d{4,}")));
        //5个或5个以上数字，不含字母，1开头号码
        matchWords.add(new SceneMatchWord(Pattern.compile("1\\d{4,}")));
    }
}

/**
 * 场景匹配词
 *
 * @author daijiyong
 */
public class SceneMatchWord implements Serializable {
    // 匹配规则
    private Pattern rule;
    /**
     * 根据用户输入内容进行匹配
     * 匹配成功返回true，失败返回false
     *
     * @param userInput 用户输入
     * @return 匹配成功或失败
     */
    public Boolean match(String userInput) {
        return matchRule(userInput);
    }
    private boolean matchRule(String str) {
        if (rule == null) {
            return false;
        }
        return rule.matcher(str).find();
    }
}

public class SceneContext {
    private final static Map<String, AbstractScene> CONTEXT = new ConcurrentHashMap<>();
    private final static ArrayList<AbstractScene> SCENES = new ArrayList<>();
    static {
        // 初始化场景集合
        SCENES.add(SceneFactory.createNumberReverseQueryScene());
        SCENES.add(SceneFactory.createMoveCarScene());
        SCENES.add(SceneFactory.createAreaCodeReverseQueryScene());
    }
    public static AbstractScene currentScene(String queryId, String userInput) {
        if (getContext().get(queryId) == null && SCENES.size() > 0) {
            for (AbstractScene as : SCENES) {
                if (as.match(userInput)) {
                    CONTEXT.put(queryId, as.clone());
                    System.out.printf("用户%s匹配到场景：%s\n", queryId, as.sceneNameCode.getName());
                    return getContext().get(queryId);
                }
            }
        }
        return getContext().get(queryId);
    }
    public static Map<String, AbstractScene> getContext() {
        return CONTEXT;
    }
}

/*
   模拟入口程序
 */
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            // 输入两个内容，用户id和用户请求内容，中间用空格隔开
            String input = scanner.nextLine();
            String[] inputArr = input.split(" ");
            AbstractScene scene = SceneContext.currentScene(inputArr[0], inputArr[1]);
            System.out.println(scene.deal(inputArr[1]));
        }
    }
}