gin框架

一.简介

Gin是一个快速而高效的Go框架，用于构建Web应用程序。它具有简单而强大的功能，如路由、中间件、模板引擎等。Gin提供了一个简单易用的API，使得开发者可以快速地构建Web应用程序。

二.特点：

1.简单易用：Gin提供了一个简单易用的API，使得开发者可以快速地构建Web应用程序。
2.路由：Gin支持路由功能，可以轻松地定义URL和处理函数之间的映射关系。
3.中间件：Gin支持中间件功能，可以轻松地处理请求和响应的钩子函数。
4.模板引擎：Gin支持模板引擎功能，可以方便地使用模板来渲染HTML内容。
5.JSON解析：Gin内置了JSON解析功能，可以方便地解析JSON数据。
6.静态文件服务：Gin内置了静态文件服务功能，可以方便地提供静态文件，如CSS、JavaScript等。
Gin的性能也相当不错，它使用了Router和Recovery两个中间件，可以快速地处理请求，并自动捕获和处理异常。Gin还提供了多种优化选项，如缓存、日志记录等，可以方便地优化应用程序性能。

下面是一个简单的Gin路由示例：

package main

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

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

   router.GET("/", func(c *gin.Context) {
       c.String(200, "Hello, this is the root route!")
   })

   router.GET("/users", func(c *gin.Context) {
       c.JSON(200, gin.H{
           "message": "List of users",
           "data": []string{"Alice", "Bob", "Charlie"},
       })
   })

   router.Run(":8080")
}

在这个例子中，我们首先导入了Gin的默认路由器gin.Default()，然后使用GET方法定义了一个根路由，当用户访问根路由时，会返回"Hello, this is the root route!"。我们还定义了一个用户列表路由，当用户访问/users时，会返回一个JSON响应，其中包含一个消息和一个用户列表。最后，我们使用Run方法启动Gin路由器，监听8080端口。

三.基本概念和用法

安装gin

go get -u github.com/gin-gonic/gin

导入Gin包：

package main

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

：

创建一个Gin路由器：

使用gin.Default()创建一个默认的路由器，这个路由器会自动加载默认的静态文件处理函数：

router := gin.Default()

定义路由：

使用router.GET()、router.POST()等方法定义路由，

router.GET("/", func(c *gin.Context) {
   c.String(200, "Hello, this is the root route!")
})

处理路由：

定义路由时，需要传入一个函数作为处理函数，这个函数会在请求到达时自动执行，例如：

router.GET("/users", func(c *gin.Context) {
   c.JSON(200, gin.H{
       "message": "List of users",
       "data": []string{"Alice", "Bob", "Charlie"},
   })
})

启动路由器：

使用router.Run()方法启动路由器，例如：

router.Run(":8080")

四.路由

路由是指通过URL请求将请求传递给相应的处理程序的过程。在Web应用程序中，路由器负责根据URL的请求来匹配相应的处理程序，并将请求传递给处理程序进行处理。

1.映射处理函数

在Gin框架中，路由是指使用router.GET()、router.POST()等方法定义URL和处理函数之间的映射关系的过程。例如，在以下代码中，定义了一个GET请求的路由，当用户访问/路径时，会执行rootHandler函数：

router.GET("/", func(c *gin.Context) {
  c.String(200, "Hello, this is the root route!")
})

在这个例子中，/是一个URL路径，func(c *gin.Context)是一个处理函数，当用户访问/路径时，Gin框架会自动调用这个处理函数进行处理。

2.路由分组

使用router.Group方法可以将多个路由分组在一起，并为每个组定义一个前缀路径。例如

