package main

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

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

    r.GET("/ping", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{
            "message": "pong",
        })
    })

    r.Run(":8080")
}

package main

import (
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
    "log"
)

type User struct {
    ID    uint   `gorm:"primaryKey"`
    Name  string `gorm:"size:255"`
    Email string `gorm:"uniqueIndex"`
    Age   int
}

func main() {
    dsn := "user:password@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local"
    db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
    if err != nil {
        log.Fatal(err)
    }

    // 自動(dòng)遷移
    db.AutoMigrate(&User{})

    // 創(chuàng)建記錄
    db.Create(&User{Name: "John", Email: "john@example.com", Age: 25})

    // 讀取記錄
    var user User
    db.First(&user, 1) // 查詢主鍵為1的用戶
    log.Println(user)

    // 更新記錄
    db.Model(&user).Update("Age", 26)

    // 刪除記錄
    db.Delete(&user)
}

my-gin-gorm-project/
│
├── cmd/
│   └── main.go        // 主程序入口
│
├── config/
│   └── config.go      // 配置文件解析
│
├── controllers/
│   └── user.go        // 用戶相關(guān)的控制器
│
├── models/
│   └── user.go        // 用戶模型定義
│
├── routes/
│   └── routes.go      // 路由定義
│
├── middlewares/
│   └── auth.go        // 認(rèn)證中間件
│
├── services/
│   └── user.go        // 用戶相關(guān)的業(yè)務(wù)邏輯
│
├── repositories/
│   └── user.go        // 用戶數(shù)據(jù)訪問(wèn)層
│
├── utils/
│   └── utils.go       // 工具函數(shù)
│
├── .env               // 環(huán)境變量文件
├── go.mod             // Go模塊文件
└── go.sum             // 依賴文件

package main

import (
    "my-gin-gorm-project/config"
    "my-gin-gorm-project/routes"
    "github.com/gin-gonic/gin"
    "gorm.io/gorm"
)

var db *gorm.DB

func main() {
    // 解析配置文件
    config.LoadConfig()

    // 初始化數(shù)據(jù)庫(kù)連接
    db = config.InitDB()

    // 設(shè)置Gin引擎
    r := gin.Default()

    // 注冊(cè)路由
    routes.RegisterRoutes(r)

    // 啟動(dòng)服務(wù)器
    r.Run(config.Config.ServerPort)
}

package config

import (
    "log"
    "os"
    "github.com/joho/godotenv"
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)

var Config struct {
    ServerPort string
    DBUser     string
    DBPassword string
    DBName     string
    DBHost     string
    DBPort     string
}

// LoadConfig 解析配置文件
func LoadConfig() {
    if err := godotenv.Load(); err != nil {
        log.Fatal("Error loading .env file")
    }

    Config.ServerPort = os.Getenv("SERVER_PORT")
    Config.DBUser = os.Getenv("DB_USER")
    Config.DBPassword = os.Getenv("DB_PASSWORD")
    Config.DBName = os.Getenv("DB_NAME")
    Config.DBHost = os.Getenv("DB_HOST")
    Config.DBPort = os.Getenv("DB_PORT")
}

// InitDB 初始化數(shù)據(jù)庫(kù)連接
func InitDB() *gorm.DB {
    dsn := Config.DBUser + ":" + Config.DBPassword + "@tcp(" + Config.DBHost + ":" + Config.DBPort + ")/" + Config.DBName + "?charset=utf8mb4&parseTime=True&loc=Local"
    db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
    if err != nil {
        log.Fatal("Failed to connect to database:", err)
    }
    return db
}

package models

import "gorm.io/gorm"

// User 用戶模型定義
type User struct {
    gorm.Model
    Name  string `gorm:"size:255"`
    Email string `gorm:"uniqueIndex"`
    Age   int
}

package controllers

import (
    "my-gin-gorm-project/models"
    "my-gin-gorm-project/services"
    "net/http"
    "github.com/gin-gonic/gin"
)

