用户功能与 Gin/GORM 入门

# 安装依赖
go get github.com/gin-gonic/gin@latest

package main

import (
    "net/http"

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

func main() {
    // Engine 是 Gin 中的核心抽象，代表一个逻辑上的 Web 服务器
    // 一个 Go 进程可以创建多个 Engine，监听不同端口
    engine := gin.Default()

    // 注册路由：GET 方法 + 路径 + 处理函数
    engine.GET("/hello", func(c *gin.Context) {
        // gin.Context 是 Gin 的核心类型，承担"处理请求 + 返回响应"的职责
        // c.Request 是 *http.Request，c.Writer 是 http.ResponseWriter
        c.JSON(http.StatusOK, gin.H{"msg": "hello, world"})
    })

    // 监听端口并启动服务，默认 :8080
    // 启动失败最常见原因是端口被占用
    if err := engine.Run(":8080"); err != nil {
        panic(err)
    }
}

package main

import (
    "net/http"

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

func main() {
    engine := gin.Default()

    // 1. 静态路由：完全匹配
    engine.GET("/users/signup", signup)

    // 2. 参数路由：用 :name 捕获路径段
    // 请求 /users/123 时，c.Param("id") 返回 "123"
    engine.GET("/users/:id", func(c *gin.Context) {
        id := c.Param("id")
        c.JSON(http.StatusOK, gin.H{"id": id})
    })

    // 3. 通配符路由：用 *name 捕获剩余路径（不能单独出现 /users/*）
    // 请求 /files/a/b/c.txt 时，c.Param("all") 返回 "/a/b/c.txt"
    engine.GET("/files/*all", func(c *gin.Context) {
        all := c.Param("all")
        c.JSON(http.StatusOK, gin.H{"path": all})
    })

    // 查询参数：URL ?key=value，用 Query 获取
    // 请求 /search?q=go&page=2
    engine.GET("/search", func(c *gin.Context) {
        q := c.Query("q")          // 不存在返回 ""
        page := c.DefaultQuery("page", "1") // 不存在返回默认值
        c.JSON(http.StatusOK, gin.H{"q": q, "page": page})
    })

    engine.Run(":8080")
}

func signup(c *gin.Context) {
    c.JSON(http.StatusOK, gin.H{"msg": "signup"})
}

package web

import (
    "net/http"

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

// UserHandler 集中管理所有用户相关路由
// 这种"按业务模块组织 Handler"的方式在中小项目里很实用
type UserHandler struct {
    // 后续会注入 svc *userService.UserService
}

// NewUserHandler 构造函数（Go 没有构造函数，约定用 NewXXX）
func NewUserHandler() *UserHandler {
    return &UserHandler{}
}

// RegisterRoutes 注册路由
// 接收 *gin.Engine 或 *gin.RouterGroup，便于分组路由
func (h *UserHandler) RegisterRoutes(server *gin.Engine) {
    // 分组路由：所有路由都有 /users 前缀
    // 避免每个路由都手写 /users/xxx，防止手抖写错
    g := server.Group("/users")
    g.POST("/signup", h.SignUp)
    g.POST("/login", h.Login)
    g.POST("/profile", h.Profile)
    g.GET("/profile", h.Profile)
}

func (h *UserHandler) SignUp(c *gin.Context) {
    c.JSON(http.StatusOK, gin.H{"msg": "signup"})
}

func (h *UserHandler) Login(c *gin.Context) {
    c.JSON(http.StatusOK, gin.H{"msg": "login"})
}

func (h *UserHandler) Profile(c *gin.Context) {
    c.JSON(http.StatusOK, gin.H{"msg": "profile"})
}

package web

import (
    "net/http"

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

// SignUpReq 用于接收注册请求
// 建议定义为方法内部类型，限制其只在本方法使用
// 也可以定义在包级别，看团队偏好
type SignUpReq struct {
    Email           string `json:"email"`
    Password        string `json:"password"`
    ConfirmPassword string `json:"confirmPassword"`
}

func (h *UserHandler) SignUp(c *gin.Context) {
    var req SignUpReq
    // Bind 会根据 Content-Type 决定如何反序列化
    // application/json → 用 JSON 反序列化
    // 如果绑定失败，Bind 会直接写一个 400 响应到前端，无需我们处理
    if err := c.Bind(&req); err != nil {
        return // Bind 已经写了响应，直接 return
    }

    // 校验逻辑放下面...
    c.JSON(http.StatusOK, gin.H{"msg": "注册成功"})
}

package web

import (
    "net/http"
    "regexp"

    "github.com/gin-gonic/gin"
    "github.com/dlclark/regexp2" // Go 官方正则不支持 (?=.) 前瞻语法
)

// 预编译正则表达式，避免每次请求都重新编译
var (
    emailRegex = regexp.MustCompile(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`)
    // 使用 regexp2 支持 (?=) 前瞻语法
    passwordRegex = regexp2.MustCompile(
        `^(?=.*[A-Za-z])(?=.*\d)(?=.*[$@$!%*#?&])[A-Za-z\d$@$!%*#?&]{8,}$`,
        regexp2.None,
    )
)

func (h *UserHandler) SignUp(c *gin.Context) {
    var req SignUpReq
    if err := c.Bind(&req); err != nil {
        return
    }

    // 校验邮箱格式
    if !emailRegex.MatchString(req.Email) {
        c.JSON(http.StatusOK, gin.H{"msg": "邮箱格式不正确"})
        return
    }

    // 校验密码强度（regexp2 的 MatchString 返回 (bool, error)）
    ok, err := passwordRegex.MatchString(req.Password)
    if err != nil || !ok {
        c.JSON(http.StatusOK, gin.H{"msg": "密码必须不少于8位，且包含数字和特殊字符"})
        return
    }

    // 校验两次密码一致
    if req.Password != req.ConfirmPassword {
        c.JSON(http.StatusOK, gin.H{"msg": "两次输入的密码不一致"})
        return
    }

    c.JSON(http.StatusOK, gin.H{"msg": "注册成功"})
}

go get github.com/gin-gonic/contrib

package web

import (
    "net/http"
    "time"

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

func SetupEngine() *gin.Engine {
    engine := gin.Default()

    // Use 注册的 middleware 会作用于所有路由
    // cors.New 返回一个 gin.HandlerFunc
    engine.Use(cors.New(cors.Config{
        // AllowOrigins: []string{"http://localhost:3000"},
        // 也可以用函数动态判断来源
        AllowOriginFunc: func(origin string) bool {
            return origin == "http://localhost:3000"
        },
        // 允许携带认证信息（cookie）
        AllowCredentials: true,
        // 允许的请求头
        AllowHeaders: []string{"Content-Type", "Authorization"},
        // 允许前端访问的响应头（JWT 场景需要暴露 x-jwt-token）
        ExposeHeaders: []string{"x-jwt-token"},
        // 允许的方法
        AllowMethods: []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
        // preflight 响应的缓存时间
        MaxAge: 12 * time.Hour,
    }))

    return engine
}

package web

import (
    "fmt"
    "time"

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

// HandlerFunc 是 func(*Context) 的衍生类型
// 所以任何接收 *gin.Context 的函数都可以作为 middleware
func Logger() gin.HandlerFunc {
    return func(c *gin.Context) {
        start := time.Now()
        // c.Next() 把控制权交给下一个 middleware / 最终的 handler
        // 在 c.Next() 之前的代码在请求处理前执行
        c.Next()
        // 在 c.Next() 之后的代码在请求处理后执行
        fmt.Printf("[%s] %s %d %v\n",
            start.Format(time.RFC3339),
            c.Request.URL.Path,
            c.Writer.Status(),
            time.Since(start),
        )
    }
}

func main() {
    engine := gin.New()
    engine.Use(Logger())
    // ...
}

go get -u gorm.io/gorm
go get -u gorm.io/driver/mysql

package db

import (
    "fmt"
    "time"

    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)

func InitMySQL() (*gorm.DB, error) {
    // DSN 格式：用户名:密码@tcp(host:port)/dbname?参数
    dsn := "root:root@tcp(localhost:3306)/webook?charset=utf8mb4&parseTime=True&loc=Local"
    db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
    if err != nil {
        return nil, fmt.Errorf("connect mysql: %w", err)
    }
    return db, nil
}

// 简单的连接池配置（生产环境必须配置）
func mustClose(db *gorm.DB) {
    sqlDB, _ := db.DB()
    sqlDB.SetMaxOpenConns(100)           // 最大连接数
    sqlDB.SetMaxIdleConns(10)            // 最大空闲连接
    sqlDB.SetConnMaxLifetime(time.Hour)  // 连接最大存活时间
}

# docker-compose.yaml
services:
  mysql8:
    image: mysql:8.0.29
    command: --default-authentication-plugin=mysql_native_password
    environment:
      MYSQL_ROOT_PASSWORD: root
    volumes:
      - ./init:/docker-entrypoint-initdb.d  # 启动时执行初始化 SQL
    ports:
      - "3306:3306"

docker compose up -d     # 启动
docker compose down      # 停止并删除容器

package dao

import (
    "time"

    "gorm.io/gorm"
)

// gorm.Model 内置了 4 个公共字段：
//   ID        uint           `gorm:"primarykey"`
//   CreatedAt time.Time
//   UpdatedAt time.Time
//   DeletedAt gorm.DeletedAt `gorm:"index"` —— 软删除
// 实践中每家公司可能有不同规范，可以不用它，自定义 BaseModel

type User struct {
    ID       int64          `gorm:"primaryKey,autoIncrement"` // 自增主键
    Email    string         `gorm:"uniqueIndex"`               // 唯一索引
    Password string         // 默认就映射为 password 列
    Nickname string
    Birthday string
    AboutMe  string
    Ctime    int64          // 创建时间（毫秒），用 int 而非 time.Time 避免时区问题
    Utime    int64          // 更新时间
}

package dao

import "gorm.io/gorm"

type UserDAO struct {
    db *gorm.DB
}

func NewUserDAO(db *gorm.DB) *UserDAO {
    return &UserDAO{db: db}
}

// Insert 创建用户
func (d *UserDAO) Insert(u User) error {
    // Create 接收指针，会把生成的 ID 回填到 u.ID
    err := d.db.Create(&u).Error
    if err != nil {
        // 唯一索引冲突会返回特定错误，需要转换为业务错误
        return err
    }
    return nil
}

> **工程视角**：`Create(&u)` 传指针，GORM 在插入后会把数据库生成的自增 `id` 写回 `u.ID`——这是 GORM 的"主键回填"。后面写"登录成功后返回用户信息"时，你不用再查一次库拿 ID，直接用回填的 `u.ID` 即可。

// FindByEmail 按邮箱查找
func (d *UserDAO) FindByEmail(email string) (User, error) {
    var u User
    // First 取第一条，没找到返回 ErrRecordNotFound
    err := d.db.Where("email = ?", email).First(&u).Error
    return u, err
}

// FindByID 按主键查找
func (d *UserDAO) FindByID(id int64) (User, error) {
    var u User
    err := d.db.First(&u, id).Error
    return u, err
}

// UpdateByID 更新非零字段
// 注意 Updates 只更新非零字段，零值字段会被忽略
// 如果要更新零值，需要用 map 或 Select
func (d *UserDAO) UpdateByID(u User) error {
    return d.db.Model(&User{}).Where("id = ?", u.ID).
        Updates(map[string]any{
            "nickname": u.Nickname,
            "birthday": u.Birthday,
            "about_me": u.AboutMe,
        }).Error
}

// 反面教材：Handler 直接操作数据库
func (h *UserHandler) SignUp(c *gin.Context) {
    var req SignUpReq
    c.Bind(&req)
    // 直接 db.Create(...) —— 问题：
    // 1. HTTP 逻辑和数据库逻辑耦合，无法复用
    // 2. 无法单元测试（要起真实数据库）
    // 3. 没有业务逻辑层，密码加密放哪里？
}

// domain/user.go —— 业务概念
package domain

type User struct {
    ID       int64
    Email    string
    Password string
    Nickname string
}

// dao/user.go —— 数据库映射
package dao

type User struct {
    ID       int64  `gorm:"primaryKey,autoIncrement"`
    Email    string `gorm:"uniqueIndex"`
    Password string
    Nickname string
    Ctime    int64
    Utime    int64
}

// internal/domain/user.go
package domain

type User struct {
    ID       int64
    Email    string
    Password string
    Nickname string
    Birthday string
    AboutMe  string
}

// internal/repository/user.go
package repository

import (
    "errors"

    "webook/internal/domain"
    "webook/internal/repository/dao"
)

var (
    ErrUserDuplicateEmail = errors.New("邮箱冲突")
    ErrUserNotFound       = errors.New("用户不存在")
)

type UserRepository interface {
    Create(user domain.User) error
    FindByEmail(email string) (domain.User, error)
    FindByID(id int64) (domain.User, error)
    Update(user domain.User) error
}

// 用接口 + 实现的方式，方便后续切换实现（如 ES、Mongo）
type userRepository struct {
    dao *dao.UserDAO
}

func NewUserRepository(dao *dao.UserDAO) UserRepository {
    return &userRepository{dao: dao}
}

func (r *userRepository) Create(user domain.User) error {
    err := r.dao.Insert(dao.User{
        Email:    user.Email,
        Password: user.Password,
        Nickname: user.Nickname,
    })
    if errors.Is(err, dao.ErrUserDuplicateEmail) {
        // 错误别名：DAO 层的数据库错误 → Repository 层的业务错误
        // 这样上层不需要依赖 dao 包，避免跨层依赖
        return ErrUserDuplicateEmail
    }
    return err
}

func (r *userRepository) FindByEmail(email string) (domain.User, error) {
    u, err := r.dao.FindByEmail(email)
    if err != nil {
        return domain.User{}, err
    }
    return domain.User{
        ID:       u.ID,
        Email:    u.Email,
        Password: u.Password,
        Nickname: u.Nickname,
    }, nil
}

// FindByID、Update 类似...

// internal/repository/dao/user.go
package dao

import (
    "errors"

    "gorm.io/gorm"
)

var ErrUserDuplicateEmail = errors.New("邮箱冲突")

type UserDAO struct {
    db *gorm.DB
}

func NewUserDAO(db *gorm.DB) *UserDAO {
    return &UserDAO{db: db}
}

func (d *UserDAO) Insert(u User) error {
    err := d.db.Create(&u).Error
    if err != nil {
        // 用 gorm.ErrDuplicatedKey（GORM v1.25+）识别唯一索引冲突
        // 旧版本需要用 strings.Contains 判断错误消息
        if errors.Is(err, gorm.ErrDuplicatedKey) {
            return ErrUserDuplicateEmail
        }
        return err
    }
    return nil
}

func (d *UserDAO) FindByEmail(email string) (User, error) {
    var u User
    err := d.db.Where("email = ?", email).First(&u).Error
    return u, err
}

// internal/service/user.go
package service

import (
    "errors"

    "golang.org/x/crypto/bcrypt"

    "webook/internal/domain"
    "webook/internal/repository"
)

var (
    ErrInvalidCredentials = errors.New("用户名或密码不对")
    ErrDuplicateEmail     = repository.ErrUserDuplicateEmail
)

type UserService struct {
    repo repository.UserRepository
}

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

// Signup 注册
// 密码加密放在 service 层（加密是业务概念，不是存储概念）
func (s *UserService) Signup(user domain.User) error {
    // BCrypt 加密：每次加密结果不同（随机盐值），无法解密，只能比对
    // cost 控制加密性能，默认 10
    hashed, err := bcrypt.GenerateFromPassword([]byte(user.Password), bcrypt.DefaultCost)
    if err != nil {
        return err
    }
    user.Password = string(hashed)
    err = s.repo.Create(user)
    if errors.Is(err, repository.ErrUserDuplicateEmail) {
        return ErrDuplicateEmail
    }
    return err
}

// Login 登录
func (s *UserService) Login(email, password string) (domain.User, error) {
    u, err := s.repo.FindByEmail(email)
    if err != nil {
        // 不管用户不存在还是密码错，都返回同一个错误
        // 防止攻击者通过错误信息枚举出哪些邮箱注册过
        return domain.User{}, ErrInvalidCredentials
    }
    // BCrypt 比对：把明文和密文比较
    err = bcrypt.CompareHashAndPassword([]byte(u.Password), []byte(password))
    if err != nil {
        return domain.User{}, ErrInvalidCredentials
    }
    return u, nil
}

// internal/web/user.go
package web

import (
    "errors"
    "net/http"
    "regexp"

    "github.com/dlclark/regexp2"
    "github.com/gin-gonic/gin"

    "webook/internal/service"
)

type UserHandler struct {
    svc *service.UserService
}

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

func (h *UserHandler) RegisterRoutes(g *gin.RouterGroup) {
    g.POST("/signup", h.SignUp)
    g.POST("/login", h.Login)
}

func (h *UserHandler) SignUp(c *gin.Context) {
    var req struct {
        Email           string `json:"email"`
        Password        string `json:"password"`
        ConfirmPassword string `json:"confirmPassword"`
    }
    if err := c.Bind(&req); err != nil {
        return
    }
    // 校验省略...

    err := h.svc.Signup(req.Email, req.Password, ...)
    if errors.Is(err, service.ErrDuplicateEmail) {
        c.JSON(http.StatusOK, gin.H{"msg": "该邮箱已注册"})
        return
    }
    if err != nil {
        c.JSON(http.StatusOK, gin.H{"msg": "系统错误"})
        return
    }
    c.JSON(http.StatusOK, gin.H{"msg": "注册成功"})
}

package main

import (
    "github.com/gin-gonic/gin"

    "webook/internal/repository"
    "webook/internal/repository/dao"
    "webook/internal/service"
    "webook/internal/web"
)

func main() {
    db := initDB()
    // DAO 层
    userDAO := dao.NewUserDAO(db)
    // Repository 层
    userRepo := repository.NewUserRepository(userDAO)
    // Service 层
    userService := service.NewUserService(userRepo)
    // Handler 层
    userHandler := web.NewUserHandler(userService)

    engine := gin.Default()
    userHandler.RegisterRoutes(engine.Group("/users"))

    engine.Run(":8080")
}

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

// 加密：每次结果不同（因为盐值随机）
hashed1, _ := bcrypt.GenerateFromPassword([]byte("123456"), bcrypt.DefaultCost)
hashed2, _ := bcrypt.GenerateFromPassword([]byte("123456"), bcrypt.DefaultCost)
// hashed1 != hashed2，但都能通过 CompareHashAndPassword 校验

// 校验：把明文和哈希比较
err := bcrypt.CompareHashAndPassword(hashed1, []byte("123456")) // nil = 匹配

// DAO 层
var ErrUserDuplicateEmail = errors.New("邮箱冲突")
// 把 gorm.ErrDuplicatedKey 转换为 ErrUserDuplicateEmail

// Repository 层
var ErrUserDuplicateEmail = errors.New("邮箱冲突") // 同名但不同包
// 把 dao.ErrUserDuplicateEmail 转换为 repository.ErrUserDuplicateEmail

// Service 层
var ErrDuplicateEmail = repository.ErrUserDuplicateEmail
// 直接转发

// Handler 层
if errors.Is(err, service.ErrDuplicateEmail) {
    c.JSON(http.StatusOK, gin.H{"msg": "该邮箱已注册"})
}

go get github.com/gin-contrib/sessions
go get github.com/gin-contrib/sessions/cookie

package web

import (
    "net/http"

    "github.com/gin-contrib/sessions"
    "github.com/gin-contrib/sessions/cookie"
    "github.com/gin-gonic/gin"
)

type UserHandler struct {
    svc *service.UserService
}

func (h *UserHandler) RegisterRoutes(g *gin.RouterGroup) {
    // 在分组上注册 Session middleware
    // 1. 初始化 store：基于 cookie 的实现（开发期用，生产用 Redis）
    //    两个 key：Authentication（身份认证）、Encryption（数据加密）
    store := cookie.NewStore([]byte("secret-authentication-key"),
        []byte("secret-encryption-key"))
    // MaxAge 控制 Cookie 过期 + 部分 store 控制 Session 数据过期
    store.Options(sessions.Options{
        MaxAge:   60 * 60 * 24, // 1 天
        HttpOnly: true,
        Secure:   false,        // 开发环境 false，生产必须 true
        SameSite: http.SameSiteLaxMode,
    })
    g.Use(sessions.Sessions("sess_id", store))

    g.POST("/login", h.Login)
    // 需要登录的路由放在下面，加登录校验 middleware
    g.GET("/profile", h.LoginRequired, h.Profile)
}

func (h *UserHandler) Login(c *gin.Context) {
    var req struct {
        Email    string `json:"email"`
        Password string `json:"password"`
    }
    if err := c.Bind(&req); err != nil {
        return
    }
    user, err := h.svc.Login(req.Email, req.Password)
    if err != nil {
        c.JSON(http.StatusOK, gin.H{"msg": "用户名或密码不对"})
        return
    }
    // 步骤 1：登录成功，取出本次请求的 Session 对象
    sess := sessions.Default(c)
    // 步骤 2：把 user_id 写进 Session（数据存后端，浏览器只拿 sess_id）
    sess.Set("user_id", user.ID)
    // 步骤 3：设置过期时间并持久化到 store
    sess.Options(sessions.Options{MaxAge: 60 * 60 * 24})
    if err := sess.Save(); err != nil {
        c.JSON(http.StatusOK, gin.H{"msg": "系统错误"})
        return
    }
    c.JSON(http.StatusOK, gin.H{"msg": "登录成功"})
}

// LoginRequired 登录校验 middleware
func (h *UserHandler) LoginRequired(c *gin.Context) {
    sess := sessions.Default(c)
    userID, ok := sess.Get("user_id").(int64)
    if !ok || userID == 0 {
        c.AbortWithStatus(http.StatusUnauthorized)
        return
    }
    // 把 user_id 放到上下文，后续 handler 可以直接用
    c.Set("user_id", userID)
    c.Next()
}

> **工程视角**：`c.Set("user_id", ...)` + `c.MustGet("user_id")` 是 Gin 里"在 middleware 和 handler 之间传值"的标准做法。注意 `sess.Get("user_id").(int64)` 这个类型断言——Session 里存的是 `interface{}`，取出来必须断言成 `int64`，断言错类型会 panic。所以 Login 时 `sess.Set("user_id", user.ID)` 要保证 `user.ID` 本就是 `int64`，别混进 `int`。

func (h *UserHandler) Profile(c *gin.Context) {
    userID := c.MustGet("user_id").(int64)
    // 查询用户信息...
    c.JSON(http.StatusOK, gin.H{"user_id": userID})
}