【Golang】Java开发者的Golang快速上手指南——从SpringBoot到Gin+GORM

// ============ Java vs Golang 变量声明 ============

// Java
// String name = "张三";
// int age = 25;
// final String CONSTANT = "常量";

// Golang
var name string = "张三"      // 完整声明
var age = 25                  // 类型推断
count := 100                  // 短变量声明（最常用，只能在函数内使用）
const CONSTANT = "常量"       // 常量

// 多变量声明
var (
    host     string = "localhost"
    port     int    = 8080
    debug    bool   = true
)

// ============ Java vs Golang 函数定义 ============

// Java
// public String sayHello(String name) {
//     return "Hello, " + name;
// }

// Golang - 返回值在参数后面
func sayHello(name string) string {
    return "Hello, " + name
}

// 多返回值（Go的特色，用于返回结果+错误）
func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("除数不能为0")
    }
    return a / b, nil
}

// 调用多返回值函数
result, err := divide(10, 2)
if err != nil {
    // 处理错误
    log.Fatal(err)
}
fmt.Println(result) // 5

// 命名返回值
func getUser() (name string, age int) {
    name = "张三"
    age = 25
    return // 裸返回
}

// ============ Java vs Golang 类/结构体 ============

// Java
// @Data
// public class User {
//     private Long id;
//     private String username;
//     private String password;
// }

// Golang - 使用struct
type User struct {
    ID       int64  `json:"id" gorm:"primaryKey"`
    Username string `json:"username" gorm:"unique;not null"`
    Password string `json:"-" gorm:"not null"` // json:"-" 表示JSON序列化时忽略
}

// 创建结构体实例
user1 := User{ID: 1, Username: "admin", Password: "123456"}
user2 := User{Username: "test"} // 其他字段为零值
user3 := &User{}                // 指针类型

// 访问字段
fmt.Println(user1.Username)

// ============ Java vs Golang 方法 ============

// Java - 方法定义在类内部
// public class User {
//     public String getInfo() {
//         return "User: " + this.username;
//     }
// }

// Golang - 方法定义在结构体外部，通过接收者关联
type User struct {
    ID       int64
    Username string
}

// 值接收者（类似Java的普通方法）
func (u User) GetInfo() string {
    return "User: " + u.Username
}

// 指针接收者（可以修改结构体字段，类似Java的setter）
func (u *User) SetUsername(name string) {
    u.Username = name
}

// 调用
user := User{ID: 1, Username: "admin"}
fmt.Println(user.GetInfo())  // User: admin
user.SetUsername("newname")
fmt.Println(user.Username)   // newname

// ============ Java vs Golang 接口 ============

// Java - 显式实现
// public interface UserService {
//     User findById(Long id);
// }
// public class UserServiceImpl implements UserService {
//     @Override
//     public User findById(Long id) { ... }
// }

// Golang - 隐式实现（鸭子类型）
type UserService interface {
    FindByID(id int64) (*User, error)
    Create(user *User) error
}

// 只要实现了接口的所有方法，就自动实现了该接口，无需显式声明
type UserServiceImpl struct {
    repo UserRepository
}

func (s *UserServiceImpl) FindByID(id int64) (*User, error) {
    return s.repo.FindByID(id)
}

func (s *UserServiceImpl) Create(user *User) error {
    return s.repo.Create(user)
}

// UserServiceImpl 自动实现了 UserService 接口
var _ UserService = (*UserServiceImpl)(nil) // 编译期检查

// ============ Java vs Golang 错误处理 ============

// Java - 异常
// try {
//     User user = userService.findById(id);
// } catch (UserNotFoundException e) {
//     log.error("用户不存在", e);
// }

// Golang - 错误返回值（没有try-catch）
user, err := userService.FindByID(id)
if err != nil {
    // 处理错误
    log.Printf("查询用户失败: %v", err)
    return nil, err
}
// 正常处理
fmt.Println(user.Username)

// 自定义错误
var ErrUserNotFound = errors.New("用户不存在")

func (s *UserServiceImpl) FindByID(id int64) (*User, error) {
    user, err := s.repo.FindByID(id)
    if err != nil {
        return nil, ErrUserNotFound
    }
    return user, nil
}