// GetUsers 獲取所有用戶
func GetUsers(c *gin.Context) {
    users := services.GetAllUsers()
    c.JSON(http.StatusOK, users)
}

// CreateUser 創(chuàng)建新用戶
func CreateUser(c *gin.Context) {
    var user models.User
    if err := c.ShouldBindJSON(&user); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }
    if err := services.CreateUser(&user); err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }
    c.JSON(http.StatusOK, user)
}

package repositories

import (
    "my-gin-gorm-project/models"
    "gorm.io/gorm"
)

var DB *gorm.DB

// SetDB 設(shè)置數(shù)據(jù)庫(kù)實(shí)例
func SetDB(db *gorm.DB) {
    DB = db
}

// GetAllUsers 獲取所有用戶
func GetAllUsers() ([]models.User, error) {
    var users []models.User
    if err := DB.Find(&users).Error; err != nil {
        return nil, err
    }
    return users, nil
}

// CreateUser 創(chuàng)建新用戶
func CreateUser(user *models.User) error {
    if err := DB.Create(user).Error; err != nil {
        return err
    }
    return nil
}

package services

import (
    "my-gin-gorm-project/models"
    "my-gin-gorm-project/repositories"
)

// GetAllUsers 獲取所有用戶
func GetAllUsers() []models.User {
    users, _ := repositories.GetAllUsers()
    return users
}

// CreateUser 創(chuàng)建新用戶
func CreateUser(user *models.User) error {
    return repositories.CreateUser(user)
}

package routes

import (
    "my-gin-gorm-project/controllers"
    "github.com/gin-gonic/gin"
)

// RegisterRoutes 注冊(cè)所有路由
func RegisterRoutes(r *gin.Engine) {
    // 用戶相關(guān)路由
    userRoutes := r.Group("/users")
    {
        userRoutes.GET("/", controllers.GetUsers)
        userRoutes.POST("/", controllers.CreateUser)
    }
}

SERVER_PORT=:8080
DB_USER=root
DB_PASSWORD=password
DB_NAME=mydb
DB_HOST=localhost
DB_PORT=3306

package utils

import (
    "time"
    "github.com/dgrijalva/jwt-go"
    "os"
    "errors"
)

var jwtSecret = []byte(os.Getenv("JWT_SECRET"))

// Claims 自定義的聲明
type Claims struct {
    UserID uint
    jwt.StandardClaims
}

// GenerateToken 生成Token
func GenerateToken(userID uint) (string, error) {
    expirationTime := time.Now().Add(24 * time.Hour)
    claims := &Claims{
        UserID: userID,
        StandardClaims: jwt.StandardClaims{
            ExpiresAt: expirationTime.Unix(),
        },
    }
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    tokenString, err := token.SignedString(jwtSecret)
    if err != nil {
        return "", err
    }
    return tokenString, nil
}

// ParseToken 解析Token
func ParseToken(tokenString string) (*Claims, error) {
    claims := &Claims{}
    token, err := jwt.ParseWithClaims(tokenString, claims, func(token *jwt.Token) (interface{}, error) {
        return jwtSecret, nil
    })
    if err != nil {
        return nil, err
    }
    if !token.Valid {
        return nil, errors.New("invalid token")
    }
    return claims, nil
}

package middlewares

import (
    "my-gin-gorm-project/utils"
    "net/http"
    "strings"

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

// AuthMiddleware 認(rèn)證中間件
func AuthMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        tokenString := c.GetHeader("Authorization")
        if tokenString == "" {
            c.JSON(http.StatusUnauthorized, gin.H{"error": "請(qǐng)求頭中缺少Token"})
            c.Abort()
            return
        }

        tokenString = strings.TrimPrefix(tokenString, "Bearer ")

        claims, err := utils.ParseToken(tokenString)
        if err != nil {
            c.JSON(http.StatusUnauthorized, gin.H{"error": "無(wú)效的Token"})
            c.Abort()
            return
        }

        c.Set("userID", claims.UserID)
        c.Next()
    }
}