全面解析 Golang Gin 框架

最新推荐文章于 2025-06-13 10:09:40 发布

Hello.Reader

最新推荐文章于 2025-06-13 10:09:40 发布

阅读量1.7k

点赞数 11

CC 4.0 BY-SA版权

分类专栏： golang 文章标签： golang gin 开发语言

本文链接：https://blog.csdn.net/weixin_43114209/article/details/144609190

1. 引言

在现代 Web 开发中，随着需求日益增加，开发者需要选择合适的工具来高效地构建应用程序。对于 Go 语言（Golang）开发者来说，Gin 是一个备受青睐的 Web 框架。它轻量、性能高、易于使用，并且具备丰富的功能，能够满足不同规模应用的需求。

1.1 为什么选择 Gin 框架

Go 语言自诞生以来，就因其简洁的语法和高效的并发处理能力而成为许多开发者的首选。而 Gin 作为一个基于 Go 的 Web 框架，能够充分发挥 Go 的优势。选择 Gin 构建 Web 应用有以下几个显著的优点：

高性能：Gin 设计上十分注重性能，能够在高并发环境下处理请求，支持高吞吐量的 Web 服务。其路由与中间件的实现非常高效，适用于大规模应用和高负载场景。
简洁易用：Gin 的 API 设计简洁明了，具有良好的文档支持，开发者可以快速上手，并且能够通过少量的代码实现常见的 Web 开发功能。
内存管理：由于 Go 语言本身的特性，Gin 拥有较低的内存消耗，这使得它在运行时能够更高效地处理请求，减少内存泄漏和性能瓶颈。
丰富的中间件支持：Gin 提供了多种内置中间件，例如日志、认证、跨域请求处理等，同时也支持开发者自定义中间件，这为应用的扩展性提供了更多可能。
广泛的社区支持：作为 Go 语言中最受欢迎的 Web 框架之一，Gin 拥有一个活跃的开发者社区。无论是通过文档、博客，还是开源代码，开发者都可以方便地获取所需的资源。

1.2 Gin 框架的特点与优势

路由系统与上下文处理：
Gin 的路由系统高效且功能强大，它允许开发者定义灵活的路由规则，并且通过 Context 对象处理请求。Context 对象不仅携带了 HTTP 请求和响应，还提供了处理请求的辅助方法，如 JSON 绑定、表单数据解析等。
中间件机制：
中间件是 Gin 的一大亮点，它能够在请求到达处理函数之前或之后，执行自定义的功能。常见的用途包括身份验证、日志记录、请求限流等。Gin 的中间件机制非常灵活，可以链式调用多个中间件，帮助开发者解耦代码，提高可维护性。
JSON 与数据绑定：
Gin 的另一个优势是其对 JSON 数据的处理能力，能够自动地将请求中的 JSON 数据绑定到结构体，减少了手动解析的工作量。此外，Gin 还支持其他类型的数据绑定，如表单数据、查询参数等。
高效的错误处理：
Gin 提供了方便的错误处理机制，允许开发者通过中间件或自定义的错误处理函数，统一处理请求中的错误并返回合适的 HTTP 状态码与响应消息，提升了 Web 服务的鲁棒性。
灵活的模板渲染与静态文件处理：
Gin 支持使用 HTML 模板渲染页面，且能够高效地服务静态文件，如图片、CSS、JavaScript 等。对于前后端分离的 Web 应用，这些特性非常重要。

1.3 Gin 与其他 Web 框架的对比

虽然 Go 语言有多种 Web 框架可供选择（如 net/http、Echo、Beego 等），但是 Gin 以其卓越的性能、简单的使用体验和强大的扩展性脱颖而出。与其他框架相比，Gin 的优势主要体现在以下几个方面：

性能：Gin 的路由匹配和请求处理机制相较于其他框架更加高效，能够承载更多的并发请求。
简洁性：Gin 的代码结构与 API 接口非常简洁，开发者无需学习复杂的概念，就能够快速编写功能完善的 Web 应用。
社区支持：Gin 拥有庞大的开发者社区，常见问题可以通过论坛或开源库得到及时解决。相比之下，其他一些框架的社区资源和支持相对较少。

2. Golang 和 Web 框架概述

