第02章 · 用户功能与 Gin / GORM 入门（正式版）

# 文件路径: ~/code/webook/ （在第四节课会正式创建，这里先体验）
# 安装 Gin 依赖（确保已 go mod init）
go get github.com/gin-gonic/gin@latest

// 文件路径: ~/code/webook/main.go（最小可运行版，体验用）
package main

import (
	"net/http"

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

func main() {
	// Engine 是 Gin 的核心抽象，代表一个逻辑上的 Web 服务器
	engine := gin.Default()

	// 注册一条路由：GET 方法 + 路径 /hello + 处理函数
	engine.GET("/hello", func(c *gin.Context) {
		// gin.Context 是本次请求的核心类型，负责"收请求 + 发响应"
		c.JSON(http.StatusOK, gin.H{"msg": "hello, world"})
	})

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

go run main.go

curl http://localhost:8080/hello

{"msg":"hello, world"}

[GIN-debug] Listening and serving HTTP on :8080
[ERROR] ... listen tcp :8080: bind: address already in use

// 文件路径: ~/code/webook/main_route.go（演示用，建议在独立临时目录里运行）
// 注意：不要和 ~/code/webook/main.go 放在同一目录，两个 main 函数会编译冲突
package main

import (
	"net/http"

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

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

	// 1. 静态路由：完全匹配路径
	engine.GET("/users/signup", func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{"msg": "signup"})
	})

	// 2. 参数路由：用 :id 捕获路径中的这一段
	// 访问 /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. 通配符路由：用 *all 捕获剩余所有路径
	// 访问 /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")  // 不存在返回默认值 "1"
		c.JSON(http.StatusOK, gin.H{"q": q, "page": page})
	})

	engine.Run(":8080")
}

curl http://localhost:8080/users/123
# 预期输出：{"id":"123"}

curl http://localhost:8080/files/a/b/c.txt
# 预期输出：{"path":"/a/b/c.txt"}

curl "http://localhost:8080/search?q=go&page=2"
# 预期输出：{"page":"2","q":"go"}

// 文件路径: ~/code/webook/internal/web/user_signup_bind.go（演示片段）
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": "注册成功"})
}

// 文件路径: ~/code/webook/internal/web/user_signup_regex.go（演示片段）
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": "注册成功"})
}

// 文件路径: ~/code/webook/internal/web/user_signup_validator.go（演示片段）
// 常用 binding 规则速查（不用背，用到查表）：
//   required        必填（不能是零值）
//   email           邮箱格式
//   min / max       字符串=长度边界；数字=数值边界
//   len             精确长度（短信验证码）
//   oneof           枚举取值（空格分隔），如 oneof=male female
//   gte / lte       ≥ / ≤
//   eqfield         必须等于另一字段（两次密码一致）
type SignUpReq struct {
	Email           string `json:"email" binding:"required,email"`
	Password        string `json:"password" binding:"required,min=8,max=72"`
	ConfirmPassword string `json:"confirmPassword" binding:"required,eqfield=Password"`
}

// 文件路径: ~/code/webook/internal/web/user_signup_err.go（演示片段）
package web

import (
	"net/http"
	"strings"

	"github.com/gin-gonic/gin"
	"github.com/go-playground/validator/v10" // Gin 依赖树里已带，直接 import
)

func (h *UserHandler) SignUp(c *gin.Context) {
	var req SignUpReq
	// ShouldBindJSON 失败不写响应，错误处理权完全在自己手里
	if err := c.ShouldBindJSON(&req); err != nil {
		// 断言成校验错误集合，逐条翻译成中文
		if ves, ok := err.(validator.ValidationErrors); ok {
			msgs := make([]string, 0, len(ves))
			for _, e := range ves {
				switch e.Field() {
				case "Email":
					msgs = append(msgs, "邮箱格式不正确")
				case "Password":
					msgs = append(msgs, "密码长度必须在 8~72 位之间")
				case "ConfirmPassword":
					msgs = append(msgs, "两次输入的密码不一致")
				default:
					msgs = append(msgs, e.Field()+" 参数不合法")
				}
			}
			c.JSON(http.StatusOK, gin.H{"msg": strings.Join(msgs, "; ")})
			return
		}
		// 断言失败说明不是校验错误，而是 JSON 本身解析不了
		c.JSON(http.StatusOK, gin.H{"msg": "请求体格式错误"})
		return
	}
	// ... 业务逻辑
}

