Gin框架（3）

文件上传与下载

文件上传

单文件上传

单文件上传指的是一次只上传一个文件。在Gin中，可以使用c.SaveUploadedFile方法来保存单个上传的文件。

// SaveUploadedFile uploads the form file to specific dst.
func (c *Context) SaveUploadedFile(file *multipart.FileHeader, dst string) error {
   src, err := file.Open()
  if err != nil {
        return err
  }
  defer src.Close()
  if err=os.MkdirAll(filepath,Dir(dst),0750);err!=nil{
    return err
  }
  out, err := os.Create(dst)
	if err != nil {
		return err
	}
	defer out.Close()

	_, err = io.Copy(out, src)
	return err
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

func singleFileUpload(c *gin.Context) {
// 从表单中获取上传的文件
file, err := c.FormFile("file")
if err != nil {
// 处理错误，可能是文件未找到或其他原因
c.JSON(http.StatusBadRequest, gin.H{"error": "File not found in form"})
return
}
  // 指定保存文件的路径，这里使用了文件的原始文件名
path := "./" + file.Filename

// 保存上传的文件到指定路径
if err := c.SaveUploadedFile(file, path); err != nil {
    // 处理错误
    c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
    return
}

// 返回成功响应
c.JSON(http.StatusOK, gin.H{"message": "File uploaded successfully", "file_path": path})
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

多文件上传

// MultipartForm is the parsed multipart form, including file uploads.
//MultipartForm 方法用于解析和处理 multipart/form-data 类型的请求，这通常用于文件上传
func (c *Context) MultipartForm() (*multipart.Form, error) {
	err := c.Request.ParseMultipartForm(c.engine.MaxMultipartMemory)
	return c.Request.MultipartForm, err
}
1
2
3
4
5
6

Gin框架处理多文件上传的实例

func uploadHandler(c *gin.Context){
  form,err:=c.MultipartForm()
  if err!=nil{
    c.JSON(http.StatusBadRequest,gin.H{"error":"Failed to parse multipart form"})
    return
  }
 // 从form中获取文件切片
    files := form.File["files"] // "files" 是HTML表单中的input[type=file]的name属性值

    // 遍历所有上传的文件
    for _, fileHeader := range files {
        // 打开文件
        file, err := fileHeader.Open()
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
            return
        }
        defer file.Close()

        // 保存文件到服务器
        filePath := "path/to/save/" + fileHeader.Filename
        err = c.SaveUploadedFile(file, filePath)
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
            return
        }

        // 处理成功后的逻辑
        c.JSON(http.StatusOK, gin.H{"message": "File uploaded successfully", "file_path": filePath})
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

文件下载

1. 使用c.File方法

Gin提供了c.File方法，可以直接从HTTP响应中提供文件。这是最简单的方法之一，但它仅适用于服务于静态文件的场景。

func downloadFile(c *gin.Context) {
    // 指定文件路径
    filePath := "path/to/your/file.txt"

    // 检查文件是否存在
    if _, err := os.Stat(filePath); err != nil {
        c.JSON(http.StatusNotFound, gin.H{"error": "File not found"})
        return
    }

    // 设置文件名作为Content-Disposition响应头的一部分
    c.Header("Content-Disposition", "attachment; filename="+filepath.Base(filePath))

    // 使用c.File方法发送文件
    c.File(filePath)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2. 使用c.Writer和io.Copy

如果你需要更多的控制，比如动态生成文件内容或者处理大文件，可以使用c.Writer和io.Copy来手动写入文件内容。

func downloadFile(c *gin.Context) {
    // 指定文件内容
    fileContent := "This is the file content."

    // 设置响应头
    c.Header("Content-Disposition", "attachment; filename=file.txt")
    c.Header("Content-Type", "text/plain")

    // 写入文件内容
    _, err := io.WriteString(c.Writer, fileContent)
    if err != nil {
        c.AbortWithStatus(http.StatusInternalServerError)
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3. 流式下载大文件

对于大文件，可以使用流式传输来避免一次性加载整个文件到内存中。

func downloadLargeFile(c *gin.Context) {
    // 指定大文件路径
    filePath := "path/to/your/largefile.zip"

    // 打开文件
    file, err := os.Open(filePath)
    if err != nil {
        c.JSON(http.StatusNotFound, gin.H{"error": "File not found"})
        return
    }
    defer file.Close()

    // 设置响应头
    c.Header("Content-Disposition", "attachment; filename="+filepath.Base(filePath))
    c.Header("Content-Type", "application/octet-stream")

    // 流式传输文件内容
    _, err = io.Copy(c.Writer, file)
    if err != nil {
        c.AbortWithStatus(http.StatusInternalServerError)
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

4. 使用http.ServeContent

Go标准库中的http.ServeContent函数可以用于提供文件下载。这个方法允许你利用http.ServeContent的缓存控制和其他功能。

func downloadFile(c *gin.Context) {
    // 指定文件路径
    filePath := "path/to/your/file.txt"

    // 检查文件是否存在
    if _, err := os.Stat(filePath); err != nil {
        c.JSON(http.StatusNotFound, gin.H{"error": "File not found"})
        return
    }

    // 打开文件
    file, err := os.Open(filePath)
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": "Error opening file"})
        return
    }
    defer file.Close()

    // 获取文件信息
    fileInfo, _ := file.Stat()

    // 设置响应头
    c.Header("Content-Disposition", "attachment; filename="+filepath.Base(filePath))
    c.Header("Content-Type", "application/octet-stream")

    // 使用http.ServeContent进行流式传输
    http.ServeContent(c.Writer, c.Request, fileInfo, int64(fileInfo.Size()), file)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

前后端分离

1. 后端：提供文件下载的HTTP路由处理函数，设置正确的响应头，并发送文件内容给前端。

2. 前端：通过HTTP请求与后端通信，并处理文件下载过程。

后端实现

package main

import (
	"io"
	"net/http"
	"os"
	"path/filepath"

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

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

	// 文件下载路由
	r.GET("/download/:filename", func(c *gin.Context) {
		filename := c.Param("filename") // 获取文件名参数
		filePath := filepath.Join("path/to/files/", filename) // 定义文件的路径

		// 检查文件是否存在
		if _, err := os.Stat(filePath); os.IsNotExist(err) {
			c.JSON(http.StatusNotFound, gin.H{"message": "File not found"})
			return
		}

		// 设置响应头
		c.Header("Content-Disposition", "attachment; filename="+filepath.Base(filePath))
		c.Header("Content-Type", "application/octet-stream")

		// 打开文件并将其写入响应流
		file, err := os.Open(filePath)
		if err != nil {
			c.JSON(http.StatusInternalServerError, gin.H{"message": "Error opening file"})
			return
		}
		defer file.Close()

		_, err = io.Copy(c.Writer, file)
		if err != nil {
			c.JSON(http.StatusInternalServerError, gin.H{"message": "Error writing file to response"})
			return
		}
	})

	r.Run(":8080") // 启动Gin服务器
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

前端实现

前端可以使用标准的HTML <a>标签或者JavaScript来发起文件下载请求。以下是两种常见的前端下载方法：

方法1：使用HTML链接

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>File Download Example</title>
</head>
<body>
    <!-- 下载链接 -->
    <a href="/download/myfile.txt" download>Download File</a>
</body>
</html>

1
2
3
4
5
6
7
8
9
10
11
12

在这个HTML示例中，<a>标签的href属性设置为文件下载的URL，download属性指定了要下载的文件名。

方法2：使用JavaScript

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>File Download Example</title>
</head>
<body>
    <button id="downloadButton">Download File</button>
    <script>
        document.getElementById('downloadButton').addEventListener('click', function() {
            fetch('/download/myfile.txt')
                .then(response => {
                    if (response.ok) return response.blob();
                    throw new Error('Network response was not ok.');
                })
                .then(blob => {
                    const url = window.URL.createObjectURL(blob);
                    const a = document.createElement('a');
                    a.style.display = 'none';
                    a.href = url;
                    a.download = 'myfile.txt';
                    document.body.appendChild(a);
                    a.click();
                    window.URL.revokeObjectURL(url);
                })
                .catch(error => {
                    console.error('There has been a problem with your fetch operation:', error);
                });
        });
    </script>
</body>
</html>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

在这个JavaScript示例中，当用户点击按钮时，会发起一个GET请求到文件下载的URL。然后，它将响应转换为Blob，并创建一个临时的URL。接着，它创建一个隐藏的<a>标签，设置href为Blob URL，并指定download属性来触发文件下载。

中间件

Middleware

中间件是Gin中的一个强大的功能，它允许开发者在处理请求的流程中插入自定义的逻辑。中间件可以用于日志记录、用户认证、跨域资源共享（CORS）处理等。
在Gin中，中间件可以通过Use方法全局注册，或者在特定路由组中注册。Gin中的中间件必须是一个gin.HandlerFunc类型

HandlerFunc

处理函数是实际处理请求的函数。它们接收一个*gin.Context对象作为参数，并返回一个响应。处理函数可以是任何满足gin.HandlerFunc类型的函数。

package main

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

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

	// 全局中间件
	r.Use(LoggingMiddleware)

	// 特定路由组的中间件
	v1 := r.Group("/v1")
	v1.Use(AuthenticationMiddleware)
	v1.GET("/books", GetBooks)

	r.Run(":8080")
}

// LoggingMiddleware 是一个记录日志的中间件
func LoggingMiddleware(c *gin.Context) {
	c.Writer.Header().Set("Access-Control-Allow-Origin", "*") // 允许跨域请求
	start := time.Now()
	c.Next() // 处理请求
	latency := time.Since(start)
	log.Printf("Request took %v", latency)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

多个中间件

r.GET，后面可以跟很多HandlerFunc方法，这些方法其实都可以叫中间件

package main

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

func m1(c *gin.Context) {
  fmt.Println("m1 ...in")
}
func m2(c *gin.Context) {
  fmt.Println("m2 ...in")
}

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

  router.GET("/", m1, func(c *gin.Context) {
    fmt.Println("index ...")
    c.JSON(200, gin.H{"msg": "响应数据"})
  }, m2)

  router.Run(":8080")
}

/*
m1  ...in
index ...
m2  ...in
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

中间件拦截响

c.Abort() 方法用于立即终止当前请求的后续处理。当你调用这个方法时，Gin 会停止执行当前路由链中的后续中间件和处理函数，并直接返回给客户端一个错误响应（通常是 500 内部服务器错误）。c.Abort()拦截，后续的HandlerFunc就不会执行了

package main

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

func m1(c *gin.Context) {
  fmt.Println("m1 ...in")
  c.JSON(200, gin.H{"msg": "第一个中间件拦截了"})
  c.Abort()
}
func m2(c *gin.Context) {
  fmt.Println("m2 ...in")
}

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

  router.GET("/", m1, func(c *gin.Context) {
    fmt.Println("index ...")
    c.JSON(200, gin.H{"msg": "响应数据"})
  }, m2)

  router.Run(":8080")
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

中间件放行

c.Next() 方法用于继续执行当前路由链中的下一个中间件或处理函数。如果你的中间件需要在处理请求之前或之后执行某些操作，但不影响后续中间件的执行，那么你应该在适当的时候调用 c.Next()。c.Next()，Next前后形成了其他语言中的请求中间件和响应中间件

package main

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

func m1(c *gin.Context) {
  fmt.Println("m1 ...in")
  c.Next()
  fmt.Println("m1 ...out")
}
func m2(c *gin.Context) {
  fmt.Println("m2 ...in")
  c.Next()
  fmt.Println("m2 ...out")
}

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

  router.GET("/", m1, func(c *gin.Context) {
    fmt.Println("index ...in")
    c.JSON(200, gin.H{"msg": "响应数据"})
    c.Next()
    fmt.Println("index ...out")
  }, m2)

  router.Run(":8080")
}

/*
m1 ...in
index ...in
m2 ...in   
m2 ...out  
index ...out
m1 ...out
*/


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

路由

Router

路由是Gin的核心，负责将请求的URL和HTTP方法映射到相应的处理函数上。Gin使用httprouter作为其路由库，这是一个高性能的路由库，支持RESTful API设计。Gin的路由机制非常灵活，允许开发者定义路由和相应的处理函数。路由可以包含动态参数、查询参数、路由组等。

Group

组是Gin中的一个概念，它允许你将一组路由组织在一起，并且可以为这个组添加前缀路径和中间件。这使得路由的组织和管理变得更加灵活。

以下是定义路由的例子：

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

	// 定义GET请求的路由
	r.GET("/books/:id", GetBookByID)

	// 定义POST请求的路由
	r.POST("/books", CreateBook)

	// 定义PUT请求的路由
	r.PUT("/books/:id", UpdateBook)

	// 定义DELETE请求的路由
	r.DELETE("/books/:id", DeleteBook)

	r.Run(":8080")
}

// GetBookByID 处理GET请求
func GetBookByID(c *gin.Context) {
	bookID := c.Param("id")
	// 根据ID获取书籍信息...
	c.JSON(http.StatusOK, gin.H{"id": bookID, "message": "Book retrieved"})
}

// CreateBook 处理POST请求
func CreateBook(c *gin.Context) {
	var book Book
	if err := c.ShouldBindJSON(&book); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}
	// 创建新书籍...
	c.JSON(http.StatusOK, gin.H{"data": book})
}

// UpdateBook 处理PUT请求
func UpdateBook(c *gin.Context) {
	bookID := c.Param("id")
	var book Book
	if err := c.ShouldBindJSON(&book); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}
	// 更新书籍信息...
	c.JSON(http.StatusOK, gin.H{"data": book})
}

// DeleteBook 处理DELETE请求
func DeleteBook(c *gin.Context) {
	bookID := c.Param("id")
	// 删除书籍...
	c.JSON(http.StatusOK, gin.H{"id": bookID, "message": "Book deleted"})
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

在上面的例子中，我们定义了四个不同的HTTP方法（GET, POST, PUT, DELETE）的路由，每个路由都有一个对应的处理函数。:id是一个动态参数，可以在处理函数中通过c.Param(“id”)获取。

日志

Gin框架提供了一个内置的日志中间件，可以帮助开发者记录HTTP请求和响应的详细信息。这对于调试、监控和分析Web应用程序的行为非常有用。Gin的日志中间件可以通过标准库中的log包或其他第三方日志库来实现。

默认的日志记录

Gin框架的默认实例（通过gin.Default()创建）已经包含了一个默认的日志记录器，它使用标准库的log包。这个日志记录器会输出每个请求的基本信息，包括请求方法、路径、状态码和处理请求所花费的时间。

package main

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

func main() {
	r := gin.Default()
	r.GET("/ping", func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{"message": "pong"})
	})
	r.Run(":8080")
}
1
2
3
4
5
6
7
8
9
10
11
12
13

在这个例子中，当你访问/ping路由时，Gin会自动记录请求的日志信息。

自定义日志中间件

如果你需要更详细的日志记录或想要使用不同的日志库，你可以创建自定义的日志中间件。以下是一个使用标准库log包创建的自定义日志中间件的例子：

package main

import (
	"log"
	"net/http"
	"time"

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

func requestLogger(c *gin.Context) {
	// 访问开始时间
	startTime := time.Now()

	// 处理请求
	c.Next()

	// 访问结束时间
	endTime := time.Now()

	// 访问耗时
	latency := endTime.Sub(startTime)

	// 记录日志
	log.Printf("%s %s %s %d %s\n", c.ClientIP(), c.Request.Method, c.Request.URL.Path, c.Writer.Status(), latency)
}

func main() {
	r := gin.New()
	r.Use(requestLogger)

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

	r.Run(":8080")
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

在这个例子中，我们定义了一个requestLogger函数，它会在每个请求处理之前记录客户端IP、请求方法、请求路径、状态码和处理请求的耗时。然后，我们通过r.Use(requestLogger)将这个日志中间件添加到Gin路由器中。

使用第三方日志库

Gin也可以与第三方日志库一起使用，例如zap、logrus或zerolog等。这些库提供了更丰富的日志记录功能，包括日志级别、结构化日志记录和异步日志记录等。

使用logrus库创建的自定义日志中间件的例子：

package main

import (
	"io/ioutil"
	"net/http"
	"time"

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

// 日志中间件
func LoggerMiddleware() gin.HandlerFunc {
	return func(c *gin.Context) {
		// 在请求处理之前记录请求开始的时间
		start := time.Now()
		c.Next()

		// 请求结束后记录请求信息
		log.WithFields(logrus.Fields{
			"method": c.Request.Method,
			"path":    c.Request.URL.Path,
			"ip":      c.ClientIP(),
			"status":  c.Writer.Status(),
			"duration": time.Since(start),
		}).Info("Request completed")
	}
}

func main() {
	// 初始化logrus
	log := logrus.New()
	log.SetFormatter(&logrus.JSONFormatter{})
	log.SetOutput(ioutil.Discard) // 设置日志输出到控制台，生产环境可以设置为文件或其他输出

	// 初始化Gin路由器
	r := gin.Default()

	// 使用自定义的日志中间件
	r.Use(LoggerMiddleware())

	// 定义一个示例路由
	r.GET("/", func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{"message": "Hello, World!"})
	})

	// 启动Gin服务器
	r.Run(":8080")
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

我们首先定义了一个LoggerMiddleware函数，它返回一个gin.HandlerFunc。这个中间件在每个请求处理之前记录请求开始的时间，并在请求处理之后记录请求的详细信息，包括HTTP方法、路径、客户端IP、状态码和处理请求的耗时。

我们使用logrus的WithFields方法来添加结构化的日志数据，并使用Info方法来记录日志。logrus.JSONFormatter用于格式化日志输出为JSON格式，而SetOutput方法设置了日志的输出目标，这里我们将其设置为控制台（ioutil.Discard）