// 错误判断
if errors.Is(err, ErrUserNotFound) {
    // 处理用户不存在的情况
}

// ============ Java vs Golang 集合 ============

// Java
// List<String> list = new ArrayList<>();
// Map<String, Integer> map = new HashMap<>();

// Golang - 切片（动态数组）
var slice []string                    // 声明
slice = make([]string, 0)             // 初始化
slice = []string{"a", "b", "c"}       // 字面量初始化
slice = append(slice, "d")            // 追加元素
fmt.Println(len(slice))               // 长度: 4
fmt.Println(slice[0])                 // 访问: a

// 遍历切片
for index, value := range slice {
    fmt.Printf("index: %d, value: %s\n", index, value)
}

// Golang - Map
var m map[string]int                  // 声明
m = make(map[string]int)              // 初始化
m = map[string]int{"age": 25}         // 字面量初始化
m["score"] = 100                      // 添加/修改
value, exists := m["age"]             // 获取（推荐用两个返回值判断是否存在）
delete(m, "age")                      // 删除

// 遍历Map
for key, value := range m {
    fmt.Printf("key: %s, value: %d\n", key, value)
}

// ============ Java vs Golang 包管理 ============

// Java - Maven pom.xml
// <dependency>
//     <groupId>org.springframework.boot</groupId>
//     <artifactId>spring-boot-starter-web</artifactId>
// </dependency>

// Golang - go.mod
// module user-login-demo
// go 1.21
// require (
//     github.com/gin-gonic/gin v1.9.1
//     gorm.io/gorm v1.25.5
// )

// 导入包
import (
    "fmt"           // 标准库
    "errors"

    "github.com/gin-gonic/gin"  // 第三方库
    "gorm.io/gorm"

    "user-login-demo/model"     // 项目内部包
    "user-login-demo/service"
)

// 别名导入
import (
    gormMysql "gorm.io/driver/mysql"  // 给包起别名
)

// 空白导入（只执行init函数，不直接使用）
import (
    _ "github.com/go-sql-driver/mysql"
)

// main.go
package main

import (
    "github.com/gin-gonic/gin"
    "net/http"
)

func main() {
    // 创建Gin引擎（类似于new SpringApplication()）
    r := gin.Default() // 包含Logger和Recovery中间件

    // 注册路由（类似于@GetMapping）
    r.GET("/hello", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{
            "message": "Hello, World!",
        })
    })

    // 启动服务（类似于SpringApplication.run()）
    r.Run(":8080") // 监听 0.0.0.0:8080
}

// ============ 路由注册 ============

r := gin.Default()

// RESTful API
r.GET("/users", listUsers)       // 查询列表
r.GET("/users/:id", getUser)     // 查询单个 :id是路径参数
r.POST("/users", createUser)     // 创建
r.PUT("/users/:id", updateUser)  // 更新
r.DELETE("/users/:id", deleteUser) // 删除

// 路由分组（类似于@RequestMapping在类上）
api := r.Group("/api/v1")
{
    api.GET("/users", listUsers)
    api.POST("/users", createUser)

    // 需要认证的路由
    auth := api.Group("/")
    auth.Use(AuthMiddleware()) // 添加认证中间件
    {
        auth.GET("/profile", getProfile)
    }
}

// ============ 获取各类请求参数 ============

// 1. 路径参数 /users/:id
// Java: @PathVariable Long id
func getUser(c *gin.Context) {
    id := c.Param("id") // 返回string
    // 转换为int64
    idInt, err := strconv.ParseInt(id, 10, 64)
    if err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": "invalid id"})
        return
    }
    // ...
}

// 2. Query参数 /users?page=1&size=10
// Java: @RequestParam Integer page
func listUsers(c *gin.Context) {
    page := c.DefaultQuery("page", "1")      // 带默认值
    size := c.Query("size")                   // 无默认值，不存在返回""
    keyword := c.QueryArray("keyword")        // 数组参数
}

// 3. JSON Body
// Java: @RequestBody LoginRequest request
type LoginRequest struct {
    Username string `json:"username" binding:"required"`
    Password string `json:"password" binding:"required,min=6"`
}

func login(c *gin.Context) {
    var req LoginRequest
    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }
    // req.Username, req.Password 可用
}