在进入 Gin 框架的具体内容之前，了解一下 Golang（Go 语言）以及 Web 开发中框架的选择逻辑对我们理解 Gin 的定位和优势是非常重要的。本部分将简要介绍 Go 语言在 Web 开发中的应用，以及 Web 框架的一些基本概念，帮助读者更好地理解为什么 Go 语言与 Gin 框架如此契合。

2.1 Golang 在 Web 开发中的应用

Go 语言自 2009 年由 Google 开发以来，凭借其简洁的语法、高效的性能和强大的并发能力，已经在系统编程、网络服务、云计算等领域得到了广泛应用。在 Web 开发中，Go 语言也逐渐成为了一个热门的选择，特别是在需要高并发、低延迟和高可扩展性的场景下。

Go 的设计哲学强调简洁性和高效性，以下是 Go 在 Web 开发中几个关键的特点：

并发支持：
Go 语言内置了协程（goroutine）和通道（channel），使得并发编程变得简单高效。Web 开发中，通常需要处理大量并发请求，而 Go 的并发模型可以轻松应对高并发场景。例如，在 Web 服务器中，多个请求可以通过 goroutine 并行处理，而不需要复杂的线程管理。
高效的性能：
Go 是一种编译型语言，其编译后的二进制文件通常运行得非常高效。相比于其他解释性语言，Go 具有更低的延迟和更高的吞吐量。在构建高性能 Web 服务时，Go 语言天然具有优势。
简洁的语法：
Go 的语法设计非常简洁，没有复杂的继承和多态，采用了面向接口的编程模型，代码可读性和可维护性较强。对于 Web 开发者来说，Go 可以让你集中精力解决业务问题，而不是被复杂的语法所困扰。
内存管理：
Go 的垃圾回收（GC）机制使得开发者可以不用过多考虑内存管理的问题。此外，Go 的内存消耗相对较小，在构建 Web 应用时，能够处理更多的并发请求，降低了内存泄漏的风险。
广泛的标准库：
Go 提供了一个功能丰富的标准库，其中包括 HTTP 服务、网络通信、数据库连接等功能。即使不使用第三方 Web 框架，Go 也能够通过其标准库开发 Web 应用。这也是 Go 在 Web 开发中能够脱颖而出的一个重要因素。

2.2 Web 框架的选择与定位

在 Web 开发中，框架是开发者用来加速应用开发、提高开发效率和代码质量的工具。框架可以帮助开发者处理很多重复性的工作，比如路由匹配、请求处理、会话管理等，从而使开发者专注于应用的业务逻辑。

对于 Go 语言的开发者来说，选择合适的 Web 框架非常重要。Go 提供了一个基础的 HTTP 包，它已经可以用来构建 Web 应用。然而，使用第三方 Web 框架往往能够提升开发效率，并且提供更高级的功能。Go 中的 Web 框架大致可以分为以下几类：

轻量型框架：
这种类型的框架通常关注于提供最基础的 Web 开发功能，轻量级、快速且易于上手。Gin 和 Echo 就是典型的轻量型框架，它们专注于高性能的路由和中间件支持，适合用于构建高效的 RESTful API 和微服务。
全栈框架：
相对于轻量型框架，全栈框架提供更多的功能，通常包括路由、模板渲染、ORM（对象关系映射）、会话管理等，可以用于开发更为复杂的 Web 应用。Beego 是 Go 中一个典型的全栈框架，它提供了丰富的功能和工具，可以加速开发过程，适合那些需要更多功能的企业级应用。
微框架：
微框架通常比轻量型框架更加简化，提供了非常基础的功能，开发者可以根据自己的需求进行扩展。微框架的目标是提供最基本的 Web 服务框架，而不干扰开发者的其他设计和选择。Chi 就是一个非常受欢迎的 Go 微框架，简洁且扩展性强。

2.3 Go 的 Web 框架选择理由

选择适合的 Web 框架时，开发者需要根据项目的具体需求做出权衡。以下是选择 Go Web 框架时需要考虑的一些关键因素：

性能要求：如果应用的并发要求非常高，框架的性能就至关重要。Gin 是以高性能著称的框架，能够在高并发场景下稳定运行。
框架的扩展性：大多数 Web 框架提供了一定的扩展性，例如中间件、插件机制等。选择一个能够支持自定义扩展的框架有助于在项目发展过程中适应不断变化的需求。
易用性与学习曲线：框架的易用性和文档支持是非常重要的。如果框架学习曲线陡峭，可能会增加开发的复杂度和时间成本。Gin 的文档清晰、示例丰富，是开发者学习和上手的好选择。
社区支持与活跃度：框架的社区支持对开发者来说至关重要。活跃的社区意味着有更多的教程、插件、解决方案等可供参考和使用。Gin 在这方面具有很大的优势，它的活跃社区使得开发者可以快速找到问题的解决办法。

