Go 语言高性能 Web 服务开发:基于 Gin + GORM + Redis 构建 RESTful API

Go 语言凭借其简洁的语法、出色的并发模型和高效的运行时,已成为构建高性能 Web 服务和微服务的首选语言。本文将带你从零搭建一个生产级的 Go Web 服务 ,采用 Gin(Web 框架)+ GORM(ORM)+ Redis(缓存)+ Viper(配置管理)+ Zap(日志) 的技术栈,实现一套完整的 RESTful API(用户注册、登录、文章增删改查)。全部代码(含注释)超过 2600 字符,涵盖项目分层架构、数据库操作、缓存策略、中间件、错误处理、单元测试等核心实践,助你快速上手 Go 后端开发。


1. 系统架构与技术选型

模块 技术选型 职责
Web 框架 Gin 1.10 高性能路由、中间件、参数绑定
ORM GORM 1.25 对象关系映射,支持 MySQL/PostgreSQL
缓存 Redis 7 (go-redis/v9) 分布式缓存,存储用户会话和热点数据
配置管理 Viper 支持 YAML/JSON/环境变量,动态加载
日志 Uber Zap 结构化日志,分级输出
参数校验 go-playground/validator 请求参数验证
依赖注入 wire(可选) 编译时依赖注入,此处手动管理

项目结构(模块化) :

text

csharp 复制代码
go-web-app/
├── cmd/
│   └── server/           # 入口 main.go
├── internal/
│   ├── config/           # 配置加载
│   ├── handler/          # HTTP 处理器(Controller)
│   ├── service/          # 业务逻辑层
│   ├── repository/       # 数据访问层(DAO)
│   ├── model/            # 数据模型(GORM + 请求/响应结构)
│   ├── cache/            # Redis 缓存操作
│   ├── middleware/       # Gin 中间件(认证、日志、限流)
│   ├── logger/           # 日志初始化
│   └── utils/            # 工具函数(JWT、密码加密等)
├── pkg/                  # 可复用包(可选)
├── configs/              # 配置文件(config.yaml)
├── go.mod / go.sum
└── README.md

2. 环境准备与依赖安装

2.1 安装 Go 1.21+ 并初始化项目

bash

go 复制代码
mkdir go-web-app && cd go-web-app
go mod init github.com/yourname/go-web-app

2.2 核心依赖

bash

bash 复制代码
go get -u github.com/gin-gonic/gin
go get -u gorm.io/gorm
go get -u gorm.io/driver/mysql
go get -u github.com/redis/go-redis/v9
go get -u github.com/spf13/viper
go get -u go.uber.org/zap
go get -u github.com/golang-jwt/jwt/v5
go get -u github.com/google/uuid
go get -u golang.org/x/crypto/bcrypt

3. 配置管理(Viper)

创建 configs/config.yaml(约 60 字符):

yaml

yaml 复制代码
server:
  port: 8080
  mode: debug
mysql:
  dsn: "root:123456@tcp(127.0.0.1:3306)/go_web?charset=utf8mb4&parseTime=True&loc=Local"
redis:
  addr: "127.0.0.1:6379"
  password: ""
  db: 0
jwt:
  secret: "your-256-bit-secret"
  expire_hours: 24
log:
  level: debug
  file_path: logs/app.log

加载配置 internal/config/config.go(约 180 字符):

go

go 复制代码
package config

import (
    "github.com/spf13/viper"
    "log"
)

type Config struct {
    Server struct {
        Port int    `mapstructure:"port"`
        Mode string `mapstructure:"mode"`
    } `mapstructure:"server"`
    MySQL struct {
        DSN string `mapstructure:"dsn"`
    } `mapstructure:"mysql"`
    Redis struct {
        Addr     string `mapstructure:"addr"`
        Password string `mapstructure:"password"`
        DB       int    `mapstructure:"db"`
    } `mapstructure:"redis"`
    JWT struct {
        Secret      string `mapstructure:"secret"`
        ExpireHours int    `mapstructure:"expire_hours"`
    } `mapstructure:"jwt"`
    Log struct {
        Level    string `mapstructure:"level"`
        FilePath string `mapstructure:"file_path"`
    } `mapstructure:"log"`
}

var AppConfig *Config

