Gin框架（2）

Gin框架核心结构

响应

返回字符串

router.GET("/txt",func(c *gin.Context){
c,String(http.StatusOK,"返回txt")
})

返回json

router.GET("/json",func(C *gin.Context){
  c.JSON(http.StatusOK,gin.H{"message":"hey","status":http.StatusOK})
})

router.GET("morejson",func(c *gin.Context){
  //使用结构体
  type Msg struct{
    Name string `json:"user:`
    Message string
    Number int
  }
  msg:=Msg{"bar","helo","23“}
           c.JSON(http.StatusOK,msg)
          }）

响应html

先使用Load HTML Glob（）或者LoadHTMLFiles()加载模板文件

在Go语言的Gin框架中，LoadHTMLGlob() 和 LoadHTMLFiles() 是两个用于加载HTML模板的方法，它们分别属于 gin.Engine 和 *gin.Context 类型。这些方法用于将HTML文件或模板文件加载到Gin应用中，以便可以用于渲染视图。

LoadHTMLGlob()

LoadHTMLGlob() 方法用于加载匹配特定模式的所有HTML模板文件。这通常用于加载同一目录下的所有模板文件。它返回一个template.Template对象，该对象可以用于执行模板渲染。

package main

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

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

	// 加载当前目录下所有的 .html 文件作为模板
	tmpl, err := template.ParseGlob("*.html")
	if err != nil {
		panic(err)
	}
	r.HTMLRender = template.HTMLRender{
		Templates: tmpl,
	}

	r.GET("/", func(c *gin.Context) {
		c.HTML(http.StatusOK, "index", gin.H{
			"message": "Hello, Gin!",
		})
	})

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

在这个例子中，ParseGlob 函数用于加载当前目录下所有.html文件，并将它们存储在tmpl变量中。然后，我们通过r.HTMLRender设置Gin的HTML渲染器，以便在处理请求时使用这些模板。

LoadHTMLFiles()

LoadHTMLFiles() 方法用于加载指定的HTML模板文件。与LoadHTMLGlob()不同，你需要显式地指定要加载的文件名。

package main

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

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

	// 加载指定的HTML模板文件
	tmpl, err := template.ParseFiles("layout.html", "index.html")
	if err != nil {
		panic(err)
	}
	r.HTMLRender = template.HTMLRender{
		Templates: tmpl,
	}

	r.GET("/", func(c *gin.Context) {
		c.HTML(http.StatusOK, "index", gin.H{
			"message": "Hello, Gin!",
		})
	})

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

在这个例子中，ParseFiles 函数用于加载layout.html和index.html两个文件，并将它们存储在tmpl变量中。同样，我们通过r.HTMLRender设置Gin的HTML渲染器。

//加载模板
router.LoadHTEMLGlob("gin框架/templates/*")

router.GET("/tem,func(c *gin.Context){
           c .HTML(http.StatusOK,"index.html",gin.H{
             "title":"Main website",
           })
                   }
             )

响应文件

router.StaticFile，router.StaticFS，c.FileFromFS，c.File，c.Writer四个函数。

router.StaticFile

• router.StaticFile 是Gin路由器提供的一个方法，用于创建一个路由，该路由将特定的文件作为静态资源暴露。

• 它接受两个参数：一个URL路径前缀和一个文件系统路径，当请求匹配该URL路径时，对应的文件将被作为响应返回。

• 这个方法适用于当你需要将单个文件作为静态资源提供时。

router.StaticFS

• router.StaticFS 也是Gin路由器的一个方法，用于创建一个路由，该路由将整个文件系统目录作为静态资源服务。

• 它接受两个参数：一个URL路径前缀和一个文件系统（通常是通过 http.Dir 创建的），匹配该URL路径的请求将可以访问目录中的所有文件。

• 这个方法适用于当你需要提供一个目录下所有文件的服务时。

c.FileFromFS

• c.FileFromFS 是 *gin.Context 的一个方法，它允许你在处理函数中直接从文件系统中读取文件并作为响应发送。

• 它接受两个参数：一个文件系统（可以通过 http.Dir 创建）和一个文件路径。

• 这个方法适用于在处理函数中动态地根据请求提供文件响应。

c.File

• c.File 是 *gin.Context 的一个方法，它是一个便捷的方法，用于从文件系统中读取文件并作为响应发送。

• 它接受一个参数，即文件的路径。

• 这个方法类似于 c.FileFromFS，但使用的是默认的文件系统，通常是本地文件系统。

c.Writer

• c.Writer 是 *gin.Context 的一个属性，它实现了 http.ResponseWriter 接口。

• 它用于直接控制响应的编写，包括设置状态码、头部信息和响应体内容。

• 开发者可以使用 c.Writer 来编写自定义的响应逻辑，包括发送文件内容。

总结

• c.Writer 提供了最大的灵活性，允许你完全控制响应的生成。

• router.StaticFile 和 router.StaticFS 提供了静态文件服务的便捷方法，适用于不同的场景。

• c.FileFromFS 和 c.File 提供了在处理函数中发送文件响应的便捷方法，其中 c.FileFromFS 允许你指定文件系统。

1. 使用 router.StaticFile 发送单个文件

package main

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

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

	// 将特定的文件作为静态资源暴露
	r.StaticFile("/favicon.ico", "/path/to/favicon.ico")

	r.Run(":8080")
}