// 文件路径: ~/code/webook/internal/web/strong_pwd_validator.go（演示片段）
package main

import (
	"net/http"

	"github.com/gin-gonic/gin"
	"github.com/gin-gonic/gin/binding"
	"github.com/go-playground/validator/v10"
)

// 定义校验函数——返回 true 表示通过
var strongPassword validator.Func = func(fl validator.FieldLevel) bool {
	pwd, ok := fl.Field().Interface().(string)
	if !ok {
		return false
	}
	hasDigit, hasSpecial := false, false
	for _, r := range pwd {
		switch {
		case r >= '0' && r <= '9':
			hasDigit = true
		case r == '!' || r == '@' || r == '#' || r == '$':
			hasSpecial = true
		}
	}
	return hasDigit && hasSpecial
}

func init() {
	// 把函数注册成名为 strongpwd 的规则（进程启动时执行一次）
	if v, ok := binding.Validator.Engine().(*validator.Validate); ok {
		v.RegisterValidation("strongpwd", strongPassword)
	}
}

type SignUpReq struct {
	// binding tag 里直接用自定义规则名，可和内置规则混用
	Password string `json:"password" binding:"required,min=8,max=72,strongpwd"`
}

func main() {
	engine := gin.Default()
	engine.POST("/users/signup", func(c *gin.Context) {
		var req SignUpReq
		if err := c.ShouldBindJSON(&req); err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"msg": err.Error()})
			return
		}
		c.JSON(http.StatusOK, gin.H{"msg": "ok"})
	})
	engine.Run(":8080")
}

go get github.com/gin-contrib/cors

// 文件路径: ~/code/webook/internal/web/engine.go（演示片段）
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{
		// 也可以用函数动态判断来源（更灵活也更安全）
		AllowOriginFunc: func(origin string) bool {
			return origin == "http://localhost:3000"
		},
		AllowCredentials: true,                 // 允许携带认证信息（cookie）
		AllowHeaders:     []string{"Content-Type", "Authorization"},
		ExposeHeaders:    []string{"x-jwt-token"}, // JWT 场景需要暴露这个头
		AllowMethods:     []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
		MaxAge:           12 * time.Hour,       // preflight 响应缓存时间
	}))

	return engine
}

// 文件路径: ~/code/webook/internal/web/logger_middleware.go（演示片段）
package web

import (
	"fmt"
	"time"

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

// Logger 返回一个 gin.HandlerFunc，即一个中间件
func Logger() gin.HandlerFunc {
	return func(c *gin.Context) {
		start := time.Now()
		// c.Next() 把控制权交给下一个 middleware / 最终 handler
		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

// 文件路径: ~/code/webook/internal/repository/dao/mysql.go（演示片段）
package dao

import (
	"fmt"
	"time"

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

func InitMySQL() (*gorm.DB, error) {
	// DSN 格式：用户名:密码@tcp(host:port)/dbname?参数
	// TranslateError: true 让 GORM 把驱动错误翻译成 gorm.ErrDuplicatedKey 等哨兵错误
	dsn := "root:root@tcp(localhost:3306)/webook?charset=utf8mb4&parseTime=True&loc=Local"
	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{TranslateError: true})
	if err != nil {
		return nil, fmt.Errorf("connect mysql: %w", err)
	}
	return db, nil
}

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

# 文件路径: ~/code/webook/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      # 停止并删容器

// 文件路径: ~/code/webook/internal/repository/dao/user.go（演示片段）
package dao

import (
	"time"

	"gorm.io/gorm"
)

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

// 文件路径: ~/code/webook/internal/repository/dao/user_crud.go（演示片段）
package dao

import "gorm.io/gorm"

type UserDAO struct {
	db *gorm.DB
}

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

// Insert 创建用户。参数是值传递：Create(&u) 会把自增 ID 回填到局部变量 u，
// 但函数返回后该副本即被丢弃，调用方拿不到这个 ID。
// 本课程注册场景不需要返回自增 ID，故用值传递即可；若要回传 ID，应把签名改成 Insert(u *User)。
func (d *UserDAO) Insert(u User) error {
	return d.db.Create(&u).Error
}

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

// UpdateByID 更新非零字段
// 注意 Updates 只更新非零字段，零值字段会被忽略
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
}

// 文件路径: ~/code/webook/internal/repository/dao/migrate.go（演示片段）
package dao

import "gorm.io/gorm"

func InitTables(db *gorm.DB) error {
	// AutoMigrate：表不存在就建表；表存在但缺列、缺索引就补上
	return db.AutoMigrate(
		&User{},
		// 后续新增表（Article、Comment...）都回到这里补一行
	)
}

// 文件路径: ~/code/webook/internal/repository/dao/base_fields.go（演示片段）
package dao

// 抽出公共字段
type BaseFields struct {
	Id    int64 `gorm:"primaryKey,autoIncrement"`
	Ctime int64
	Utime int64
}

type User struct {
	BaseFields                     // 匿名嵌入——默认平铺
	Email    string `gorm:"uniqueIndex"`
	Password string
	Nickname string
}
// users 表的列：id / ctime / utime / email / password / nickname

type Article struct {
	Base BaseFields `gorm:"embedded"` // 有名字段——必须加 embedded 才平铺
	Title string
}
// articles 表的列：id / ctime / utime / title

type Post struct {
	Base   BaseFields `gorm:"embedded"`
	Author BaseFields `gorm:"embedded;embeddedPrefix:author_"` // 重名加前缀
	Title  string
}
// posts 表的列：id / ctime / utime / author_id / author_ctime / author_utime / title

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

// 文件路径: ~/code/webook/internal/domain/user.go
package domain

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

// 文件路径: ~/code/webook/internal/repository/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
}

// 文件路径: ~/code/webook/internal/domain/user.go
package domain

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

// 文件路径: ~/code/webook/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
}

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 层业务错误
		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
}