func LoadConfig() {
    viper.SetConfigName("config")
    viper.SetConfigType("yaml")
    viper.AddConfigPath("./configs")
    if err := viper.ReadInConfig(); err != nil {
        log.Fatalf("读取配置文件失败: %v", err)
    }
    if err := viper.Unmarshal(&AppConfig); err != nil {
        log.Fatalf("解析配置失败: %v", err)
    }
    // 支持环境变量覆盖
    viper.AutomaticEnv()
}

4. 日志模块(Zap)

internal/logger/logger.go(约 150 字符):

go

go 复制代码
package logger

import (
    "go.uber.org/zap"
    "go.uber.org/zap/zapcore"
    "os"
    "github.com/yourname/go-web-app/internal/config"
)

var Logger *zap.Logger

func InitLogger() {
    cfg := config.AppConfig.Log
    level := zapcore.InfoLevel
    if err := level.UnmarshalText([]byte(cfg.Level)); err != nil {
        level = zapcore.DebugLevel
    }
    encoderCfg := zap.NewProductionEncoderConfig()
    encoderCfg.EncodeTime = zapcore.ISO8601TimeEncoder
    encoder := zapcore.NewJSONEncoder(encoderCfg)

    // 输出到控制台和文件
    file, _ := os.Create(cfg.FilePath)
    core := zapcore.NewTee(
        zapcore.NewCore(encoder, zapcore.AddSync(file), level),
        zapcore.NewCore(encoder, zapcore.AddSync(os.Stdout), level),
    )
    Logger = zap.New(core, zap.AddCaller(), zap.AddStacktrace(zapcore.ErrorLevel))
    defer Logger.Sync()
}

func Sync() {
    _ = Logger.Sync()
}

5. 数据模型(GORM)

internal/model/user.go 和 internal/model/article.go(约 280 字符):

go

csharp 复制代码
// model/user.go
package model

import (
    "time"
    "gorm.io/gorm"
)

type User struct {
    ID        uint           `gorm:"primaryKey" json:"id"`
    Username  string         `gorm:"uniqueIndex;size:50;not null" json:"username"`
    Password  string         `gorm:"size:255;not null" json:"-"` // 不输出
    Email     string         `gorm:"uniqueIndex;size:100" json:"email"`
    Status    int            `gorm:"default:1" json:"status"` // 1启用 0禁用
    CreatedAt time.Time      `json:"created_at"`
    UpdatedAt time.Time      `json:"updated_at"`
    DeletedAt gorm.DeletedAt `gorm:"index" json:"-"`
}

// model/article.go
type Article struct {
    ID        uint      `gorm:"primaryKey" json:"id"`
    Title     string    `gorm:"size:200;not null" json:"title"`
    Content   string    `gorm:"type:text" json:"content"`
    AuthorID  uint      `gorm:"index;not null" json:"author_id"`
    Author    User      `gorm:"foreignKey:AuthorID" json:"author,omitempty"`
    Category  string    `gorm:"size:50" json:"category"`
    ViewCount int       `gorm:"default:0" json:"view_count"`
    CreatedAt time.Time `json:"created_at"`
    UpdatedAt time.Time `json:"updated_at"`
}

6. 数据库与 Redis 初始化

internal/repository/db.go(约 120 字符):

go

go 复制代码
package repository

import (
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
    "github.com/yourname/go-web-app/internal/config"
    "github.com/yourname/go-web-app/internal/model"
    "github.com/yourname/go-web-app/internal/logger"
)

var DB *gorm.DB

func InitDB() {
    var err error
    DB, err = gorm.Open(mysql.Open(config.AppConfig.MySQL.DSN), &gorm.Config{
        SkipDefaultTransaction: true,
        PrepareStmt:            true,
    })
    if err != nil {
        logger.Logger.Fatal("数据库连接失败", zap.Error(err))
    }
    // 自动迁移
    if err := DB.AutoMigrate(&model.User{}, &model.Article{}); err != nil {
        logger.Logger.Fatal("数据库迁移失败", zap.Error(err))
    }
    logger.Logger.Info("数据库连接成功")
}

internal/cache/redis.go(约 110 字符):

go

go 复制代码
package cache

import (
    "context"
    "github.com/redis/go-redis/v9"
    "github.com/yourname/go-web-app/internal/config"
    "github.com/yourname/go-web-app/internal/logger"
)

var Rdb *redis.Client
var Ctx = context.Background()

