# demo2 **Repository Path**: webturing/demo2 ## Basic Information - **Project Name**: demo2 - **Description**: No description available - **Primary Language**: Java - **License**: MIT - **Default Branch**: master - **Homepage**: None - **GVP Project**: No ## Statistics - **Stars**: 0 - **Forks**: 0 - **Created**: 2025-05-26 - **Last Updated**: 2026-05-26 ## Categories & Tags **Categories**: Uncategorized **Tags**: None ## README # 基于SSM的越算越聪明的24点小游戏开发 ## 1. 项目概述 ### 1.1 项目简介 这是一个基于Spring + SpringMVC + MyBatis框架开发的24点小游戏，核心特点是**越算越聪明**——通过数据库缓存和动态学习机制，随着使用次数增加，求解速度越来越快。 ### 1.2 核心亮点 - 🧠 **越算越聪明**：通过责任链模式 + 数据库缓存，首次计算后存入数据库，再次遇到直接快速查询 - 🎯 **多种求解策略**：随机搜索、暴力搜索、AI智能搜索，效率逐级提升 - 📦 **数据库学习**：自动保存求解结果，建立24点云题库，后续计算直接查表 - 🔧 **工程化设计**：MVC模式、单例模式、责任链模式，代码结构清晰易扩展 ### 1.3 技术栈 - **后端框架**：Spring 5.2 + SpringMVC 5.2 + MyBatis 3.5 - **数据库**：MySQL 5.7+ - **Web容器**：Tomcat 8+ - **JDK版本**：1.8 - **构建工具**：Maven - **版本控制**：Git ### 1.4 项目结构 ``` project/ ├── src/main/ │ ├── java/demo2/ │ │ ├── controller/ # 控制层 │ │ │ ├── StartGameController.java # 随机开始 │ │ │ ├── InputDataController.java # 输入数据 │ │ │ ├── SolveGameController.java # 求解游戏 │ │ │ ├── SaveDataController.java # 保存数据 │ │ │ └── QueryDBController.java # 查询数据库 │ │ ├── service/ # 业务层 │ │ │ ├── Point24Service.java │ │ │ └── Point24ServiceImpl.java │ │ ├── mapper/ # 数据层 │ │ │ ├── Point24Mapper.java │ │ │ └── Point24.xml │ │ ├── pojo/ # 实体类 │ │ │ └── Point24.java │ │ ├── util/ # 工具类 │ │ │ ├── Game.java # 游戏核心类(单例) │ │ │ ├── GameHandler.java # 责任链接口 │ │ │ ├── QueryDBGameHandler.java # 数据库查询 │ │ │ ├── RandomGameHandler.java # 随机搜索 │ │ │ ├── BruteGameHandler.java # 暴力搜索 │ │ │ └── ai/ # AI算法 │ │ │ ├── Searcher.java # 搜索器接口 │ │ │ ├── BruteSearcher.java # 暴力搜索实现 │ │ │ ├── RandomSearcher.java # 随机搜索实现 │ │ │ ├── Canto.java # 康托展开 │ │ │ └── Permutation2DFS.java # 全排列DFS │ │ └── parser/ # 表达式解析 │ │ ├── BinaryTree.java # 二叉树表达式 │ │ └── OperatorPriority.java # 运算符优先级 │ ├── resources/ │ │ ├── applicationContext.xml # Spring配置 │ │ └── springMVC.xml # SpringMVC配置 │ └── webapp/WEB-INF/ │ ├── web.xml # Web配置 │ └── jsp/ │ └── index.jsp # 主页面 └── pom.xml # Maven配置 ``` --- ## 2. 核心功能 ### 2.1 功能模块 | 功能 | 说明 | |------|------| | 随机产生 | 随机生成4个1-9的数字 | | 输入数据 | 用户手动输入4个数字 | | 快速求解 | 通过责任链模式智能求解 | | 存数据库 | 将解保存到数据库，下次直接查询 | | 结果展示 | 展示所有可能的24点解法 | ### 2.2 核心流程 ``` 用户输入数字 ↓ 责任链开始处理 ↓ 【第一步】QueryDBGameHandler：查询数据库（越算越聪明的关键） ↓ 命中缓存？ 是 → 直接返回结果 ✨ 速度极快 否 → 进入下一环 ↓ 【第二步】RandomGameHandler：随机搜索（快速尝试） ↓ 找到解？ 是 → 返回结果 否 → 进入下一环 ↓ 【第三步】BruteGameHandler：暴力搜索（穷举所有可能） ↓ 找到解？ 是 → 返回结果 否 → 无解 ↓ 结果展示 + 存入数据库（为下次学习做准备） ``` --- ## 3. "越算越聪明"的实现原理 ### 3.1 责任链模式 ```java public interface GameHandler { void handleRequest(); // 处理请求 void setNextHandler(GameHandler nextHandler); // 设置下一环节 boolean solve(); // 求解 } ``` ### 3.2 数据库查询处理器（第一环） ```java public class QueryDBGameHandler implements GameHandler { @Override public boolean solve() { // 先排序，减少hash冲突，提高查询效率 List list = Game.getInstance().getDigits().subList(0, 4); Collections.sort(list); // 查询数据库 List result = point24Service.list(list.toString()); // 命中缓存，直接返回 if (!result.isEmpty()) { Game.getInstance().getSolution().add(result.get(0).toString()); return true; // ✨ 快速返回，不用重新计算 } return false; // 未命中，进入下一环节 } } ``` ### 3.3 暴力搜索处理器（最后一环） ```java public class BruteGameHandler implements GameHandler { @Override public boolean solve() { // 使用康拓展开进行全排列枚举 // 4! * 4^3 * 5 = 24 * 64 * 5 = 7680 种可能 solutions = new BruteSearcher().searchAll(arr); Game.getInstance().setSolution(solutions); return !solutions.isEmpty(); } } ``` ### 3.4 数据持久化（学习过程） ```java @RequestMapping("save") public ModelAndView save() { List list = game.getDigits().subList(0, 4); Collections.sort(list); // 查询已有的解 List cs = point24Service.list(list.toString()); // 保存新解（去重） for (String sol : game.getSolution()) { Point24 point24 = new Point24(); point24.setNumbers(list.toString()); point24.setSolution(sol); if (!cs.contains(point24)) { point24Service.add(point24); // 存入数据库 } } } ``` --- ## 4. 核心算法设计 ### 4.1 后缀表达式计算（栈的应用） ```java private static double eval(String[] exp) { Stack S = new Stack<>(); for (String tok : exp) { if (isNumber(tok)) { S.push(Double.parseDouble(tok)); } else { if(S.size() < 2) return ERROR; double b = S.pop(); double a = S.pop(); double c = calculate(a, b, tok); S.push(c); } } return S.size() == 1 ? S.peek() : ERROR; } ``` ### 4.2 从后缀式到中缀式（二叉树中序遍历） ```java // 构建二叉树 static BinaryTree createBinaryTree(List exp) { Stack S = new Stack<>(); for (String tok : exp) { if (isNumber(tok)) { S.push(new BinaryTree(tok)); } else { BinaryTree right = S.pop(); BinaryTree left = S.pop(); S.push(new BinaryTree(tok, left, right)); } } return S.peek(); } // 中序遍历生成中缀表达式（带括号） void midVisit(StringBuffer buffer) { buffer.append("("); if(left != null) left.midVisit(buffer); buffer.append(root); if(right != null) right.midVisit(buffer); buffer.append(")"); } ``` ### 4.3 康拓展开（全排列生成） ```java static final int FAC[] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880}; public static int[] codel(int x, int m) { int[] label = new int[m]; int[] n = new int[m]; for (int i = 0; i < m; i++) label[i] = 1; for (int i = 0; i < m; i++) { int cnt = x / FAC[m - 1 - i]; x = x % FAC[m - 1 - i]; for (int j = 0; j < m; j++) { if (label[j] == 0) continue; if (cnt == 0) { label[j] = 0; n[i] = j; break; } cnt--; } } return n; } ``` ### 4.4 高效枚举（5种二叉树形态） 4个运算数 + 3个运算符，只有5种合法的二叉树形态： ``` 1. {a, b, X, c, Y, d, Z} 2. {a, b, c, X, Y, d, Z} 3. {a, b, X, c, d, Y, Z} 4. {a, b, c, X, d, Y, Z} 5. {a, b, c, d, X, Y, Z} ``` 总共只需枚举：4! × 4³ × 5 = 7680 种可能 --- ## 5. 系统设计 ### 5.1 MVC架构 ``` ┌─────────────────────────────────────────┐ │ View (index.jsp) │ │ 输入表单 + 结果展示 │ └────────────┬────────────────────────────┘ │ ┌────────────▼────────────────────────────┐ │ Controller层 │ │ ├─ StartGameController（随机开始） │ │ ├─ InputDataController（输入数据） │ │ ├─ SolveGameController（求解） │ │ └─ SaveDataController（保存） │ └────────────┬────────────────────────────┘ │ ┌────────────▼────────────────────────────┐ │ Service层（Point24Service） │ └────────────┬────────────────────────────┘ │ ┌────────────▼────────────────────────────┐ │ Mapper层（Point24Mapper） │ └────────────┬────────────────────────────┘ │ ┌────────────▼────────────────────────────┐ │ MySQL数据库（point24表） │ └─────────────────────────────────────────┘ ``` ### 5.2 数据库表设计 ```sql CREATE TABLE point24 ( id INT PRIMARY KEY AUTO_INCREMENT, numbers VARCHAR(50), -- 排序后的数字，如 "[1,2,3,4]" solution VARCHAR(200) -- 解法，如 "((1+2)+3)*4" ); ``` ### 5.3 单例模式（Game） ```java public class Game { private static Game instance = new Game(); private Game() { digits = new ArrayList<>(); for (int i = 1; i <= 9; i++) { digits.add(i); } } public static Game getInstance() { return instance; } } ``` --- ## 6. 配置文件 ### 6.1 applicationContext.xml ```xml ``` ### 6.2 springMVC.xml ```xml ``` --- ## 7. 使用示例 ### 7.1 快速开始 1. 访问：`http://localhost:8080/start` （随机产生数字） 2. 点击「快速求解」计算 3. 点击「存数据库」保存结果（下次直接查表） ### 7.2 界面预览 #### 输入界面 ``` ┌──────────────────────────────────────────────────────────┐ │ 🎯 越算越聪明的24点小游戏 │ ├──────────────────────────────────────────────────────────┤ │ │ │ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ │ │ │ 3 │ │ 3 │ │ 8 │ │ 8 │ │ │ └─────┘ └─────┘ └─────┘ └─────┘ │ │ a b c d │ │ │ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │ │ 输入数据 │ │ 随机产生 │ │ 快速求解 │ │ 存数据库 │ │ │ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │ │ │ └──────────────────────────────────────────────────────────┘ ``` #### 结果展示 ``` ┌──────────────────────────────────────────────────────────┐ │ 📊 计算状态：找到 3 种解法 │ ├──────────────────────────────────────────────────────────┤ │ │ │ ┌──────────────────────────────────────────────────┐ │ │ │ [3, 3, 8, 8] ──► 8÷(3-8÷3) = 24 │ │ │ │ [3, 3, 8, 8] ──► (3+3)×(8-8÷8) = 24 │ │ │ │ [3, 3, 8, 8] ──► 8×3÷(3-8÷8) = 24 │ │ │ └──────────────────────────────────────────────────┘ │ │ │ │ 💡 提示：存入数据库后，下次遇到相同数字可立即获得答案！ │ │ │ └──────────────────────────────────────────────────────────┘ ``` --- ## 8. 项目总结 ### 8.1 核心技术 | 技术点 | 说明 | |--------|------| | SSM框架 | Spring IoC + SpringMVC + MyBatis整合 | | 责任链模式 | QueryDB → Random → Brute，越算越快 | | 单例模式 | Game全局唯一实例 | | 后缀表达式 | 栈计算，避免括号优先级问题 | | 二叉树遍历 | 后缀式 → 中缀式转换 | | 康拓展开 | 高效全排列枚举 | | 数据库缓存 | 记忆化搜索，越算越聪明 | ### 8.2 性能对比 | 求解方式 | 首次 | 第二次（已缓存） | |----------|------|-----------------| | 暴力搜索 | ~50ms | O(1)查表 <1ms 🚀 | | 数据库查询 | - | 直接命中，无需计算 | ### 8.3 学习路径 随着用户使用，数据库中积累的24点题目越来越多，**"云题库"越来越丰富**，求解速度越来越快，真正实现了"越算越聪明"！ ## 9. 从 HelloWorld.c 到 SSM 分布式求解 ### 9.1 学习迭代路径 ``` HelloWorld.c → C语言算法 → Java面向对象 → Web开发 → SSM企业级 ← 本项目 ``` 本项目体现了计算机专业学习的**四个层次**： | 层次 | 本项目体现 | 核心能力 | |------|-----------|----------| | **语言层** | Java、SQL、JSP | 语法与工具掌握 | | **算法层** | DFS、康拓展开、后缀表达式 | 计算思维 | | **工程层** | MVC、责任链、缓存 | 系统设计 | | **架构层** | Spring IoC、MyBatis ORM | 企业级框架 | ### 9.2 本项目的"学习迭代"思想 **核心观点：计算机专业的核心竞争力 = 结合最新工具 + 不停学习 + 不停项目迭代** 本项目完美诠释了"越算越聪明"的学习哲学： ``` V1.0: 暴力搜索（每次都重算）→ V2.0: 随机搜索（快速尝试） ↓ V3.0: 数据库缓存（学习记忆）← 本项目核心创新 ↓ 未来: Redis + 微服务 + AI ``` **代码迭代体现学习过程：** ```java // 初级：不用数据库，每次重算 List solve(int[] arr) { return new BruteSearcher().searchAll(arr); } // 高级：查数据库，越算越快 List solve(int[] arr) { List cached = point24Service.list(arr); if (!cached.isEmpty()) return cached; // ✨ 命中缓存！ List result = new BruteSearcher().searchAll(arr); saveToDB(arr, result); // 学习，保存结果 return result; } ``` ### 9.3 本项目涉及的核心课程 | 课程 | 应用 | |------|------| | 数据结构 | 栈(后缀表达式计算)、二叉树(表达式转换)、Set(去重) | | 算法原理 | DFS枚举、康拓展开、记忆化搜索 | | 编译原理 | 中缀→后缀→二叉树转换 | | 数据库 | MySQL缓存、索引优化 | | 设计模式 | 单例、责任链、IoC | | 软件工程 | MVC分层、模块化、版本控制 | ### 9.4 未来迭代方向 ``` SSM单机 → SpringBoot简化 → Redis缓存 → 微服务分布式 → AI预测求解 ``` --- ### 💡 核心启示 **计算机专业的竞争力不在于会多少语言，而在于：** 1. **持续学习**：从C→Java→Spring，与时俱进 2. **迭代改进**：从暴力搜索→数据库缓存，量变质变 3. **系统思维**：从单文件→分层架构，宏观设计 4. **工具善用**：从手工→框架→云原生，效率提升 **本项目"越算越聪明"的真谛：程序在记忆化搜索中学习，我们在项目迭代中成长！**