HDU-CS-Wiki on Veno's Blog

不再继续参与 HDU-CS-Wiki 维护的声明

Sun, 28 Sep 2025 16:53:58 +0800

本人将不再参与 HDU-CS-Wiki 的维护。此前提及的 “HDU-CS-Wiki 后端教程”，现暂定统一改名为《Veno 的后端教程》。今后该教程的全部内容仅在本博客发布。若在其他平台出现本博客教程的内容，均视为转载，需遵循 CC BY-NC-SA 4.0 协议，并标明原文链接，侵权必究。

Veno 的后端教程大纲

Sun, 20 Jul 2025 00:21:21 +0800

2025-09-28 编辑：本人将不再参与 hdu-cs.wiki 的编辑。后端教程不会继续在 Wiki 上更新。

Before Beginning

前置知识需求: CS61A, 或掌握至少一门编程语言（如Python）的扎实基础，理解函数、类、简单数据结构（列表、字典、集合等）、递归等核心编程概念, 畅通的网络环境, 了解Python的基础写法, 基本的英语阅读能力, 提问的艺术, 基础CLI操作

第一部分：后端基础 (Python + FastAPI + SQLModel)

教学目标(一)

快速上手: 让学生在几小时内，从零开始搭建起一个功能完整的 CRUD (增删改查) API。
建立自信: 通过 FastAPI 强大的自动文档和 SQLModel 的易用性，让学生感受到现代工具带来的便捷，消除对后端的畏难心理。
文档阅读: FastAPI 有着非常用户友好的文档, 利用它来培养阅读文档的习惯. 这也是本教程选择SQLModel而不是SQLAlchemy的原因之一
正确使用AI: 不要让Copilot变成Copybot
整个教程的每个模块会维护和精进同一个项目(不与 Project 1 相同, 教程项目更倾向于教学示范)
理解或掌握以下知识：

路由函数 (Routing) 与 HTTP 方法 (GET, POST, PUT, DELETE)。
SQL, ORM 与数据库操作 (CRUD)。
API-服务-数据的基本三层架构模式。
中间件 (Middleware) 的作用。
基本的安全思想.
基本的单元测试和集成测试概念和写法
配置管理: 学会分离开发, 测试, 生产环境
学会现代部署: 掌握使用 Docker 和 Docker Compose 对应用进行容器化部署的基本技能。
学会阅读框架文档
基本的 Git 团队协作能力

课程大纲(一)

Lab 0

VSCode 配置, 环境变量, Python 虚拟环境, PEP规范和类型标注
前后端的基本概念, 后端是什么
uv Python 环境管理
Git基本配置, Github
…

模块一: API 和 HTTP

API 和路由函数
路径参数和查询参数
HTTP, GET 和 POST 方法
请求体和数据校验(pydantic)
API 文档 (展示FastAPI的自动生成的 Swagger 文档)
…
作业:
- 阅读文档, 找到如何使用 FastAPI 构造一个上传文件的接口.
- 通过阅读文档, 发现并解决 FastAPI 中路由函数先后定义产生的问题.
拓展阅读:
- HTTP MDN, 图解HTTP
- RESTful API 和 WebSocket
- API测试工具
- …

模块二：数据库

SQL语句: 手动使用SQL来进行基础的查询和数据库操作
ORM 与模型: ORM概念, 使用 SQLModel，定义第一个数据模型。
连接数据库: 使用 SQLite 作为入门数据库，配置数据库连接。
实现 CRUD: 编写完整的增、删、改、查四个 API 接口。
数据库事务的概念和重要性(ACID), SQLModel 的 session
索引设计
作业:
- 提供一个复杂的数据库 ER 图, 要求编写几个不同复杂度的 SQL 查询语句, 覆盖连接 (JOIN), 分组 (GROUP BY), 子查询等。
- 用ORM的关系预加载优化一个 N+1 查询问题.
拓展阅读:
- SQL, NoSQL(MongoDB, Redis, Neo4j)
- 索引, 外键, 多对多…
- alembic 等数据库同步工具
- ACID、CAP 和 BASE
- 软删除
- SQL 注入
- …

模块三：代码的规范化

