7-Gin 中自定义控制器 --[Gin 框架入门精讲与实战案例]

在 Gin 框架中，"控制器"通常指的是处理 HTTP 请求的逻辑。虽然 Gin 本身没有像一些其他框架（例如 Django 或 Ruby on Rails）那样明确地定义 "控制器"的概念，但你可以通过组织代码来实现类似的功能。

Gin 使用路由组和中间件来帮助组织你的应用程序逻辑。为了创建自定义控制器，你可以按照以下几种方式来做：

1.定义一个结构体作为控制器：

你可以创建一个 Go 结构体，并为这个结构体添加方法，这些方法将作为路由处理器函数。每个方法可以接收 *gin.Context 参数。

2.使用路由组：

你可以在 Gin 中创建路由组，并将相关的路由分配给特定的控制器结构体的方法。

3.组合中间件：

如果你的控制器需要执行某些预处理或后处理逻辑，你可以编写中间件并将其应用于特定的路由或路由组。

下面是一个简单的例子，展示了如何创建一个名为 UserController 的自定义控制器：

package main

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

// UserController 定义用户控制器结构体
type UserController struct{}

// NewUserController 创建新的用户控制器实例
func NewUserController() *UserController {
	return &UserController{}
}

// Index 用户列表页面
func (uc *UserController) Index(c *gin.Context) {
	c.JSON(http.StatusOK, gin.H{"message": "User List"})
}

// Show 显示单个用户信息
func (uc *UserController) Show(c *gin.Context) {
	id := c.Param("id")
	c.JSON(http.StatusOK, gin.H{"user_id": id})
}

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

	// 创建用户控制器实例
	userController := NewUserController()

	// 定义路由组
	userRoutes := router.Group("/users")
	{
		userRoutes.GET("", userController.Index)
		userRoutes.GET("/:id", userController.Show)
	}

	// 启动HTTP服务，默认在0.0.0.0:8080启动服务
	router.Run()
}

在这里插入图片描述

在这个例子中，我们定义了一个 UserController 结构体，它有两个方法：Index 和 Show。然后我们创建了该控制器的一个实例，并将其方法与路由关联起来。这样就实现了类似于 MVC 模式中的控制器功能。

gin 控制器分组

好的，下面是三个使用 Gin 框架实现控制器分组的完整示例。每个示例展示了不同的组织和分组方式，以便你可以根据你的项目需求选择最适合的方法。

示例 1: 使用结构体方法作为控制器

在这个示例中，我们将创建一个 UserController 结构体，并将用户相关的路由逻辑放在这个结构体的方法中。

package main

import (
	"net/http" // 导入 net/http 包用于 HTTP 状态码

	"github.com/gin-gonic/gin" // 导入 Gin Web 框架
)

// UserController 用户控制器结构体，用于处理与用户相关的 HTTP 请求。
type UserController struct{}

// NewUserController 创建并返回一个新的用户控制器实例。
func NewUserController() *UserController {
	return &UserController{}
}

// List 处理获取所有用户的 HTTP GET 请求。
// 该方法接收一个 gin.Context 参数，用于处理请求和响应。
func (uc *UserController) List(c *gin.Context) {
	// 返回 JSON 格式的成功响应，包含消息 "List of users"
	c.JSON(http.StatusOK, gin.H{"message": "List of users"})
}

// Detail 处理获取单个用户详情的 HTTP GET 请求。
// 该方法接收一个 gin.Context 参数，用于处理请求和响应。
func (uc *UserController) Detail(c *gin.Context) {
	// 从 URL 参数中提取用户 ID
	id := c.Param("id")
	// 返回 JSON 格式的成功响应，包含用户 ID
	c.JSON(http.StatusOK, gin.H{"user_id": id})
}

func main() {
	// 创建默认的 Gin 路由引擎实例
	router := gin.Default()

	// 创建用户控制器实例
	userCtrl := NewUserController()

	// 定义路由组 "/users"，所有与用户相关的路由都将在这个路径下
	userRoutes := router.Group("/users")
	{
		// 将 HTTP GET 请求 "/" 映射到用户控制器的 List 方法，用于列出所有用户
		userRoutes.GET("", userCtrl.List)
		// 将 HTTP GET 请求 "/:id" 映射到用户控制器的 Detail 方法，用于显示特定用户的详情
		userRoutes.GET("/:id", userCtrl.Detail)
	}

	// 启动 HTTP 服务器，在端口 8080 上监听并服务请求
	router.Run(":8080")
}

在这里插入图片描述

示例 2: 使用独立的包来组织控制器

这里我们将控制器放在独立的包中，这样可以使代码更加模块化和易于维护。

首先，在名为 controllers 的目录下创建 user_controller.go 文件：

// controllers/user_controller.go
package controllers

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

// UserController 用户控制器
type UserController struct{}

// NewUserController 创建新的用户控制器实例
func NewUserController() *UserController {
	return &UserController{}
}

// List 显示所有用户
func (uc *UserController) List(c *gin.Context) {
	c.JSON(http.StatusOK, gin.H{"message": "List of users"})
}

