3天搞定学分查询系统：一份保姆级教程
官方文档往往篇幅冗长，核心逻辑淹没在海量配置项中，让人抓不住重点。
很多开发者面对“学分查询”这种看似简单的需求，容易陷入过度设计或性能瓶颈的误区。
这份保姆级教程将剥离冗余概念，直接切入从0到1搭建高性能查询系统的实战流程。
项目目标与场景拆解
在动手写代码前，必须明确“学分查询”到底要解决什么问题。
这不是一个简单的 SELECT * FROM student 操作。
高校场景下，数据量通常在百万级，且存在并发读写的复杂情况。
我们的核心目标有三个：低延迟响应：查询耗时需控制在 200ms 以内。
高并发支撑：开学季选课查询高峰期，需支撑每秒 5000+ 请求。
数据一致性：确保学分变更（如补考通过）后，查询结果实时同步。很多初学者喜欢用 ORM 框架一把梭，但在高并发读场景下，原生 SQL 配合连接池往往更高效。
我们选择 Python + FastAPI + PostgreSQL 技术栈，理由如下：FastAPI：异步支持好，天然适合 I/O 密集型查询。
PostgreSQL：JSONB 支持灵活，索引能力强，适合存储复杂的学分结构。
Python：生态丰富，后期扩展数据分析模块方便。目录结构与环境搭建
清晰的目录结构是工程化的第一步，避免后期代码堆砌成“屎山”。
建议采用分层架构，将业务逻辑、数据访问、接口定义严格分离。
project_root/
├── app/
│ ├── main.py # 应用入口，配置中间件
│ ├── core/
│ │ ├── config.py # 配置管理，读取环境变量
│ │ ├── security.py # 认证授权逻辑
│ │ └── database.py # 数据库连接池配置
│ ├── models/
│ │ ├── student.py # SQLAlchemy 数据模型
│ │ └── credit.py # 学分记录模型
│ ├── schemas/
│ │ ├── query.py # Pydantic 请求/响应模型
│ │ └── response.py # 统一返回格式
│ ├── services/
│ │ └── credit_service.py # 核心业务逻辑层
│ └── routers/
│ └── credit.py # API 路由定义
├── tests/
│ ├── test_query.py # 单元测试
│ └── conftest.py # 测试夹具
├── requirements.txt # 依赖管理
└── .env # 环境变量文件环境初始化关键步骤：创建虚拟环境：
python -m venv venv
source venv/bin/activate # Linux/Mac
# venv\Scripts\activate # Windows安装核心依赖：
pip install fastapi uvicorn sqlalchemy asyncpg pydantic python-dotenv pytest httpx注意：asyncpg 是 PostgreSQL 的高性能异步驱动，务必使用，不要用同步驱动。配置环境变量：
在 .env 文件中配置数据库连接信息：
DATABASE_URL=postgresql+asyncpg://user:pass@localhost:5432/credit_db
POOL_SIZE=20
MAX_OVERFLOW=40核心代码实现与逐行讲解
这一部分是整个系统的灵魂。
我们将实现一个带缓存、带索引优化的异步查询接口。
1. 数据库连接池配置
连接池是性能优化的第一道防线。
错误配置会导致连接泄漏或资源耗尽。
# app/core/database.py
import asyncio
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from sqlalchemy.orm import sessionmaker
from app.core.config import settings# 创建异步引擎，参数详解见下方注释
engine = create_async_engine(settings.DATABASE_URL,echo=False, # 生产环境关闭 SQL 日志，避免 I/O 开销pool_size=settings.POOL_SIZE, # 保持的连接数max_overflow=settings.MAX_OVERFLOW, # 允许超出 pool_size 的连接数pool_timeout=30, # 获取连接的超时时间pool_recycle=1800 # 连接回收时间，防止数据库主动断开
)AsyncSessionLocal = sessionmaker(bind=engine,class_=AsyncSession,expire_on_commit=False # 提交后不自动过期，避免二次查询
)# 依赖注入，供 FastAPI 路由使用
async def get_db():async with AsyncSessionLocal() as session:try:yield sessionfinally:await session.close()逐行解析：pool_recycle=1800：PostgreSQL 默认空闲连接存活时间通常较短，设置回收机制可避免 Connection lost 错误。
expire_on_commit=False：在查询场景中，我们不需要频繁刷新对象状态，关闭此选项可减少一次隐式查询。2. 数据模型定义
学分数据结构通常包含：学生ID、课程ID、学分值、成绩状态、学期。
# app/models/credit.py
from sqlalchemy import Column, Integer, String, Float, DateTime, Index
from sqlalchemy.dialects.postgresql import JSONB
from datetime import datetime
from app.core.database import Baseclass CreditRecord(Base):__tablename__ = 'credit_records'id = Column(Integer, primary_key=True, index=True)student_id = Column(Integer, index=True, nullable=False) # 建立索引，加速按学生查询course_id = Column(Integer, index=True, nullable=False)course_name = Column(String(100), nullable=False)credit_value = Column(Float, nullable=False)status = Column(String(20), default='pending') # pending, passed, failedsemester = Column(String(20), nullable=False)created_at = Column(DateTime, default=datetime.utcnow)# 复合索引：针对“查询某学生某学期学分”的高频场景__table_args__ = (Index('idx_student_semester', 'student_id', 'semester'),)关键点：Index：单列索引不够，必须使用复合索引。
JSONB：如果未来需要存储课程详情（如教师、教室），使用 JSONB 字段比频繁建表更灵活，且支持部分索引。3. 核心查询服务
这是性能优化的核心区域。
我们将实现“先查缓存，后查数据库”的逻辑，并对结果进行序列化优化。
# app/services/credit_service.py
import asyncio
from typing import List
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from app.models.credit import CreditRecord
from app.schemas.query import CreditResponseclass CreditService:def __init__(self, db: AsyncSession):self.db = dbasync def get_student_credits(self, student_id: int, semester: str) - List[CreditResponse]:查询指定学生指定学期的所有学分记录# 1. 构建查询语句，只选择必要字段，减少网络传输query = select(CreditRecord.course_name,CreditRecord.credit_value,CreditRecord.status,CreditRecord.semester).where(CreditRecord.student_id == student_id,CreditRecord.semester == semester)# 2. 执行异步查询result = await self.db.execute(query)rows = result.fetchall()# 3. 内存中构建响应对象，避免 ORM 实例化开销# 注意：这里没有使用 model_validate，而是直接构造字典，速度更快credits = []for row in rows:credits.append(CreditResponse(course_name=row.course_name,credit_value=row.credit_value,status=row.status,semester=row.semester))return credits避坑指南：不要使用 db.get() 查询列表：它只适用于主键查询，列表查询必须用 select。
字段裁剪：永远不要 SELECT *。只返回前端需要的字段，能降低 30% 以上的带宽消耗。4. API 路由层
路由层保持轻量，只做参数验证和服务调用。
# app/routers/credit.py
from fastapi import APIRouter, Depends, HTTPException, Query
from sqlalchemy.ext.asyncio import AsyncSession
from app.core.database import get_db
from app.services.credit_service import CreditService
from app.schemas.response import ApiResponserouter = APIRouter(prefix=/api/credit, tags=[credit])@router.get(/query, response_model=ApiResponse)
async def query_credits(student_id: int = Query(..., gt=0, description=学生ID，必须大于0),semester: str = Query(..., min_length=4, max_length=4, description=学期，格式如2023-1),db: AsyncSession = Depends(get_db)
):查询学生学分接口service = CreditService(db)# 调用服务层获取数据try:credits = await service.get_student_credits(student_id, semester)except Exception as e:# 记录日志，这里省略具体日志实现raise HTTPException(status_code=500, detail=查询失败，请稍后重试)# 统一返回格式return ApiResponse(code=0,message=success,data=credits)参数校验细节：gt=0：防止非法 ID。
min_length=4：强制学期格式标准化，避免脏数据进入数据库。运行与测试：验证性能边界
代码写完只是开始，测试才是真本事。
我们将使用 pytest 进行单元测试，并用 Locust 进行压测。
1. 单元测试
测试重点在于：边界条件、异常处理、数据准确性。
# tests/test_query.py
import pytest
from httpx import AsyncClient
from app.main import app@pytest.mark.asyncio
async def test_query_credits_success():# 模拟数据库数据插入逻辑省略async with AsyncClient(app=app, base_url=http://test) as ac:response = await ac.get(/api/credit/query, params={student_id: 1,semester: 2023-1})assert response.status_code == 200data = response.json()assert data[code] == 0assert len(data[data]) 0@pytest.mark.asyncio
async def test_query_invalid_semester():async with AsyncClient(app=app, base_url=http://test) as ac:response = await ac.get(/api/credit/query, params={student_id: 1,semester: 2023 # 错误格式})assert response.status_code == 422 # FastAPI 默认验证错误码2. 压力测试与瓶颈定位
在 Stack Overflow 上，关于“FastAPI 慢”的讨论中，80% 的问题出在数据库连接池或 N+1 查询上。
我们的压测脚本如下（使用 Locust）：
# load_test.py
from locust import HttpUser, task, between
import randomclass CreditUser(HttpUser):wait_time = between(0.1, 0.5) # 模拟用户思考时间@taskdef query_credit(self):student_id = random.randint(1, 10000)semester = 2023-1self.client.get(f/api/credit/query?student_id={student_id}semester={semester})压测结果分析：CPU 占用：若 CPU 飙高，检查是否开启了 echo=True 或序列化了大对象。
DB 连接数：监控 PostgreSQL 的 pg_stat_activity。若连接数逼近 max_connections，说明连接池配置过小或存在连接泄漏。
P99 延迟：若 P99 远高于 P50，说明存在长尾请求，通常由锁竞争或慢查询引起。优化扩展：从能用到了好
基础功能跑通后，我们需要考虑生产环境的极端情况。
1. 引入 Redis 缓存
对于“学期”这种低频变更的数据，缓存是提升性能的最有效手段。
缓存策略：Cache-Aside Pattern。
# 在 CreditService 中增加缓存逻辑
import redis.asyncio as redis
import jsonclass CreditService:def __init__(self, db: AsyncSession, redis_client: redis.Redis):self.db = dbself.redis = redis_clientasync def get_student_credits(self, student_id: int, semester: str):cache_key = fcredit:{student_id}:{semester}# 1. 尝试从缓存读取cached_data = await self.redis.get(cache_key)if cached_data:return json.loads(cached_data)# 2. 缓存未命中，查询数据库# ... 执行之前的 DB 查询逻辑 ...credits = await self._fetch_from_db(student_id, semester)# 3. 写入缓存，设置 5 分钟过期await self.redis.setex(cache_key, 300, json.dumps([c.dict() for c in credits]))return credits注意事项：缓存穿透：若查询不存在的 ID，需缓存空结果，防止恶意攻击打穿数据库。
缓存击穿：热点 Key 过期瞬间，大量请求打到 DB。可使用互斥锁或逻辑过期解决。2. 数据库索引优化
使用 EXPLAIN ANALYZE 分析慢查询。
-- 查看执行计划
EXPLAIN ANALYZE
SELECT course_name, credit_value
FROM credit_records
WHERE student_id = 12345 AND semester = '2023-1';理想执行计划：Index Scan using idx_student_semester：使用了复合索引。
Rows Removed by Filter: 0：没有多余的行过滤。若出现 Seq Scan（顺序扫描），说明索引未生效或数据量过大导致优化器放弃索引。此时需考虑分区表策略。
3. 读写分离
当写操作（录入成绩）开始影响读操作（查询学分）时，必须引入读写分离。主库：负责 INSERT, UPDATE, DELETE。
从库：负责 SELECT。
中间件：使用 pgBouncer 或应用层配置双连接池。小结与实战建议
回顾整个“学分查询”系统的搭建过程，我们完成了从架构设计到性能调优的全链路实战。
核心收获：异步是标配：Python 的 FastAPI 必须配合 asyncpg 才能真正发挥性能，同步驱动会阻塞事件循环。
索引决定生死：复合索引的设计要基于最高频的查询场景，盲目加索引会拖慢写操作。
缓存是加速器：对于读多写少的场景，Redis 缓存能将响应时间从 50ms 降至 5ms 以内。
监控不能少：没有监控的优化都是盲调。必须接入 Prometheus + Grafana 监控 QPS、延迟、错误率。给培训机构学员的建议：
不要满足于“跑通代码”。
面试官问的不是“你怎么写 SQL”，而是“为什么用这个索引”、“缓存失效了怎么办”、“高并发下连接池怎么配”。
这些细节，才是区分初级和中级工程师的分水岭。
还有什么不懂的？评论区留言挨个回。 3天搞定学分查询系统：一份保姆级教程
3天搞定学分查询系统：一份保姆级教程
官方文档往往篇幅冗长，核心逻辑淹没在海量配置项中，让人抓不住重点。
很多开发者面对“学分查询”这种看似简单的需求，容易陷入过度设计或性能瓶颈的误区。
这份保姆级教程将剥离冗余概念，直接切入从0到1搭建高性能查询系统的实战流程。
项目目标与场景拆解
在动手写代码前，必须明确“学分查询”到底要解决什么问题。
这不是一个简单的 SELECT * FROM student 操作。
高校场景下，数据量通常在百万级，且存在并发读写的复杂情况。
我们的核心目标有三个：低延迟响应：查询耗时需控制在 200ms 以内。
高并发支撑：开学季选课查询高峰期，需支撑每秒 5000+ 请求。
数据一致性：确保学分变更（如补考通过）后，查询结果实时同步。很多初学者喜欢用 ORM 框架一把梭，但在高并发读场景下，原生 SQL 配合连接池往往更高效。
我们选择 Python + FastAPI + PostgreSQL 技术栈，理由如下：FastAPI：异步支持好，天然适合 I/O 密集型查询。
PostgreSQL：JSONB 支持灵活，索引能力强，适合存储复杂的学分结构。
Python：生态丰富，后期扩展数据分析模块方便。目录结构与环境搭建
清晰的目录结构是工程化的第一步，避免后期代码堆砌成“屎山”。
建议采用分层架构，将业务逻辑、数据访问、接口定义严格分离。
project_root/
├── app/
│ ├── main.py # 应用入口，配置中间件
│ ├── core/
│ │ ├── config.py # 配置管理，读取环境变量
│ │ ├── security.py # 认证授权逻辑
│ │ └── database.py # 数据库连接池配置
│ ├── models/
│ │ ├── student.py # SQLAlchemy 数据模型
│ │ └── credit.py # 学分记录模型
│ ├── schemas/
│ │ ├── query.py # Pydantic 请求/响应模型
│ │ └── response.py # 统一返回格式
│ ├── services/
│ │ └── credit_service.py # 核心业务逻辑层
│ └── routers/
│ └── credit.py # API 路由定义
├── tests/
│ ├── test_query.py # 单元测试
│ └── conftest.py # 测试夹具
├── requirements.txt # 依赖管理
└── .env # 环境变量文件环境初始化关键步骤：创建虚拟环境：
python -m venv venv
source venv/bin/activate # Linux/Mac
# venv\Scripts\activate # Windows安装核心依赖：
pip install fastapi uvicorn sqlalchemy asyncpg pydantic python-dotenv pytest httpx注意：asyncpg 是 PostgreSQL 的高性能异步驱动，务必使用，不要用同步驱动。配置环境变量：
在 .env 文件中配置数据库连接信息：
DATABASE_URL=postgresql+asyncpg://user:pass@localhost:5432/credit_db
POOL_SIZE=20
MAX_OVERFLOW=40核心代码实现与逐行讲解
这一部分是整个系统的灵魂。
我们将实现一个带缓存、带索引优化的异步查询接口。
1. 数据库连接池配置
连接池是性能优化的第一道防线。
错误配置会导致连接泄漏或资源耗尽。
# app/core/database.py
import asyncio
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from sqlalchemy.orm import sessionmaker
from app.core.config import settings# 创建异步引擎，参数详解见下方注释
engine = create_async_engine(settings.DATABASE_URL,echo=False, # 生产环境关闭 SQL 日志，避免 I/O 开销pool_size=settings.POOL_SIZE, # 保持的连接数max_overflow=settings.MAX_OVERFLOW, # 允许超出 pool_size 的连接数pool_timeout=30, # 获取连接的超时时间pool_recycle=1800 # 连接回收时间，防止数据库主动断开
)AsyncSessionLocal = sessionmaker(bind=engine,class_=AsyncSession,expire_on_commit=False # 提交后不自动过期，避免二次查询
)# 依赖注入，供 FastAPI 路由使用
async def get_db():async with AsyncSessionLocal() as session:try:yield sessionfinally:await session.close()逐行解析：pool_recycle=1800：PostgreSQL 默认空闲连接存活时间通常较短，设置回收机制可避免 Connection lost 错误。
expire_on_commit=False：在查询场景中，我们不需要频繁刷新对象状态，关闭此选项可减少一次隐式查询。2. 数据模型定义
学分数据结构通常包含：学生ID、课程ID、学分值、成绩状态、学期。
# app/models/credit.py
from sqlalchemy import Column, Integer, String, Float, DateTime, Index
from sqlalchemy.dialects.postgresql import JSONB
from datetime import datetime
from app.core.database import Baseclass CreditRecord(Base):__tablename__ = 'credit_records'id = Column(Integer, primary_key=True, index=True)student_id = Column(Integer, index=True, nullable=False) # 建立索引，加速按学生查询course_id = Column(Integer, index=True, nullable=False)course_name = Column(String(100), nullable=False)credit_value = Column(Float, nullable=False)status = Column(String(20), default='pending') # pending, passed, failedsemester = Column(String(20), nullable=False)created_at = Column(DateTime, default=datetime.utcnow)# 复合索引：针对“查询某学生某学期学分”的高频场景__table_args__ = (Index('idx_student_semester', 'student_id', 'semester'),)关键点：Index：单列索引不够，必须使用复合索引。
JSONB：如果未来需要存储课程详情（如教师、教室），使用 JSONB 字段比频繁建表更灵活，且支持部分索引。3. 核心查询服务
这是性能优化的核心区域。
我们将实现“先查缓存，后查数据库”的逻辑，并对结果进行序列化优化。
# app/services/credit_service.py
import asyncio
from typing import List
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from app.models.credit import CreditRecord
from app.schemas.query import CreditResponseclass CreditService:def __init__(self, db: AsyncSession):self.db = dbasync def get_student_credits(self, student_id: int, semester: str) - List[CreditResponse]:查询指定学生指定学期的所有学分记录# 1. 构建查询语句，只选择必要字段，减少网络传输query = select(CreditRecord.course_name,CreditRecord.credit_value,CreditRecord.status,CreditRecord.semester).where(CreditRecord.student_id == student_id,CreditRecord.semester == semester)# 2. 执行异步查询result = await self.db.execute(query)rows = result.fetchall()# 3. 内存中构建响应对象，避免 ORM 实例化开销# 注意：这里没有使用 model_validate，而是直接构造字典，速度更快credits = []for row in rows:credits.append(CreditResponse(course_name=row.course_name,credit_value=row.credit_value,status=row.status,semester=row.semester))return credits避坑指南：不要使用 db.get() 查询列表：它只适用于主键查询，列表查询必须用 select。
字段裁剪：永远不要 SELECT *。只返回前端需要的字段，能降低 30% 以上的带宽消耗。4. API 路由层
路由层保持轻量，只做参数验证和服务调用。
# app/routers/credit.py
from fastapi import APIRouter, Depends, HTTPException, Query
from sqlalchemy.ext.asyncio import AsyncSession
from app.core.database import get_db
from app.services.credit_service import CreditService
from app.schemas.response import ApiResponserouter = APIRouter(prefix=/api/credit, tags=[credit])@router.get(/query, response_model=ApiResponse)
async def query_credits(student_id: int = Query(..., gt=0, description=学生ID，必须大于0),semester: str = Query(..., min_length=4, max_length=4, description=学期，格式如2023-1),db: AsyncSession = Depends(get_db)
):查询学生学分接口service = CreditService(db)# 调用服务层获取数据try:credits = await service.get_student_credits(student_id, semester)except Exception as e:# 记录日志，这里省略具体日志实现raise HTTPException(status_code=500, detail=查询失败，请稍后重试)# 统一返回格式return ApiResponse(code=0,message=success,data=credits)参数校验细节：gt=0：防止非法 ID。
min_length=4：强制学期格式标准化，避免脏数据进入数据库。运行与测试：验证性能边界
代码写完只是开始，测试才是真本事。
我们将使用 pytest 进行单元测试，并用 Locust 进行压测。
1. 单元测试
测试重点在于：边界条件、异常处理、数据准确性。
# tests/test_query.py
import pytest
from httpx import AsyncClient
from app.main import app@pytest.mark.asyncio
async def test_query_credits_success():# 模拟数据库数据插入逻辑省略async with AsyncClient(app=app, base_url=http://test) as ac:response = await ac.get(/api/credit/query, params={student_id: 1,semester: 2023-1})assert response.status_code == 200data = response.json()assert data[code] == 0assert len(data[data]) 0@pytest.mark.asyncio
async def test_query_invalid_semester():async with AsyncClient(app=app, base_url=http://test) as ac:response = await ac.get(/api/credit/query, params={student_id: 1,semester: 2023 # 错误格式})assert response.status_code == 422 # FastAPI 默认验证错误码2. 压力测试与瓶颈定位
在 Stack Overflow 上，关于“FastAPI 慢”的讨论中，80% 的问题出在数据库连接池或 N+1 查询上。
我们的压测脚本如下（使用 Locust）：
# load_test.py
from locust import HttpUser, task, between
import randomclass CreditUser(HttpUser):wait_time = between(0.1, 0.5) # 模拟用户思考时间@taskdef query_credit(self):student_id = random.randint(1, 10000)semester = 2023-1self.client.get(f/api/credit/query?student_id={student_id}semester={semester})压测结果分析：CPU 占用：若 CPU 飙高，检查是否开启了 echo=True 或序列化了大对象。
DB 连接数：监控 PostgreSQL 的 pg_stat_activity。若连接数逼近 max_connections，说明连接池配置过小或存在连接泄漏。
P99 延迟：若 P99 远高于 P50，说明存在长尾请求，通常由锁竞争或慢查询引起。优化扩展：从能用到了好
基础功能跑通后，我们需要考虑生产环境的极端情况。
1. 引入 Redis 缓存
对于“学期”这种低频变更的数据，缓存是提升性能的最有效手段。
缓存策略：Cache-Aside Pattern。
# 在 CreditService 中增加缓存逻辑
import redis.asyncio as redis
import jsonclass CreditService:def __init__(self, db: AsyncSession, redis_client: redis.Redis):self.db = dbself.redis = redis_clientasync def get_student_credits(self, student_id: int, semester: str):cache_key = fcredit:{student_id}:{semester}# 1. 尝试从缓存读取cached_data = await self.redis.get(cache_key)if cached_data:return json.loads(cached_data)# 2. 缓存未命中，查询数据库# ... 执行之前的 DB 查询逻辑 ...credits = await self._fetch_from_db(student_id, semester)# 3. 写入缓存，设置 5 分钟过期await self.redis.setex(cache_key, 300, json.dumps([c.dict() for c in credits]))return credits注意事项：缓存穿透：若查询不存在的 ID，需缓存空结果，防止恶意攻击打穿数据库。
缓存击穿：热点 Key 过期瞬间，大量请求打到 DB。可使用互斥锁或逻辑过期解决。2. 数据库索引优化
使用 EXPLAIN ANALYZE 分析慢查询。
-- 查看执行计划
EXPLAIN ANALYZE
SELECT course_name, credit_value
FROM credit_records
WHERE student_id = 12345 AND semester = '2023-1';理想执行计划：Index Scan using idx_student_semester：使用了复合索引。
Rows Removed by Filter: 0：没有多余的行过滤。若出现 Seq Scan（顺序扫描），说明索引未生效或数据量过大导致优化器放弃索引。此时需考虑分区表策略。
3. 读写分离
当写操作（录入成绩）开始影响读操作（查询学分）时，必须引入读写分离。主库：负责 INSERT, UPDATE, DELETE。
从库：负责 SELECT。
中间件：使用 pgBouncer 或应用层配置双连接池。小结与实战建议
回顾整个“学分查询”系统的搭建过程，我们完成了从架构设计到性能调优的全链路实战。
核心收获：异步是标配：Python 的 FastAPI 必须配合 asyncpg 才能真正发挥性能，同步驱动会阻塞事件循环。
索引决定生死：复合索引的设计要基于最高频的查询场景，盲目加索引会拖慢写操作。
缓存是加速器：对于读多写少的场景，Redis 缓存能将响应时间从 50ms 降至 5ms 以内。
监控不能少：没有监控的优化都是盲调。必须接入 Prometheus + Grafana 监控 QPS、延迟、错误率。给培训机构学员的建议：
不要满足于“跑通代码”。
面试官问的不是“你怎么写 SQL”，而是“为什么用这个索引”、“缓存失效了怎么办”、“高并发下连接池怎么配”。
这些细节，才是区分初级和中级工程师的分水岭。
还有什么不懂的？评论区留言挨个回。