Golang中如何设计API项目的结构

在Go中构建API项目结构时，通常遵循标准布局模式，但会根据具体需求调整。你的结构基本合理，以下是一个更成熟的生产级结构示例：

- cmd/
  - api/
    - main.go          # 应用入口，依赖初始化
- internal/
  - api/
    - handlers/        # HTTP处理器
      - user_handler.go
      - product_handler.go
    - middleware/      # 中间件
    - routes/          # 路由定义
  - domain/
    - models/          # 领域模型
      - user.go
      - product.go
    - repositories/    # 仓储接口
      - user_repository.go
      - product_repository.go
  - services/          # 业务逻辑层
    - user_service.go
    - product_service.go
  - infrastructure/
    - db/              # 数据访问实现
      - postgres/
        - user_repository_impl.go
        - product_repository_impl.go
      - migrations/    # 数据库迁移
    - cache/           # 缓存实现
- pkg/                 # 可公开的库代码
  - utils/
  - logger/
- config/              # 配置文件
- scripts/             # 部署脚本
- go.mod
- go.sum

关于数据库访问的最佳实践，推荐使用依赖注入方式。以下是具体实现示例：

1. 仓储层接口定义 (internal/domain/repositories/user_repository.go):

package repositories

import "your-project/internal/domain/models"

type UserRepository interface {
    FindByID(id uint) (*models.User, error)
    Create(user *models.User) error
    Update(user *models.User) error
    Delete(id uint) error
}

2. 仓储实现 (internal/infrastructure/db/postgres/user_repository_impl.go):

package postgres

import (
    "gorm.io/gorm"
    "your-project/internal/domain/models"
    "your-project/internal/domain/repositories"
)

type userRepository struct {
    db *gorm.DB
}

func NewUserRepository(db *gorm.DB) repositories.UserRepository {
    return &userRepository{db: db}
}

func (r *userRepository) FindByID(id uint) (*models.User, error) {
    var user models.User
    result := r.db.First(&user, id)
    return &user, result.Error
}

func (r *userRepository) Create(user *models.User) error {
    return r.db.Create(user).Error
}

3. 服务层 (internal/services/user_service.go):

package services

import (
    "your-project/internal/domain/models"
    "your-project/internal/domain/repositories"
)

type UserService struct {
    userRepo repositories.UserRepository
}

func NewUserService(userRepo repositories.UserRepository) *UserService {
    return &UserService{userRepo: userRepo}
}

func (s *UserService) GetUser(id uint) (*models.User, error) {
    return s.userRepo.FindByID(id)
}

func (s *UserService) CreateUser(user *models.User) error {
    // 业务逻辑验证
    if user.Name == "" {
        return errors.New("user name is required")
    }
    return s.userRepo.Create(user)
}

4. 处理器层 (internal/api/handlers/user_handler.go):

package handlers

import (
    "net/http"
    "strconv"
    "your-project/internal/services"
)

type UserHandler struct {
    userService *services.UserService
}

func NewUserHandler(userService *services.UserService) *UserHandler {
    return &UserHandler{userService: userService}
}

func (h *UserHandler) GetUser(w http.ResponseWriter, r *http.Request) {
    idStr := r.URL.Query().Get("id")
    id, err := strconv.ParseUint(idStr, 10, 32)
    if err != nil {
        http.Error(w, "invalid id", http.StatusBadRequest)
        return
    }
    
    user, err := h.userService.GetUser(uint(id))
    if err != nil {
        http.Error(w, err.Error(), http.StatusNotFound)
        return
    }
    
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(user)
}

5. 依赖初始化 (cmd/api/main.go):

package main

import (
    "gorm.io/driver/postgres"
    "gorm.io/gorm"
    "your-project/internal/api/handlers"
    "your-project/internal/api/routes"
    "your-project/internal/infrastructure/db/postgres"
    "your-project/internal/services"
)

func main() {
    // 初始化数据库连接
    dsn := "host=localhost user=postgres password=postgres dbname=mydb port=5432"
    db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
    if err != nil {
        panic("failed to connect database")
    }
    
    // 初始化仓储
    userRepo := postgres.NewUserRepository(db)
    
    // 初始化服务
    userService := services.NewUserService(userRepo)
    
    // 初始化处理器
    userHandler := handlers.NewUserHandler(userService)
    
    // 设置路由
    router := routes.NewRouter(userHandler)
    
    // 启动服务器
    http.ListenAndServe(":8080", router)
}

这种结构的主要优势：

1. 关注点分离：各层职责明确，便于测试和维护
2. 依赖倒置：高层模块不依赖低层模块的具体实现
3. 易于测试：可以通过mock仓储进行单元测试
4. 可替换性：数据库实现可以轻松替换（如从PostgreSQL切换到MySQL）

对于依赖注入，Go社区常用以下方式：

• 手动依赖注入（如上述示例）
• 使用wire、fx等依赖注入框架
• 通过构造函数传递依赖

这种结构避免了全局数据库连接，使每个组件显式声明其依赖，提高了代码的可测试性和可维护性。