2.4 Web 开发中的常见框架

除了 Go 语言中的 Gin，其他语言中也有众多的 Web 框架，这些框架各有优缺点，适用于不同的场景：

Node.js：例如 Express、Koa。Node.js 使用单线程事件驱动模型，适合处理大量 I/O 密集型的请求。
Python：例如 Django、Flask。Django 是一个全栈框架，适用于大型 Web 应用，Flask 是一个轻量级框架，适用于简单的 Web 服务。
Ruby：例如 Ruby on Rails。Rails 是一个全栈框架，帮助开发者快速开发和部署 Web 应用。
Java：例如 Spring Boot。Spring Boot 是一个全栈框架，支持创建企业级的应用，具有强大的功能和稳定性。

3. Gin 框架入门

在本节中，我们将带你快速入门 Gin 框架，从安装到创建你的第一个 Web 应用。Gin 是一个轻量级、高性能的 Go Web 框架，适合用于构建快速、高并发的 Web 应用。通过本节的内容，你将学习如何安装 Gin，并使用它构建一个简单的 Web 服务。

3.1 安装与初始化

在开始使用 Gin 之前，首先需要安装 Go 语言开发环境。可以参考 Go 官方文档来完成安装：Go 安装文档。

安装好 Go 环境后，接下来是安装 Gin 框架。Gin 是通过 Go 的包管理工具 go get 来安装的。

安装 Gin

打开终端（命令行工具），执行以下命令来安装 Gin：
```
go get -u github.com/gin-gonic/gin
```
这会将 Gin 框架安装到 Go 的工作空间中。-u 参数会确保你安装的是最新版本。
确认安装成功：

你可以通过运行以下命令来检查 Gin 是否成功安装：
```
go list github.com/gin-gonic/gin
```
如果没有错误信息，说明 Gin 已经安装成功。

初始化一个 Gin 项目

创建一个新的 Go 项目文件夹，例如：
```
mkdir my-gin-app
cd my-gin-app
```
初始化 Go 项目，生成 go.mod 文件：
```
go mod init my-gin-app
```
创建一个 Go 源代码文件 main.go，这个文件将包含我们构建 Web 应用的代码。

3.2 创建第一个 Gin 应用

在本节中，我们将通过创建一个简单的 “Hello, World!” 应用来快速上手 Gin。

打开 main.go 文件，编写如下代码：

package main

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

func main() {
     
     
    // 创建一个默认的 Gin 路由引擎
    r := gin.Default()

    // 设置一个 GET 路由
    r.GET("/", func(c *gin.Context) {
     
     
        c.JSON(200, gin.H{
     
     
            "message": "Hello, World!",
        })
    })

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

解释：

gin.Default()：创建一个默认的 Gin 引擎，它启用了日志和恢复中间件。
r.GET("/", func(c *gin.Context))：定义了一个 GET 路由，处理根路径 / 的请求，返回一个 JSON 响应。
r.Run(":8080")：启动 Web 服务器并监听 8080 端口。

保存文件后，在终端中执行以下命令来运行程序：
```
go run main.go
```
如果一切顺利，你会看到如下输出，说明 Gin 服务已经启动：
```
[GIN-debug] Listening and serving HTTP on :8080
```
打开浏览器，访问 http://localhost:8080，你应该会看到如下 JSON 响应：
```
{
     
     
  "message": "Hello, World!"
}
```
恭喜你！你已经成功地使用 Gin 框架构建了一个简单的 Web 应用。

3.3 路由与请求处理

Gin 提供了灵活的路由功能，你可以根据不同的 HTTP 方法（如 GET、POST、PUT、DELETE）定义不同的路由和处理函数。我们在上面的示例中只使用了 GET 方法，但 Gin 还支持其他 HTTP 方法。

示例：处理多个 HTTP 方法

以下是一个包含多个 HTTP 方法的示例：

package main

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

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

    // GET 路由
    r.GET("/hello", func(c *gin.Context) {
   
   
        c.JSON(200, gin.H{
   
   
            "message": "GET request received",
        })
    })

    // POST 路由
    r.POST("/hello", func(c *gin.Context) {
   
   
        c.JSON(200, gin.H{
   
   
            "message": "POST request received",
        })
    })

    // PUT 路由
    r.PUT("/hello", func(c *gin.Context) {
   
   
        c.JSON(200, gin.H{
   
   
            "message": "PUT request received",
        })
    })

    // DELETE 路由
    r.DELETE("/hello", func(c *gin.Context) {
   
   
        c.JSON(200, gin.H{
   
   
            "message": "DELETE request received",
        })
    })

    r.Run(":8080")
}

