第 17 课：后端语言 — Python / Go / Rust / Java

所属阶段：第四阶段「语言与框架」（第 17-22 课） 前置条件：第 9 课（Skill 编写）、第 13 课（TDD 流程） 本课收获：为你的主力后端语言配置完整的 ECC 规则和 Skill

---

一、本课概述

ECC 不只是一个通用的 AI 编程增强框架 --- 它对每种主流后端语言都提供了量身定制的 Skill 和 Agent。这些 Skill 涵盖了编码规范、测试策略、代码审查和并发模式，让 Claude Code 在你的主力语言中表现得像一个有十年经验的高级工程师。

本课回答三个问题：

1. ECC 支持哪些后端语言？ --- 完整的 Skill 对照表
2. 语言 Skill 有什么共性结构？ --- 理解通用骨架，举一反三
3. 如何为你的主力语言配置 ECC？ --- 从 Skill 选择到 TDD 实战

---

二、后端语言 Skill 对照表

ECC 为 8 种后端语言提供了专用 Skill 体系。每种语言至少覆盖三个维度：编码规范 、测试策略 、代码审查。

2.1 完整对照表

语言	编码规范 Skill	测试 Skill	审查 Agent	附加 Skill
Python	python-patterns	python-testing	python-reviewer	django-patterns, django-tdd, django-security
Go	golang-patterns	golang-testing	go-reviewer	---
Rust	rust-patterns	rust-testing	rust-reviewer	---
Java	java-coding-standards	springboot-tdd	java-reviewer	springboot-patterns, springboot-security, jpa-patterns
Kotlin	kotlin-patterns	kotlin-testing	kotlin-reviewer	kotlin-coroutines-flows, kotlin-exposed-patterns, kotlin-ktor-patterns
C++	cpp-coding-standards	cpp-testing	cpp-reviewer	---
C#	dotnet-patterns	csharp-testing	csharp-reviewer	---
Perl	perl-patterns	perl-testing	---	perl-security

2.2 语言生态丰富度

从附加 Skill 的数量可以看出 ECC 对各语言的支持深度：

Kotlin  ████████████  6 个 Skill（含框架级 Ktor、Exposed、协程）
Java    ████████████  5 个 Skill（含 Spring Boot 全套）
Python  ████████████  5 个 Skill（含 Django 全套）
Go      ████          3 个 Skill
Rust    ████          3 个 Skill
C++     ████          3 个 Skill
C#      ████          3 个 Skill
Perl    ████          3 个 Skill

提示 ：Skill 数量不等于支持质量。Go 虽然只有 3 个 Skill，但 golang-patterns 覆盖了并发、错误处理、接口设计等核心主题，信息密度很高。

---

三、语言 Skill 共性结构

无论哪种语言，ECC 的编码规范 Skill 都遵循相同的骨架结构。理解这个骨架，你就能快速上手任何语言的 Skill。

3.1 四大共性维度

每个语言 Skill 都会覆盖以下四个维度：

维度	含义	示例（Go）	示例（Python）
命名惯用法	变量、函数、类型的命名规范	camelCase 未导出, PascalCase 导出	snake_case 函数, PascalCase 类
错误处理	语言惯用的错误处理模式	返回 (value, error) 二元组	try/except + 自定义异常层级
并发模式	语言原生的并发/异步机制	goroutine + channel	asyncio + async/await
测试框架	推荐的测试工具和组织方式	testing 标准库 + table-driven	pytest + fixture + parametrize

3.2 命名惯用法对比

┌─────────┬──────────────┬──────────────┬──────────────┐
│  语言    │  变量/函数    │  类型/类      │  常量         │
├─────────┼──────────────┼──────────────┼──────────────┤
│ Python  │ snake_case   │ PascalCase   │ UPPER_SNAKE  │
│ Go      │ camelCase    │ PascalCase   │ PascalCase   │
│ Rust    │ snake_case   │ PascalCase   │ UPPER_SNAKE  │
│ Java    │ camelCase    │ PascalCase   │ UPPER_SNAKE  │
│ Kotlin  │ camelCase    │ PascalCase   │ UPPER_SNAKE  │
│ C++     │ snake_case   │ PascalCase   │ kPascalCase  │
│ C#      │ camelCase    │ PascalCase   │ PascalCase   │
│ Perl    │ snake_case   │ PascalCase   │ UPPER_SNAKE  │
└─────────┴──────────────┴──────────────┴──────────────┘