router.Group("/path",func(c* gin.Context){
{
r.Get("/1",func(c*gin.Context){
//函数逻辑
}
r.Post("/",func(c*gin.Context){
//函数逻辑
}
}
//
//或者是
api=router.Group("/path")
api.Get("/1",func(c*gin.Context){
//函数逻辑
}
api.Post("/",func(c*gin.Context){
//函数逻辑
}

3.路由中间件和路由错误处理

使用router.Use方法可以将多个路由中间件添加到路由器中，这些中间件将在请求处理之前或之后执行。例如：

package main
import (
   "fmt"
   "log"
   "net/http"
   "github.com/gin-gonic/gin"
)

func main() {
   // 创建一个Gin路由器
   router := gin.Default()
   // 使用中间件来记录请求日志
   router.Use(gin.Logger())
   // 使用中间件来捕获并处理异常
   router.Use(gin.Recover())
   // 定义一个路由处理函数
   router.GET("/", func(c *gin.Context) {
       // 设置响应头
       c.Header("Content-Type", "text/plain")
       // 设置响应内容
       c.String(http.StatusOK, "Hello, Gin!")
   })
   router.Use(func(c *gin.Context) error {
  // 设置请求头
  c.Header("Content-Type", "application/json")
  // 验证用户身份
  if c.Request.Header.Get("Authorization") != "Bearer token" {
      return gin.Error(http.StatusUnauthorized, "未授权")
  }
  // 继续处理请求
  return nil
})
   // 定义一个路由处理函数，用于处理错误请求
   router.DefaultHandler(func(c *gin.Context) {
       log.Println("未匹配到任何路由")
       c.JSON(http.StatusInternalServerError, gin.H{
           "message": "服务器内部错误",
       })
   })
   // 启动服务器
   err := router.Run(":8080")
   if err != nil {
       log.Fatal("无法启动服务器: ", err)
   }
}

使用router.Use方法将gin.Logger和gin.Recover两个中间件（该中间件为gin框架自带）添加到路由器中，分别用于记录请求日志和捕获并处理异常。

接下来，自定义了一个路由处理函数，用于处理正常的GET请求

路由错误处理：使用router.DefaultHandler方法可以定义一个默认的路由错误处理函数，用于处理未匹配到任何路由的请求

路由钩子（Hook）

简介

在Gin框架中，路由钩子（Hook）是一种在请求处理之前或之后执行特定操作的方法。路由钩子可以用于设置请求头、记录日志、处理异常等。Gin框架提供了以下几种路由钩子：

钩子

router.BeforeEach：在每个请求处理之前执行的钩子。
router.AfterEach：在每个请求处理之后执行的钩子。
router.Before：在请求处理之前执行的钩子，但只针对特定的路由。
router.After：在请求处理之后执行的钩子，但只针对特定的路由。

案例

下面 是一个示例，展示了如何使用路由钩子来记录日志：

package main

import (
   "fmt"
   "log"
   "net/http"
   "github.com/gin-gonic/gin"
)
func main() {
   // 创建一个Gin路由器
   router := gin.Default()
   // 使用Before钩子来记录日志
   router.Before(func(c *gin.Context) {
       log.Println("请求路径:", c.Request.URL.Path)
   })
   // 添加路由
   router.GET("/", func(c *gin.Context) {
       c.String(http.StatusOK, "Hello, Gin!")
   })
   // 启动服务器
   err := router.Run(":8080")
   if err != nil {
       log.Fatal("无法启动服务器: ", err)
   }
}

gin.Context

gin.Context 是 Go 语言的 github.com/gin-gonic/gin 包中的一个结构体，它封装了一个 HTTP 请求的上下文（context）。在 Gin 框架中，gin.Context 对象用于处理 HTTP 请求的生命周期，包括解析 URL、处理请求头、处理请求体等。

gin.Context 对象包含了许多属性，例如请求方法（Request.Method）、请求 URL（Request.URL.String()）、请求头（Request.Header）、请求体（Request.Body）等。通过这些属性，可以获取到 HTTP 请求的详细信息，以便进行相应的处理。

如果你想要获取 HTTP 请求的 body，可以使用 gin.Context.Request.Body 属性。例如，以下代码获取了 HTTP 请求的 body 内容：

package main

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

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

  router.POST("/upload", func(c *gin.Context) {
      data, err := ioutil.ReadAll(c.Request.Body)
      if err != nil {
          c.JSON(500, gin.H{"error": err.Error()})
          return
      }

      fmt.Println("Uploaded data:", string(data))
      c.JSON(200, gin.H{"message": "Data uploaded successfully"})
  })

  router.Run(":8080")
}

在这个例子中，我们使用 ioutil.ReadAll(c.Request.Body) 函数从 gin.Context.Request.Body 中读取请求的 body 内容，并将其输出到控制台上。

五.JSON

函数c.JSON

c.JSON 是 Go 语言的 github.com/gin-gonic/gin 包中的一个函数，用于将响应数据以 JSON 格式返回给客户端。它接收两个参数：一个是响应状态码（status code），另一个是一个映射（map），表示响应的数据。

例如，以下代码使用 c.JSON 函数返回一个 JSON 响应给客户端：

package main

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

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

 router.GET("/users", func(c *gin.Context) {
   users := []map[string]string{
     {
       "id":    1,
       "name":  "Alice",
       "email": "alice@example.com",
     },
     {
       "id":    2,
       "name":  "Bob",
       "email": "bob@example.com",
     },
   }

   c.JSON(200, users)
 })

 router.Run(":8080")
}

在这个例子中，我们定义了一个处理 GET 请求的函数，它返回一个包含两个用户对象的数组。然后，我们使用 c.JSON 函数将这个数组以 JSON 格式返回给客户端，状态码为 200。

客户端收到这个 JSON 响应后，会将它解析为 JSON 对象，并将其转换为 Go 语言的 map。这样，客户端就可以访问和处理响应数据了。

读取json文件

如果你想要使用 JSON 文件而不是直接在代码中定义响应数据，可以使用 Go 语言的 os 和 ioutil 包来读取 JSON 文件。

例如，假设你有一个名为 data.json 的 JSON 文件，其中包含以下数据：

{
 "users": [
   {
     "id": 1,
     "name": "Alice",
     "email": "alice@example.com"
   },
   {
     "id": 2,
     "name": "Bob",
     "email": "bob@example.com"
   }
 ]
}

读取返回客户端

你可以使用以下代码读取这个 JSON 文件，并将其作为响应数据返回给客户端

package main

import (
 "encoding/json"
 "fmt"
 "github.com/gin-gonic/gin"
 "io/ioutil"
)
func main() {
 router := gin.Default()
 // 读取 JSON 文件
 data, err := ioutil.ReadFile("data.json")
 if err != nil {
   fmt.Println("Error reading JSON file:", err)
   return
 }
 // 将 JSON 数据解析为 Go 语言的 map
 var jsonMap map[string]interface{}
 err = json.Unmarshal(data, &jsonMap)
 if err != nil {
   fmt.Println("Error unmarshalling JSON data:", err)
   return
 }
 // 获取响应数据
 users := jsonMap["users"]
 // 返回 JSON 响应
 router.GET("/users", func(c *gin.Context) {
   c.JSON(200, users)
 })
 router.Run(":8080")
}

在这个例子中，我们使用 ioutil.ReadFile 函数读取 data.json 文件，并将其内容解析为一个 Go 语言的 map。然后，我们使用这个 map 来获取响应数据，并将其作为 JSON 响应返回给客户端。

读取到map里或者结构体里面

//首先把json文件读取到字节切片里
data, err := ioutil.ReadFile("./main.json")
	if err != nil {
		fmt.Println("read file error")
		return
	}
//可以读取到结构体里
type Person struct {
   Name string `json:"name"`
   Age  int    `json:"age"`
}
var person Person
json.Unmarshal(data,&person)
//读取到map里面
var JsonMap map [string]interfaceP{}

map[string]interface{}中interface{}

map[string]interface{} 是 Go 语言的一种类型，它是一个映射（map）类型，其中键的类型为 string，值的类型为 interface{}。

interface{} 类型表示一个接口，可以容纳任何类型的值。因此，map[string]interface{} 类型允许你存储不同类型的值作为键的映射。

例如，你可以将一个整数映射到字符串，一个字符串映射到一个布尔值，等等。

package main

import (
 "fmt"
)
func main() {
 // 创建一个 map[string]interface{} 类型的变量
 m := map[string]interface{}{}
 // 将一个整数映射到字符串
 m["age"] = 30
 // 将一个字符串映射到一个布尔值
 m["isStudent"] = false
 // 打印映射
 fmt.Println(m)
}

输出

map[age:30 isStudent:false]

在这个例子中，我们创建了一个 map[string]interface{} 类型的变量 m，并将其映射到整数和布尔值。然后，我们打印了映射，可以看到键的类型为 string，值的类型为 interface{}。

json文件的写入

main2, err := os.Create("./main2.json")
	if err != nil {
		fmt.Println("create file error")
		return
	}
	defer main2.Close()
	jsonData, err := json.Marshal(jsonMap)
	_, err = main2.Write(jsonData)

六.绑定URL

简介

在Gin框架中，可以使用正则表达式或字符串来绑定URL参数，例如/user/:id。绑定URL参数的方法如下：

绑定URL参数：

在路由中使用:符号来绑定URL参数，例如/user/:id。在路由处理函数中，可以使用c.Param方法来获取绑定URL路径参数的值，例如：

router.GET("/user/:id", func(c *gin.Context) {
 id := c.Param("id")
 // 处理请求
})

如果是/user/a
那么id=a;

绑定url参数的值

就是去解析出路径？后面的参数

router.GET("/user/:id?+key=value", func(c *gin.Context) {
   id := c.Param("id")
   key := c.Query("key")
   value := c.Query("value")
   // 处理请求
})

请求：
GET /user/123?key=test&value=1
解析后：
id=123
key=text
value=1

七.模板引擎

简介

模板引擎（Template Engine）是一种将模板代码与数据（如变量和模板函数）结合起来，生成可渲染的HTML或其他格式化文本的技术。模板引擎允许开发者在不修改模板代码的情况下，动态地替换模板中的变量和函数，从而实现动态内容的生成。

在Gin框架中，可以使用github.com/gin-gonic/gin/render包来使用模板引擎。该包提供了一个名为render的函数，该函数接受一个模板文件路径和一个数据对象作为参数，并返回一个渲染后的HTML字符串。

实例

以下是一个简单的示例，展示了如何使用模板引擎来生成一个简单的HTML页面：

package main
import (
   "github.com/gin-gonic/gin"
)
func main() {
   router := gin.Default()
   router.GET("/", func(c *gin.Context) {
       data := map[string]interface{}{
           "title": "Hello, World!",
           "message": "Welcome to the Gin framework.",
       }
       c.HTML(200, "index.html", data)
   })
   router.Run(":8080")
}

在这个例子中，我们使用c.HTML方法来生成一个HTML页面。c.HTML方法接受两个参数：HTTP状态码和模板文件路径。我们使用data变量来存储模板中的数据，并将其传递给模板文件进行渲染。

模板文件index.html可以包含以下内容：

<!DOCTYPE html>
<html>
<head>
   <title><%= title %></title>
</head>
<body>
   <h1><%= message %></h1>
</body>
</html>

在这个例子中，我们使用了<%=和%>来插入变量和模板函数的值。例如，<%= title %>表示插入title变量的值，<%= message %>表示插入message变量的值。

传输与c.JSON的区别

相当于在c.JSON的基础上有传送了一个网页

八.跨域资源共享

简介

跨域资源共享（CORS）是一种HTTP协议扩展，允许在不同域名或端口之间进行跨域请求。CORS是一种现代浏览器支持的HTTP协议，它允许服务器在响应中添加一个名为Access-Control-Allow-Origin的头，该头指定了允许访问请求的来源域名或端口。

CORS的主要目的是为了安全地允许跨域请求，防止跨站请求伪造（CSRF）攻击。通过CORS，服务器可以检查请求的来源，并允许或拒绝请求，从而保护应用程序免受恶意请求的影响。

在现代浏览器中，CORS已经成为了默认支持的功能。这意味着，当浏览器发起跨域请求时，如果服务器没有设置Access-Control-Allow-Origin头，则浏览器会阻止请求的发送。因此，服务器需要设置Access-Control-Allow-Origin头，以便浏览器能够正确处理跨域请求。

在Go语言中，可以使用net/http包来处理CORS请求。例如，可以使用http.HandleFunc方法来处理CORS请求，并使用w.Header().Set方法来设置Access-Control-Allow-Origin头。

总之，跨域资源共享（CORS）是一种HTTP协议扩展，允许在不同域名或端口之间进行跨域请求。CORS是一种现代浏览器支持的HTTP协议，它允许服务器在响应中添加一个名为Access-Control-Allow-Origin的头，该头指定了允许访问请求的来源域名或端口。

就是只有设置了允许的域名才允许访问

CORS（跨域资源共享）是一种HTTP协议扩展，允许在不同域名或端口之间进行跨域请求时，服务器允许或拒绝请求，从而保护应用程序免受恶意请求的影响。

在现代浏览器中，CORS已经成为了默认支持的功能。这意味着，当浏览器发起跨域请求时，如果服务器没有设置Access-Control-Allow-Origin头，则浏览器会阻止请求的发送。因此，服务器需要设置Access-Control-Allow-Origin头，以便浏览器能够正确处理跨域请求。

CORS头通常包含一个值，该值表示允许访问请求的来源域名或端口。例如，如果服务器允许来自example.com和example.org的请求，则可以在响应中设置Access-Control-Allow-Origin头如下：

Access-Control-Allow-Origin: example.com, example.org

在这个例子中，服务器允许来自example.com和example.org的请求。

CORS头除了Access-Control-Allow-Origin头之外，还可以包含其他字段，例如Access-Control-Allow-Headers和Access-Control-Allow-Methods，用于控制请求中允许的HTTP头和HTTP方法。

总之，CORS是一种现代浏览器支持的HTTP协议，它允许服务器在响应中添加头，从而控制跨域请求的来源和类型。

九.静态文件服务

简介

Gin也支持静态文件服务，可以将静态文件（如CSS、JavaScript、图片等）提供给客户端。

在Gin框架中，静态文件服务是通过router.Static()方法提供的

实例

在这个例子中，我们使用router.Static()方法将静态文件服务提供到/static路径上，并将其指向./static目录。然后，我们使用router.GET()方法将根路径/映射到一个处理函数，该函数返回一个简单的字符串。最后，我们使用router.Run()方法启动HTTP服务器，并将其绑定到端口8080。

当客户端请求/static路径上的静态文件时，Gin框架会自动从./static目录中查找文件，并将它们发送给客户端。

总之，Gin框架的静态文件服务是通过router.Static()方法提供的，它使得开发人员能够方便地提供静态文件服务

package main
import (
   "github.com/gin-gonic/gin"
)
func main() {
   router := gin.Default()
   // 提供静态文件服务
   router.Static("/static", "./static")
   router.GET("/", func(c *gin.Context) {
       c.String(200, "Hello, world!")
   })
   router.Run(":8080")
}

如果访问的路径是static/a,那就会自动传输a文件

静态文件服务和模板引擎传输网页的区别

板引擎和Gin框架的静态文件服务都是将动态内容和静态文件分开处理的技术。

模板引擎通常用于将动态内容与HTML模板结合，以便在服务器上生成完整的HTML页面。模板引擎可以将动态内容（如数据查询结果）插入到HTML模板中，从而生成具有动态内容的HTML页面。模板引擎还可以处理JavaScript、CSS等其他动态内容。

Gin框架的静态文件服务则只提供静态文件，包括HTML、CSS、JavaScript等。Gin框架不会处理动态内容，而是直接将静态文件发送给客户端。因此，Gin框架的静态文件服务与模板引擎的区别在于它们处理动态内容和静态文件的方式不同。

模板引擎通常用于生成完整的HTML页面，而Gin框架的静态文件服务则只提供静态文件。如果需要将动态内容和静态文件一起使用，可以考虑使用其他技术，如服务器端渲染（SSR）或JavaScript框架（如React或Vue.js）来处理动态内容。