问题引入: 当业务逻辑变复杂时，所有代码都写在路由函数里的坏处。
重构代码: 引入三层架构思想, 把先前的代码清晰分为API层, 服务层, 路由层.
如何避免过度设计
拓展阅读:
- IoC 和依赖注入
- 22种设计模式
- SOLID 原则
- 领域驱动设计
- …

模块四：中间件

中间件基本概念
中间件一般应用场景
错误处理中间件(统一错误响应格式)
CORS中间件
作业:
- 编写一个简单的记录API日志的中间件, 统计请求处理时长.
- 实现自定义异常处理中间件
拓展阅读:
- …

模块五: 基本的安全思想

JWT Token
passwd_hashed
CORS
环境变量管理敏感信息
永远不要相信用户的输入
…
作业:
- 实现一个完整的注册登陆流程, 密码哈希存储
- 利用中间件实现API的Token鉴权
- …
拓展阅读:
- …

模块六：交付你的第一个后端服务 (容器化)

Docker 入门: 讲解什么是 Docker, 它解决了什么问题.
Dockerfile: 为 FastAPI 应用编写一个 Dockerfile
Docker Compose
作业:
- …
拓展阅读:
- 除了Docker以外的容器, Podman, container.d
- CI/CD, Github Actions
- …

Project 1: 电子书商城

与前端组协调, 后端小组与前端小组共同完成电子书商城项目.
要求:
- 强制使用 Feature Branch 工作流
- 编写有意义的 Commit Message
- 团队成员之间需要进行 Code Review

第二部分：后端进阶 (Go + Gin)

教学目标(二)

深入原理: 通过 Go 的显式特性，让学生深刻理解路由、中间件、ORM 等概念的底层实现本质。
培养底层思维: 从一个“框架使用者”转变为一个能思考性能、并发、内存管理的“工程师”。
掌握 Go 后端开发: 熟练使用 Go 语言、Gin 框架和 GORM 来构建高性能的后端服务，并掌握 Go 的指针、错误处理等核心特性。
熟悉高级组件: 使用 Redis 缓存，使用消息队列。
衔接微服务架构: 理解从单体应用到微服务的演进过程，初步掌握 RPC (gRPC)、服务注册与发现、容器编排 (Kubernetes) 等核心概念。

课程大纲(二)

Lab 0: Go语言基础

Go 语法, Go环境搭建, 工作区概念, Go Modules, Goroutine

模块一：重新认识路由和框架

路由的本质: 先用 Go 标准库 net/http 手写一个简单的 Web 服务器，暴露路由函数。
引入 Gin: 讲解 Gin 如何用更优雅的方式解决了 net/http 的路由和分组问题。
Gin 的 Context
…
作业:
- 尝试使用 net/http 实现一个支持不同HTTP方法的路由分发器
拓展阅读:
- gin-swagger
- 大厂基于Gin的框架
- GORM

模块二：再论架构与中间件的本质

通过接口和构造函数手动注入依赖, 本质上为了解决相同的问题
中间件的本质: 手写一个最简单的 Gin 中间件, 本质是一个接收 *gin.Context 并调用 c.Next() 的函数. 责任链模式.
…
作业:
- 替换Gin框架的默认Logger中间件
- 实现一个 Panic 恢复中间件, 确保单个请求的崩溃不会导致整个服务宕机, 并能记录下崩溃的堆栈信息
拓展阅读:
- Go的闭包
- go 的反射机制和适用场景

模块三: 消息队列

问题引入: 当服务所需要的请求量越来越多
RabbitMQ(AMQP 模型) 和 Kafka(流模型) 的区别和适用场景
ACK, 持久化和重试
什么时候应当为系统引入消息队列才不会显得累赘
…
作业:
- 实现一个异步任务, 通过API提交某个耗时请求之后, 服务将任务放入RabbitMQ后立即返回, 让一个Worker服务消费任务
拓展阅读:
- 死信队列
- Kafka核心概念: Topic, Partition, Offset, Consumer Group
- RocketMQ

模块四: 缓存

Redis
缓存的常见策略 (Cache-aside, Read-through, Write-through)
缓存穿透、缓存击穿、缓存雪崩的原因和解决方案
Redis 常见数据结构的使用场景
什么时候应当引入缓存才不会显得累赘
…
作业:
- 为某个高频读取的API增加Redis缓存(Cache-aside), 并进行压测, 对比QPS和响应时间。
拓展阅读:
- 缓存与数据库一致性问题
- 分布式锁的概念与基于Redis的实现