// 4. 表单参数
func formHandler(c *gin.Context) {
    username := c.PostForm("username")
    password := c.DefaultPostForm("password", "")
}

// 5. Header
func headerHandler(c *gin.Context) {
    token := c.GetHeader("Authorization")
}

// ============ 响应处理 ============

// 1. JSON响应
c.JSON(http.StatusOK, gin.H{
    "code":    200,
    "message": "success",
    "data":    user,
})

// 2. 使用结构体响应
type Response struct {
    Code    int         `json:"code"`
    Message string      `json:"message"`
    Data    interface{} `json:"data,omitempty"`
}

c.JSON(http.StatusOK, Response{
    Code:    200,
    Message: "success",
    Data:    user,
})

// 3. 错误响应
c.JSON(http.StatusBadRequest, gin.H{
    "code":    400,
    "message": "参数错误",
})

// 4. 重定向
c.Redirect(http.StatusMovedPermanently, "https://example.com")

// 5. 设置Header
c.Header("X-Custom-Header", "value")

// 6. 设置Cookie
c.SetCookie("token", "xxx", 3600, "/", "localhost", false, true)

// ============ 中间件 ============
// 类似于Java的Filter/Interceptor

// 定义中间件
func LoggerMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        // 请求前
        startTime := time.Now()
        path := c.Request.URL.Path

        c.Next() // 继续处理请求

        // 请求后
        latency := time.Since(startTime)
        statusCode := c.Writer.Status()
        log.Printf("[%d] %s %v", statusCode, path, latency)
    }
}

// 认证中间件
func AuthMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        token := c.GetHeader("Authorization")
        if token == "" {
            c.JSON(http.StatusUnauthorized, gin.H{"error": "未登录"})
            c.Abort() // 终止后续处理
            return
        }

        // 解析token，获取用户信息
        userID, err := parseToken(token)
        if err != nil {
            c.JSON(http.StatusUnauthorized, gin.H{"error": "token无效"})
            c.Abort()
            return
        }

        // 将用户信息存入Context，后续Handler可以获取
        c.Set("userID", userID)
        c.Next()
    }
}

// 在Handler中获取中间件设置的值
func getProfile(c *gin.Context) {
    userID, _ := c.Get("userID")
    // 或者使用类型断言
    userID := c.MustGet("userID").(int64)
}

// 使用中间件
r := gin.Default()
r.Use(LoggerMiddleware()) // 全局中间件

api := r.Group("/api")
api.Use(AuthMiddleware()) // 分组中间件

// config/database.go
package config

import (
    "fmt"
    "log"

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

var DB *gorm.DB

func InitDB() {
    dsn := "root:password@tcp(127.0.0.1:3306)/test_db?charset=utf8mb4&parseTime=True&loc=Local"

    db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
        Logger: logger.Default.LogMode(logger.Info), // 打印SQL日志
    })
    if err != nil {
        log.Fatal("数据库连接失败:", err)
    }

    // 获取底层sql.DB，设置连接池
    sqlDB, _ := db.DB()
    sqlDB.SetMaxIdleConns(10)           // 最大空闲连接数
    sqlDB.SetMaxOpenConns(100)          // 最大打开连接数
    sqlDB.SetConnMaxLifetime(time.Hour) // 连接最大存活时间

    DB = db
    log.Println("数据库连接成功")
}

// model/user.go
package model

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

// User 用户模型
// 类似于Java的@Entity
type User struct {
    ID        int64          `json:"id" gorm:"primaryKey;autoIncrement"`
    Username  string         `json:"username" gorm:"type:varchar(50);uniqueIndex;not null"`
    Password  string         `json:"-" gorm:"type:varchar(255);not null"` // json:"-" 不返回给前端
    Nickname  string         `json:"nickname" gorm:"type:varchar(50)"`
    Email     string         `json:"email" gorm:"type:varchar(100)"`
    Status    int            `json:"status" gorm:"default:1"` // 1:正常 0:禁用
    CreatedAt time.Time      `json:"createdAt" gorm:"autoCreateTime"`
    UpdatedAt time.Time      `json:"updatedAt" gorm:"autoUpdateTime"`
    DeletedAt gorm.DeletedAt `json:"-" gorm:"index"` // 软删除
}