3.3 错误处理模式对比

各语言的错误处理哲学差异很大，但 ECC 的 Skill 都会强调一个共同点：永远不要吞掉错误。

# Python --- 异常层级
class AppError(Exception): pass
class NotFoundError(AppError): pass
class ValidationError(AppError): pass

try:
    user = find_user(user_id)
except NotFoundError:
    return {"error": "User not found"}, 404

// Go --- 显式错误返回
user, err := findUser(userID)
if err != nil {
    if errors.Is(err, ErrNotFound) {
        return nil, fmt.Errorf("user %s not found: %w", userID, err)
    }
    return nil, err
}

// Rust --- Result 类型 + ? 操作符
fn find_user(id: &str) -> Result<User, AppError> {
    let user = db.query(id).map_err(|e| AppError::NotFound(e))?;
    Ok(user)
}

3.4 并发模式对比

语言	并发原语	通信方式	ECC Skill 关注点
Python	asyncio / threading	Queue / Event	避免 GIL 陷阱，异步 IO 优先
Go	goroutine	channel	"Don't communicate by sharing memory"
Rust	tokio / std::thread	mpsc channel	所有权系统保证线程安全
Java	Thread / ExecutorService	BlockingQueue	线程池配置，避免死锁
Kotlin	coroutine	Flow / Channel	结构化并发，kotlin-coroutines-flows

---

四、语言特定 Agent 与命令

4.1 代码审查 Agent

每种语言都有专用的 Reviewer Agent，它们不只是通用的代码审查，而是深入理解语言惯用法：

Agent	审查重点
python-reviewer	PEP 8 合规、类型标注完整性、Django ORM N+1
go-reviewer	接口最小化、error wrapping、goroutine 泄漏
rust-reviewer	所有权和生命周期、unsafe 使用审计、clippy 警告
java-reviewer	Spring Bean 作用域、JPA 懒加载、空指针防护
kotlin-reviewer	空安全使用、协程作用域泄漏、data class 不可变性
cpp-reviewer	内存管理、智能指针使用、RAII 模式
csharp-reviewer	async/await 死锁、IDisposable 实现、LINQ 性能

4.2 构建错误解决 Agent

当编译或构建失败时，ECC 提供了语言专用的 Build Resolver：

通用：build-error-resolver
Go：go-build-resolver
Java：java-build-resolver
Kotlin：kotlin-build-resolver
Rust：rust-build-resolver
C++：cpp-build-resolver
Dart：dart-build-resolver
Python：pytorch-build-resolver（PyTorch 专用）

这些 Agent 理解各语言构建工具的错误格式（go build、cargo build、gradle build），能快速定位并修复问题。

4.3 语言特定 TDD 命令

ECC 的 /tdd 命令是通用的 TDD 入口，但配合语言 Skill 使用效果更好：

# 通用 TDD 流程
/tdd

# 配合语言审查命令（在 TDD 完成后执行）
# Python 项目
/code-review   # 自动匹配 python-reviewer

# Go 项目
/code-review   # 自动匹配 go-reviewer

# Java/Spring Boot 项目
/code-review   # 自动匹配 java-reviewer

TDD 流程中，语言 Skill 的 测试框架 部分会被自动注入：

语言	测试 Skill 注入的内容
Python	pytest fixture 模式、parametrize、mock.patch
Go	table-driven tests、testify 断言、httptest
Rust	#[cfg(test)] 模块、proptest 属性测试
Java	JUnit 5 + Mockito、Spring Boot @WebMvcTest
Kotlin	kotest + MockK、协程测试 runTest

---

五、框架级 Skill 深入

5.1 Python + Django 生态

Django 在 ECC 中有完整的 Skill 链：