保存代码并执行：
```
go run main.go
```
你现在可以通过不同的 HTTP 方法来访问 /hello 路由：
- GET /hello 返回 “GET request received”
- POST /hello 返回 “POST request received”
- PUT /hello 返回 “PUT request received”
- DELETE /hello 返回 “DELETE request received”

你可以使用浏览器、Postman 或 cURL 来测试这些请求。

3.4 路由参数与查询参数

Gin 支持通过 URL 参数和查询参数来传递数据。这使得你能够处理动态路由和传递复杂的查询信息。

示例：路由参数

r.GET("/user/:id", func(c *gin.Context) {
   
   
    id := c.Param("id")
    c.JSON(200, gin.H{
   
   
        "user_id": id,
    })
})

在这个示例中，:id 是一个路由参数，访问 http://localhost:8080/user/123 时，Gin 会提取 id 参数并返回：

{
   
   
  "user_id": "123"
}

示例：查询参数

r.GET("/search", func(c *gin.Context) {
   
   
    query := c.DefaultQuery("q", "default")
    c.JSON(200, gin.H{
   
   
        "search_query": query,
    })
})

在这个示例中，我们使用了 DefaultQuery 方法来获取查询参数 q，如果没有提供该参数，则使用默认值 default。访问 http://localhost:8080/search?q=golang 会返回：

{
   
   
  "search_query": "golang"
}

3.5 错误处理与响应

Gin 提供了简单的错误处理和响应机制。你可以在路由处理函数中通过 c.JSON 或 c.String 方法返回不同的 HTTP 状态码和消息。

示例：错误响应

r.GET("/error", func(c *gin.Context) {
   
   
    c.JSON(400, gin.H{
   
   
        "error": "Bad Request",
    })
})

访问 http://localhost:8080/error 会返回：

{
   
   
  "error": "Bad Request"
}

4. Gin 的核心概念

在本节中，我们将深入探讨 Gin 框架 的一些核心概念，帮助你更好地理解 Gin 的工作原理。这些概念包括路由、中间件、和 上下文。掌握这些核心概念，将有助于你更高效地开发基于 Gin 的 Web 应用。

4.1 路由与路由组

路由是 Gin 中的基础概念，它负责将客户端的 HTTP 请求（如 GET、POST 请求）映射到相应的处理函数。Gin 的路由系统非常灵活且高效，能够满足各种不同的需求。

路由的基本使用

我们已经在之前的示例中看过如何定义一个简单的路由：

r.GET("/hello", func(c *gin.Context) {
   
   
    c.JSON(200, gin.H{
   
   
        "message": "Hello, World!",
    })
})

在这个示例中，r.GET("/hello", ...) 定义了一个 GET 请求的路由，它会将所有访问 /hello 路径的请求转发给指定的处理函数。Gin 支持多种 HTTP 方法，例如 GET、POST、PUT、DELETE 等。

路由参数

Gin 支持动态路由参数，这使得你能够定义包含变量的路由。例如：

r.GET("/user/:id", func(c *gin.Context) {
   
   
    id := c.Param("id")
    c.JSON(200, gin.H{
   
   
        "user_id": id,
    })
})

当你访问 http://localhost:8080/user/123 时，id 参数会被提取并返回：

{
   
   
  "user_id": "123"
}

路由组

路由组（Router Groups）是 Gin 中的一个强大功能，它允许你将多个相关的路由进行分组，并且为整个组设置公共的前缀或中间件。这可以帮助你更好地组织路由，尤其是在大型应用中。

例如，假设你有一组用户相关的路由，可以通过路由组来组织：

