gin+gorm实现goweb项目

已于 2024-06-14 17:20:42 修改
阅读量1.9k 收藏 38
点赞数 27
CC 4.0 BY-SA版权
文章标签： gin go web 后端 架构
于 2024-06-14 15:21:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44284775/article/details/139682385

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

Gin

  • Gin 是一个用 Go 编写的轻量级、高性能的 Web 框架。它的主要功能是处理 HTTP 请求和响应，帮助开发者快速构建 Web 应用程序和 API 服务。

  • 通俗解释
    Gin 框架就像一个服务员，负责接收客户的订单（HTTP 请求），根据菜单（路由规则）将订单转交给合适的厨师（处理函数），厨师准备好食物（生成响应数据）后，服务员再将食物递给客户（返回 HTTP 响应）。

1. 主要功能

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

2. 工作流程

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

3. 示例

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")
}

Gorm

  • Gorm 是一个用 Go 编写的 ORM（对象关系映射）库，它的主要功能是简化数据库操作。Gorm 通过将数据库表映射为 Go 结构体，使得开发者可以使用 Go 代码来执行数据库的增删改查等操作，而不需要直接编写 SQL 语句。

  • 通俗解释：Gorm 就像一个翻译器，它把开发者写的 Go 代码翻译成数据库能够理解的 SQL 语句，并且负责执行这些 SQL 语句，将结果再翻译回 Go 语言的数据结构。

1. 主要功能

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

2. 工作流程

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

3. 示例

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)
    }

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

    // 创建记录
    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)
}

Gin+Gorm项目实操

1. 项目目录结构

my-gin-gorm-project/
│
├── cmd/
│   └── main.go        // 主程序入口
│
├── config/
│   └── config.go      // 配置文件解析
│
├── controllers/
│   └── user.go        // 用户相关的控制器
│
├── models/
│   └── user.go        // 用户模型定义
│
├── routes/
│   └── routes.go      // 路由定义
│
├── middlewares/
│   └── auth.go        // 认证中间件
│
├── services/
│   └── user.go        // 用户相关的业务逻辑
│
├── repositories/
│   └── user.go        // 用户数据访问层
│
├── utils/
│   └── utils.go       // 工具函数
│
├── .env               // 环境变量文件
├── go.mod             // Go模块文件
└── go.sum             // 依赖文件

2. 主程序入口（cmd/main.go）

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()

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

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

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

    // 启动服务器
    r.Run(config.Config.ServerPort)
}

3. 配置文件解析（config/config.go）

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 初始化数据库连接
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
}

4. 用户模型定义（models/user.go）

package models

import "gorm.io/gorm"

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

5. 用户相关的控制器（controllers/user.go）

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 创建新用户
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)
}

6. 用户数据访问层（repositories/user.go）

package repositories

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

var DB *gorm.DB

// SetDB 设置数据库实例
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 创建新用户
func CreateUser(user *models.User) error {
    if err := DB.Create(user).Error; err != nil {
        return err
    }
    return nil
}

7. 用户相关的业务逻辑（services/user.go）

package services

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

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

// CreateUser 创建新用户
func CreateUser(user *models.User) error {
    return repositories.CreateUser(user)
}

8. 路由定义（routes/routes.go）

package routes

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

// RegisterRoutes 注册所有路由
func RegisterRoutes(r *gin.Engine) {
    // 用户相关路由
    userRoutes := r.Group("/users")
    {
        userRoutes.GET("/", controllers.GetUsers)
        userRoutes.POST("/", controllers.CreateUser)
    }
}

9. 环境变量文件（.env）

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

10. 补充：关于utils和Middlewares的区别以及使用

Utils（工具类）

  • 功能：工具类目录用于存放项目中常用的工具函数和通用模块。这些函数和模块通常独立于业务逻辑，可以在项目的各个部分复用。

  • 存放内容：

    1. 通用工具函数：例如字符串处理函数、日期时间处理函数、加密解密函数等。
    2. 配置解析函数：用于解析配置文件或环境变量的函数。
    3. 日志记录函数：处理日志记录的工具。
    4. Token处理：如Token的生成、解析、验证等。
    5. 其他通用模块：如错误处理函数、文件操作函数等。

  • 示例

    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
}

