• 设为首页
  • 收藏本站
  • 积分充值
  • VIP赞助
  • 手机版
  • 微博
  • 微信
    微信公众号 添加方式:
    1:搜索微信号(888888
    2:扫描左侧二维码
  • 快捷导航
    福建二哥 门户 查看主题

    gin+gorm实现goweb项目的示例代码

    发布者: 怀卉1097 | 发布时间: 2025-8-14 12:08| 查看数: 16| 评论数: 0|帖子模式

    Gin


    • Gin 是一个用 Go 编写的轻量级、高性能的 Web 框架。它的主要功能是处理 HTTP 请求和响应,帮助开发者快速构建 Web 应用程序和 API 服务。
    • 通俗解释
      Gin 框架就像一个服务员,负责接收客户的订单(HTTP 请求),根据菜单(路由规则)将订单转交给合适的厨师(处理函数),厨师准备好食物(生成响应数据)后,服务员再将食物递给客户(返回 HTTP 响应)。


    1. 主要功能


    • 路由:Gin 允许你定义不同的 URL 路径和 HTTP 方法(如 GET、POST),并将它们映射到相应的处理函数。
    • 中间件:可以在请求处理过程中插入多个中间件函数,用于认证、日志记录等操作。
    • 参数绑定:支持从 URL、表单、JSON 等位置获取参数并绑定到结构体中。
    • 错误处理:提供方便的错误处理机制,统一管理错误响应。


    2. 工作流程


    • 定义路由:开发者定义各种路由和它们对应的处理函数。
    • 启动服务器:Gin 框架启动一个 HTTP 服务器,监听特定端口。
    • 接收请求:当有 HTTP 请求到达时,Gin 根据请求的路径和方法查找对应的处理函数。
    • 执行中间件:在处理函数执行之前,依次执行注册的中间件。
    • 处理请求:调用对应的处理函数,生成响应数据。
    • 返回响应:将响应数据返回给客户端。


    3. 示例
    1. package main

    2. import (
    3.     "github.com/gin-gonic/gin"
    4.     "net/http"
    5. )

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

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

    13.     r.Run(":8080")
    14. }
    复制代码
    Gorm


    • Gorm 是一个用 Go 编写的 ORM(对象关系映射)库,它的主要功能是简化数据库操作。Gorm 通过将数据库表映射为 Go 结构体,使得开发者可以使用 Go 代码来执行数据库的增删改查等操作,而不需要直接编写 SQL 语句。
    • 通俗解释:Gorm 就像一个翻译器,它把开发者写的 Go 代码翻译成数据库能够理解的 SQL 语句,并且负责执行这些 SQL 语句,将结果再翻译回 Go 语言的数据结构。
    1. 主要功能


    • 模型定义:将数据库表映射为 Go 结构体,定义字段及其属性。
    • 查询:提供简洁的查询方法,如创建记录、读取记录、更新记录、删除记录等。
    • 关系:支持数据库表之间的关系,如一对一、一对多、多对多关系。
    • 迁移:自动迁移数据库表结构,使其与 Go 结构体保持同步。
    2. 工作流程


    • 定义模型:开发者定义与数据库表对应的 Go 结构体。
    • 初始化数据库连接:配置数据库连接信息,并建立连接。
    • 执行操作:使用 Gorm 提供的方法来进行数据库操作,如创建、查询、更新、删除等。
    • 处理结果:将数据库操作的结果映射回 Go 结构体中,供业务逻辑使用。
    3. 示例
    1. package main

    2. import (
    3.     "gorm.io/driver/mysql"
    4.     "gorm.io/gorm"
    5.     "log"
    6. )

    7. type User struct {
    8.     ID    uint   `gorm:"primaryKey"`
    9.     Name  string `gorm:"size:255"`
    10.     Email string `gorm:"uniqueIndex"`
    11.     Age   int
    12. }

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

    19.     // 自动迁移
    20.     db.AutoMigrate(&User{})

    21.     // 创建记录
    22.     db.Create(&User{Name: "John", Email: "john@example.com", Age: 25})

    23.     // 读取记录
    24.     var user User
    25.     db.First(&user, 1) // 查询主键为1的用户
    26.     log.Println(user)

    27.     // 更新记录
    28.     db.Model(&user).Update("Age", 26)

    29.     // 删除记录
    30.     db.Delete(&user)
    31. }
    复制代码
    Gin+Gorm项目实操


    1. 项目目录结构
    1. my-gin-gorm-project/

    2. ├── cmd/
    3. │   └── main.go        // 主程序入口

    4. ├── config/
    5. │   └── config.go      // 配置文件解析

    6. ├── controllers/
    7. │   └── user.go        // 用户相关的控制器

    8. ├── models/
    9. │   └── user.go        // 用户模型定义

    10. ├── routes/
    11. │   └── routes.go      // 路由定义

    12. ├── middlewares/
    13. │   └── auth.go        // 认证中间件

    14. ├── services/
    15. │   └── user.go        // 用户相关的业务逻辑

    16. ├── repositories/
    17. │   └── user.go        // 用户数据访问层

    18. ├── utils/
    19. │   └── utils.go       // 工具函数

    20. ├── .env               // 环境变量文件
    21. ├── go.mod             // Go模块文件
    22. └── go.sum             // 依赖文件
    复制代码
    2. 主程序入口(cmd/main.go)
    1. package main

    2. import (
    3.     "my-gin-gorm-project/config"
    4.     "my-gin-gorm-project/routes"
    5.     "github.com/gin-gonic/gin"
    6.     "gorm.io/gorm"
    7. )

    8. var db *gorm.DB

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

    12.     // 初始化数据库连接
    13.     db = config.InitDB()

    14.     // 设置Gin引擎
    15.     r := gin.Default()

    16.     // 注册路由
    17.     routes.RegisterRoutes(r)

    18.     // 启动服务器
    19.     r.Run(config.Config.ServerPort)
    20. }
    复制代码
    3. 配置文件解析(config/config.go)
    1. package config

    2. import (
    3.     "log"
    4.     "os"
    5.     "github.com/joho/godotenv"
    6.     "gorm.io/driver/mysql"
    7.     "gorm.io/gorm"
    8. )

    9. var Config struct {
    10.     ServerPort string
    11.     DBUser     string
    12.     DBPassword string
    13.     DBName     string
    14.     DBHost     string
    15.     DBPort     string
    16. }

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

    22.     Config.ServerPort = os.Getenv("SERVER_PORT")
    23.     Config.DBUser = os.Getenv("DB_USER")
    24.     Config.DBPassword = os.Getenv("DB_PASSWORD")
    25.     Config.DBName = os.Getenv("DB_NAME")
    26.     Config.DBHost = os.Getenv("DB_HOST")
    27.     Config.DBPort = os.Getenv("DB_PORT")
    28. }

    29. // InitDB 初始化数据库连接
    30. func InitDB() *gorm.DB {
    31.     dsn := Config.DBUser + ":" + Config.DBPassword + "@tcp(" + Config.DBHost + ":" + Config.DBPort + ")/" + Config.DBName + "?charset=utf8mb4&parseTime=True&loc=Local"
    32.     db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
    33.     if err != nil {
    34.         log.Fatal("Failed to connect to database:", err)
    35.     }
    36.     return db
    37. }
    复制代码
    4. 用户模型定义(models/user.go)
    1. package models

    2. import "gorm.io/gorm"

    3. // User 用户模型定义
    4. type User struct {
    5.     gorm.Model
    6.     Name  string `gorm:"size:255"`
    7.     Email string `gorm:"uniqueIndex"`
    8.     Age   int
    9. }
    复制代码
    5. 用户相关的控制器(controllers/user.go)
    1. package controllers

    2. import (
    3.     "my-gin-gorm-project/models"
    4.     "my-gin-gorm-project/services"
    5.     "net/http"
    6.     "github.com/gin-gonic/gin"
    7. )

    8. // GetUsers 获取所有用户
    9. func GetUsers(c *gin.Context) {
    10.     users := services.GetAllUsers()
    11.     c.JSON(http.StatusOK, users)
    12. }

    13. // CreateUser 创建新用户
    14. func CreateUser(c *gin.Context) {
    15.     var user models.User
    16.     if err := c.ShouldBindJSON(&user); err != nil {
    17.         c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
    18.         return
    19.     }
    20.     if err := services.CreateUser(&user); err != nil {
    21.         c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
    22.         return
    23.     }
    24.     c.JSON(http.StatusOK, user)
    25. }
    复制代码
    6. 用户数据访问层(repositories/user.go)
    1. package repositories

    2. import (
    3.     "my-gin-gorm-project/models"
    4.     "gorm.io/gorm"
    5. )

    6. var DB *gorm.DB

    7. // SetDB 设置数据库实例
    8. func SetDB(db *gorm.DB) {
    9.     DB = db
    10. }

    11. // GetAllUsers 获取所有用户
    12. func GetAllUsers() ([]models.User, error) {
    13.     var users []models.User
    14.     if err := DB.Find(&users).Error; err != nil {
    15.         return nil, err
    16.     }
    17.     return users, nil
    18. }

    19. // CreateUser 创建新用户
    20. func CreateUser(user *models.User) error {
    21.     if err := DB.Create(user).Error; err != nil {
    22.         return err
    23.     }
    24.     return nil
    25. }
    复制代码
    7. 用户相关的业务逻辑(services/user.go)
    1. package services

    2. import (
    3.     "my-gin-gorm-project/models"
    4.     "my-gin-gorm-project/repositories"
    5. )

    6. // GetAllUsers 获取所有用户
    7. func GetAllUsers() []models.User {
    8.     users, _ := repositories.GetAllUsers()
    9.     return users
    10. }

    11. // CreateUser 创建新用户
    12. func CreateUser(user *models.User) error {
    13.     return repositories.CreateUser(user)
    14. }
    复制代码
    8. 路由定义(routes/routes.go)
    1. package routes

    2. import (
    3.     "my-gin-gorm-project/controllers"
    4.     "github.com/gin-gonic/gin"
    5. )

    6. // RegisterRoutes 注册所有路由
    7. func RegisterRoutes(r *gin.Engine) {
    8.     // 用户相关路由
    9.     userRoutes := r.Group("/users")
    10.     {
    11.         userRoutes.GET("/", controllers.GetUsers)
    12.         userRoutes.POST("/", controllers.CreateUser)
    13.     }
    14. }
    复制代码
    9. 环境变量文件(.env)
    1. SERVER_PORT=:8080
    2. DB_USER=root
    3. DB_PASSWORD=password
    4. DB_NAME=mydb
    5. DB_HOST=localhost
    6. DB_PORT=3306
    复制代码
    10. 补充:关于utils和Middlewares的区别以及使用


    Utils(工具类)


    • 功能:工具类目录用于存放项目中常用的工具函数和通用模块。这些函数和模块通常独立于业务逻辑,可以在项目的各个部分复用。
    • 存放内容:
      通用工具函数:例如字符串处理函数、日期时间处理函数、加密解密函数等。
      配置解析函数:用于解析配置文件或环境变量的函数。
      日志记录函数:处理日志记录的工具。
      Token处理:如Token的生成、解析、验证等。
      其他通用模块:如错误处理函数、文件操作函数等。
    示例
    1. package utils

    2. import (
    3.     "time"
    4.     "github.com/dgrijalva/jwt-go"
    5.     "os"
    6.     "errors"
    7. )

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

    9. // Claims 自定义的声明
    10. type Claims struct {
    11.     UserID uint
    12.     jwt.StandardClaims
    13. }

    14. // GenerateToken 生成Token
    15. func GenerateToken(userID uint) (string, error) {
    16.     expirationTime := time.Now().Add(24 * time.Hour)
    17.     claims := &Claims{
    18.         UserID: userID,
    19.         StandardClaims: jwt.StandardClaims{
    20.             ExpiresAt: expirationTime.Unix(),
    21.         },
    22.     }
    23.     token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    24.     tokenString, err := token.SignedString(jwtSecret)
    25.     if err != nil {
    26.         return "", err
    27.     }
    28.     return tokenString, nil
    29. }

    30. // ParseToken 解析Token
    31. func ParseToken(tokenString string) (*Claims, error) {
    32.     claims := &Claims{}
    33.     token, err := jwt.ParseWithClaims(tokenString, claims, func(token *jwt.Token) (interface{}, error) {
    34.         return jwtSecret, nil
    35.     })
    36.     if err != nil {
    37.         return nil, err
    38.     }
    39.     if !token.Valid {
    40.         return nil, errors.New("invalid token")
    41.     }
    42.     return claims, nil
    43. }
    复制代码
    Middlewares(中间件)


    • 功能:中间件目录用于存放在HTTP请求处理过程中需要执行的额外操作。这些操作通常在请求到达具体的业务逻辑处理之前或之后进行,主要用于请求的预处理和后处理。
    • 存放内容:
      认证中间件:如Token验证中间件,确保请求携带有效的Token。
      日志中间件:记录请求日志,包括请求的路径、方法、响应时间等。
      错误处理中间件:统一处理错误并返回标准的错误响应。
      CORS中间件:处理跨域请求。
      其他预处理或后处理操作:如请求限流、压缩响应等。
    示例
    1. package middlewares

    2. import (
    3.     "my-gin-gorm-project/utils"
    4.     "net/http"
    5.     "strings"

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

    8. // AuthMiddleware 认证中间件
    9. func AuthMiddleware() gin.HandlerFunc {
    10.     return func(c *gin.Context) {
    11.         tokenString := c.GetHeader("Authorization")
    12.         if tokenString == "" {
    13.             c.JSON(http.StatusUnauthorized, gin.H{"error": "请求头中缺少Token"})
    14.             c.Abort()
    15.             return
    16.         }

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

    18.         claims, err := utils.ParseToken(tokenString)
    19.         if err != nil {
    20.             c.JSON(http.StatusUnauthorized, gin.H{"error": "无效的Token"})
    21.             c.Abort()
    22.             return
    23.         }

    24.         c.Set("userID", claims.UserID)
    25.         c.Next()
    26.     }
    27. }
    复制代码
    11. 项目运行流程


    • 配置解析和数据库连接:在主程序入口中,首先加载配置文件并初始化数据库连接。
    • 路由注册:接着,注册所有的路由。
    • 控制器和服务层的调用:当路由被访问时,控制器会调用相应的服务层方法。
    • 数据访问:服务层通过数据访问层(Repository)来进行数据库操作。
    到此这篇关于gin+gorm实现goweb项目的示例代码的文章就介绍到这了,更多相关gin+gorm实现goweb内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

    来源:互联网
    免责声明:如果侵犯了您的权益,请联系站长(1277306191@qq.com),我们会及时删除侵权内容,谢谢合作!

    最新评论

    浏览过的版块

    QQ Archiver 手机版 小黑屋 福建二哥 ( 闽ICP备2022004717号|闽公网安备35052402000345号 )

    Powered by Discuz! X3.5 © 2001-2023

    快速回复 返回顶部 返回列表