// Detail 显示单个用户详情
func (uc *UserController) Detail(c *gin.Context) {
	id := c.Param("id")
	c.JSON(http.StatusOK, gin.H{"user_id": id})
}

然后在主文件中引用并使用它：

package main

import (
	"gin_7_3/controllers"

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

// main函数是程序的入口点。
func main() {
	// 初始化gin默认路由器。
	router := gin.Default()

	// 创建一个新的用户控制器实例。
	userCtrl := controllers.NewUserController()

	// 创建用户路由组。
	userRoutes := router.Group("/users")

	// 定义用户相关的路由和处理函数。
	{
		// 注册处理用户列表请求的路由。
		userRoutes.GET("", userCtrl.List)
		// 注册处理用户详情请求的路由。
		userRoutes.GET("/:id", userCtrl.Detail)
	}

	// 启动HTTP服务器，监听端口8080。
	router.Run(":8080")
}

在这里插入图片描述

示例 3: 使用中间件与控制器分组结合

下面是一个将中间件与控制器分组结合使用的完整示例。这个例子展示了如何创建一个简单的身份验证中间件，并将其应用到特定的路由组中，确保只有经过身份验证的请求才能访问某些用户信息。

1. 创建中间件

首先，我们定义一个简单的身份验证中间件 AuthMiddleware。该中间件会检查请求头中的 Authorization 字段，以确定请求是否携带了有效的令牌。

package main

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

// AuthMiddleware 简单的身份验证中间件
func AuthMiddleware() gin.HandlerFunc {
	return func(c *gin.Context) {
		token := c.GetHeader("Authorization")
		if token == "" {
			c.JSON(http.StatusUnauthorized, gin.H{"error": "Unauthorized"})
			c.Abort() // 中断后续处理
			return
		}
		// 这里可以添加更复杂的验证逻辑，比如解码 JWT 令牌等
		c.Next() // 继续执行下一个中间件或处理器
	}
}

2. 定义控制器

接下来，我们定义一个 UserController 来处理用户相关的 HTTP 请求。

// UserController 用户控制器结构体，用于处理与用户相关的 HTTP 请求。
type UserController struct{}

// NewUserController 创建并返回一个新的用户控制器实例。
func NewUserController() *UserController {
	return &UserController{}
}

// List 处理获取所有用户的 HTTP GET 请求。
func (uc *UserController) List(c *gin.Context) {
	c.JSON(http.StatusOK, gin.H{"message": "List of users"})
}

// Detail 处理获取单个用户详情的 HTTP GET 请求。
func (uc *UserController) Detail(c *gin.Context) {
	id := c.Param("id")
	c.JSON(http.StatusOK, gin.H{"user_id": id})
}

3. 设置路由和中间件

最后，在主函数中设置路由器、创建控制器实例、定义带中间件的路由组，并启动服务器。

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

	// 创建用户控制器实例
	userCtrl := NewUserController()

	// 定义不带中间件的公共路由
	publicRoutes := router.Group("/public")
	{
		publicRoutes.GET("/ping", func(c *gin.Context) {
			c.JSON(http.StatusOK, gin.H{"message": "pong"})
		})
	}

	// 定义带中间件的受保护路由
	protected := router.Group("/users", AuthMiddleware())
	{
		protected.GET("", userCtrl.List)
		protected.GET("/:id", userCtrl.Detail)
	}

	// 启动 HTTP 服务器，在端口 8080 上监听并服务请求
	router.Run(":8080")
}

在这里插入图片描述

在这个示例中，我们做了以下几件事：

创建了一个简单的身份验证中间件 AuthMiddleware，它检查每个请求的 Authorization 头。
定义了 UserController 结构体及其方法来处理用户相关的 HTTP 请求。
使用 router.Group 方法创建了两个不同的路由组：
- /public 路由组不需要任何身份验证。
- /users 路由组则需要通过 AuthMiddleware 的验证。
最后，我们在 :8080 端口上启动了 HTTP 服务器。

这种方式不仅使代码组织得更加清晰，而且也提高了安全性，因为你可以很容易地为特定的路由组添加必要的中间件来控制访问权限。

gin 控制器的继承

在 Go 语言中，严格意义上并没有类的概念，因此也没有传统意义上的继承机制。然而，你可以通过组合和接口来实现类似的功能。对于 Gin 控制器来说，我们可以通过结构体嵌入（匿名字段）或者接口的方式来模拟“继承”的行为。

下面是三个使用不同方法来模拟控制器继承的完整示例：

示例 1: 使用结构体嵌入

Go 语言中的结构体可以包含其他结构体作为匿名字段，这样就可以共享字段和方法，这类似于面向对象编程中的继承概念。

package main