// TableName 指定表名（默认是结构体名的蛇形复数：users）
func (User) TableName() string {
    return "t_user"
}

// 自动建表（类似于JPA的ddl-auto）
func AutoMigrate() {
    err := config.DB.AutoMigrate(&User{})
    if err != nil {
        log.Fatal("自动迁移失败:", err)
    }
}

// repository/user_repository.go
package repository

import (
    "user-login-demo/config"
    "user-login-demo/model"
    "gorm.io/gorm"
)

type UserRepository struct {
    db *gorm.DB
}

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

// Create 创建用户
// Java: userMapper.insert(user)
func (r *UserRepository) Create(user *model.User) error {
    return r.db.Create(user).Error
}

// FindByID 根据ID查询
// Java: userMapper.selectById(id)
func (r *UserRepository) FindByID(id int64) (*model.User, error) {
    var user model.User
    err := r.db.First(&user, id).Error
    if err != nil {
        return nil, err
    }
    return &user, nil
}

// FindByUsername 根据用户名查询
// Java: userMapper.selectOne(new QueryWrapper<User>().eq("username", username))
func (r *UserRepository) FindByUsername(username string) (*model.User, error) {
    var user model.User
    err := r.db.Where("username = ?", username).First(&user).Error
    if err != nil {
        return nil, err
    }
    return &user, nil
}

// FindAll 查询所有
// Java: userMapper.selectList(null)
func (r *UserRepository) FindAll() ([]model.User, error) {
    var users []model.User
    err := r.db.Find(&users).Error
    return users, err
}

// FindByPage 分页查询
// Java: userMapper.selectPage(page, queryWrapper)
func (r *UserRepository) FindByPage(page, pageSize int) ([]model.User, int64, error) {
    var users []model.User
    var total int64

    offset := (page - 1) * pageSize

    // 查询总数
    r.db.Model(&model.User{}).Count(&total)

    // 分页查询
    err := r.db.Offset(offset).Limit(pageSize).Find(&users).Error

    return users, total, err
}

// Update 更新用户
// Java: userMapper.updateById(user)
func (r *UserRepository) Update(user *model.User) error {
    return r.db.Save(user).Error
}

// UpdateFields 更新指定字段
// Java: userMapper.update(null, new UpdateWrapper<User>().eq("id", id).set("nickname", nickname))
func (r *UserRepository) UpdateFields(id int64, fields map[string]interface{}) error {
    return r.db.Model(&model.User{}).Where("id = ?", id).Updates(fields).Error
}

// Delete 删除用户（软删除）
// Java: userMapper.deleteById(id)
func (r *UserRepository) Delete(id int64) error {
    return r.db.Delete(&model.User{}, id).Error
}

// 真正删除
func (r *UserRepository) HardDelete(id int64) error {
    return r.db.Unscoped().Delete(&model.User{}, id).Error
}

// 条件查询
db.Where("status = ?", 1).
   Where("created_at > ?", time.Now().AddDate(0, 0, -7)).
   Find(&users)

// OR条件
db.Where("status = ?", 1).Or("role = ?", "admin").Find(&users)

// IN查询
db.Where("id IN ?", []int64{1, 2, 3}).Find(&users)

// LIKE查询
db.Where("username LIKE ?", "%admin%").Find(&users)

// 排序
db.Order("created_at DESC").Find(&users)

// 选择字段
db.Select("id", "username", "nickname").Find(&users)

// 原生SQL
db.Raw("SELECT * FROM t_user WHERE status = ?", 1).Scan(&users)
db.Exec("UPDATE t_user SET status = ? WHERE id = ?", 0, 1)

// 链式调用
db.Model(&User{}).
   Select("id, username").
   Where("status = ?", 1).
   Order("id DESC").
   Offset(0).
   Limit(10).
   Find(&users)

// ============ 事务处理 ============

// 方式1：手动事务
tx := db.Begin()
if err := tx.Create(&user1).Error; err != nil {
    tx.Rollback()
    return err
}
if err := tx.Create(&user2).Error; err != nil {
    tx.Rollback()
    return err
}
tx.Commit()