func InitRedis() {
    Rdb = redis.NewClient(&redis.Options{
        Addr:     config.AppConfig.Redis.Addr,
        Password: config.AppConfig.Redis.Password,
        DB:       config.AppConfig.Redis.DB,
    })
    if _, err := Rdb.Ping(Ctx).Result(); err != nil {
        logger.Logger.Fatal("Redis连接失败", zap.Error(err))
    }
    logger.Logger.Info("Redis连接成功")
}

7. 工具函数(JWT + 密码加密)

internal/utils/jwt.go(约 220 字符):

go

go 复制代码
package utils

import (
    "errors"
    "time"
    "github.com/golang-jwt/jwt/v5"
    "github.com/yourname/go-web-app/internal/config"
)

type Claims struct {
    UserID   uint   `json:"user_id"`
    Username string `json:"username"`
    jwt.RegisteredClaims
}

func GenerateToken(userID uint, username string) (string, error) {
    expire := time.Duration(config.AppConfig.JWT.ExpireHours) * time.Hour
    claims := Claims{
        UserID:   userID,
        Username: username,
        RegisteredClaims: jwt.RegisteredClaims{
            ExpiresAt: jwt.NewNumericDate(time.Now().Add(expire)),
            IssuedAt:  jwt.NewNumericDate(time.Now()),
        },
    }
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    return token.SignedString([]byte(config.AppConfig.JWT.Secret))
}

func ParseToken(tokenString string) (*Claims, error) {
    token, err := jwt.ParseWithClaims(tokenString, &Claims{}, func(t *jwt.Token) (interface{}, error) {
        return []byte(config.AppConfig.JWT.Secret), nil
    })
    if err != nil {
        return nil, err
    }
    if claims, ok := token.Claims.(*Claims); ok && token.Valid {
        return claims, nil
    }
    return nil, errors.New("无效token")
}

internal/utils/password.go(约 80 字符):

go

go 复制代码
package utils

import "golang.org/x/crypto/bcrypt"

func HashPassword(password string) (string, error) {
    bytes, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
    return string(bytes), err
}

func CheckPassword(hashed, plain string) bool {
    err := bcrypt.CompareHashAndPassword([]byte(hashed), []byte(plain))
    return err == nil
}

8. Repository 层(数据访问)

internal/repository/user_repo.go(约 180 字符):

go

go 复制代码
package repository

import (
    "github.com/yourname/go-web-app/internal/model"
    "gorm.io/gorm"
)

type UserRepository struct {
    db *gorm.DB
}

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

func (r *UserRepository) Create(user *model.User) error {
    return r.db.Create(user).Error
}

func (r *UserRepository) FindByUsername(username string) (*model.User, error) {
    var user model.User
    err := r.db.Where("username = ?", username).First(&user).Error
    return &user, err
}

func (r *UserRepository) FindByID(id uint) (*model.User, error) {
    var user model.User
    err := r.db.First(&user, id).Error
    return &user, err
}

func (r *UserRepository) Update(user *model.User) error {
    return r.db.Save(user).Error
}

internal/repository/article_repo.go(约 200 字符):

go

go 复制代码
package repository

import (
    "github.com/yourname/go-web-app/internal/model"
    "gorm.io/gorm"
)

type ArticleRepository struct {
    db *gorm.DB
}

func NewArticleRepository() *ArticleRepository {
    return &ArticleRepository{db: DB}
}

func (r *ArticleRepository) Create(article *model.Article) error {
    return r.db.Create(article).Error
}

func (r *ArticleRepository) FindByID(id uint) (*model.Article, error) {
    var article model.Article
    err := r.db.Preload("Author").First(&article, id).Error
    return &article, err
}

func (r *ArticleRepository) List(page, size int, category string) ([]model.Article, int64, error) {
    var articles []model.Article
    var total int64
    query := r.db.Model(&model.Article{}).Preload("Author")
    if category != "" {
        query = query.Where("category = ?", category)
    }
    if err := query.Count(&total).Error; err != nil {
        return nil, 0, err
    }
    offset := (page - 1) * size
    err := query.Order("created_at DESC").Offset(offset).Limit(size).Find(&articles).Error
    return articles, total, err
}

func (r *ArticleRepository) Update(article *model.Article) error {
    return r.db.Save(article).Error
}

func (r *ArticleRepository) Delete(id uint) error {
    return r.db.Delete(&model.Article{}, id).Error
}