userGroup := r.Group("/user")
{
   
   
    userGroup.GET("/:id", func(c *gin.Context) {
   
   
        id := c.Param("id")
        c.JSON(200, gin.H{
   
   
            "user_id": id,
        })
    })

    userGroup.POST("/create", func(c *gin.Context) {
   
   
        // 创建用户的逻辑
        c.JSON(200, gin.H{
   
   
            "message": "User created",
        })
    })
}

在上面的代码中，所有的用户路由都以 /user 为前缀，例如 /user/:id 和 /user/create。路由组有助于减少重复代码并提高可维护性。

4.2 中间件

中间件 是 Web 开发中的一个重要概念，它是位于请求和响应之间的处理层。Gin 中的中间件机制非常强大，允许你在请求处理前后执行一些额外的操作。

中间件可以用于许多场景，例如：

请求日志记录
请求认证与授权
请求限流
CORS 支持（跨域资源共享）

使用内置中间件

Gin 提供了一些常用的内置中间件，例如：

日志中间件（Logger）：记录每个 HTTP 请求的日志。
恢复中间件（Recovery）：防止由于程序崩溃导致服务中断，自动恢复并返回 500 错误。

使用这些内置中间件非常简单：

r := gin.Default()  // gin.Default() 会自动启用 Logger 和 Recovery 中间件

r.GET("/ping", func(c *gin.Context) {
   
   
    c.JSON(200, gin.H{
   
   
        "message": "pong",
    })
})

r.Run(":8080")

在上面的代码中，gin.Default() 会自动启用两个中间件：Logger 和 Recovery。每次请求都会先经过这两个中间件处理。

自定义中间件

除了内置的中间件，Gin 还支持开发者自定义中间件。自定义中间件需要满足以下格式：

func MyMiddleware() gin.HandlerFunc {
   
   
    return func(c *gin.Context) {
   
   
        // 在请求处理之前
        fmt.Println("Before request")

        // 继续处理请求
        c.Next()

        // 在请求处理之后
        fmt.Println("After request")
    }
}

然后，你可以将这个中间件应用到路由或路由组：

r := gin.Default()

// 应用自定义中间件
r.Use(MyMiddleware())

r.GET("/ping", func(c *gin.Context) {
   
   
    c.JSON(200, gin.H{
   
   
        "message": "pong",
    })
})

r.Run(":8080")

在上面的例子中，MyMiddleware 中间件将在每次请求时被调用。

中间件的执行顺序

Gin 中间件的执行顺序是按照 Use 的顺序进行的。例如，如果你注册了多个中间件，它们会按照注册的顺序依次执行。

请求进入时，中间件会按照注册顺序从上到下执行。
请求离开时，中间件会按照注册顺序从下到上执行。

4.3 上下文（Context）

上下文（gin.Context）是 Gin 的一个核心概念，它封装了当前 HTTP 请求的所有信息，包括请求数据、响应数据、路由参数等。每当 Gin 处理一个 HTTP 请求时，它都会创建一个 Context 对象，并将其传递到处理函数中。

使用 Context 处理请求

你可以通过 c（gin.Context）对象访问请求的各类信息。例如：

r.GET("/user/:id", func(c *gin.Context) {
   
   
    // 获取路由参数
    id := c.Param("id")

    // 获取查询参数
    name := c.DefaultQuery("name", "Guest")

    // 设置响应内容
    c.JSON(200, gin.H{
   
   
        "user_id": id,
        "name": name,
    })
})

在上面的例子中，c.Param("id") 获取了路由参数 id，c.DefaultQuery("name", "Guest") 获取了查询参数 name，如果没有提供该参数，默认值为 Guest。

处理请求数据

Gin 提供了非常方便的方法来处理请求数据，包括表单数据、JSON 数据等。你可以通过以下方式获取请求中的数据：

获取 JSON 数据：

r.POST("/json", func(c *gin.Context) {
     
     
    var jsonData map[string]interface{
     
     }
    if err := c.ShouldBindJSON(&jsonData); err != nil {
     
     
        c.JSON(400, gin.H{
     
     "error": "Invalid JSON"})
        return
    }
    c.JSON(200, gin.H{
     
     "received": jsonData})
})

获取表单数据：

r.POST("/form", func(c *gin.Context) {
     
     
    name := c.DefaultPostForm("name", "Guest")
    age := c.DefaultPostForm("age", "0")
    c.JSON(200, gin.H{
     
     "name": name, "age": age})
})

