your-project/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/yourname/project/
│   │   │       ├── controller/       # 控制器层，处理HTTP请求
│   │   │       │   └── UserController.java
│   │   │       ├── service/          # 业务逻辑层接口
│   │   │       │   └── UserService.java
│   │   │       ├── service/impl/     # 业务逻辑层实现
│   │   │       │   └── UserServiceImpl.java
│   │   │       ├── dao/              # 数据访问层
│   │   │       │   └── UserDao.java
│   │   │       └── config/           # 配置类（Spring配置）
│   │   │           └── WebConfig.java
│   │   └── resources/
│   │       ├── application.properties # 配置文件
│   │       └── views/                 # 视图文件夹（JSP、Thymeleaf等）
│   │           └── user.jsp
└── pom.xml                           # Maven配置文件

用户点击按钮
    ↓
Controller 接收请求 -> 调用 Model 获取数据
    ↓
Controller 选择对应 View
    ↓
View 渲染并返回给用户

graph TD
    %% 定义节点样式，模拟字符图的方框感
    classDef box fill:#fff,stroke:#333,stroke-width:1px,align:left;

    %% 1. 支付宝服务器
    Node1["<b>支付宝服务器</b><br/>回调请求: HTTPS/HTTP"]:::box

    %% 连接线 1
    Node1 -->|"访问公网 IP:8080"| Node2

    %% 2. 云服务器 FRPS
    Node2["<b>云服务器 FRPS</b><br/>镜像: fatedier/frps<br/>      bind_port: 7000        (FRPC 建立隧道)<br/>      remotePort: 8080       (公网访问端口)"]:::box

    %% 连接线 2
    Node2 -->|"TCP 隧道<br/>(remotePort 8080 -> FRPC localPort 8099)"| Node3

    %% 3. macOS Docker FRPC
    Node3["<b>macOS Docker FRPC</b><br/>镜像: fatedier/frpc<br/>localIP: 10.153.129.175     (宿主机 IP)<br/>localPort: 8099 (SpringBoot 端口)"]:::box

    %% 连接线 3
    Node3 -->|"访问宿主机 SpringBoot"| Node4

    %% 4. 宿主机 SpringBoot
    Node4["<b>宿主机 SpringBoot</b><br/>端口: 8099<br/>Docker 映射可选"]:::box

    %% 连接线 4
    Node4 -->|"返回响应"| Node5

    %% 5. 返回路径
    Node5["FRPC -> FRPS -> 支付宝"]:::box

timestamp = 1000000
nonce = 123456
signature = sha1(token, timestamp, nonce)
echostr = ABC

SignatureUtil.check(token, signature, timestamp, nonce)

private static final String BASE_URL = "https://api.weixin.qq.com/";

@Bean
public Retrofit retrofit(){
    return new Retrofit.Builder()
            .baseUrl(BASE_URL)
            .addConverterFactory(JacksonConverterFactory.create())
            .build();
}

@Autowired
private Retrofit retrofit;

num,questionBh
5,02ac8e3a76404d668bea36a31c90fc7b
*,********************************

import json
from typing import List, Dict, Any