func (r *ArticleRepository) IncrementViewCount(id uint) error {
    return r.db.Model(&model.Article{}).Where("id = ?", id).UpdateColumn("view_count", gorm.Expr("view_count + 1")).Error
}

9. Service 层(业务逻辑)

internal/service/user_service.go(约 220 字符):

go

go 复制代码
package service

import (
    "errors"
    "github.com/yourname/go-web-app/internal/model"
    "github.com/yourname/go-web-app/internal/repository"
    "github.com/yourname/go-web-app/internal/utils"
)

type UserService struct {
    repo *repository.UserRepository
}

func NewUserService() *UserService {
    return &UserService{repo: repository.NewUserRepository()}
}

func (s *UserService) Register(username, password, email string) (*model.User, error) {
    // 检查用户名是否存在
    if _, err := s.repo.FindByUsername(username); err == nil {
        return nil, errors.New("用户名已存在")
    }
    hashed, err := utils.HashPassword(password)
    if err != nil {
        return nil, err
    }
    user := &model.User{
        Username: username,
        Password: hashed,
        Email:    email,
        Status:   1,
    }
    if err := s.repo.Create(user); err != nil {
        return nil, err
    }
    return user, nil
}

func (s *UserService) Login(username, password string) (string, *model.User, error) {
    user, err := s.repo.FindByUsername(username)
    if err != nil {
        return "", nil, errors.New("用户名或密码错误")
    }
    if user.Status == 0 {
        return "", nil, errors.New("用户已被禁用")
    }
    if !utils.CheckPassword(user.Password, password) {
        return "", nil, errors.New("用户名或密码错误")
    }
    token, err := utils.GenerateToken(user.ID, user.Username)
    return token, user, err
}

internal/service/article_service.go(约 250 字符):

go

go 复制代码
package service

import (
    "errors"
    "github.com/yourname/go-web-app/internal/model"
    "github.com/yourname/go-web-app/internal/repository"
    "github.com/yourname/go-web-app/internal/cache"
    "encoding/json"
    "time"
)

type ArticleService struct {
    repo *repository.ArticleRepository
}

func NewArticleService() *ArticleService {
    return &ArticleService{repo: repository.NewArticleRepository()}
}

func (s *ArticleService) Create(title, content, category string, authorID uint) (*model.Article, error) {
    article := &model.Article{
        Title:    title,
        Content:  content,
        Category: category,
        AuthorID: authorID,
    }
    if err := s.repo.Create(article); err != nil {
        return nil, err
    }
    return article, nil
}

func (s *ArticleService) GetArticleByID(id uint) (*model.Article, error) {
    // 先查缓存
    cacheKey := "article:" + string(rune(id))
    val, err := cache.Rdb.Get(cache.Ctx, cacheKey).Result()
    if err == nil {
        var article model.Article
        if err := json.Unmarshal([]byte(val), &article); err == nil {
            return &article, nil
        }
    }
    // 查数据库
    article, err := s.repo.FindByID(id)
    if err != nil {
        return nil, errors.New("文章不存在")
    }
    // 异步增加浏览量
    go func() {
        _ = s.repo.IncrementViewCount(id)
    }()
    // 写入缓存(10分钟)
    data, _ := json.Marshal(article)
    _ = cache.Rdb.Set(cache.Ctx, cacheKey, data, 10*time.Minute).Err()
    return article, nil
}

func (s *ArticleService) ListArticles(page, size int, category string) ([]model.Article, int64, error) {
    return s.repo.List(page, size, category)
}

func (s *ArticleService) UpdateArticle(id uint, title, content, category string) (*model.Article, error) {
    article, err := s.repo.FindByID(id)
    if err != nil {
        return nil, errors.New("文章不存在")
    }
    if title != "" {
        article.Title = title
    }
    if content != "" {
        article.Content = content
    }
    if category != "" {
        article.Category = category
    }
    if err := s.repo.Update(article); err != nil {
        return nil, err
    }
    // 删除缓存
    cacheKey := "article:" + string(rune(id))
    _ = cache.Rdb.Del(cache.Ctx, cacheKey).Err()
    return article, nil
}

func (s *ArticleService) DeleteArticle(id uint) error {
    if err := s.repo.Delete(id); err != nil {
        return err
    }
    cacheKey := "article:" + string(rune(id))
    _ = cache.Rdb.Del(cache.Ctx, cacheKey).Err()
    return nil
}

10. Handler 层(控制器)与路由

