综合练习

这一课你将能做到

1. 从零搭出规范目录结构的多文件 Go 项目（模块、internal、接口、分层）
2. 把前 11 课串成一次真实交付：切片/map、接口与 mock、并发锁、错误链、JSON、net/http、表驱动测试
3. 用 go build 产出可部署二进制，跑通全部测试并理解优雅关停

为什么要学

单点知识都学过了，但「把它们装进同一个项目」是另一项能力：包怎么分、依赖朝哪个方向流、错误在哪里包装、锁加在哪一层——这些工程决策正是初级和熟练开发者的分水岭。

本课做一个内存版 Todo REST API（体积小到一页能放下，五脏俱全到能过面试：分层、接口抽象、并发安全、错误处理、HTTP、测试、构建一个不少）。做完它，你的简历上就有了第一个能拿得出手的 Go 项目。

先建立图像

todo-api/
├── go.mod                      module example.com/todo-api
├── main.go                     组装：store + handler + server
├── internal/
│   ├── store/store.go          存储层：Store 接口 + 内存实现（map + Mutex）
│   └── api/handler.go          HTTP 层：路由、JSON、错误转状态码
└── internal/store/store_test.go 表驱动测试

请求流转：
POST /todos → api.Handler → store.Store 接口 → MemoryStore（加锁写 map）
                 │ 依赖倒置：api 只认识接口，不认识具体实现
                 ▼ 未来把 MemoryStore 换成数据库实现，api 一行不改

两条设计决策提前说明：接口定义在消费方（api 包声明自己需要什么，而不是 store 强塞一个接口出来——Go 惯例）；internal 目录对外完全隐藏实现（第 5 课）。

跟着做

步骤 0：初始化项目

$ mkdir todo-api && cd todo-api
$ go mod init example.com/todo-api
$ mkdir internal/store internal/api

步骤 1：存储层——接口 + 内存实现（第 3/4/6/7 课全部登场）

internal/store/store.go：

package store

import (
	"errors"
	"sort"
	"sync"
)

// ErrNotFound 是哨兵错误：api 层据此转 404
var ErrNotFound = errors.New("todo 不存在")

type Todo struct {
	ID   int    `json:"id"`
	Text string `json:"text"`
	Done bool   `json:"done"`
}

// Store 是消费方（api 包）视角的最小接口
type Store interface {
	Add(text string) Todo
	List() []Todo
	Get(id int) (Todo, error)
	Toggle(id int) (Todo, error)
}

// MemoryStore：map + 互斥锁的线程安全实现
type MemoryStore struct {
	mu    sync.Mutex
	todos map[int]Todo
	next  int
}

func NewMemoryStore() *MemoryStore {
	return &MemoryStore{todos: make(map[int]Todo), next: 1}
}

func (s *MemoryStore) Add(text string) Todo {
	s.mu.Lock()
	defer s.mu.Unlock()
	t := Todo{ID: s.next, Text: text}
	s.todos[t.ID] = t
	s.next++
	return t
}

func (s *MemoryStore) List() []Todo {
	s.mu.Lock()
	defer s.mu.Unlock()
	out := make([]Todo, 0, len(s.todos))
	for _, t := range s.todos {
		out = append(out, t)
	}
	sort.Slice(out, func(i, j int) bool { return out[i].ID < out[j].ID })
	return out
}

func (s *MemoryStore) Get(id int) (Todo, error) {
	s.mu.Lock()
	defer s.mu.Unlock()
	t, ok := s.todos[id] // comma-ok：第 3 课
	if !ok {
		return Todo{}, ErrNotFound
	}
	return t, nil
}

func (s *MemoryStore) Toggle(id int) (Todo, error) {
	s.mu.Lock()
	defer s.mu.Unlock()
	t, ok := s.todos[id]
	if !ok {
		return Todo{}, ErrNotFound
	}
	t.Done = !t.Done
	s.todos[id] = t // map 的 value 是拷贝，必须写回
	return t, nil
}