class DataLoader:
    """
    负责从文件加载和验证数据 [cite: 137]
    """
    def __init__(self, file_path: str):
        self.file_path = file_path

    def load_data(self) -> List[Dict[str, Any]]:
        """
        加载并返回原始数据列表 [cite: 137]
        """
        try:
            with open(self.file_path, 'r', encoding='utf-8') as f:
                return json.load(f)
        except FileNotFoundError:
            print(f"❌ 错误：文件未找到，请确保 '{self.file_path}' 存在。")
            return []
        except json.JSONDecodeError:
            print(f"❌ 错误：'{self.file_path}' 文件不是有效的 JSON 格式。")
            return []
        except Exception as e:
            print(f"❌ 错误：加载文件时发生未知错误: {e}")
            return []

    def filter_valid_questions(self, data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
        """
        过滤出状态为 200 且包含详情的有效题目 [cite: 139]
        """
        return [
            item for item in data 
            if item.get('status') == 200 and item.get('detail')
        ]

from typing import List, Dict, Any

class QuestionService:
    """
    提供题目查询和格式化服务 [cite: 153]
    """

    def __init__(self, questions: List[Dict[str, Any]]):
        self.questions = questions

    def format_question_output(self, q_data: Dict[str, Any], show_answer: bool = False) -> str:
        """格式化单个题目输出 [cite: 153]"""
        question = q_data['detail']['question']
        knowledge = q_data['detail'].get('knowledgePoint', {})
        test_cases = q_data['detail'].get('questionTestList', [])

        output = [
            "=" * 60,
            f"ID: {question['id']}",
            f"标题: {question['title']}",
            f"类型: {question['type']} | 难度: {question['difficulty']}",
            f"知识点: {knowledge.get('name', 'N/A')}",
            "-" * 60,
            "📝 题目内容:",
            question['content'].strip(),
            f"\n测试用例 ({len(test_cases)}个):"
        ]

        for idx, case in enumerate(test_cases[:3]):
            output.append(f"  - 输入: {case.get('input', '无')} | 预期输出: {case.get('output', '无')}")

        if show_answer:
            output.append("\n💡 标准答案:")
            output.append(question['answer'].strip())

        output.append("=" * 60)
        return "\n".join(output)

    def find_by_id(self, question_id: str) -> Dict[str, Any]:
        for item in self.questions:
            if item['id'] == question_id:
                return item
        return None

    def find_by_type(self, q_type: str) -> List[Dict[str, Any]]:
        return [
            item for item in self.questions
            if item['detail']['question']['type'] == q_type
        ]

    def find_by_difficulty(self, difficulty: str) -> List[Dict[str, Any]]:
        return [
            item for item in self.questions
            if item['detail']['question']['difficulty'] == difficulty
        ]

    def search_by_keyword(self, keyword: str) -> List[Dict[str, Any]]:
        keyword = keyword.lower()
        results = []
        for item in self.questions:
            question = item['detail']['question']
            title = question['title'].lower()
            content = question['content'].lower()
            if keyword in title or keyword in content:
                results.append(item)
        return results

    def get_statistics(self) -> tuple:
        """返回(类型集合, 难度集合) [cite: 159]"""
        types = set()
        difficulties = set()
        for item in self.questions:
            question = item['detail']['question']
            types.add(question['type'])
            difficulties.add(question['difficulty'])
        return sorted(list(types)), sorted(list(difficulties))

from data_loader import DataLoader
from question_service import QuestionService

class QuestionAnalyzerApp:
    def __init__(self, file_path: str):
        # 1. 加载数据
        loader = DataLoader(file_path)
        raw_data = loader.load_data()
        valid_questions = loader.filter_valid_questions(raw_data)

        print(f"✅ 数据加载成功。找到 {len(raw_data)} 条记录，其中 {len(valid_questions)} 条有效。")

        # 2. 初始化服务
        self.service = QuestionService(valid_questions)

    def run(self):
        if not self.service.questions:
            print("🛑 数据集为空，程序退出。")
            return

        while True:
            self._print_menu()
            choice = input("请输入操作编号 (1-6): ").strip()

            if choice == '1':
                self._handle_find_by_id()
            elif choice == '2':
                self._handle_statistics()
            elif choice == '3':
                self._handle_find_by_type()
            elif choice == '4':
                self._handle_find_by_difficulty()
            elif choice == '5':
                self._handle_search()
            elif choice == '6':
                print("👋 感谢使用，程序已退出。")
                break
            else:
                print("⚠️ 无效的输入，请重新输入编号 (1-6)。")

            input("\n按 Enter 键继续...")

    def _print_menu(self):
        print("\n" + "=" * 50)
        print("📚 题目数据分析器 v3.0 (Modular) - 请选择操作:")
        print("=" * 50)
        print("1. 🔍 按 ID 查找题目和答案")
        print("2. 📊 统计与列出所有类型/难度")
        print("3. 🔢 按题目类型查找 (预览)")
        print("4. ⭐ 按题目难度查找 (预览)")
        print("5. 🔎 关键字搜索 (标题/内容)")
        print("6. ❌ 退出程序")
        print("-" * 50)

    def _handle_find_by_id(self):
        q_id = input("请输入要查找的题目 ID: ").strip()
        show_ans = input("是否显示标准答案? (y/n): ").lower() == 'y'
        item = self.service.find_by_id(q_id)
        if item:
            print(f"\n🔍 找到题目 (ID: {q_id}):")
            print(self.service.format_question_output(item, show_ans))
        else:
            print(f"❌ 未找到 ID 为 '{q_id}' 的题目。")

    def _handle_statistics(self):
        types, difficulties = self.service.get_statistics()
        print("\n📊 数据集统计:")
        print(f" - 所有题目类型: {', '.join(types)}")
        print(f" - 所有题目难度: {', '.join(difficulties)}")

    def _handle_find_by_type(self):
        q_type = input("请输入要查找的题目类型: ").strip()
        self._search_and_print(self.service.find_by_type, q_type, f"类型为 '{q_type}'")

    def _handle_find_by_difficulty(self):
        difficulty = input("请输入要查找的题目难度: ").strip()
        self._search_and_print(self.service.find_by_difficulty, difficulty, f"难度为 '{difficulty}'")

    def _handle_search(self):
        keyword = input("请输入要搜索的关键字: ").strip()
        self._search_and_print(self.service.search_by_keyword, keyword, f"包含关键字 '{keyword}'")

    def _search_and_print(self, func, arg, desc):
        limit = input("请输入限制显示的数量 (默认5): ")
        limit = int(limit) if limit.isdigit() else 5

        results = func(arg)
        print(f"\n🔍 找到 {len(results)} 个{desc}的题目。显示前 {min(len(results), limit)} 个。")

        for item in results[:limit]:
            print(self.service.format_question_output(item, show_answer=False))

if __name__ == "__main__":
    app = QuestionAnalyzerApp('ans.json')
    app.run()