10.1 请求/响应结构(internal/model/dto.go,约 120 字符)

go

c 复制代码
package model

type RegisterRequest struct {
    Username string `json:"username" binding:"required,min=3,max=20"`
    Password string `json:"password" binding:"required,min=6"`
    Email    string `json:"email" binding:"required,email"`
}

type LoginRequest struct {
    Username string `json:"username" binding:"required"`
    Password string `json:"password" binding:"required"`
}

type CreateArticleRequest struct {
    Title    string `json:"title" binding:"required"`
    Content  string `json:"content" binding:"required"`
    Category string `json:"category"`
}

type UpdateArticleRequest struct {
    Title    string `json:"title"`
    Content  string `json:"content"`
    Category string `json:"category"`
}

type ArticleListQuery struct {
    Page     int    `form:"page" binding:"min=1"`
    Size     int    `form:"size" binding:"min=1,max=100"`
    Category string `form:"category"`
}

10.2 用户 Handler(internal/handler/user_handler.go,约 220 字符)

go

go 复制代码
package handler

import (
    "net/http"
    "github.com/gin-gonic/gin"
    "github.com/yourname/go-web-app/internal/model"
    "github.com/yourname/go-web-app/internal/service"
)

type UserHandler struct {
    svc *service.UserService
}

func NewUserHandler() *UserHandler {
    return &UserHandler{svc: service.NewUserService()}
}

func (h *UserHandler) Register(c *gin.Context) {
    var req model.RegisterRequest
    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"code": 400, "msg": "参数错误: " + err.Error()})
        return
    }
    user, err := h.svc.Register(req.Username, req.Password, req.Email)
    if err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"code": 400, "msg": err.Error()})
        return
    }
    c.JSON(http.StatusOK, gin.H{"code": 0, "msg": "注册成功", "data": user})
}

func (h *UserHandler) Login(c *gin.Context) {
    var req model.LoginRequest
    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"code": 400, "msg": "参数错误"})
        return
    }
    token, user, err := h.svc.Login(req.Username, req.Password)
    if err != nil {
        c.JSON(http.StatusUnauthorized, gin.H{"code": 401, "msg": err.Error()})
        return
    }
    c.JSON(http.StatusOK, gin.H{
        "code": 0,
        "msg":  "登录成功",
        "data": gin.H{"token": token, "user": user},
    })
}

10.3 文章 Handler(internal/handler/article_handler.go,约 300 字符)

go

go 复制代码
package handler

import (
    "net/http"
    "strconv"
    "github.com/gin-gonic/gin"
    "github.com/yourname/go-web-app/internal/model"
    "github.com/yourname/go-web-app/internal/service"
    "github.com/yourname/go-web-app/internal/utils"
)

type ArticleHandler struct {
    svc *service.ArticleService
}

func NewArticleHandler() *ArticleHandler {
    return &ArticleHandler{svc: service.NewArticleService()}
}

// 创建文章(需要登录)
func (h *ArticleHandler) Create(c *gin.Context) {
    claims, exists := c.Get("claims")
    if !exists {
        c.JSON(http.StatusUnauthorized, gin.H{"code": 401, "msg": "未登录"})
        return
    }
    userClaims := claims.(*utils.Claims)
    var req model.CreateArticleRequest
    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"code": 400, "msg": "参数错误"})
        return
    }
    article, err := h.svc.Create(req.Title, req.Content, req.Category, userClaims.UserID)
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"code": 500, "msg": err.Error()})
        return
    }
    c.JSON(http.StatusOK, gin.H{"code": 0, "msg": "创建成功", "data": article})
}

func (h *ArticleHandler) Get(c *gin.Context) {
    id, _ := strconv.Atoi(c.Param("id"))
    article, err := h.svc.GetArticleByID(uint(id))
    if err != nil {
        c.JSON(http.StatusNotFound, gin.H{"code": 404, "msg": err.Error()})
        return
    }
    c.JSON(http.StatusOK, gin.H{"code": 0, "data": article})
}

func (h *ArticleHandler) List(c *gin.Context) {
    var query model.ArticleListQuery
    if err := c.ShouldBindQuery(&query); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"code": 400, "msg": "参数错误"})
        return
    }
    if query.Page == 0 {
        query.Page = 1
    }
    if query.Size == 0 {
        query.Size = 10
    }
    articles, total, err := h.svc.ListArticles(query.Page, query.Size, query.Category)
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"code": 500, "msg": err.Error()})
        return
    }
    c.JSON(http.StatusOK, gin.H{
        "code": 0,
        "data": gin.H{
            "list":  articles,
            "total": total,
            "page":  query.Page,
            "size":  query.Size,
        },
    })
}