这里，/favicon.ico 将始终映射到 /path/to/favicon.ico 文件，无论请求的URL是什么。

2. 使用 router.StaticFS 提供目录作为静态资源

package main

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

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

	// 将某个目录作为静态资源服务
	r.StaticFS("/static", http.Dir("/path/to/static/files"))

	r.Run(":8080")
}

在这个例子中，任何请求到 /static 路径下的文件都将从 /path/to/static/files 目录中提供。

3.是一个使用 c.FileFromFS 方法的代码示例

package main

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

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

	// 定义一个路由，使用 c.FileFromFS 方法发送文件
	r.GET("/files/*any", func(c *gin.Context) {
		// 从请求的URI中提取文件名
		fileName := c.Param("any")

		// 假设我们有一个自定义的文件系统目录 "myFiles/"
		fs := http.Dir("myFiles/")

		// 使用 c.FileFromFS 方法从文件系统中读取文件并发送响应
		c.FileFromFS(fileName, fs)
	})

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

在这个例子中，我们创建了一个Gin服务器，并定义了一个路由来处理 /files/*any 路径下的请求。*any 是一个通配符，它匹配任何子路径，并将匹配的部分作为文件名传递给处理函数。

4. 使用 c.File 发送文件

package main

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

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

	// 设置一个路由，使用 c.File 方法发送文件
	r.GET("/download/:filename", func(c *gin.Context) {
		filename := c.Param("filename")
		c.File(filename) // 直接发送文件
	})

	r.Run(":8080")
}

在这个例子中，当客户端请求 /download/:filename 路由时，c.File 会发送与 :filename 匹配的文件。

5. 使用 c.Writer 自定义文件响应

package main

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

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

	// 创建一个路由，使用 c.Writer 发送文件
	r.GET("/download", func(c *gin.Context) {
		// 读取文件内容
		fileBytes, err := ioutil.ReadFile("/path/to/file.txt")
		if err != nil {
			http.Error(c.Writer, "File not found", http.StatusNotFound)
			return
		}

		// 设置响应头
		c.Writer.Header().Set("Content-Type", "text/plain")
		c.Writer.WriteHeader(http.StatusOK)

		// 写入文件内容
		_, _ = c.Writer.Write(fileBytes)
	})

	r.Run(":8080")
}

请求

Gin提供了多种方式来获取和验证请求参数，包括查询参数（Query Parameters）、表单参数（Form Parameters）和路径参数（Path Parameters）。以下是如何使用Gin处理这些不同类型的请求参数的示例：

查询参数（Query Parameters）

查询参数是附加在URL后面的键值对，通常用于过滤和排序等操作。

package main

import (
	"net/http"

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

func main() {
	r := gin.Default()
	r.GET("/users", func(c *gin.Context) {
		name := c.Query("name")
		page := c.DefaultQuery("page", "1")

		c.JSON(http.StatusOK, gin.H{
			"name": name,
			"page": page,
		})
	})
	r.Run(":8080")
}

表单参数（Form Parameters）

表单参数通常通过POST请求发送，用于提交数据。

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

    r.POST("/login", func(c *gin.Context) {
        // 获取所有的表单数据
        form := c.PostForm()
        username := form["username"] // 获取username字段的所有值
        password := form["password"] // 获取password字段的所有值

        // 处理表单数据...
        c.JSON(http.StatusOK, gin.H{
            "username": username[0],
            "password": password[0],
        })
    })
}

路径参数（Path Parameters）

路径参数是定义在路由中的参数，用于动态路由匹配。

package main

import ( 	"net/http"

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

func main() { 	r := gin.Default() 	r.GET("/users/:id", func(c
*gin.Context) { 		userID := c.Param("id") 		c.JSON(http.StatusOK, gin.H{ 			"user_id": userID, 		}) 	}) 	r.Run(":8080") }

使用 gin.Context 获取参数

gin.Context 提供了多种方法来获取请求参数：

• Query：获取URL查询参数。

• QueryArray：获取URL查询参数的所有值（当参数有多个值时使用）。

• DefaultQuery：获取URL查询参数，如果不存在则返回默认值。

• Param：获取路径参数。

• Params：获取所有路径参数。

• PostForm：获取POST请求的表单参数。

• MultipartForm：获取multipart表单数据，通常用于文件上传。

• JSON：获取JSON格式的请求体。

• XML：获取XML格式的请求体。