模块五：从单体到微服务

单体应用的痛点, 为什么业界会需要微服务架构
RPC概念, 以及RPC的底层本质
gRPC: Protobuf, 服务定义, 四种通信模式, 在Go中的实践
作业:
- 创建两个微服务：user-service 和 order-service。order-service 在创建订单时，需要通过 gRPC 调用 user-service 来验证用户信息是否存在

模块六：Kubernetes

什么是容器编排? 为什么已经有compose了还需要k8s?
k8s 架构和核心概念讲解
kind
作业:
- 为一个简单的微服务编写Kubernetes的Deployment和Service的YAML文件, 并使用kind在本地部署起来
- 在kind集群中滚动更新 (Rolling Update) 和回滚 (Rollback) 一个服务
拓展阅读:
- k8s 官方文档
- …

Project 2 : 电商平台

参考2024年字节后端青训营项目. 要求使用gRPC的微服务架构, 使用k8s集群进行部署.

延伸

一起收集一下常见的各种典型后端项目的设计与实现方式.

HDU-CS-Wiki 后端开发入门教程的教学大纲设想

Sun, 13 Jul 2025 14:18:18 +0800

2025-09-28 编辑：本人将不再参与 hdu-cs.wiki 的编辑。后端教程不会继续在 Wiki 上更新。

需要给HDU-CS-Wiki写后端入门教程了, 在这里罗列一下自己的想法.

这个教程教授的目标我更希望是能传达后端开发的心法, 能教会小白在面对一个自己从来没接触过的Web框架甚至新的编程语言时, 如何用同样的思路, 通用的知识, 通过阅读框架文档, 来实现自己想做的项目功能. 明确这个目标, 才不会把教程写的像是重写了一遍Web框架文档, 变得像Gin框架学习笔记之类的东西一样.

教学语言和使用框架的选择我想到了几个, Node.js+Express, Python+FastAPI, Go+Gin.