import (
	"net/http"

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

// BaseController 基础控制器
type BaseController struct{}

// Response 成功响应
func (bc *BaseController) Response(c *gin.Context, data interface{}) {
	c.JSON(http.StatusOK, gin.H{"data": data})
}

// UserController 用户控制器，继承自 BaseController
type UserController struct {
	BaseController // 匿名字段
}

// List 显示所有用户
func (uc *UserController) List(c *gin.Context) {
	uc.Response(c, "List of users")
}

// main函数是程序的入口点。
func main() {
	// 初始化gin默认路由器。
	router := gin.Default()

	// 实例化用户控制器。
	userCtrl := &UserController{}

	// 创建用户路由组，基路径为"/users"。
	userRoutes := router.Group("/users")
	{
		// 定义GET请求的路由规则，处理用户列表请求。
		userRoutes.GET("", userCtrl.List)
	}

	// 启动服务器，监听端口为8080。
	router.Run(":8080")
}

在这里插入图片描述

在这个例子中，UserController 结构体包含了 BaseController 作为一个匿名字段，所以它可以直接访问 BaseController 的方法。

示例 2: 使用接口定义公共方法

你也可以定义一个接口，并让多个控制器实现这个接口。这种方式更符合 Go 的设计理念——接口分离原则。

package main

import (
	"net/http"

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

// ControllerInterface 定义控制器接口
type ControllerInterface interface {
	Response(c *gin.Context, data interface{})
}

// BaseController 实现了 ControllerInterface 接口的基础控制器
type BaseController struct{}

// Response 成功响应
func (bc *BaseController) Response(c *gin.Context, data interface{}) {
	c.JSON(http.StatusOK, gin.H{"data": data})
}

// UserController 用户控制器，实现了 ControllerInterface 接口
type UserController struct {
	*BaseController // 匿名字段
}

// List 显示所有用户
func (uc *UserController) List(c *gin.Context) {
	uc.Response(c, "List of users--taoyuan")
}

// main函数是程序的入口点。
func main() {
	// 初始化gin路由器，使用默认的中间件。
	router := gin.Default()

	// 初始化UserController，它继承自BaseController。
	userCtrl := &UserController{&BaseController{}}

	// 创建用户相关的路由组，以"/users"开头。
	userRoutes := router.Group("/users")
	{
		// 定义GET请求的路由处理函数，处理用户列表的请求。
		userRoutes.GET("", userCtrl.List)
	}

	// 启动HTTP服务器，监听8080端口。
	router.Run(":8080")
}

在这里插入图片描述

在这个例子中，BaseController 实现了一个接口 ControllerInterface，然后 UserController 继承了 BaseController 并实现了该接口的方法。

示例 3: 使用组合模式

组合模式允许你将多个不同的控制器或组件组合起来创建新的功能。这里我们不直接继承，而是通过组合不同的基础控制器来构建更复杂的控制器。

package main

import (
	"net/http"

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

// AuthController 身份验证控制器
type AuthController struct{}

// AuthResponse 返回认证信息
func (ac *AuthController) AuthResponse(c *gin.Context) {
	c.JSON(http.StatusOK, gin.H{"auth": "authenticated"})
}

// BaseController 基础控制器
type BaseController struct {
	*AuthController // 包含身份验证控制器
}

// Response 成功响应
func (bc *BaseController) Response(c *gin.Context, data interface{}) {
	bc.AuthResponse(c)
	c.JSON(http.StatusOK, gin.H{"data": data})
}

// UserController 用户控制器，包含基础控制器
type UserController struct {
	*BaseController // 包含基础控制器
}

// List 显示所有用户
func (uc *UserController) List(c *gin.Context) {
	uc.Response(c, "List of users")
}

// main函数是程序的入口点。
func main() {
	// 初始化gin路由器。
	router := gin.Default()

	// 初始化认证控制器。
	authCtrl := &AuthController{}

	// 初始化基础控制器，并传入认证控制器。
	baseCtrl := &BaseController{authCtrl}

	// 初始化用户控制器，并传入基础控制器。
	userCtrl := &UserController{baseCtrl}

	// 创建用户路由组。
	userRoutes := router.Group("/users")
	{
		// 定义用户列表路由。
		userRoutes.GET("", userCtrl.List)
	}

	// 启动服务器，监听8080端口。
	router.Run(":8080")
}

在这里插入图片描述

在这个例子中，UserController 通过组合 BaseController 和 AuthController 来提供额外的功能。这种方式提供了很大的灵活性，可以根据需要添加或移除组件。

这三个示例展示了如何在 Go 和 Gin 中利用结构体嵌入、接口以及组合模式来模拟控制器的“继承”。每种方法都有其适用场景，你可以根据项目的具体需求选择最合适的方式。

下载示例代码

Gin 框架入门精讲与实战案例代码

1.定义一个结构体作为控制器：

2.使用路由组：

3.组合中间件：

gin 控制器分组

示例 1: 使用结构体方法作为控制器

示例 2: 使用独立的包来组织控制器

示例 3: 使用中间件与控制器分组结合

1. 创建中间件

2. 定义控制器

3. 设置路由和中间件

gin 控制器的继承

示例 1: 使用结构体嵌入

示例 2: 使用接口定义公共方法

示例 3: 使用组合模式

下载示例代码

Latest comments

Categories