// 方式2：自动事务（推荐）
// 类似于Java的@Transactional
err := db.Transaction(func(tx *gorm.DB) error {
    if err := tx.Create(&user1).Error; err != nil {
        return err // 返回错误会自动回滚
    }
    if err := tx.Create(&user2).Error; err != nil {
        return err
    }
    return nil // 返回nil会自动提交
})

// dto/request.go
package dto

// 注册请求
type RegisterRequest struct {
    Username string `json:"username" binding:"required,min=3,max=20"`
    Password string `json:"password" binding:"required,min=6,max=20"`
    Nickname string `json:"nickname" binding:"max=50"`
    Email    string `json:"email" binding:"omitempty,email"`
}

// 登录请求
type LoginRequest struct {
    Username string `json:"username" binding:"required"`
    Password string `json:"password" binding:"required"`
}

// dto/response.go
package dto

// 统一响应结构
type Response struct {
    Code    int         `json:"code"`
    Message string      `json:"message"`
    Data    interface{} `json:"data,omitempty"`
}

// 登录响应
type LoginResponse struct {
    Token    string `json:"token"`
    UserInfo UserVO `json:"userInfo"`
}

// 用户VO（不包含敏感信息）
type UserVO struct {
    ID       int64  `json:"id"`
    Username string `json:"username"`
    Nickname string `json:"nickname"`
    Email    string `json:"email"`
}

// 成功响应
func Success(data interface{}) Response {
    return Response{Code: 200, Message: "success", Data: data}
}

// 失败响应
func Error(code int, message string) Response {
    return Response{Code: code, Message: message}
}

// service/user_service.go
package service

import (
    "errors"
    "time"

    "golang.org/x/crypto/bcrypt"
    "github.com/golang-jwt/jwt/v5"

    "user-login-demo/dto"
    "user-login-demo/model"
    "user-login-demo/repository"
)

var jwtSecret = []byte("your-secret-key")

type UserService struct {
    repo *repository.UserRepository
}

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

// Register 用户注册
func (s *UserService) Register(req *dto.RegisterRequest) error {
    // 检查用户名是否已存在
    existUser, _ := s.repo.FindByUsername(req.Username)
    if existUser != nil {
        return errors.New("用户名已存在")
    }

    // 密码加密
    hashedPassword, err := bcrypt.GenerateFromPassword([]byte(req.Password), bcrypt.DefaultCost)
    if err != nil {
        return errors.New("密码加密失败")
    }

    // 创建用户
    user := &model.User{
        Username: req.Username,
        Password: string(hashedPassword),
        Nickname: req.Nickname,
        Email:    req.Email,
        Status:   1,
    }

    return s.repo.Create(user)
}

// Login 用户登录
func (s *UserService) Login(req *dto.LoginRequest) (*dto.LoginResponse, error) {
    // 查询用户
    user, err := s.repo.FindByUsername(req.Username)
    if err != nil {
        return nil, errors.New("用户名或密码错误")
    }

    // 校验密码
    err = bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(req.Password))
    if err != nil {
        return nil, errors.New("用户名或密码错误")
    }

    // 检查状态
    if user.Status != 1 {
        return nil, errors.New("账号已被禁用")
    }

    // 生成JWT Token
    token, err := s.generateToken(user.ID)
    if err != nil {
        return nil, errors.New("生成Token失败")
    }

    return &dto.LoginResponse{
        Token: token,
        UserInfo: dto.UserVO{
            ID:       user.ID,
            Username: user.Username,
            Nickname: user.Nickname,
            Email:    user.Email,
        },
    }, nil
}

// generateToken 生成JWT Token
func (s *UserService) generateToken(userID int64) (string, error) {
    claims := jwt.MapClaims{
        "user_id": userID,
        "exp":     time.Now().Add(24 * time.Hour).Unix(),
        "iat":     time.Now().Unix(),
    }

    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    return token.SignedString(jwtSecret)
}

// ParseToken 解析JWT Token
func (s *UserService) ParseToken(tokenString string) (int64, error) {
    token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
        return jwtSecret, nil
    })

    if err != nil || !token.Valid {
        return 0, errors.New("token无效")
    }

    claims, ok := token.Claims.(jwt.MapClaims)
    if !ok {
        return 0, errors.New("token解析失败")
    }

    userID := int64(claims["user_id"].(float64))
    return userID, nil
}