Express的网络开源教程我感觉是最多最主流的, 核心思想. 然而本人现在实在没接触过js的生态, 如果真要写那要么现学现卖, 要么喊谷子哥代写了. (谷子哥留个博客链接我好加友链(x

Python+FastAPI, 好处是语法比较简单, Python也是一个非常适合初学者入门而不被劝退的语言. 缺点是有可能会不得不引入一些框架核心的高级特性, 比如通过依赖注入获取db_session, 以及显式的异步调用, 以及会有解释型语言不可避免的运行时类型错误问题.

Go+Gin, 语法很简洁, 没什么语法糖, 但没有传统的类和对象, 而是指针和结构体, 这对于小白来说可能会提高使用难度. 但是可能不那么简单也能算做优点, 因为Go的语言特性会让它的代码比较好读, 很适合让学习者思考这些框架是如何一步步搭建起来的, 核心的特性本质上是些什么东西, 可以去甚至可以尝试自己搭建一个简单的Web框架.

我有种比较大胆的想法是, 先用Python+FastAPI+SQLModel做最基本的后端开发导入, 用短时间无痛构建一个完整且现代的服务, 目标是用最简单的代码讲述后端几个比较重要的概念, API和HTTP, 数据库, 经典的三层架构, 中间件, 容器, git协作. 然后用Go, 深入原理, 知其然而知其所以然, 同时也能向上引申, 从单体应用到微服务架构, 云原生的概念, 引出现代企业级后端的很多解决方案, k8s, redis, 消息队列等等.

无论怎么转变语言和框架, 但是后端开发的本质思路是不变的, 路由注册, 请求解析, 业务逻辑, 数据交互, 响应生成. 教程需要强调的是教会人共通的后端思维, 教会人如何根据框架文档写代码. 我自己也并不熟悉很多的框架, 比如我从来没有用过Gin去写过代码. 但是我想把我如何通过查一个陌生的框架的文档, 找到如何注册一个路由注册一个中间件, 把这个过程给显式地表达出来. 我认为这种能力远比精通某一个Web框架更重要. 可能可以设置一个作业, 比如通过查找文档, 自己找到如何在FastAPI中实现一个文件上传的功能.

然后可以介绍很多很不错的开源教程, 介绍很多好用的工具, Git团队协作需要的基本知识等等, 可以有很多外链

我不太确定这样的教程思路是否合适, 还是很希望多提点建议的.

让Gemini给我列了一个按照我那种大胆思路的教学大纲. 它的大纲我觉得还是太侧重于推崇Go语言这一点了. 我觉得每个人都可能会有自己的喜好, 我可能会更倾向于客观告诉学习者不同语言的特点, 优缺点, 鼓励多尝试, 找到适合自己的, 也提升不同语言的适应能力.

Gemini的大纲如下:

第一部分：Python + FastAPI + SQLModel (快速入门与核心概念构建)

核心定位: “信心助推器”。在最短的时间内，让一个新手无痛地构建一个完整、现代且专业的 API 服务，使其快速获得成就感，并对后端开发的核心概念有一个直观、感性的认识。
教学目标 (Teaching Goals)
- 快速上手: 让学生在几小时内，从零开始搭建起一个功能完整的 CRUD (增删改查) API。
- 建立自信: 通过 FastAPI 强大的自动文档和 SQLModel 的易用性，让学生感受到现代工具带来的开发乐趣，消除对后端的畏难心理。
- 掌握核心概念: 深刻理解以下通用概念：
```
1. 路由函数 (Routing) 与 HTTP 方法 (GET, POST, PUT, DELETE)。
2. ORM 与数据库操作 (CRUD)。
3. API-服务-数据 的三层架构模式。
4. 中间件 (Middleware) 的作用。
5. 学会现代部署: 掌握使用 Docker 和 Docker Compose 对应用进行容器化部署的基本技能。
```
课程大纲 (Course Outline)
- 模块一：你好，后端世界！ (第一个 API)
  - 环境搭建: Python 与 venv 虚拟环境，使用 pip 安装 FastAPI。
  - Hello, World: 编写第一个 @app.get("/") 路由函数。
  - 核心讲解: 什么是 HTTP？什么是 API？GET 和 POST 方法的区别。
  - “魔法”展示: 介绍并使用 FastAPI 自动生成的交互式文档 (Swagger UI)，让学生可以立刻测试自己的 API。
- 模块二：让数据持久化 (数据库操作)
  - ORM 与模型: 介绍 SQLModel，定义第一个数据模型 (例如 Article 模型)。
  - 连接数据库: 使用 SQLite 作为入门数据库，配置数据库连接。
  - 实现 CRUD: 编写完整的增、删、改、查四个 API 接口。
  - 深入 Pydantic: 讲解 FastAPI 如何利用 Pydantic 模型自动完成请求数据的校验。
- 模块三：代码的专业化之路 (三层架构)
  - 问题引入: 当业务逻辑变复杂时，所有代码都写在路由函数里的坏处。
  - 重构代码: 引入三层架构思想，将代码清晰地分离为：
    - API 层 (api/routes.py): 只负责处理 HTTP 请求和响应。
    - 服务层 (services.py): 负责处理核心的业务逻辑。
    - 数据层 (data/repository.py): 负责与数据库进行交互。
  - 核心讲解: 讲解分层的好处：解耦、可测试性、可维护性。
- 模块四：中间件的妙用
  - 概念讲解: 什么是中间件？它就像一个洋葱，层层包裹你的请求。
  - 实践: 编写一个简单的中间件，例如记录每个请求的处理时间，并将其添加到日志中。
- 模块五：交付你的第一个后端服务 (Docker 容器化)
  - Docker 入门: 讲解什么是 Docker，它解决了什么问题。
  - 编写 Dockerfile: 为我们的 FastAPI 应用编写一个 Dockerfile。
  - 使用 Docker Compose: 编写 docker-compose.yml，一键启动我们的应用服务和数据库服务。

第二部分：Go + Gin + GORM (深入原理与架构进阶)

核心定位: “能力深化器”。在第一部分的基础上，用更接近底层的语言重新构建同一个应用，让学生从“知其然”到“知其所以然”。同时向上引申，打开通往微服务和云原生世界的大门。
教学目标 (Teaching Goals)
- 深入原理: 通过 Go 的显式特性，让学生深刻理解路由、中间件、ORM 等概念的底层实现本质。
- 培养底层思维: 从一个“框架使用者”转变为一个能思考性能、并发、内存管理的“工程师”。
- 掌握 Go 后端开发: 熟练使用 Go 语言、Gin 框架和 GORM 来构建高性能的后端服务，并掌握 Go 的指针、错误处理等核心特性。
- 衔接微服务架构: 理解从单体应用到微服务的演进过程，初步掌握 RPC (gRPC)、服务注册与发现、容器编排 (Kubernetes) 等核心概念。
课程大纲 (Course Outline)
- 模块一：换一种语言，见一片新天地 (Go 与 Gin)
  - 环境与基础: Go 环境搭建、工作区概念、Go Modules 依赖管理。
  - 向下探索 (1) - 路由的本质: 先用 Go 标准库 net/http 手写一个简单的 Web 服务器，暴露路由函数。
  - 引入 Gin: 讲解 Gin 如何用更优雅的方式解决了 net/http 的路由和分组问题。
  - 核心讲解: Go 的 struct 与指针、if err != nil 的错误处理哲学。用 Go 重新实现第一个 API。
- 模块二：在静态类型世界里操作数据 (GORM)
  - GORM 基础: 使用 GORM 定义数据模型并连接数据库 (如 PostgreSQL)。
  - 重构 CRUD: 用 GORM 重新实现增删改查功能。
  - 对比思考: 对比 GORM 和 SQLModel，探讨静态类型 ORM 和动态类型 ORM 的设计差异。
- 模块三：再论架构与中间件的本质
```
Go 的分层: 在 Go 项目中再次实践三层架构。
向下探索 (2) - 中间件的本质: 手写一个最简单的 Gin 中间件，让学生明白它就是一个接收 *gin.Context 并调用 c.Next() 的函数。揭示其中间件“责任链模式”的本质。
```
- 模块四：释放 Go 的力量 (并发编程)
  - Goroutine 入门: 讲解 Go 如何用 go 关键字轻松开启一个协程。
  - 实践: 举例说明并发的威力，例如模拟一个需要同时请求多个外部服务的场景。
- 模块五：向上引申 - 从单体到微服务
```
理论篇: 讲解单体应用的痛点，引出微服务架构。介绍什么是 RPC，以及 gRPC 为何在云原生时代如此流行。
实践篇: 将我们的“文章服务”改造成一个独立的 gRPC 服务。然后，创建一个新的 Gin 项目作为 API 网关，由它来接收外部 HTTP 请求，再通过 RPC 调用后端的 gRPC 服务。
```
- 模块六：云原生之巅的惊鸿一瞥 (Kubernetes)
  - 概念讲解: 什么是容器编排？为什么有了 Docker 还需要 Kubernetes (k8s)？
  - 初体验: 编写简单的 k8s Deployment 和 Service 配置文件，将我们之前容器化的 Go 微服务部署到本地的 k8s 集群 (如 Minikube 或 kind) 中。
  - 课程总结: 回顾整个旅程，学生已经从一个 API 的实现者，成长为一个理解现代后端架构的准工程师。

后续和计科协后端组成员讨论出的几个点:

课程形式: 线上文档, 放在wiki
课程大作业: Proj1, 单体python后端应用(待定), 需要有前端, 可能和前端组进行沟通, Proj2, Go微服务架构的电商系统(参考去年青训营), proj2可以不用前端或提供简陋前端. 都是小组作业(git协作).
教程编写周期: 暑假把第一部分教程完成, 完成一部分Proj2内容.
教程学习周期: 一个学期学习一个部分. 第一学期需要一部分时间学习基础编程, 考虑达到CS61A的水准之后再开始学习本课程, 第二学期Proj2耗时较长, 可能需要两三个月
编写教程不是最终目的, 培养一个入门的后端开发者才是最终目的, 在此基础上尽量让教程可以被复用. 因此我们需要在教学过程中及时跟进学习者的反馈, 并且讨论出合适的大作业评估方案. 之后才是进一步精进教程.
对于教程编写者, 需要考虑教程实现的性价比最高的方案, 避免投入产出不成正比导致的教程编写未半而中道崩殂. 不要为了这个教程把自己搞的太累.