mkdir todo-api
cd todo-api
go mod init todo.com/api # 你可以使用任何你喜欢的模块名

go get github.com/go-chi/chi/v5

package model

import "time"

// Todo 代表一个待办事项
type Todo struct {
	ID        int       `json:"id"`
	Title     string    `json:"title"`
	Completed bool      `json:"completed"`
	CreatedAt time.Time `json:"created_at"`
}

package repository

import "todo.com/api/internal/model"

// TodoRepository 定义了与待办事项数据存储交互的方法
type TodoRepository interface {
	Create(todo model.Todo) (model.Todo, error)
	FindByID(id int) (model.Todo, error)
	FindAll() ([]model.Todo, error)
}

package repository

import (
	"fmt"
	"sync"
	"time"
	"todo.com/api/internal/model"
)

// InMemoryTodoRepository 是 TodoRepository 接口的内存实现
type InMemoryTodoRepository struct {
	mu      sync.RWMutex
	todos   map[int]model.Todo
	currentID int
}

// NewInMemoryTodoRepository 创建一个新的内存仓库实例
func NewInMemoryTodoRepository() *InMemoryTodoRepository {
	return &InMemoryTodoRepository{
		todos:   make(map[int]model.Todo),
		currentID: 0,
	}
}

func (r *InMemoryTodoRepository) Create(todo model.Todo) (model.Todo, error) {
	r.mu.Lock()
	defer r.mu.Unlock()

	r.currentID++
	todo.ID = r.currentID
	todo.CreatedAt = time.Now()
	r.todos[todo.ID] = todo
	
	return todo, nil
}

func (r *InMemoryTodoRepository) FindByID(id int) (model.Todo, error) {
	r.mu.RLock()
	defer r.mu.RUnlock()

	todo, exists := r.todos[id]
	if !exists {
		return model.Todo{}, fmt.Errorf("todo with id %d not found", id)
	}
	return todo, nil
}

func (r *InMemoryTodoRepository) FindAll() ([]model.Todo, error) {
	r.mu.RLock()
	defer r.mu.RUnlock()

	allTodos := make([]model.Todo, 0, len(r.todos))
	for _, todo := range r.todos {
		allTodos = append(allTodos, todo)
	}
	return allTodos, nil
}

package service

import (
	"todo.com/api/internal/model"
	"todo.com/api/internal/repository"
)

// TodoService 封装了待办事项相关的业务逻辑
type TodoService struct {
	repo repository.TodoRepository // 依赖于接口，而不是具体实现
}

// NewTodoService 创建一个新的TodoService实例
func NewTodoService(repo repository.TodoRepository) *TodoService {
	return &TodoService{repo: repo}
}

func (s *TodoService) CreateTodo(title string) (model.Todo, error) {
	// 可以在这里添加业务逻辑，比如检查title是否为空，是否包含敏感词等
	if title == "" {
		return model.Todo{}, fmt.Errorf("title cannot be empty")
	}
	newTodo := model.Todo{
		Title:     title,
		Completed: false,
	}
	return s.repo.Create(newTodo)
}

func (s *TodoService) GetTodo(id int) (model.Todo, error) {
	return s.repo.FindByID(id)
}

func (s *TodoService) ListTodos() ([]model.Todo, error) {
	return s.repo.FindAll()
}

package handler

import (
	"encoding/json"
	"net/http"
	"strconv"
	"todo.com/api/internal/service"
    "github.com/go-chi/chi/v5"
)

// TodoHandler 负责处理待办事项的HTTP请求
type TodoHandler struct {
	service *service.TodoService
}

// NewTodoHandler 创建一个新的TodoHandler实例
func NewTodoHandler(s *service.TodoService) *TodoHandler {
	return &TodoHandler{service: s}
}

// CreateTodoHandler 处理创建待办事项的请求
func (h *TodoHandler) CreateTodoHandler(w http.ResponseWriter, r *http.Request) {
	var request struct {
		Title string `json:"title"`
	}
	if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
		http.Error(w, "Invalid request body", http.StatusBadRequest)
		return
	}

	todo, err := h.service.CreateTodo(request.Title)
	if err != nil {
		// 更具体地返回业务错误
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusCreated)
	json.NewEncoder(w).Encode(todo)
}

// ListTodosHandler 处理获取所有待办事项的请求
func (h *TodoHandler) ListTodosHandler(w http.ResponseWriter, r *http.Request) {
	todos, err := h.service.ListTodos()
	if err != nil {
		http.Error(w, "Failed to retrieve todos", http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(todos)
}

// GetTodoHandler 处理获取单个待办事项的请求
func (h *TodoHandler) GetTodoHandler(w http.ResponseWriter, r *http.Request) {
    // chi 帮助我们方便地获取URL参数
	idStr := chi.URLParam(r, "id")
	id, err := strconv.Atoi(idStr)
	if err != nil {
		http.Error(w, "Invalid todo ID", http.StatusBadRequest)
		return
	}

	todo, err := h.service.GetTodo(id)
	if err != nil {
		// 更好地处理 "not found" 错误
		http.Error(w, err.Error(), http.StatusNotFound)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(todo)
}

package main

import (
	"log"
	"net/http"
	"todo.com/api/internal/handler"
	"todo.com/api/internal/repository"
	"todo.com/api/internal/service"

	"github.com/go-chi/chi/v5"
	"github.com/go-chi/chi/v5/middleware"
)

func main() {
	// 1. 创建依赖实例 (从底层到上层)
	// 如果要换成PostgreSQL，只需要在这里替换这一行！
	repo := repository.NewInMemoryTodoRepository()
	todoService := service.NewTodoService(repo)
	todoHandler := handler.NewTodoHandler(todoService)

	// 2. 创建路由器实例
	r := chi.NewRouter()

	// 使用一些有用的中间件
	r.Use(middleware.Logger) // 记录每个请求的日志
	r.Use(middleware.Recoverer) // 从panic中恢复，返回500错误

	// 3. 设置路由
	r.Route("/todos", func(r chi.Router) {
		r.Post("/", todoHandler.CreateTodoHandler)
		r.Get("/", todoHandler.ListTodosHandler)
		r.Get("/{id:[0-9]+}", todoHandler.GetTodoHandler) // 使用正则表达式确保ID是数字
	})

	// 4. 启动服务器
	log.Println("Server starting on port :8080")
	if err := http.ListenAndServe(":8080", r); err != nil {
		log.Fatalf("Failed to start server: %v", err)
	}
}