处理响应数据

gin.Context 提供了多种方法来设置响应数据，包括：

c.JSON(status, obj)：将响应数据以 JSON 格式返回。
c.String(status, format, args...)：将响应数据以字符串格式返回。
c.HTML(status, tmpl, obj)：将响应数据以 HTML 格式返回。

5. Gin 的中间件机制

Gin 的中间件机制是它的一个核心特性，使得开发者可以在请求处理的过程中，插入自定义的处理逻辑。中间件在请求和响应周期中扮演着重要角色，它们可以用于执行预处理、请求认证、日志记录、错误处理、响应修改等任务。

在本节中，我们将深入探讨 Gin 中的中间件机制，包括如何定义和使用中间件、内置中间件的使用、以及中间件的执行顺序。

5.1 什么是中间件？

中间件 是一个函数，它位于 HTTP 请求和响应的处理流程之间，允许开发者在处理请求前后进行干预。中间件可以通过对请求进行修改或对响应进行处理，帮助实现一些跨路由或跨应用的通用功能。

在 Gin 中，中间件的执行流程是同步的，只有在当前中间件完成执行后，才能进入下一个中间件或路由处理函数。

中间件的执行顺序

请求到达服务器时，中间件会按照注册的顺序从上到下依次执行。
如果中间件执行完毕并调用了 c.Next()，请求会继续传递给下一个中间件或最终的路由处理函数。
如果在中间件中调用了 c.Abort()，请求会停止继续传递，后续的中间件和路由处理函数将不会被执行。

5.2 定义和使用中间件

在 Gin 中，中间件是一个返回 gin.HandlerFunc 类型的函数。gin.HandlerFunc 是一个接受 *gin.Context 参数并返回 void 的函数类型。

自定义中间件

以下是定义和使用自定义中间件的示例：

package main

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

// 定义一个自定义中间件
func MyMiddleware() gin.HandlerFunc {
   
   
    return func(c *gin.Context) {
   
   
        // 请求处理之前的逻辑
        fmt.Println("Before request")
        
        // 记录请求开始时间
        start := time.Now()

        // 继续处理请求
        c.Next()

        // 请求处理之后的逻辑
        duration := time.Since(start)
        fmt.Printf("Request duration: %v\n", duration)
    }
}

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

    // 使用自定义中间件
    r.Use(MyMiddleware())

    r.GET("/ping", func(c *gin.Context) {
   
   
        c.JSON(200, gin.H{
   
   
            "message": "pong",
        })
    })

    r.Run(":8080")
}

在上面的例子中，MyMiddleware 是一个自定义中间件，它会在每次请求时打印请求开始的时间，并在请求结束时计算并打印请求的持续时间。

中间件的顺序

Gin 会按照注册的顺序执行中间件。例如，如果你想在某个路由的处理中间件之前执行某些操作，可以通过 Use 方法将它们按顺序排列：

r.Use(FirstMiddleware())
r.Use(SecondMiddleware())
r.GET("/ping", func(c *gin.Context) {
   
   
    c.JSON(200, gin.H{
   
   
        "message": "pong",
    })
})

在上述代码中，FirstMiddleware 会先于 SecondMiddleware 执行。

5.3 Gin 内置中间件

Gin 提供了几个常用的内置中间件，这些中间件可以帮助开发者更轻松地实现一些常见的功能，如日志记录、恢复处理、跨域请求等。

1. Logger 中间件

Gin 默认提供了 Logger 中间件，它会记录每个请求的日志信息，包括请求的时间、方法、路径、响应状态等。

r := gin.Default()  // gin.Default() 启用 Logger 和 Recovery 中间件

r.GET("/ping", func(c *gin.Context) {
   
   
    c.JSON(200, gin.H{
   
   
        "message": "pong",
    })
})

r.Run(":8080")

gin.Default() 创建的 Gin 引擎自动启用了 Logger 和 Recovery 两个中间件。你可以通过自定义日志格式来调整输出的日志内容，或者将日志写入文件。

2. Recovery 中间件

Recovery 中间件用于捕获和恢复由于程序错误导致的 panic，从而避免服务器崩溃。它会在发生 panic 时，恢复并返回 500 错误。

r := gin.Default()  // gin.Default() 启用 Recovery 中间件

r.GET("/panic"

最低0.47元/天解锁文章

200万优质内容无限畅学