func (h *ArticleHandler) Update(c *gin.Context) {
    id, _ := strconv.Atoi(c.Param("id"))
    var req model.UpdateArticleRequest
    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"code": 400, "msg": "参数错误"})
        return
    }
    article, err := h.svc.UpdateArticle(uint(id), req.Title, req.Content, req.Category)
    if err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"code": 400, "msg": err.Error()})
        return
    }
    c.JSON(http.StatusOK, gin.H{"code": 0, "msg": "更新成功", "data": article})
}

func (h *ArticleHandler) Delete(c *gin.Context) {
    id, _ := strconv.Atoi(c.Param("id"))
    if err := h.svc.DeleteArticle(uint(id)); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"code": 400, "msg": err.Error()})
        return
    }
    c.JSON(http.StatusOK, gin.H{"code": 0, "msg": "删除成功"})
}

10.4 中间件(JWT 认证 + 日志)

internal/middleware/auth.go(约 120 字符):

go

go 复制代码
package middleware

import (
    "net/http"
    "strings"
    "github.com/gin-gonic/gin"
    "github.com/yourname/go-web-app/internal/utils"
)

func AuthMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        authHeader := c.GetHeader("Authorization")
        if authHeader == "" {
            c.JSON(http.StatusUnauthorized, gin.H{"code": 401, "msg": "缺少token"})
            c.Abort()
            return
        }
        parts := strings.SplitN(authHeader, " ", 2)
        if len(parts) != 2 || parts[0] != "Bearer" {
            c.JSON(http.StatusUnauthorized, gin.H{"code": 401, "msg": "token格式错误"})
            c.Abort()
            return
        }
        claims, err := utils.ParseToken(parts[1])
        if err != nil {
            c.JSON(http.StatusUnauthorized, gin.H{"code": 401, "msg": "无效token: " + err.Error()})
            c.Abort()
            return
        }
        c.Set("claims", claims)
        c.Next()
    }
}

internal/middleware/logger.go(约 80 字符):

go

scss 复制代码
package middleware

import (
    "time"
    "github.com/gin-gonic/gin"
    "github.com/yourname/go-web-app/internal/logger"
    "go.uber.org/zap"
)

func LoggerMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        start := time.Now()
        c.Next()
        duration := time.Since(start)
        logger.Logger.Info("HTTP请求",
            zap.String("method", c.Request.Method),
            zap.String("path", c.Request.URL.Path),
            zap.Int("status", c.Writer.Status()),
            zap.Duration("duration", duration),
        )
    }
}

10.5 路由注册与主程序

internal/router/router.go(约 150 字符):

go

erlang 复制代码
package router

import (
    "github.com/gin-gonic/gin"
    "github.com/yourname/go-web-app/internal/handler"
    "github.com/yourname/go-web-app/internal/middleware"
)

func SetupRouter() *gin.Engine {
    r := gin.New()
    r.Use(gin.Recovery())
    r.Use(middleware.LoggerMiddleware())

    // 用户接口
    userHandler := handler.NewUserHandler()
    r.POST("/api/register", userHandler.Register)
    r.POST("/api/login", userHandler.Login)

    // 文章接口(需认证)
    articleHandler := handler.NewArticleHandler()
    auth := r.Group("/api/articles")
    auth.Use(middleware.AuthMiddleware())
    {
        auth.POST("/", articleHandler.Create)
        auth.GET("/:id", articleHandler.Get)
        auth.GET("/", articleHandler.List)
        auth.PUT("/:id", articleHandler.Update)
        auth.DELETE("/:id", articleHandler.Delete)
    }
    return r
}

cmd/server/main.go(约 140 字符):

go

go 复制代码
package main

import (
    "fmt"
    "net/http"
    "github.com/yourname/go-web-app/internal/config"
    "github.com/yourname/go-web-app/internal/logger"
    "github.com/yourname/go-web-app/internal/repository"
    "github.com/yourname/go-web-app/internal/cache"
    "github.com/yourname/go-web-app/internal/router"
)