// GetUserByID 根据ID获取用户信息
func (s *UserService) GetUserByID(id int64) (*dto.UserVO, error) {
    user, err := s.repo.FindByID(id)
    if err != nil {
        return nil, errors.New("用户不存在")
    }

    return &dto.UserVO{
        ID:       user.ID,
        Username: user.Username,
        Nickname: user.Nickname,
        Email:    user.Email,
    }, nil
}

// controller/user_controller.go
package controller

import (
    "net/http"

    "github.com/gin-gonic/gin"

    "user-login-demo/dto"
    "user-login-demo/service"
)

type UserController struct {
    service *service.UserService
}

func NewUserController() *UserController {
    return &UserController{service: service.NewUserService()}
}

// Register 用户注册
// POST /api/register
func (ctrl *UserController) Register(c *gin.Context) {
    var req dto.RegisterRequest
    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(http.StatusBadRequest, dto.Error(400, "参数错误: "+err.Error()))
        return
    }

    err := ctrl.service.Register(&req)
    if err != nil {
        c.JSON(http.StatusBadRequest, dto.Error(400, err.Error()))
        return
    }

    c.JSON(http.StatusOK, dto.Success(nil))
}

// Login 用户登录
// POST /api/login
func (ctrl *UserController) Login(c *gin.Context) {
    var req dto.LoginRequest
    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(http.StatusBadRequest, dto.Error(400, "参数错误"))
        return
    }

    resp, err := ctrl.service.Login(&req)
    if err != nil {
        c.JSON(http.StatusBadRequest, dto.Error(400, err.Error()))
        return
    }

    c.JSON(http.StatusOK, dto.Success(resp))
}

// GetProfile 获取当前用户信息（需要登录）
// GET /api/profile
func (ctrl *UserController) GetProfile(c *gin.Context) {
    // 从Context中获取中间件设置的用户ID
    userID := c.MustGet("userID").(int64)

    user, err := ctrl.service.GetUserByID(userID)
    if err != nil {
        c.JSON(http.StatusNotFound, dto.Error(404, err.Error()))
        return
    }

    c.JSON(http.StatusOK, dto.Success(user))
}

// middleware/auth.go
package middleware

import (
    "net/http"
    "strings"

    "github.com/gin-gonic/gin"

    "user-login-demo/dto"
    "user-login-demo/service"
)

func AuthMiddleware() gin.HandlerFunc {
    userService := service.NewUserService()

    return func(c *gin.Context) {
        // 从Header获取Token
        authHeader := c.GetHeader("Authorization")
        if authHeader == "" {
            c.JSON(http.StatusUnauthorized, dto.Error(401, "请先登录"))
            c.Abort()
            return
        }

        // 解析Bearer Token
        parts := strings.SplitN(authHeader, " ", 2)
        if len(parts) != 2 || parts[0] != "Bearer" {
            c.JSON(http.StatusUnauthorized, dto.Error(401, "Token格式错误"))
            c.Abort()
            return
        }

        // 解析Token获取用户ID
        userID, err := userService.ParseToken(parts[1])
        if err != nil {
            c.JSON(http.StatusUnauthorized, dto.Error(401, "Token无效或已过期"))
            c.Abort()
            return
        }

        // 将用户ID存入Context
        c.Set("userID", userID)
        c.Next()
    }
}

// main.go
package main

import (
    "log"

    "github.com/gin-gonic/gin"

    "user-login-demo/config"
    "user-login-demo/controller"
    "user-login-demo/middleware"
    "user-login-demo/model"
)

func main() {
    // 初始化数据库
    config.InitDB()

    // 自动迁移
    config.DB.AutoMigrate(&model.User{})

    // 创建Gin引擎
    r := gin.Default()

    // 创建Controller
    userCtrl := controller.NewUserController()

    // 注册路由
    api := r.Group("/api")
    {
        // 公开接口
        api.POST("/register", userCtrl.Register)
        api.POST("/login", userCtrl.Login)

        // 需要认证的接口
        auth := api.Group("/")
        auth.Use(middleware.AuthMiddleware())
        {
            auth.GET("/profile", userCtrl.GetProfile)
        }
    }

    // 启动服务
    log.Println("服务启动在 :8080")
    r.Run(":8080")
}