【9.2】Golang后端开发系列--Gin路由定义与实战使用

文章目录

一、Gin 框架路由的基本定义方式

1. 简单路由创建

使用 gin.Default() 创建一个带有默认中间件的路由引擎，然后通过 GET, POST, PUT, DELETE 等方法来定义不同 HTTP 方法的路由。

package main

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

func main() {
	// 创建带有默认中间件的路由引擎
	r := gin.Default()

	// 定义 GET 请求的路由
	r.GET("/hello", func(c *gin.Context) {
		c.String(http.StatusOK, "Hello, World!")
	})

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

2. 路由参数

使用 : 来定义路由参数，通过 c.Param() 方法从请求中提取参数。

r.GET("/users/:userID", func(c *gin.Context) {
    userID := c.Param("userID")
    c.String(http.StatusOK, "User ID: %s", userID)
})

3. 查询参数

使用 c.Query() 方法来获取查询参数。

r.GET("/search", func(c *gin.Context) {
    query := c.Query("q")
    c.String(http.StatusOK, "Search query: %s", query)
})

二、商业大项目中的路由定义和服务调用

1. 路由模块化

为了使代码结构更清晰和易于维护，将路由定义分散到不同的文件和包中。

routes/user.go

package routes

import (
	"github.com/gin-gonic/gin"
	"yourproject/services"
)

func SetupUserRoutes(r *gin.RouterGroup) {
	r.GET("/", services.GetAllUsers)
	r.GET("/:id", services.GetUserByID)
	r.POST("/", services.CreateUser)
	r.PUT("/:id", services.UpdateUser)
	r.DELETE("/:id", services.DeleteUser)
}

services/user.go

package services

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

func GetAllUsers(c *gin.Context) {
	// 调用数据访问层或其他服务层的函数来获取用户列表
	users, err := userService.GetAll()
	if err!= nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to fetch users"})
		return
	}
	c.JSON(http.StatusOK, users)
}

func GetUserByID(c *gin.Context) {
	id := c.Param("id")
	user, err := userService.GetByID(id)
	if err!= nil {
		c.JSON(http.StatusNotFound, gin.H{"error": "User not found"})
		return
	}
	c.JSON(http.StatusOK, user)
}

func CreateUser(c *gin.Context) {
	var newUser User
	if err := c.BindJSON(&newUser); err!= nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid input"})
		return
	}
	if err := userService.Create(newUser); err!= nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create user"})
		return
	}
	c.JSON(http.StatusCreated, gin.H{"message": "User created successfully"})
}

func UpdateUser(c *gin.Context) {
	id := c.Param("id")
	var updatedUser User
	if err := c.BindJSON(&updatedUser); err!= nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid input"})
		return
	}
	if err := userService.Update(id, updatedUser); err!= nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to update user"})
		return
	}
	c.JSON(http.StatusOK, gin.H{"message": "User updated successfully"})
}

func DeleteUser(c *gin.Context) {
	id := c.Param("id")
	if err := userService.Delete(id); err!= nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to delete user"})
		return
	}
	c.JSON(http.StatusOK, gin.H{"message": "User deleted successfully"})
}

2. 路由组和中间件

使用路由组来组织相关的路由，并且可以为路由组添加中间件。

routes/router.go

package routes

import (
	"github.com/gin-gonic/gin"
	"yourproject/middleware"
	"yourproject/services"
)

func SetupRoutes() *gin.Engine {
	r := gin.Default()

	// 公共中间件，例如日志、认证等
	r.Use(middleware.Logger(), middleware.Authenticate())

	// 用户路由组
	users := r.Group("/users")
	SetupUserRoutes(users)

	// 产品路由组
	products := r.Group("/products")
	SetupProductRoutes(products)

	return r
}

3. 中间件的使用

中间件可以在请求处理的不同阶段执行逻辑，如日志记录、认证、授权、错误处理等。

middleware/logger.go

package middleware

import (
	"github.com/gin-gonic/gin"
	"log"
	"time"
)

func Logger() gin.HandlerFunc {
	return func(c *gin.Context) {
		start := time.Now()
		c.Next()
		duration := time.Since(start)
		log.Printf("%s %s %s %v", c.Request.Method, c.Request.URL.Path, c.Writer.Status(), duration)
	}
}

middleware/authenticate.go

package middleware

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

func Authenticate() gin.HandlerFunc {
	return func(c *gin.Context) {
		// 检查用户是否认证，例如通过 token 验证
		if!isAuthenticated(c) {
			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Unauthorized"})
			return
		}
		c.Next()
	}
}

func isAuthenticated(c *gin.Context) bool {
	// 实际的认证逻辑，例如检查请求头中的 token
	authHeader := c.GetHeader("Authorization")
	if authHeader == "" {
		return false
	}
	// 更复杂的验证逻辑，如验证 token 的有效性
	return true
}

4. 服务层调用

将业务逻辑封装在服务层，路由处理函数负责调用相应的服务。

services/user_service.go

package services

import (
	"errors"
)

type UserService struct{}

func (s *UserService) GetAll() ([]User, error) {
	// 模拟从数据库或其他数据源获取用户列表
	// 这里应该调用实际的数据访问层函数
	users := []User{
		{ID: "1", Name: "Alice"},
		{ID: "2", Name: "Bob"},
	}
	return users, nil
}

func (s *UserService) GetByID(id string) (*User, error) {
	// 模拟根据 ID 获取用户
	// 这里应该调用实际的数据访问层函数
	if id == "1" {
		return &User{ID: "1", Name: "Alice"}, nil
	}
	return nil, errors.New("User not found")
}

func (s *UserService) Create(user User) error {
	// 模拟创建用户
	// 这里应该调用实际的数据访问层函数
	return nil
}

func (s *UserService) Update(id string, user User) error {
	// 模拟更新用户
	// 这里应该调用实际的数据访问层函数
	return nil
}

func (s *UserService) Delete(id string) error {
	// 模拟删除用户
	// 这里应该调用实际的数据访问层函数
	return nil
}

5. 错误处理

在路由处理函数和服务层中都要进行错误处理，确保将错误信息正确返回给客户端。

func GetUserByID(c *gin.Context) {
	id := c.Param("id")
	user, err := userService.GetByID(id)
	if err!= nil {
		c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
		return
	}
	c.JSON(http.StatusOK, user)
}

6. 版本控制

对于 API 的不同版本，可以使用路由组进行管理。

func SetupRoutes() *gin.Engine {
	r := gin.Default()

	v1 := r.Group("/v1")
	SetupV1Routes(v1)

	v2 := r.Group("/v2")
	SetupV2Routes(v2)

	return r
}

7. 路由注册

在 main 函数中注册路由并启动服务。

package main

import (
	"yourproject/routes"
)

func main() {
	r := routes.SetupRoutes()
	r.Run(":8080")
}

通过上述方式，在商业大项目中使用 Gin 框架时，可以将路由定义、中间件、服务调用和错误处理等部分分离，实现清晰的分层架构，提高代码的可维护性和可扩展性。这样做有助于团队协作开发，并且方便对不同功能模块进行单独测试和优化。同时，合理使用路由组和中间件可以确保不同路由的逻辑隔离和功能复用。