第2个项目 - RESTful API Todo服务

package models

import "time"

// Todo 待办事项结构体
type Todo struct {
	ID          int       `json:"id"`
	Title       string    `json:"title"`
	Description string    `json:"description"`
	Completed   bool      `json:"completed"`
	CreatedAt   time.Time `json:"created_at"`
	UpdatedAt   time.Time `json:"updated_at"`
}

// CreateTodoRequest 创建Todo的请求结构
type CreateTodoRequest struct {
	Title       string `json:"title" binding:"required,min=1,max=100"`
	Description string `json:"description" binding:"max=500"`
}

// UpdateTodoRequest 更新Todo的请求结构
type UpdateTodoRequest struct {
	Title       *string `json:"title" binding:"omitempty,min=1,max=100"`
	Description *string `json:"description" binding:"omitempty,max=500"`
	Completed   *bool   `json:"completed"`
}

package storage

import (
	"errors"
	"sync"
	"time"

	"github.com/yourusername/rest-api-todo/models"
)

var (
	ErrNotFound = errors.New("todo not found")
)

// MemoryStorage 内存存储（线程安全）
type MemoryStorage struct {
	todos  map[int]*models.Todo
	nextID int
	mu     sync.RWMutex
}

// NewMemoryStorage 创建新的内存存储
func NewMemoryStorage() *MemoryStorage {
	return &MemoryStorage{
		todos:  make(map[int]*models.Todo),
		nextID: 1,
	}
}

// GetAll 获取所有待办事项
func (s *MemoryStorage) GetAll() []*models.Todo {
	s.mu.RLock()
	defer s.mu.RUnlock()

	todos := make([]*models.Todo, 0, len(s.todos))
	for _, todo := range s.todos {
		todos = append(todos, todo)
	}
	return todos
}

// GetByID 根据ID获取待办事项
func (s *MemoryStorage) GetByID(id int) (*models.Todo, error) {
	s.mu.RLock()
	defer s.mu.RUnlock()

	todo, exists := s.todos[id]
	if !exists {
		return nil, ErrNotFound
	}
	return todo, nil
}

// Create 创建新的待办事项
func (s *MemoryStorage) Create(title, description string) *models.Todo {
	s.mu.Lock()
	defer s.mu.Unlock()

	now := time.Now()
	todo := &models.Todo{
		ID:          s.nextID,
		Title:       title,
		Description: description,
		Completed:   false,
		CreatedAt:   now,
		UpdatedAt:   now,
	}

	s.todos[s.nextID] = todo
	s.nextID++

	return todo
}

// Update 更新待办事项
func (s *MemoryStorage) Update(id int, title, description *string, completed *bool) (*models.Todo, error) {
	s.mu.Lock()
	defer s.mu.Unlock()

	todo, exists := s.todos[id]
	if !exists {
		return nil, ErrNotFound
	}

	// 更新字段
	if title != nil {
		todo.Title = *title
	}
	if description != nil {
		todo.Description = *description
	}
	if completed != nil {
		todo.Completed = *completed
	}
	todo.UpdatedAt = time.Now()

	return todo, nil
}

// Delete 删除待办事项
func (s *MemoryStorage) Delete(id int) error {
	s.mu.Lock()
	defer s.mu.Unlock()

	if _, exists := s.todos[id]; !exists {
		return ErrNotFound
	}

	delete(s.todos, id)
	return nil
}

package handlers

import (
	"net/http"
	"strconv"

	"github.com/gin-gonic/gin"
	"github.com/yourusername/rest-api-todo/models"
	"github.com/yourusername/rest-api-todo/storage"
)

// TodoHandler 处理Todo相关的HTTP请求
type TodoHandler struct {
	storage *storage.MemoryStorage
}

// NewTodoHandler 创建新的TodoHandler
func NewTodoHandler(storage *storage.MemoryStorage) *TodoHandler {
	return &TodoHandler{storage: storage}
}

// GetAll 获取所有待办事项
// GET /todos
func (h *TodoHandler) GetAll(c *gin.Context) {
	todos := h.storage.GetAll()
	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"data":    todos,
		"count":   len(todos),
	})
}

// GetByID 获取单个待办事项
// GET /todos/:id
func (h *TodoHandler) GetByID(c *gin.Context) {
	// 解析ID参数
	id, err := strconv.Atoi(c.Param("id"))
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"error":   "无效的ID",
		})
		return
	}

	// 查询数据
	todo, err := h.storage.GetByID(id)
	if err != nil {
		c.JSON(http.StatusNotFound, gin.H{
			"success": false,
			"error":   "待办事项不存在",
		})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"data":    todo,
	})
}

// Create 创建待办事项
// POST /todos
func (h *TodoHandler) Create(c *gin.Context) {
	var req models.CreateTodoRequest

	// 解析并验证请求body
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"error":   "请求参数错误: " + err.Error(),
		})
		return
	}

	// 创建Todo
	todo := h.storage.Create(req.Title, req.Description)

	c.JSON(http.StatusCreated, gin.H{
		"success": true,
		"message": "创建成功",
		"data":    todo,
	})
}

