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

王小酱
16 阅读7分钟

所属阶段：第四阶段「语言与框架」（第 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
Pythonpython-patternspython-testingpython-reviewerdjango-patterns, django-tdd, django-security
Gogolang-patternsgolang-testinggo-reviewer—
Rustrust-patternsrust-testingrust-reviewer—
Javajava-coding-standardsspringboot-tddjava-reviewerspringboot-patterns, springboot-security, jpa-patterns
Kotlinkotlin-patternskotlin-testingkotlin-reviewerkotlin-coroutines-flows, kotlin-exposed-patterns, kotlin-ktor-patterns
C++cpp-coding-standardscpp-testingcpp-reviewer—
C#dotnet-patternscsharp-testingcsharp-reviewer—
Perlperl-patternsperl-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 + channelasyncio + async/await
测试框架推荐的测试工具和组织方式testing 标准库 + table-drivenpytest + 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 关注点
Pythonasyncio / threadingQueue / Event避免 GIL 陷阱，异步 IO 优先
Gogoroutinechannel"Don't communicate by sharing memory"
Rusttokio / std::threadmpsc channel所有权系统保证线程安全
JavaThread / ExecutorServiceBlockingQueue线程池配置，避免死锁
KotlincoroutineFlow / Channel结构化并发，kotlin-coroutines-flows

四、语言特定 Agent 与命令

4.1 代码审查 Agent

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

Agent审查重点
python-reviewerPEP 8 合规、类型标注完整性、Django ORM N+1
go-reviewer接口最小化、error wrapping、goroutine 泄漏
rust-reviewer所有权和生命周期、unsafe 使用审计、clippy 警告
java-reviewerSpring Bean 作用域、JPA 懒加载、空指针防护
kotlin-reviewer空安全使用、协程作用域泄漏、data class 不可变性
cpp-reviewer内存管理、智能指针使用、RAII 模式
csharp-reviewerasync/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 注入的内容
Pythonpytest fixture 模式、parametrize、mock.patch
Gotable-driven tests、testify 断言、httptest
Rust#[cfg(test)] 模块、proptest 属性测试
JavaJUnit 5 + Mockito、Spring Boot @WebMvcTest
Kotlinkotest + 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
框架 SkillDjango/Spring Boot/Ktor 等有完整的 Skill 链
配置方式Skill 选择 + Rules 安装，按项目类型组合

九、下节预告

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

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

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

avatar
文章
阅读
粉丝