func main() {
    // 加载配置
    config.LoadConfig()
    // 初始化日志
    logger.InitLogger()
    defer logger.Sync()
    // 初始化数据库
    repository.InitDB()
    // 初始化Redis
    cache.InitRedis()
    // 设置路由
    r := router.SetupRouter()
    // 启动服务
    port := config.AppConfig.Server.Port
    addr := fmt.Sprintf(":%d", port)
    logger.Logger.Info("服务启动", zap.String("addr", addr))
    if err := http.ListenAndServe(addr, r); err != nil {
        logger.Logger.Fatal("服务启动失败", zap.Error(err))
    }
}

11. 单元测试(示例)

internal/service/article_service_test.go(约 150 字符):

go

go 复制代码
package service

import (
    "testing"
    "github.com/stretchr/testify/assert"
    "github.com/yourname/go-web-app/internal/model"
)

// 此处需要mock repository,简化示例
func TestArticleService_Create(t *testing.T) {
    // 因依赖数据库,实际使用mock或测试数据库
    // 略
    assert.True(t, true)
}

12. 运行与测试

12.1 启动 MySQL 和 Redis(Docker)

bash

arduino 复制代码
docker run -d --name mysql -e MYSQL_ROOT_PASSWORD=123456 -p 3306:3306 mysql:8
docker run -d --name redis -p 6379:6379 redis:7

12.2 运行服务

bash

go 复制代码
go run cmd/server/main.go

12.3 API 测试(使用 curl)

bash

makefile 复制代码
# 注册
curl -X POST http://localhost:8080/api/register -H "Content-Type: application/json" -d '{"username":"alice","password":"123456","email":"alice@test.com"}'
# 登录
curl -X POST http://localhost:8080/api/login -H "Content-Type: application/json" -d '{"username":"alice","password":"123456"}'
# 创建文章(带 token)
curl -X POST http://localhost:8080/api/articles -H "Authorization: Bearer <your_token>" -H "Content-Type: application/json" -d '{"title":"Go 语言入门","content":"Go 是静态语言...","category":"编程"}'
# 获取文章列表
curl http://localhost:8080/api/articles?page=1&size=10

13. 总结与优化建议

本文完整实现了一个基于 Gin + GORM + Redis + Viper + Zap 的 Go Web 服务,涵盖用户认证、文章管理、缓存、中间件等核心模块。全部代码(含注释)总计约 2700 字符,结构清晰,符合企业级项目分层。

生产级增强建议:

  • 优雅关闭 :使用 context 和 signal 实现服务平滑退出。
  • 连接池:配置 GORM 和 Redis 的连接池参数。
  • 分布式锁:利用 Redis 实现防止库存超卖等场景。
  • API 版本管理 :使用路由分组 /v1/api。
  • Docker 打包:编写 Dockerfile 和 docker-compose 一键部署。
  • 配置加密 :使用 SOPS 或 Vault 管理敏感信息。
  • 错误码统一:定义业务错误码(如 10001 用户名已存在)。

Go 语言的简洁和高效让 Web 开发变得愉快,掌握这套技术栈,你将能够独立构建高性能的后端服务。如果本文对你有帮助,欢迎在思否评论区交流讨论。

相关推荐
码事漫谈4 小时前
以后人人都可以成为导演
后端
Resean02234 小时前
Spring 源码分析(二)配置类的解析与扫描
java·后端·spring
一只爱撸猫的程序猿4 小时前
五周、两个开源仓库、九次拦截之后:AI 时代程序员缺的到底是什么
人工智能·后端·开源
北城笑笑5 小时前
Vue 110 ,若依SSE流式接口限次空500排查与解决
前端·javascript·vue.js·后端·vue
ServBay6 小时前
Local harness 将退役,VS Code 本地开发要不要搬到云端?
后端·ai编程·visual studio code
ashiho6 小时前
【LeetCode hot 100】3. 无重复字符的最长子串 (三种解法)
java·数据结构·后端·算法·leetcode·滑动窗口
张一凡937 小时前
你的 AGENTS.md,真的管到模型写代码了吗?
前端·后端·agent
00后程序员7 小时前
iOS 实时活动怎么开发,Windows 上用 KXBuild 和 ActivityKit 写灵动岛
后端·ios
程序员cxuan7 小时前
推荐 10 个 WorkBuddy 中的邪修用法
人工智能·后端·程序员
Bacon8 小时前
给项目做一次"全身 CT":Agent Skills 生态里的代码体检全链路
前端·人工智能·后端