Middlewares（中间件）

  • 功能：中间件目录用于存放在HTTP请求处理过程中需要执行的额外操作。这些操作通常在请求到达具体的业务逻辑处理之前或之后进行，主要用于请求的预处理和后处理。

  • 存放内容：

    1. 认证中间件：如Token验证中间件，确保请求携带有效的Token。
    2. 日志中间件：记录请求日志，包括请求的路径、方法、响应时间等。
    3. 错误处理中间件：统一处理错误并返回标准的错误响应。
    4. CORS中间件：处理跨域请求。
    5. 其他预处理或后处理操作：如请求限流、压缩响应等。

  • 示例

    package middlewares

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

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

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

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

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

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

11. 项目运行流程

  • 配置解析和数据库连接：在主程序入口中，首先加载配置文件并初始化数据库连接。
  • 路由注册：接着，注册所有的路由。
  • 控制器和服务层的调用：当路由被访问时，控制器会调用相应的服务层方法。
  • 数据访问：服务层通过数据访问层（Repository）来进行数据库操作。
JawCat
关注
Gin(十一):集成 gorm
代码猎奇站
08-02 1577
点击蓝色字关注我们！一个努力中的公众号长的好看的人都关注了随着项目的不断扩大，总有一天，项目中的表和表中的字段多的数不胜数，如果此时仍旧使用 SQL 语言来执行增删改查，...
gin 项目结构_基于gin框架快速开发应用(实战类型项目)
weixin_39645003的博客
12-22 1112
### 技术选型框架: gin日志处理: zaporm: gorm优雅重启HTTP服务: gracehttp测试框架: ginkgo### 接口风格RESTFUL### 项目结构* api - handler函数* route - 路由注册* model - 数据模型以及数据库操作* doc - 接口文档* log - 日志处理* config - 配置文件* tools - 公共工具类* ve...
go web项目框架（viper+gin+gorm）适合初学者使用
01-26
go web项目框架（viper+gin+gorm）适合初学者使用
Web开发实战：Gin + GORM 构建企业级 API 项目
最新发布
gopher123的博客
06-13 1063
本文介绍了如何使用Gin框架和GORM构建企业级API项目，实现用户注册、登录(JWT)、分页查询等功能。项目采用分层架构(Controller→Service→Model)，包含数据库配置、中间件(JWT鉴权)、路由注册等核心模块，并提供了详细的技术栈和项目结构说明。文章还介绍了环境初始化、实体定义、接口实现等关键步骤，最后展示了可拓展方向(如接入Casbin、Swagger等)和学习收获。这是一个完整可扩展的Golang后端项目模板，适合管理后台、微服务等场景。
Gin框架结合gorm使用
热门推荐
qq_42057890的博客
02-02 1万+
Gin框架结合Gorm使用 目录 Gin框架结合Gorm使用 前言 一、介绍 二、使用步骤 1.创建项目 2.开始main.go 3.router的初始化 4.controller的初始化 5.services的初始化 6.models的初始化 7.my.init的初始化 8.开始测试 总结 前言 笔者为golang语言的初学者，之前一直是使用beego框架和框架中自带的orm，使用这一套框架做项目也有大半年了，总的来说对于初学者来讲入门也是可以的。在使用了一段时间当...
5. gin集成Gorm
YouMing_Li的博客
03-06 934
本节主要介绍如何使用gin集成gorm，并完成用户的创建、修改、删除、查询等功能。
golang基础学习+Gin框架搭建+Gorm关系映射
king_0943的博客
04-23 801
import (//注册路由//登录路由//修改密码//查询所有用户//删除某个用户//参赛选手列表return r服务启动成功。
基于GIN + GORM + WIRE实现的web脚手架，支持gorm数据库操作、cors 跨域、集成jwt鉴权等.zip
01-03
这是一个基于Go语言开发的Web应用框架，利用了GIN作为HTTP路由库，GORM作为ORM（对象关系映射）工具，WIRE进行依赖注入，以及JWT（JSON Web Tokens）进行身份验证，同时集成了CORS（跨源资源共享）支持、logrus日志...
由gin + gorm + jwt + casbin组合实现的RBAC权限管理脚手架Golang-gin-web.zip
11-06
Gin是一个高效的Web框架，Gorm是一个用于Go语言的ORM库，JWT（Json Web Token）常用于身份验证，而Casbin则是一个强大的访问控制库。 首先，Gin框架是基于Gorilla/Mux的轻量级HTTP服务器，它使用中间件来处理请求。...
基于 gin+gorm+redis+mysql 读写分离的电子商城.zip
04-19
MySQL广泛应用于各种规模和类型的项目，包括但不限于： Web应用程序：作为众多网站和Web服务（如电子商务、社交媒体、内容管理系统等）的后台数据库。 数据分析与报表：与数据仓库技术结合，支持OLAP（在线分析...
管理系统系列--Gin + GORM + Casbin + vue-element-admin 实现的权限管理系统(.zip
02-25
Gin是一个用Go语言编写的轻量级Web框架，它提供了快速开发Web应用的能力。Gin基于Martini设计模式，但性能更高，因为它使用了HTTP路由器/gRPC实现。在本项目中，Gin主要负责处理HTTP请求，路由分发，以及与后端业务...
用golang搭建springboot风格项目结构 gin+gorm
魑魅魍魉
12-15 4361
用Go语言来搭建一个springboot风格的web项目结构，web层使用gin框架，数据持久层使用gorm框架
wblog：基于gin + gorm开发的个人博客项目
02-03
博客 初衷 作为一名web开发程序员居然没有自己的博客，都不好意思对外宣称自己的开发web的。以前也有写博客的习惯，但是都是用的现有的博客网站。 技术选型 网址： orm： 数据库： 全文检索： 文件存储： 配置文件 项目结构 -wblog |-conf 配置文件目录 |-controllers 控制器目录 |-helpders 公共方法目录 |-models 数据库访问目录 |-static 静态资源目录 |-css css文件目录 |-images 图片目录 |-js js文件目录 |-libs js类库 |-system 系统配置文件加载目录 |-tests 测试目录 |-vendor 项目依赖其他开源项目目录 |-views 模板文件目录 |-main.go 程序执行入口 去做 系统日志 网站统计 文章，页面访问统计 github登录发表评论 rss 定时备份系统数据 邮箱订阅功能 安装部署 本项目使用govendor管理依赖包
Go语言Gin框架+Gorm实战CRUD
ecloud_developer的博客
12-21 2294
Gin 和 Gorm 是 Go 编程语言中流行的开源库。但是，它们服务于不同的目的，通常在 web 开发项目中一起使用。 Gin 是一个用于构建 HTTP 服务器的 web 框架。它提供了一个简单易用的 API，用于处理 HTTP 请求和响应、路由、中间件和其他常见的 web 应用程序所需的功能。它以其高性能和简约为特点，提供了轻量级和灵活的解决方案来构建 web 服务器。 Gorm 是 Go 的一个 ORM（对象关系映射）库。
go web 实战 （gin + grom + mysql + jwt）
小跳的博客
03-17 453
使用 gin 实现用户注册，登陆等 API接口，适用于前后端分离。
gin+gorm 集成环境搭建
scola001的专栏
10-28 918
如果报错：'swag' 不是内部或外部命令。安装 gorm的mysql驱动。安装 gin-swagger。安装 热启动 fresh。再执行 swag init。创建目录 online。
Go+Gin+GORM+Mysql实现最基础的CRUD
m0_73646471的博客
01-10 677
1.准备工作1.准备工作1.安装go的环境2.安装数据库mysql安装后在解压目录下新建ini文件并且拷入：[mysqld]# 设置3306端口port=3306# 设置mysql的安装目录 ----------是你的文件路径-------------# 设置mysql数据库的数据的存放目录 ---------是你的文件路径data文件夹自行创建# 允许最大连接数# 允许连接失败的次数。# 服务端使用的字符集默认为utf8mb4。
【Go】-基于Gin框架的博客项目
knoci的博客
10-30 994
这是Gin框架的Blog小demo，基本实现了登录注册,社区,发帖,投票功能，一些拓展的功能没有实现，但是其核心对于入门Gin来说，是不错的练习。
手把手教你基于gin从零搭建一个属于你自己的go项目(一)
耕耘——从菜鸟到高手的蜕变
12-03 4191
因为自己想写点小玩意，本来是打算用egg.js来写服务端的，后来发现了个更好玩的midway，但是后来发现自己手上的服务器都是一核2g的小水管，用node有点难顶，于是乎决定用其他技术栈来解决问题，在kotlin和go中初步调研之后发现go更符合自己的需求，于是乎就有了这个系列的笔记输出。首先，我们可以选择一个心仪的文件夹，在它下面新建一个项目目录，名字的话可以根据自己的喜好来选择，就如下图一样，我新建了一个名为 go_server的项目目录，此刻它的下面空空如也。一般情况下，系统变量不需要修改。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值