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

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

    // 自动迁移
    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)
}

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             // 依赖文件

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

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
}

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 创建新用户
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 设置数据库实例
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
}

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

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

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 认证中间件
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()
    }
}