// 文件路径: ~/code/webook/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+）识别唯一索引冲突
		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
}

// 文件路径: ~/code/webook/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 {
	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
	}
	err = bcrypt.CompareHashAndPassword([]byte(u.Password), []byte(password))
	if err != nil {
		return domain.User{}, ErrInvalidCredentials
	}
	return u, nil
}

// 文件路径: ~/code/webook/internal/web/user.go
package web

import (
	"errors"
	"net/http"

	"github.com/gin-gonic/gin"

	"webook/internal/domain"
	"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(domain.User{Email: req.Email, Password: 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": "注册成功"})
}

// 文件路径: ~/code/webook/main.go（组装片段）
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()
	userDAO := dao.NewUserDAO(db)             // DAO 层
	userRepo := repository.NewUserRepository(userDAO) // Repository 层
	userService := service.NewUserService(userRepo)    // Service 层
	userHandler := web.NewUserHandler(userService)    // Handler 层

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

// 文件路径: ~/code/webook/internal/service/bcrypt_demo.go（演示片段）
package service

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

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

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

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

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

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

// Handler 层：只依赖 Service
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

// 文件路径: ~/code/webook/internal/web/user_session.go（演示片段）
package web

import (
	"net/http"

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

func (h *UserHandler) RegisterRoutes(g *gin.RouterGroup) {
	// 1. 初始化 store：基于 cookie 的实现（开发期用，生产用 Redis）
	// 第二个 key（加密 key）长度必须是 16/24/32 字节，否则首次写 Session 会报错
	store := cookie.NewStore([]byte("a-key-for-auth-must-be-32-bytes!"),
		[]byte("a-key-for-encryption-32-bytes-ok"))
	store.Options(sessions.Options{
		MaxAge:   60 * 60 * 24,
		HttpOnly: true,
		Secure:   false, // 开发环境 false，生产必须 true
		SameSite: http.SameSiteLaxMode,
	})
	g.Use(sessions.Sessions("sess_id", store))

	g.POST("/login", h.Login)
	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
	}
	// 登录成功，把 user_id 写进 Session（数据存后端，浏览器只拿 sess_id）
	sess := sessions.Default(c)
	sess.Set("user_id", user.ID)
	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
	}
	c.Set("user_id", userID) // 传给后续 handler
	c.Next()
}

func (h *UserHandler) Profile(c *gin.Context) {
	userID := c.MustGet("user_id").(int64)
	c.JSON(http.StatusOK, gin.H{"user_id": userID})
}

// 用法上三者几乎一致——都是 Marshal / Unmarshal 一对函数
type SignupReq struct {
    Email    string `json:"email" binding:"required,email"` // tag 同时服务 JSON 映射与参数校验
    Password string `json:"password" binding:"required,min=8"`
}
req := SignupReq{Email: "a@b.com", Password: "abc123"}
data, _ := json.Marshal(req) // 想换 jsoniter / sonic，主要就是改 import 和别名

