Golang项目结构最佳实践推荐

对于Fiber项目，我推荐以下符合Go惯用法的项目结构：

// cmd/
//   main.go
// internal/
//   config/
//     config.go
//   handlers/
//     user_handler.go
//   models/
//     user.go
//   services/
//     user_service.go
//   repositories/
//     user_repository.go
//   routes/
//     routes.go
// pkg/
//   database/
//     database.go
//   middleware/
//     auth.go
//   utils/
//     validator.go

具体实现示例：

// cmd/main.go
package main

import (
    "github.com/yourproject/internal/config"
    "github.com/yourproject/internal/routes"
    "github.com/gofiber/fiber/v2"
)

func main() {
    app := fiber.New()
    
    // 初始化配置
    cfg := config.Load()
    
    // 设置路由
    routes.Setup(app, cfg)
    
    app.Listen(":3000")
}

// internal/config/config.go
package config

type Config struct {
    DBHost     string
    DBPort     string
    DBUser     string
    DBPassword string
    DBName     string
}

func Load() *Config {
    return &Config{
        DBHost:     "localhost",
        DBPort:     "5432",
        DBUser:     "postgres",
        DBPassword: "password",
        DBName:     "mydb",
    }
}

// internal/handlers/user_handler.go
package handlers

import (
    "github.com/yourproject/internal/services"
    "github.com/gofiber/fiber/v2"
)

type UserHandler struct {
    userService services.UserService
}

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

func (h *UserHandler) GetUser(c *fiber.Ctx) error {
    id := c.Params("id")
    user, err := h.userService.GetUser(id)
    if err != nil {
        return c.Status(404).JSON(fiber.Map{"error": "User not found"})
    }
    return c.JSON(user)
}

// internal/services/user_service.go
package services

import (
    "github.com/yourproject/internal/models"
    "github.com/yourproject/internal/repositories"
)

type UserService interface {
    GetUser(id string) (*models.User, error)
}

type userService struct {
    userRepo repositories.UserRepository
}

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

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

// internal/repositories/user_repository.go
package repositories

import (
    "github.com/yourproject/internal/models"
    "github.com/yourproject/pkg/database"
)

type UserRepository interface {
    FindByID(id string) (*models.User, error)
}

type userRepository struct {
    db *database.DB
}

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

func (r *userRepository) FindByID(id string) (*models.User, error) {
    var user models.User
    err := r.db.Where("id = ?", id).First(&user).Error
    return &user, err
}

// internal/routes/routes.go
package routes

import (
    "github.com/yourproject/internal/config"
    "github.com/yourproject/internal/handlers"
    "github.com/yourproject/internal/repositories"
    "github.com/yourproject/internal/services"
    "github.com/yourproject/pkg/database"
    "github.com/yourproject/pkg/middleware"
    "github.com/gofiber/fiber/v2"
)

func Setup(app *fiber.App, cfg *config.Config) {
    // 初始化数据库
    db := database.Connect(cfg)
    
    // 初始化依赖
    userRepo := repositories.NewUserRepository(db)
    userService := services.NewUserService(userRepo)
    userHandler := handlers.NewUserHandler(userService)
    
    // 路由分组
    api := app.Group("/api")
    api.Use(middleware.Logger())
    
    // 用户路由
    users := api.Group("/users")
    users.Get("/:id", userHandler.GetUser)
}

这个结构遵循Go项目的标准布局：

• cmd/：包含应用程序入口点
• internal/：私有应用程序代码，外部项目无法导入
• pkg/：可导出的库代码
• 使用依赖注入实现松耦合
• 清晰的关注点分离（handler/service/repository）

学习Go惯用法的最佳方式是：

1. 阅读官方文档和Effective Go
2. 研究标准库的源代码
3. 查看知名开源项目的结构（如Docker、Kubernetes、Prometheus）
4. 遵循Go社区的约定和模式