django-patterns     → ORM 查询优化、视图模式、中间件
django-tdd          → Django TestCase、Factory Boy、API 测试
django-security     → CSRF、SQL 注入、XSS 防护
django-verification → 部署前检查清单

5.2 Java + Spring Boot 生态

springboot-patterns      → 分层架构、依赖注入、配置管理
springboot-tdd           → @SpringBootTest、@WebMvcTest、TestContainers
springboot-security      → Spring Security 配置、JWT、OAuth2
springboot-verification  → 部署前检查清单

5.3 Kotlin 生态（最丰富）

Kotlin 是 ECC 中 Skill 覆盖最广的后端语言：

kotlin-patterns          → 空安全、密封类、扩展函数
kotlin-testing           → kotest、MockK、协程测试
kotlin-coroutines-flows  → 结构化并发、Flow 操作符、异常处理
kotlin-exposed-patterns  → Exposed ORM DSL、事务管理、HikariCP
kotlin-ktor-patterns     → 路由 DSL、内容协商、插件系统

---

六、实战配置指南

6.1 为你的语言选择 Skill 组合

根据项目类型选择合适的 Skill 组合：

Python Web API 项目：
  python-patterns + python-testing + django-patterns + django-tdd + api-design

Go 微服务项目：
  golang-patterns + golang-testing + api-design + postgres-patterns

Rust CLI 工具项目：
  rust-patterns + rust-testing

Java Spring Boot 项目：
  java-coding-standards + springboot-patterns + springboot-tdd + jpa-patterns

Kotlin Ktor 项目：
  kotlin-patterns + kotlin-testing + kotlin-ktor-patterns + kotlin-exposed-patterns

6.2 Rules 层配置

除了 Skill，还需要安装对应语言的 Rules：

# ECC rules 目录结构
rules/
├── common/          # 通用规则（必装）
├── typescript/      # TypeScript 规则
├── python/          # Python 规则
├── golang/          # Go 规则
└── swift/           # Swift 规则

安装命令：

# 安装通用 + 语言规则
./install.sh python
./install.sh golang

# 或手动复制
cp -r rules/common ~/.claude/rules/common
cp -r rules/python ~/.claude/rules/python

---

七、本课练习

练习 1：查看你的语言 Skill（10 分钟）

选择你的主力后端语言，阅读对应的编码规范 Skill：

# 以 Python 为例
cat skills/python-patterns/README.md

# 以 Go 为例
cat skills/golang-patterns/README.md

回答问题：

• 该 Skill 覆盖了哪些主题？
• 错误处理部分推荐了什么模式？
• 有没有你不认同的惯用法？

练习 2：执行 TDD + 语言审查（20 分钟）

用你的主力语言完成以下流程：

1. 用 /tdd 命令为一个简单函数（如字符串验证工具）执行完整的 RED-GREEN-IMPROVE 循环
2. 完成后用 /code-review 触发语言专用审查
3. 记录 Reviewer Agent 给出的反馈

练习 3：对比两种语言的错误处理（15 分钟）

选择两种你熟悉的语言，分别阅读它们的编码规范 Skill 中关于错误处理的部分。写一段 200 字以内的对比总结。

练习 4（选做）：思考题

如果你要为一种 ECC 尚未支持的语言（如 Zig、Elixir）编写 Skill，你会先写哪三个部分？为什么？

---

八、本课小结

你应该记住的	内容
支持范围	8 种后端语言，每种至少 3 个 Skill
共性结构	命名惯用法、错误处理、并发模式、测试框架
语言 Agent	每种语言有专用 Reviewer + Build Resolver
框架 Skill	Django/Spring Boot/Ktor 等有完整的 Skill 链
配置方式	Skill 选择 + Rules 安装，按项目类型组合

---

九、下节预告

第 18 课：前端框架 --- React / Next.js / Vue / Nuxt

下节课我们将进入前端领域，学习 ECC 如何支持现代前端框架。你将了解 E2E 测试的完整方案（Playwright + POM 模式），以及前后端 Skill 如何协作形成完整的应用覆盖。

预习建议 ：提前浏览 skills/frontend-patterns 和 skills/e2e-testing 目录，感受前端 Skill 的内容组织方式。