mkdir -p ~/code/webook && cd ~/code/webook
go mod init github.com/yourname/webook
go get github.com/gin-gonic/gin@latest

// 文件路径: ~/code/webook/main.go
package main

import (
	"net/http"

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

func main() {
	engine := gin.Default()
	engine.GET("/hello", func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{"msg": "hello, world"})
	})
	engine.Run(":8080")
}

go run main.go &
curl http://localhost:8080/hello
# 预期输出：{"msg":"hello, world"}

mkdir -p ~/code/webook/internal/web

// 文件路径: ~/code/webook/internal/web/user.go
package web

import (
	"net/http"

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

type UserHandler struct {
	svc UserService // 先用占位类型，第 4 步补真 Service
}

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

func (h *UserHandler) RegisterRoutes(g *gin.RouterGroup) {
	g.POST("/signup", h.SignUp)
	g.POST("/login", h.Login)
	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"})
}

# 先准备 docker-compose.yaml（见 3.5.2 节），然后：
docker compose up -d

// 文件路径: ~/code/webook/internal/repository/dao/user.go
package dao

import (
	"errors"

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

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

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

type UserDAO struct {
	db *gorm.DB
}

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

func InitMySQL() (*gorm.DB, error) {
	// TranslateError: true 让 errors.Is(err, gorm.ErrDuplicatedKey) 能生效
	dsn := "root:root@tcp(localhost:3306)/webook?charset=utf8mb4&parseTime=True&loc=Local"
	return gorm.Open(mysql.Open(dsn), &gorm.Config{TranslateError: true})
}

func (d *UserDAO) Insert(u User) error {
	err := d.db.Create(&u).Error
	if err != nil {
		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
}

// 文件路径: ~/code/webook/internal/repository/dao/migrate.go
package dao

import "gorm.io/gorm"

func InitTables(db *gorm.DB) error {
	return db.AutoMigrate(&User{})
}

// 在 main 里临时加：dao.InitTables(db) —— 见第 5 步 main 组装

// 文件路径: ~/code/webook/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}
}

func (s *UserService) Signup(user domain.User) error {
	hashed, err := bcrypt.GenerateFromPassword([]byte(user.Password), bcrypt.DefaultCost)
	if err != nil {
		return err
	}
	user.Password = string(hashed)
	if err := s.repo.Create(user); err != nil {
		if errors.Is(err, repository.ErrUserDuplicateEmail) {
			return ErrDuplicateEmail
		}
		return err
	}
	return nil
}

func (s *UserService) Login(email, password string) (domain.User, error) {
	u, err := s.repo.FindByEmail(email)
	if err != nil {
		return domain.User{}, ErrInvalidCredentials
	}
	if err := bcrypt.CompareHashAndPassword([]byte(u.Password), []byte(password)); err != nil {
		return domain.User{}, ErrInvalidCredentials
	}
	return u, nil
}

// 文件路径: ~/code/webook/main.go（最终组装版，含前面各层）
package main

import (
	"log"

	"github.com/gin-gonic/gin"

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

func main() {
	db, err := dao.InitMySQL()
	if err != nil {
		log.Fatalf("init mysql: %v", err)
	}
	if err := dao.InitTables(db); err != nil {
		log.Fatalf("init tables: %v", err)
	}
	userDAO := dao.NewUserDAO(db)
	userRepo := repository.NewUserRepository(userDAO)
	userService := service.NewUserService(userRepo)
	userHandler := web.NewUserHandler(userService)

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

curl -X POST http://localhost:8080/users/signup \
  -H 'Content-Type: application/json' \
  -d '{"email":"alice@qq.com","password":"abc123!@","confirmPassword":"abc123!@"}'
# 预期输出：{"msg":"注册成功"}

curl -X POST http://localhost:8080/users/signup \
  -H 'Content-Type: application/json' \
  -d '{"email":"alice@qq.com","password":"abc123!@","confirmPassword":"abc123!@"}'
# 预期输出：{"msg":"该邮箱已注册"}

curl -c /tmp/cookie.txt -X POST http://localhost:8080/users/login \
  -H 'Content-Type: application/json' \
  -d '{"email":"alice@qq.com","password":"abc123!@"}'
# 预期输出：{"msg":"登录成功"}，且 -c 把 sess_id 存进 /tmp/cookie.txt

curl -b /tmp/cookie.txt http://localhost:8080/users/profile
# 预期输出：{"user_id":1}

curl http://localhost:8080/users/profile
# 预期：401 Unauthorized（没带 Session）