// Update 更新待办事项
// PUT /todos/:id
func (h *TodoHandler) Update(c *gin.Context) {
	// 解析ID参数
	id, err := strconv.Atoi(c.Param("id"))
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"error":   "无效的ID",
		})
		return
	}

	var req models.UpdateTodoRequest

	// 解析并验证请求body
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"error":   "请求参数错误: " + err.Error(),
		})
		return
	}

	// 更新Todo
	todo, err := h.storage.Update(id, req.Title, req.Description, req.Completed)
	if err != nil {
		c.JSON(http.StatusNotFound, gin.H{
			"success": false,
			"error":   "待办事项不存在",
		})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"message": "更新成功",
		"data":    todo,
	})
}

// Delete 删除待办事项
// DELETE /todos/:id
func (h *TodoHandler) Delete(c *gin.Context) {
	// 解析ID参数
	id, err := strconv.Atoi(c.Param("id"))
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"error":   "无效的ID",
		})
		return
	}

	// 删除Todo
	err = h.storage.Delete(id)
	if err != nil {
		c.JSON(http.StatusNotFound, gin.H{
			"success": false,
			"error":   "待办事项不存在",
		})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"message": "删除成功",
	})
}

package middleware

import (
	"log"
	"time"

	"github.com/gin-gonic/gin"
)

// Logger 日志中间件
func Logger() gin.HandlerFunc {
	return func(c *gin.Context) {
		// 记录开始时间
		startTime := time.Now()

		// 处理请求
		c.Next()

		// 计算耗时
		duration := time.Since(startTime)

		// 打印日志
		log.Printf(
			"[%s] %s %s %d %s",
			c.Request.Method,
			c.Request.RequestURI,
			c.ClientIP(),
			c.Writer.Status(),
			duration,
		)
	}
}

package main

import (
	"log"

	"github.com/gin-gonic/gin"
	"github.com/yourusername/rest-api-todo/handlers"
	"github.com/yourusername/rest-api-todo/middleware"
	"github.com/yourusername/rest-api-todo/storage"
)

func main() {
	// 创建存储
	store := storage.NewMemoryStorage()

	// 创建处理器
	todoHandler := handlers.NewTodoHandler(store)

	// 创建Gin引擎
	router := gin.Default()

	// 添加中间件
	router.Use(middleware.Logger())

	// 添加CORS中间件（允许跨域）
	router.Use(func(c *gin.Context) {
		c.Writer.Header().Set("Access-Control-Allow-Origin", "*")
		c.Writer.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
		c.Writer.Header().Set("Access-Control-Allow-Headers", "Content-Type")
		
		if c.Request.Method == "OPTIONS" {
			c.AbortWithStatus(204)
			return
		}
		
		c.Next()
	})

	// 注册路由
	api := router.Group("/api/v1")
	{
		todos := api.Group("/todos")
		{
			todos.GET("", todoHandler.GetAll)
			todos.GET("/:id", todoHandler.GetByID)
			todos.POST("", todoHandler.Create)
			todos.PUT("/:id", todoHandler.Update)
			todos.DELETE("/:id", todoHandler.Delete)
		}
	}

	// 添加健康检查接口
	router.GET("/health", func(c *gin.Context) {
		c.JSON(200, gin.H{
			"status": "ok",
			"message": "Todo API is running",
		})
	})

	// 启动服务器
	log.Println("🚀 服务器启动在 http://localhost:8080")
	if err := router.Run(":8080"); err != nil {
		log.Fatalf("启动服务器失败: %v", err)
	}
}

package handlers

import (
	"bytes"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"testing"

	"github.com/gin-gonic/gin"
	"github.com/stretchr/testify/assert"
	"github.com/yourusername/rest-api-todo/storage"
)

func TestCreateTodo(t *testing.T) {
	// 设置测试环境
	gin.SetMode(gin.TestMode)
	store := storage.NewMemoryStorage()
	handler := NewTodoHandler(store)
	
	router := gin.New()
	router.POST("/todos", handler.Create)
	
	// 准备测试数据
	reqBody := map[string]string{
		"title":       "测试Todo",
		"description": "这是一个测试",
	}
	jsonData, _ := json.Marshal(reqBody)
	
	// 发送请求
	req, _ := http.NewRequest("POST", "/todos", bytes.NewBuffer(jsonData))
	req.Header.Set("Content-Type", "application/json")
	w := httptest.NewRecorder()
	router.ServeHTTP(w, req)
	
	// 验证结果
	assert.Equal(t, 201, w.Code)
	
	var response map[string]interface{}
	json.Unmarshal(w.Body.Bytes(), &response)
	assert.True(t, response["success"].(bool))
}