Hollis写字的地方

Gin渲染

Wed, 13 Sep 2023 20:00:00 +0800

HTML渲染

我们首先定义一个存放模板文件的templates文件夹，然后在其内部按照业务分别定义一个posts文件夹和一个users文件夹。 posts/index.html文件的内容如下：

{{define "posts/index.html"}}
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>posts/index</title>
</head>
<body>
    {{.title}}
</body>
</html>
{{end}}

users/index.html文件的内容如下：

{{define "users/index.html"}}
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>users/index</title>
</head>
<body>
    {{.title}}
</body>
</html>
{{end}}

Gin框架中使用LoadHTMLGlob()或者LoadHTMLFiles()方法进行HTML模板渲染。

func main() {
	r := gin.Default()
	r.LoadHTMLGlob("templates/**/*")
	//r.LoadHTMLFiles("templates/posts/index.html", "templates/users/index.html")
	r.GET("/posts/index", func(c *gin.Context) {
		c.HTML(http.StatusOK, "posts/index.html", gin.H{
			"title": "posts/index",
		})
	})

	r.GET("users/index", func(c *gin.Context) {
		c.HTML(http.StatusOK, "users/index.html", gin.H{
			"title": "users/index",
		})
	})

	r.Run(":8080")

自定义模板函数

定义一个不转义相应内容的safe模板函数如下：

func main() {
	router := gin.Default()
	router.SetFuncMap(template.FuncMap{
		"safe": func(str string) template.HTML{
			return template.HTML(str)
		},
	})
	router.LoadHTMLFiles("./index.tmpl")

	router.GET("/index", func(c *gin.Context) {
		c.HTML(http.StatusOK, "index.tmpl", "<a href='https://liwenzhou.com'>李文周的博客</a>")
	})

	router.Run(":8080")
}

在index.tmpl中使用定义好的safe模板函数：

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <title>修改模板引擎的标识符</title>
</head>
<body>
<div>{{ . | safe }}</div>
</body>
</html>

静态文件处理

当我们渲染的HTML文件中引用了静态文件时，我们只需要按照以下方式在渲染页面前调用gin.Static方法即可。

func main() {
	r := gin.Default()
	r.Static("/static", "./static")
	r.LoadHTMLGlob("templates/**/*")
   // ...
	r.Run(":8080")
}

使用模板继承

Gin框架默认都是使用单模板，如果需要使用block template功能，可以通过"github.com/gin-contrib/multitemplate"库实现，具体示例如下：

首先，假设我们项目目录下的templates文件夹下有以下模板文件，其中home.tmpl和index.tmpl继承了base.tmpl：

templates
├── includes
│   ├── home.tmpl
│   └── index.tmpl
├── layouts
│   └── base.tmpl
└── scripts.tmpl

然后我们定义一个loadTemplates函数如下：

func loadTemplates(templatesDir string) multitemplate.Renderer {
	r := multitemplate.NewRenderer()
	layouts, err := filepath.Glob(templatesDir + "/layouts/*.tmpl")
	if err != nil {
		panic(err.Error())
	}
	includes, err := filepath.Glob(templatesDir + "/includes/*.tmpl")
	if err != nil {
		panic(err.Error())
	}
	// 为layouts/和includes/目录生成 templates map
	for _, include := range includes {
		layoutCopy := make([]string, len(layouts))
		copy(layoutCopy, layouts)
		files := append(layoutCopy, include)
		r.AddFromFiles(filepath.Base(include), files...)
	}
	return r
}

我们在main函数中

func indexFunc(c *gin.Context){
	c.HTML(http.StatusOK, "index.tmpl", nil)
}

func homeFunc(c *gin.Context){
	c.HTML(http.StatusOK, "home.tmpl", nil)
}

func main(){
	r := gin.Default()
	r.HTMLRender = loadTemplates("./templates")
	r.GET("/index", indexFunc)
	r.GET("/home", homeFunc)
	r.Run()
}

补充文件路径处理

关于模板文件和静态文件的路径，我们需要根据公司/项目的要求进行设置。可以使用下面的函数获取当前执行程序的路径。

func getCurrentPath() string {
	if ex, err := os.Executable(); err == nil {
		return filepath.Dir(ex)
	}
	return "./"
}

返回Json

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

    // 方法1：使用map
    r.GET("/json01", func(c *gin.Context) {
       data := gin.H{ // gin.H is a shortcut for map[string]any
          "name":   "tom",
          "age":    26,
          "gender": "male",
       }
       c.JSON(http.StatusOK, data)
    })

    // 方法2：使用struct，使用tag来定制json字段的名称。
    r.GET("/json02", func(c *gin.Context) {
       var person struct {
          Name   string `json:"name"` // 这里一定要是可导出的，否则json获取不到数据。如果想要指定json字段的名称，可以使用Tag。
          Age    int    `json:"age"`
          Gender string `json:"gender"`
       }
       person.Name = "Jane"
       person.Age = 24
       person.Gender = "female"
       c.JSON(http.StatusOK, person) // 传入结构体类型的数据
    })

    r.Run(":9003")
}

context组件

Wed, 13 Sep 2023 20:00:01 +0800

context组件

在 Gin 框架中，context是一个非常重要的组件，它用于处理 HTTP 请求和响应，以及在请求处理过程中传递数据和控制流。以下是对 Gin 框架中context的详细介绍：

HTTP请求和响应管理： context对象封装了 HTTP 请求和响应的所有信息，包括 HTTP 方法、请求路径、请求头、请求参数、响应状态码、响应头等。通过context，您可以轻松地访问和操作这些信息。
参数解析： Gin的context提供了方便的方法来解析 HTTP 请求中的参数，包括查询参数、表单数据、JSON请求体等。您可以使用Bind、ShouldBind等方法来将请求参数绑定到 Go 结构体中，从而方便地进行验证和处理。
路由参数： context还允许您从 URL 路径中提取参数。例如，如果您定义了一个路由/user/:id，则可以使用context.Param("id")来获取:id占位符的值。
中间件支持： Gin 的中间件是一种机制，可以在请求处理过程中添加预处理逻辑，如身份验证、日志记录、错误处理等。context对象可以在中间件之间传递，以便在请求处理过程中共享数据和控制流。中间件可以通过context的方法来操作请求和响应。
错误处理：在处理请求期间，如果发生错误，您可以使用context的Abort、JSON等方法来处理错误并生成适当的响应。例如，您可以使用context.AbortWithStatus来中止请求处理并返回指定的HTTP状态码。
响应生成：使用context，您可以方便地生成 HTTP 响应，包括设置响应状态码、响应头和响应体。例如，您可以使用context.JSON、context.String等方法来生成 JSON 响应或纯文本响应。
上下文数据传递：您可以在context对象中存储自定义数据，这些数据在请求处理过程中可以跨中间件和处理函数传递。这对于在整个请求周期中共享信息非常有用。
请求上下文的超时和取消： Gin的context支持上下文的超时和取消。这意味着您可以设置一个超时，以确保长时间运行的请求不会无限期地等待响应。

总之，Gin 框架的context是一个非常重要的组件，它为处理 HTTP 请求和响应提供了丰富的功能和工具，使得开发 Web 应用变得更加便捷和灵活。通过熟练使用context，您可以更好地控制和管理您的 Web 应用程序的行为。

获取参数

Wed, 13 Sep 2023 20:00:01 +0800

1.query string参数

在 Gin 框架中，你可以使用上下文对象（c）来获取查询字符串（query string）参数。查询字符串参数通常是在 URL 中以 ? 后面的键值对形式传递的，如 http://example.com/path?param1=value1&param2=value2。

以下是如何在 Gin 框架中获取查询字符串参数的示例：

package main

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

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

    // 定义一个路由处理程序，用于获取查询字符串参数
    router.GET("/query", func(c *gin.Context) {
        // 使用 c.DefaultQuery 方法获取查询字符串参数，并设置默认值（可选）
        param1 := c.DefaultQuery("param1", "default_value")

        // 使用 c.Query 方法获取查询字符串参数，如果参数不存在则返回空字符串
        param2 := c.Query("param2")

        // 打印获取到的参数值
        c.JSON(200, gin.H{
            "param1": param1,
            "param2": param2,
        })
    })

    router.Run(":8080")
}

在上述示例中，我们创建了一个路由 /query，在这个路由下定义了一个处理程序函数。在处理程序函数内部，我们使用 c.DefaultQuery 方法来获取查询字符串参数 param1，并设置了一个默认值。同时，使用 c.Query 方法来获取查询字符串参数 param2。然后，我们将获取到的参数值返回给客户端。

运行这个示例，你可以通过访问 http://localhost:8080/query?param1=value1&param2=value2 来测试获取查询字符串参数的功能。

2.Form表单参数

在 Gin 框架中，你可以使用上下文对象（c）来获取通过 POST 请求提交的表单参数。以下是如何获取表单参数的示例：

package main

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

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

    // 定义一个路由处理程序，用于处理 POST 请求提交的表单参数
    router.POST("/submit", func(c *gin.Context) {
        // 使用 c.PostForm 方法获取表单参数
        param1 := c.PostForm("param1")
        param2 := c.PostForm("param2")

        // 打印获取到的参数值
        c.JSON(200, gin.H{
            "param1": param1,
            "param2": param2,
        })
    })

    router.Run(":8080")
}

在上述示例中，我们创建了一个路由 /submit，在这个路由下定义了一个处理程序函数。在处理程序函数内部，我们使用 c.PostForm 方法来获取表单参数 param1 和 param2 的值。然后，我们将获取到的参数值返回给客户端。

要测试这个示例，你可以使用一个工具（例如，Postman 或 cURL）来发送 POST 请求，将表单参数发送到 http://localhost:8080/submit。

注意：在实际应用中，你可能需要先检查参数是否存在，以及进行错误处理等操作，以确保应用的安全性和稳定性。

3.路径参数

在 Gin 框架中，你可以使用路由参数来获取路径中的参数。路径参数是路由中的一部分，可以通过路由模式中的占位符来捕获。以下是如何获取路径参数的示例：

package main

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

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

    // 定义一个路由，包含路径参数
    router.GET("/user/:id", func(c *gin.Context) {
        // 使用 c.Param 方法来获取路径参数
        userID := c.Param("id")

        // 打印获取到的路径参数值
        c.JSON(200, gin.H{
            "userID": userID,
        })
    })

    router.Run(":8080")
}

在上述示例中，我们创建了一个路由 /user/:id，其中 :id 是路径参数的占位符。在路由处理程序函数内部，我们使用 c.Param 方法来获取路径参数的值，并将其存储在 userID 变量中。然后，我们将获取到的路径参数值返回给客户端。

你可以通过访问类似 http://localhost:8080/user/123 的 URL 来测试路径参数的功能，其中 123 是路径参数的值。

如果你需要在路由中使用多个路径参数，只需在路由模式中添加更多的占位符，然后在处理程序函数中使用 c.Param 方法来获取它们的值。例如，/user/:id/:name 可以捕获两个路径参数 id 和 name 的值。

4.参数绑定

在 Gin 框架中，参数绑定是一种非常方便的方式，用于将 HTTP 请求中的参数（例如查询字符串参数、表单参数、路径参数）绑定到 Go 结构体的字段上，以便于处理请求和验证输入数据。Gin 框架支持多种参数绑定方式，包括 Query 参数绑定、表单参数绑定、JSON 参数绑定和路径参数绑定等。

以下是 Gin 框架中参数绑定的示例：

假设我们有一个简单的 Go 结构体定义如下：

type User struct {
    ID   int    `form:"id" json:"id" binding:"required"`
    Name string `form:"name" json:"name" binding:"required"`
}

然后，我们可以通过不同的方式绑定参数到这个结构体。

Query 参数绑定：从查询字符串参数中绑定数据。

func GetUser(c *gin.Context) {
    var user User
    if err := c.ShouldBindQuery(&user); err == nil {
        // 在这里可以使用 user 结构体中的字段
        c.JSON(http.StatusOK, user)
    } else {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
    }
}

表单参数绑定：从 POST 请求的表单参数中绑定数据。

func CreateUser(c *gin.Context) {
    var user User
    if err := c.ShouldBind(&user); err == nil {
        // 在这里可以使用 user 结构体中的字段
        c.JSON(http.StatusCreated, user)
    } else {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
    }
}

JSON 参数绑定：从 JSON 请求体中绑定数据。

func UpdateUser(c *gin.Context) {
    var user User
    if err := c.ShouldBindJSON(&user); err == nil {
        // 在这里可以使用 user 结构体中的字段
        c.JSON(http.StatusOK, user)
    } else {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
    }
}

路径参数绑定：从路径参数中绑定数据。

func GetUserByID(c *gin.Context) {
    var user User
    if err := c.ShouldBindUri(&user); err == nil {
        // 在这里可以使用 user 结构体中的字段
        c.JSON(http.StatusOK, user)
    } else {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
    }
}

这些示例展示了不同的参数绑定方式。在每个示例中，我们使用 ShouldBind、ShouldBindQuery、ShouldBindJSON 和 ShouldBindUri 方法来将请求参数绑定到 User 结构体中，并进行错误处理。在实际应用中，你可以根据请求的内容选择合适的参数绑定方式来处理数据。同时，你可以使用 binding 标签来定义参数的验证规则，以确保数据的完整性和正确性。

文件上传

Wed, 13 Sep 2023 20:00:01 +0800

在 Gin 框架中进行文件上传是一项常见的任务，它允许你接收客户端上传的文件并对其进行处理。以下是如何在 Gin 框架中执行文件上传的示例：

首先，确保你已经导入了 Gin 框架和 multipart/form-data 包：

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

然后，你可以创建一个路由来处理文件上传请求。下面是一个示例：

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

    // 设置上传文件的最大大小（可选）
    r.MaxMultipartMemory = 8 << 20 // 8 MB

    // 创建一个路由，用于处理文件上传
    r.POST("/upload", func(c *gin.Context) {
        // 从请求中获取上传的文件
        file, err := c.FormFile("file")

        if err != nil {
            c.JSON(http.StatusBadRequest, gin.H{
                "error": err.Error(),
            })
            return
        }

        // 你可以在这里执行对上传文件的操作，比如保存到服务器或处理文件内容

        // 示例：将上传的文件保存到服务器
        filePath := "uploads/" + file.Filename
        if err := c.SaveUploadedFile(file, filePath); err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{
                "error": err.Error(),
            })
            return
        }

        c.JSON(http.StatusOK, gin.H{
            "message": "File uploaded successfully",
            "filename": file.Filename,
        })
    })

    r.Run(":8080")
}

在上述示例中，我们首先创建了一个路由 /upload，用于处理文件上传请求。在处理程序函数内部，我们使用 c.FormFile 方法来获取上传的文件。然后，我们可以选择保存文件到服务器或进行其他操作。

在示例中，我们使用 c.SaveUploadedFile 方法将上传的文件保存到服务器。你需要指定一个目标文件路径，这里我们将文件保存在 uploads/ 目录下。

确保你在服务器上创建了 uploads/ 目录，以便保存上传的文件。

最后，我们返回一个 JSON 响应，通知客户端文件上传成功。

要测试这个示例，你可以使用表单提交一个包含文件上传字段的 POST 请求。如果你使用 Postman 等工具，确保将请求类型设置为 multipart/form-data，并添加一个文件字段（通常命名为 file）。

这是一个简单的文件上传示例，你可以根据实际需求对文件进行更复杂的处理。同时，你也可以添加文件类型验证、文件大小限制等更多的安全措施。

重定向

Wed, 13 Sep 2023 20:00:01 +0800

重定向

在 Gin 框架中，你可以实现 HTTP 重定向和路由重定向，它们有一些区别：

1.HTTP 重定向

HTTP 重定向是通过发送特定的 HTTP 响应来实现的，通常使用 3xx 状态码来指示重定向。在 Gin 中，你可以使用 c.Redirect 方法来执行 HTTP 重定向。

1
2
3

func RedirectHandler(c *gin.Context) {
    c.Redirect(http.StatusFound, "/new-location")
}

c 是 Gin 上下文对象。
http.StatusFound 是 HTTP 302 Found 状态码，用于指示重定向。
"/new-location" 是重定向目标 URL。

HTTP 重定向是在客户端与服务器之间进行的，客户端收到重定向响应后，会根据响应头中的新地址重新发起请求。

用户侧的URL地址会发生改变。

2.路由重定向

路由重定向是指在应用程序的路由层级进行的重定向，它是通过修改路由规则来实现的。在 Gin 中，你可以使用 c.Request.URL.Path 来进行路由重定向。

func RouteRedirectHandler(c *gin.Context) {
    // 使用 c.Request.URL.Path 进行路由重定向
    c.Request.URL.Path = "/new-route"
    router.HandleContext(c)
}

路由重定向是在服务器端进行的，客户端不需要知道关于重定向的任何信息，它只需向原始路径发出请求，服务器会根据路由规则将其重定向到新的路径。

用户侧的URL地址不会发生变化。

总的来说，HTTP 重定向是通过发送 HTTP 响应告知客户端进行重定向，而路由重定向是在服务器端通过修改路由规则将请求重定向到新的路由处理程序函数。在 Gin 中，你可以根据具体需求选择使用哪种方式来实现重定向。

路由

Wed, 13 Sep 2023 20:00:01 +0800

路由

在 Gin 框架中，路由可以分为以下几种类别：

基本路由：

基本路由是 Gin 中最简单的路由形式，它指定了请求的 HTTP 方法（GET、POST、PUT、DELETE 等）和路径。基本路由由 GET、POST、PUT、DELETE 等方法调用创建。

router.GET("/get", func(c *gin.Context) {
    // 处理 GET 请求
})

router.POST("/post", func(c *gin.Context) {
    // 处理 POST 请求
})

// 同样的方式创建其他 HTTP 方法的路由

Any 和 NoRoute 是两个用于处理路由的特殊方法，它们具有不同的用途：
Any 方法：

Any 方法用于注册一个路由处理器，该处理器会匹配所有 HTTP 请求方法（GET、POST、PUT、DELETE 等）。这意味着你可以使用 Any 方法来处理多个不同 HTTP 方法的请求。
1
2
3
router.Any("/route", func(c *gin.Context) {
    // 这个处理程序将匹配所有 HTTP 方法的请求
})
这对于需要在多个不同的请求方法下执行相同操作的路由非常有用。然而，需要注意的是，在某些情况下，你可能需要谨慎使用 Any 方法，因为它可能导致代码不够清晰。
NoRoute 方法：

NoRoute 方法用于设置一个处理程序，该处理程序会在请求的路径没有匹配到任何路由时执行。换句话说，当客户端请求的路径在路由中没有匹配项时，将触发 NoRoute 处理程序。
1
2
3
4
router.NoRoute(func(c *gin.Context) {
    // 这个处理程序将在没有匹配路由的情况下执行
    c.JSON(http.StatusNotFound, gin.H{"message": "Not Found"})
})
NoRoute 处理程序通常用于自定义 404 错误页面或返回 JSON 404 响应。它允许你更精确地控制在请求未匹配到任何路由时客户端会收到什么响应。

路由参数：

路由参数允许你在路径中包含变量，这些变量可以捕获 URL 中的特定部分。例如，:id 可以用于捕获数字或字符串等。
1 2 3 4

router.GET("/user/:id", func(c *gin.Context) { userID := c.Param("id") // 使用 userID 处理请求 })
查询字符串参数：

查询字符串参数是通过 URL 的查询字符串传递的参数，可以通过 c.Query 或 c.DefaultQuery 方法来获取。
1 2 3 4

router.GET("/search", func(c *gin.Context) { query := c.Query("q") // 使用 query 处理请求 })

分组路由：

分组路由允许你将多个路由分组在一起，以便在它们之间应用相同的中间件或共享相同的路由前缀。这有助于组织和管理路由。

v1 := router.Group("/v1")
{
    v1.GET("/user", func(c *gin.Context) {
        // 处理 v1 版本的用户路由
    })

    v1.GET("/post", func(c *gin.Context) {
        // 处理 v1 版本的文章路由
    })
}

中间件：

Gin 框架支持中间件，它们可以在路由处理之前或之后执行特定的逻辑。中间件可以用于验证身份、日志记录、权限控制等。
1 2

// 中间件示例 router.GET("/admin", AuthMiddleware(), AdminHandler)

分组中的中间件：

你可以在分组中为一组路由应用中间件，以便将相同的中间件应用于多个路由。

// 在分组中使用中间件
v1 := router.Group("/v1")
v1.Use(AuthMiddleware())
{
    v1.GET("/user", UserHandler)
    v1.GET("/post", PostHandler)
}

静态文件服务：

Gin 框架允许你为静态文件（如图像、样式表、脚本等）提供服务，以便可以通过 HTTP 访问它们。这可以通过 gin.Static 方法来实现。
1

router.Static("/static", "/path/to/static/files")

这些是 Gin 框架中常见的路由类别。你可以根据应用程序的需求组合和使用这些不同类型的路由。 Gin 的灵活性使得可以创建复杂的路由结构，以满足各种需求。

中间件

Wed, 13 Sep 2023 20:00:01 +0800

在 Gin 框架中，中间件是一种机制，它允许你在请求到达路由处理程序之前或之后执行一些逻辑。中间件通常用于执行一些公共的任务，例如身份验证、日志记录、数据验证、权限控制等。Gin 中间件是一组函数，可以按照指定的顺序应用到路由上。

以下是 Gin 框架中间件的详细介绍：

创建中间件：

中间件是一个函数，其签名如下：
1

func(c *gin.Context)
中间件函数接受一个 Gin 上下文对象 c，它允许你访问请求信息、响应信息以及进行处理。

应用中间件：

在 Gin 中，可以使用 Use 方法来将中间件应用到路由组或单个路由上。例如：

// 将中间件应用到所有路由组上
router.Use(LoggerMiddleware(), AuthMiddleware())

// 将中间件应用到路由分组中
v1 := router.Group("/v1")
v1.Use(LoggerMiddleware(),AuthMiddleware())

// 将中间件应用到单个路由上
router.GET("/admin", AuthMiddleware(), AdminHandler)

注意，中间件的执行顺序与它们添加到路由上的顺序有关，按照添加的顺序依次执行。

你可以将中间件应用到全局（对所有路由有效）或仅应用到特定的路由组或路由上。使用 Use 方法添加到全局中间件，使用 Group 方法创建路由组并在路由组上应用中间件，或者在单个路由上使用 Use 方法应用中间件。

中间件示例：

下面是一些常见的中间件示例：
- 日志记录中间件：用于记录请求和响应信息，以便调试和监控。
- 身份验证中间件：用于验证用户身份，通常检查令牌或会话是否有效。
- 权限控制中间件：用于检查用户是否有权限执行特定操作。
- CORS 中间件：用于处理跨域资源共享 (CORS) 请求，以确保安全的跨域通信。
- 缓存中间件：用于缓存响应，以减少服务器负载和提高性能。
- 数据验证中间件：用于验证请求数据的有效性，防止恶意输入。
中间件的执行流程：

Gin 中间件的执行流程是串行的，按照添加的顺序依次执行。在每个中间件中，你可以执行一些前置操作，然后使用 c.Next() 将控制权传递给下一个中间件或路由处理程序。如果不调用 c.Next()，后续中间件或路由将不会执行，请求会被终止。
1 2 3 4 5

func MyMiddleware(c *gin.Context) { // 前置操作 c.Next() // 传递控制权给下一个中间件或路由处理程序 // 后置操作 }
如果需要在中间件中执行一些操作后终止请求流程，可以使用 c.Abort()，它会阻止后续中间件和路由的执行。

中间件的参数：

你可以将参数传递给中间件函数，以便在中间件中访问它们。例如，如果你需要在中间件中传递配置信息，可以这样做：

func CustomMiddleware(config Config) gin.HandlerFunc {
    return func(c *gin.Context) {
        // 使用 config 参数执行中间件操作
        c.Next()
    }
}

// 在路由中应用带有参数的中间件
router.Use(CustomMiddleware(myConfig))

内置中间件：

Gin 框架提供了一些内置的中间件，如 gin.Logger() 用于记录请求日志、gin.Recovery() 用于处理恐慌和崩溃等。你可以使用这些内置中间件来快速添加常见功能。

中间件中的错误处理：

如果中间件中发生了错误，你可以使用 c.AbortWithError 来中止请求并返回错误响应。这可以用于处理身份验证失败、权限不足等情况。

func AuthMiddleware(c *gin.Context) {
    if !isAuthenticated(c) {
        c.AbortWithError(http.StatusUnauthorized, errors.New("Unauthorized"))
        return
    }
    c.Next()
}

总的来说，Gin 框架中间件提供了一种灵活和强大的方式来管理和处理请求。你可以根据应用程序的需求创建自定义中间件，并将它们应用到不同的路由或路由组上，以实现各种功能和控制逻辑。

Go语言编程大全-学习笔记

Sun, 18 May 2025 22:07:00 +0800

课程地址：【高性能golang】Go语言编程大全，10大专题精讲（28H）

2025-05-18

go module依赖管理

介绍

Go Modules 是 Go 语言自 1.11 起引入、1.16 起默认启用的 依赖管理系统，用来解决旧的 GOPATH 模式下包管理混乱、版本不可控的问题。

🧱 一、Go Modules 基本概念

1. 什么是 Module？

一个 Module 是一个包含 go.mod 文件的代码集合。
它定义了模块的路径、所依赖的模块、版本等信息。

一个项目根目录下的 go.mod 表示这个目录是一个 Go Module。

2. Module 路径（module path）

一般是一个类似 github.com/user/project 的路径。
这个路径对应一个仓库地址，Go 用它来定位源码（通过代理或 HTML 中的 go-import 标签）。

3. `go.mod` 文件内容示例：

module github.com/user/myapp

go 1.21

require (
    github.com/gin-gonic/gin v1.9.1
    golang.org/x/sys v0.5.0
)

字段说明：

字段	含义
`module`	模块路径（项目名）
`go`	最低 Go 版本要求
`require`	依赖模块及其版本
`replace`	替换模块路径（用于本地调试或使用 fork）
`exclude`	排除某个版本的模块

📁 二、常见文件说明

`go.mod`

项目模块定义和依赖版本的声明。

`go.sum`

模块版本校验文件，包含模块的哈希值，确保下载模块未被篡改。

🛠️ 三、常用命令

命令	说明
`go mod init <module-path>`	初始化模块，生成 `go.mod`
`go get <module>@<version>`	获取依赖模块，添加到 `go.mod`
`go mod tidy`	清理 `go.mod` 和 `go.sum`，删除未用依赖，补全遗漏的依赖
`go mod vendor`	把所有依赖复制到 `vendor/` 目录
`go list -m all`	查看所有模块依赖
`go mod graph`	显示模块依赖图
`go mod verify`	校验模块哈希是否匹配 `go.sum`
`go mod edit`	手动修改 `go.mod`（不常用）

🔁 四、replace 和私有模块

`replace` 示例：

`1`	`replace github.com/user/old => ../local/path`

用本地代码替换远程模块，常用于本地调试、Fork 自己的版本。

私有模块支持（如 GitLab、Gitee 等）：

1
2

export GOPRIVATE=gitlab.mycorp.com
export GOPROXY=direct

🌐 五、模块代理机制（GOPROXY）

Go 默认使用 Go 官方的模块代理（proxy）加速模块下载。

默认值（Go 1.13+）：

`1`	`GOPROXY=https://proxy.golang.org,direct`

修改为国内代理（推荐）：

`1`	`export GOPROXY=https://goproxy.cn,direct`

,direct 表示如果代理不可用，就直连源码仓库。

🧭 六、依赖解析机制

Go 会从 go.mod 读取你需要的模块；
然后解析出这些模块自身的 go.mod；
构建一个最终依赖图；
优先使用最小兼容版本（Minimal Version Selection, MVS）；
使用 Go Proxy 下载 .mod, .zip, .info 三个文件；
校验其哈希值是否与 go.sum 匹配。

🧪 七、Go Modules 开发中的常见场景

✅ 本地模块引用：

`1`	`replace example.com/lib => ../lib`

✅ 指定 Git commit：

`1`	`go get github.com/user/repo@d92efb3`

✅ 忽略模块校验：

`1`	`export GONOSUMDB=github.com/yourcompany/*`

🧠 总结

特性	说明
独立于 GOPATH	每个模块自包含，不依赖全局目录
支持版本控制	每个依赖可指定版本
加速下载与缓存	内建模块代理、校验和数据库
更强的可重现性	`go.sum` 确保一致性

模块代理机制

Go Module 的**模块代理机制（Module Proxy）**是 Go 在模块下载和依赖管理方面的核心优化之一，目的是：

✅ 加速模块下载；
✅ 增强构建的可重复性；
✅ 降低对 Git 仓库或私有网络的依赖；
✅ 增强安全性（配合校验和数据库）。

🧱 一、模块代理机制简介

🔗 什么是模块代理（Go Proxy）？

模块代理是一个服务器，遵循 Go 官方的规范，用于缓存和分发 Go 模块（源码压缩包、版本信息、go.mod 文件等），Go 编译器通过它们下载依赖。

默认的官方模块代理是：

`1`	`https://proxy.golang.org`

🌐 二、模块代理的工作流程

当你运行如：

`1`	`go get github.com/gin-gonic/gin@v1.9.1`

Go 会按如下顺序尝试获取模块：

通过模块代理请求：

`1`	`https://proxy.golang.org/github.com/gin-gonic/gin/@v/v1.9.1.zip`

如果模块代理返回成功，就使用这个缓存版本构建项目。
如果代理失败（404/超时），且设置了 GOPROXY=direct，就直接访问源码仓库（如 GitHub）去 clone 下载。
Go 校验模块的哈希值与 go.sum 是否匹配，确保安全性（由 sum.golang.org 提供哈希数据库）。

📦 三、Go Proxy 下载的三类文件

Go Module Proxy 提供以下 3 类文件：

路径	含义
`@v/list`	所有可用版本号
`@v/<version>.mod`	该版本的 go.mod 文件内容
`@v/<version>.zip`	模块源码打包（供编译使用）
`@v/<version>.info`	包含版本、时间戳等元信息

⚙️ 四、环境变量控制模块代理行为

变量名	用途
`GOPROXY`	设置使用哪些代理服务器，顺序使用
`GOSUMDB`	设置校验和数据库地址（默认为 `sum.golang.org`）
`GONOSUMDB`	设置不进行校验和校验的模块
`GOPRIVATE`	声明私有模块（不通过 proxy 和 sumdb）

✏️ 示例：配置中国用户常用的代理

使用七牛云的 Go Proxy：

`1`	`export GOPROXY=https://goproxy.cn,direct`

,direct 表示如果代理无法找到模块，则 fallback 到源仓库（如 GitHub）。

🔒 五、私有模块处理（配合 GOPRIVATE）

如果你使用私有仓库如 GitLab/Gitea，必须设置：

`1`	`export GOPRIVATE=git.mycompany.com`

这会告诉 Go：

不使用 proxy 下载该模块；
不校验其 go.sum；
直接通过 Git 克隆源码。

你还可能需要配置 Git 凭证访问私有仓库，如：

`1`	`git config --global url."git@github.com:".insteadOf "https://github.com/"`

🔧 六、开发中常见的代理配置方式

配置为全局代理 + fallback：

`1`	`export GOPROXY=https://goproxy.io,direct`

忽略某些模块的校验（如私有）：

`1`	`export GONOSUMDB=git.mycompany.com/*`

🛠️ 七、如何搭建自己的 Go Proxy（高级）

Go 官方提供的 Athens 是一个开源 Go Proxy 服务端，可以搭建在内网用于缓存、加速、控制模块依赖。

搭建 Athens 可用于：

内网开发；
CI/CD 编译缓存；
隔离外部依赖风险。

🧠 总结

模块代理特性	说明
默认代理	`https://proxy.golang.org`
可配置多个代理	`GOPROXY=url1,url2,...`
本地无感缓存机制	下载的模块存入 `$GOPATH/pkg/mod`
支持私有仓库	通过 `GOPRIVATE` 控制
支持校验和数据库	`GOSUMDB=sum.golang.org`
支持自建代理服务	如 Athens、goproxy.cn

GOPRIVATE 是 Go Module 引入的一个 环境变量，用于声明哪些模块是 “私有的”，从而：

🚫 禁用这些模块的 代理（GOPROXY） 下载；
🔒 禁用这些模块的 校验和数据库（GOSUMDB） 校验；
✅ 改为 直接通过 Git/SVN 等源头方式拉取模块源码；
🔑 常配合 Git 凭据（如 SSH）用于访问私有仓库。

GOPRIVATE 详解

🧱 一、`GOPRIVATE` 的作用详解

Go 默认使用：

1
2

GOPROXY=https://proxy.golang.org
GOSUMDB=sum.golang.org

这会把你下载的所有模块（包括你私有的）：

发给 Google 的代理服务器；
校验模块是否安全（go.sum）；

⚠️ 如果你有私有代码仓库（如 GitHub Enterprise, GitLab, Gitee 企业版），这些默认行为会导致：

模块无法通过代理下载；
或私密模块泄漏到第三方服务。

为了解决这个问题，Go 提供了 GOPRIVATE。

✏️ 二、如何使用 `GOPRIVATE`

示例一：声明一个私有仓库前缀

`1`	`export GOPRIVATE=git.mycompany.com`

示例二：支持多个私有路径（用逗号 `,` 分隔）

`1`	`export GOPRIVATE=git.mycompany.com,github.com/myteam/*`

示例三：搭配 Go Proxy 一起使用（推荐）

1
2

export GOPROXY=https://goproxy.cn,direct
export GOPRIVATE=github.com/myorg/*

含义：

公共依赖走 goproxy.cn；
github.com/myorg/* 的模块 跳过 proxy 和 sumdb，使用 Git 下载。

🔍 三、GOPRIVATE 会影响哪些行为？

行为	公共模块	私有模块（命中 GOPRIVATE）
通过 GOPROXY 下载	✅ 是	🚫 否（走 direct）
校验模块哈希（go.sum）	✅ 是（sum.golang.org）	🚫 否（跳过 GOSUMDB）
报错信息是否包含模块路径	✅ 是	🚫 否（更安全）
是否允许自动 fallback 到 Git	❌ 默认不允许	✅ 允许（但需 Git 凭证）

🔐 四、与私有 Git 仓库联合使用

如果你使用的是私有 GitLab、Gitea 等：

步骤 1：配置 `GOPRIVATE`

`1`	`export GOPRIVATE=gitlab.mycorp.com`

步骤 2：配置 Git 凭证访问（SSH 或 HTTP 认证）

例如使用 SSH：

`1`	`git config --global url."git@gitlab.mycorp.com:".insteadOf "https://gitlab.mycorp.com/"`

或使用令牌：

`1`	`git config --global url."https://<token>@gitlab.mycorp.com/".insteadOf "https://gitlab.mycorp.com/"`

🧠 五、常见误区和注意事项

问题	原因
`go get` 私有模块失败	没有设置 `GOPRIVATE`，默认尝试走 proxy
私有模块泄露到 `proxy.golang.org`？	没设 `GOPRIVATE`，Go 默认会上报路径
明明设置了 GOPRIVATE，还是失败	检查 Git 凭证、网络连通性、模块路径拼写
`go.sum` 报错/验证失败	可能误设了 `GOSUMDB`，应配合使用

✅ 六、总结：`GOPRIVATE` 设置规范

场景	推荐设置
仅公共模块开发	无需设置
公司内部私有模块	`GOPRIVATE=git.mycorp.com`
多个私有组织/项目前缀	`GOPRIVATE=git.mycorp.com,github.com/myteam/*`
和国内代理一起使用	`GOPROXY=https://goproxy.cn,direct` + `GOPRIVATE=...`

go get详细流程

在 Go 语言中，go get 命令的工作机制是基于 Go Modules（自 Go 1.11 引入，Go 1.16 起默认启用），其寻找和下载第三方库的流程可以分为几个关键步骤：

一、总体流程概览（以 `go get github.com/user/repo` 为例）

解析模块路径（Module Path）
- 你输入的地址 github.com/user/repo 被认为是一个模块路径（module path），Go 会解析它。
确定版本
- 如果你指定了版本，如 go get github.com/user/repo@v1.2.3，Go 就获取那个版本。
- 如果没有指定，Go 会解析该模块的最新稳定版本（根据 tag、默认分支）。
查找代理（Go Proxy）
- Go 默认使用 Go Module Proxy 下载模块，而不是直接访问 Git 仓库。
- 默认的代理是 https://proxy.golang.org，但可以通过 GOPROXY 环境变量修改。
  - 示例：GOPROXY=https://proxy.golang.org,direct

通过代理获取元信息

Go 会发送请求到代理，比如：

https://proxy.golang.org/github.com/user/repo/@v/list  # 列出版本
https://proxy.golang.org/github.com/user/repo/@v/v1.2.3.info  # 获取版本信息
https://proxy.golang.org/github.com/user/repo/@v/v1.2.3.mod   # 获取 go.mod
https://proxy.golang.org/github.com/user/repo/@v/v1.2.3.zip   # 获取源码 ZIP 包

如果代理不可用，会回退到源码仓库
- 如果你配置了 GOPROXY=direct 或代理返回 404，Go 会尝试：
  - 通过 go-import 元标签从模块路径中找到仓库 URL；
  - 克隆 Git 仓库、checkout 到目标版本。

二、当 Go 不使用 Proxy（GOPROXY=direct）时怎么找源码？

解析模块路径
- Go 会发起请求到：
  1
  
  https://github.com/user/repo?go-get=1
  来获取 <meta name="go-import" content="..."> 标签，这告诉 Go 去哪里获取源码。
  
  当执行 go get github.com/user/repo.git 时会直接克隆 https://github.com/user/repo.git，而无需先发送 go-get=1 请求。

HTML 返回中的 go-import 标签

比如 GitHub 返回如下 HTML：

`1`	`<meta name="go-import" content="github.com/user/repo git https://github.com/user/repo">`

根据标签内容去 Git 拉代码
- Go 就会通过 git clone https://github.com/user/repo 拉取源码；
- 然后 checkout 到正确的 tag 或 commit hash。

三、常见环境变量

环境变量	用途
`GOPROXY`	Go 模块代理（默认是 `https://proxy.golang.org`）
`GONOSUMDB`	指定不校验校验和的模块
`GOSUMDB`	校验模块安全性的数据库（默认是 `sum.golang.org`）
`GOPRIVATE`	指定私有模块（Go 不会通过 proxy/sumdb 获取这些）

示例：go get 真实流程（不使用代理）

设置：
1

export GOPROXY=direct

执行：

`1`	`go get github.com/gin-gonic/gin@v1.9.1`

Go 执行流程：
- 访问 https://github.com/gin-gonic/gin?go-get=1
- 解析 <meta name="go-import"> 为 git 仓库 URL
- 执行：
  1 2
  
  git clone https://github.com/gin-gonic/gin git checkout tags/v1.9.1

go get子模块

go get gorm.io/gorm/logger会：

1.先发送GET请求https://gorm.io/gorm/logger?go-get=1，查不到源码地址；

2.再回溯一级目录，请求https://gorm.io/gorm?go-get=1。

总结

步骤	说明
模块路径解析	把 `go get` 的地址解释成模块
查询模块代理	默认使用 proxy.golang.org 查询
获取元信息	`.info`, `.mod`, `.zip`
拉源码（必要时）	如果没有缓存/代理失败，使用 Git 克隆代码

模块版本控制规范

语义版本格式：主版本号.次版本号.补丁号，版本号递增规则如下：

主要版本号在发布不兼容的公共接口更改后，例如模块里的某个包被删除，必须递增必须将次要和补丁版本设置为零。
次要版本号在发布向后兼容的更改后，例如添加新函数后，必须递增且补丁版本设置为零。
补丁版本号在不修改到公共接口的情况下，例如 Bug 修复或者做了一些优化，必须递增。

一个版本标示着软件的不可变快照。

补丁号后面可以跟 -pre、+build、-pre+build 等表示预发版或构建元数据。

主版本为 0 或有预发布后缀，则它是不稳定版本，不稳定版本不受兼容性限制，如 0.2.0 可能与 0.1.0 不兼容，1.5.0-beta 可能与 1.5.0 不兼容。

go语言中，go module 每个版本以 v 开头，后面跟语义版本。

当 vcs 为 git 时，通常情况下模块的版本就是 git tag 的版本。

没有语义版本时会生成一个伪版本，例如v0.0.0-20180306012644-bacd9c7efldd，第二部分表示代码生成的时间，第三部分是commit的前12个字符。

image-20250518193140074

代码仓库没有 tag 或者 tag 名称不符合格式要求，则会生成伪版本号。

模块版本兼容

主版本为 2 或更高版本时，go 模块路径必须带有像 /v2 或 /v3 这样的主版本后缀，比如：

“github.com/gocolly/colly/v2”，“github.com/mailru/go-clickhouse/v2”。

go get 和 go install 可以指定版本号，如:

`1`	`go get github.com/cespare/xxhash@v1.1.0`

主版本号不同表示不兼容，一个项目里可能同时依赖不同的主版本号，如：

image-20250518194923201

go get -u 不会更新主版本号，即 -u 表示更新到当前主版本号下的最新版本。

在使用 go module 规范之前，有些第三方库的高版本没有加 /v2 或 /v3 后缀，此时需要加 incompatible，如github.com/go-redis/redis v6.15.9+incompatible 路径没有 /v6 后缀。

主版本后缀不允许有 /v0 或 /v1出现。作为特殊情况，即使在 v0 和 v1，以 gopkg.in/ 开头的模块路径必须始终具有主版本后缀。后缀必须以点开头，而不是斜杠，例如 gopkg.in/check.vl，gopkg.in/yaml.v3。

image-20250518213109087

logrus日志库学习笔记

Fri, 02 Aug 2024 06:30:00 +0800

logrus 是 Go 语言中一个非常流行和功能强大的日志库。它提供了丰富的功能，支持结构化日志、灵活的日志级别、钩子（hook）、格式化输出等特性，适合用来记录各种类型的日志信息。

`logrus` 的基本使用

以下是使用 logrus 的一些基本操作示例：

1. 安装 `logrus`

使用 go get 命令安装 logrus：

`1`	`go get github.com/sirupsen/logrus`

2. 基本日志记录

logrus 支持不同级别的日志记录，如 Info、Warn、Error、Debug 等。以下是一个简单的示例：

package main
import (
    "github.com/sirupsen/logrus"
)
func main() {
    logrus.Info("This is an info message")
    logrus.Warn("This is a warning message")
    logrus.Error("This is an error message")
    logrus.Debug("This is a debug message") // 默认情况下，Debug 级别日志不会被输出
}

3. 设置日志级别

你可以设置全局的日志级别，低于该级别的日志将不会输出：

func main() {
    logrus.SetLevel(logrus.WarnLevel)

    logrus.Info("This message will not be logged")
    logrus.Warn("This is a warning message")
    logrus.Error("This is an error message")
}

4. 格式化日志输出

logrus 支持多种日志输出格式，例如文本和 JSON：

文本格式（默认）：

func main() {
    logrus.SetFormatter(&logrus.TextFormatter{
        FullTimestamp: true,
    })
    logrus.Info("This is a text formatted log")
}

JSON 格式：

func main() {
    logrus.SetFormatter(&logrus.JSONFormatter{})
    logrus.Info("This is a JSON formatted log")
}

5. 自定义字段

logrus 支持结构化日志，可以在日志中添加自定义字段：

func main() {
    logrus.WithFields(logrus.Fields{
        "user_id": 12345,
        "event":   "user_login",
    }).Info("User login event")
}

6. 输出到文件

你可以将日志输出到文件，而不是标准输出：

import (
    "os"
)

func main() {
    file, err := os.OpenFile("logrus.log", os.O_CREATE|os.O_WRONLY | os.O_APPEND, 0666)
    if err == nil {
        logrus.SetOutput(file)
    } else {
        logrus.Info("Failed to log to file, using default stderr")
    }

    logrus.Info("This log will be written to the file")
}

1
2

// 将日志输出设置为同时写入文件和标准输出
logrus.SetOutput(io.MultiWriter(file, os.Stdout))

7. 钩子（Hooks）

logrus 支持钩子，可以在日志记录前后执行一些自定义操作，比如将日志发送到远程服务器：

type MyCustomHook struct{}

func (hook *MyCustomHook) Levels() []logrus.Level {
    return logrus.AllLevels
}

func (hook *MyCustomHook) Fire(entry *logrus.Entry) error {
    // 在这里可以将日志发送到远程服务器或做其他操作
    fmt.Println("Custom hook fired for log:", entry.Message)
    return nil
}

func main() {
    logrus.AddHook(&MyCustomHook{})

    logrus.Info("This log will trigger the custom hook")
}

常见场景使用

记录 HTTP 请求日志：可以使用 logrus 记录 HTTP 请求的相关信息，比如方法、路径、状态码等。
分环境日志输出：可以根据不同的环境（开发、测试、生产）配置不同的日志级别和输出格式。
集成第三方日志系统：通过钩子将日志发送到诸如 ELK、Splunk、Datadog 等日志系统进行集中管理和分析。

参数和选项配置

在使用 logrus 时，有多种参数和选项可以配置，以满足不同的日志记录需求。这些设置涵盖了日志格式、日志级别、输出目标等多个方面。

1. 日志级别（Log Level）

你可以设置 logrus 的全局日志级别，只有等于或高于该级别的日志才会输出：

`1`	`logrus.SetLevel(logrus.WarnLevel)`

常用的日志级别有（依次降低）：

logrus.PanicLevel：记录 Panic 日志并触发 panic。
logrus.FatalLevel：记录 Fatal 日志并调用 os.Exit(1) 退出程序。
logrus.ErrorLevel：记录错误日志。
logrus.WarnLevel：记录警告日志。
logrus.InfoLevel：记录信息性日志。
logrus.DebugLevel：记录调试日志。
logrus.TraceLevel：记录更细粒度的调试日志。

logrus 默认的日志级别是 InfoLevel。这意味着在默认情况下，logrus 会记录 Info 级别及更高（Warn、Error、Fatal、Panic）的日志，而不会输出低于 InfoLevel 的日志（如 Debug 和 Trace 级别的日志）。

2. 日志格式（Formatter）

logrus 支持不同的日志格式，可以通过 SetFormatter 方法来设置。

2.1 文本格式（TextFormatter）

这是 logrus 的默认格式器，适合人类阅读。

1
2
3

logrus.SetFormatter(&logrus.TextFormatter{
    FullTimestamp: true, // 启用完整时间戳
})

TextFormatter 的常用参数：

DisableColors: 禁用输出的颜色（默认为 false）。
FullTimestamp: 启用完整时间戳（默认为 false，即只显示时间）。
TimestampFormat: 自定义时间戳格式，默认是 time.RFC3339。
DisableTimestamp: 禁用时间戳输出。
ForceQuote: 强制对字段进行引用。

2.2 JSON 格式（JSONFormatter）

适合机器处理或日志收集系统使用。

1
2
3

logrus.SetFormatter(&logrus.JSONFormatter{
    TimestampFormat: time.RFC3339, // 自定义时间格式
})

JSONFormatter 的常用参数：

TimestampFormat: 自定义时间戳格式。
PrettyPrint: 美化输出的 JSON，便于调试（默认为 false）。
DisableHTMLEscape: 禁用 HTML 字符转义。

3. 输出目标（Output）

默认情况下，logrus 将日志输出到标准输出（os.Stdout），你可以使用 SetOutput 方法改变输出目标，如输出到文件或其他日志处理器。

file, err := os.OpenFile("logrus.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
if err == nil {
    logrus.SetOutput(file)
} else {
    logrus.Error("Failed to log to file, using default stderr")
}

4. 钩子（Hooks）

logrus 支持钩子机制，可以在日志事件发生前或发生后执行特定的操作。你可以使用钩子来将日志发送到外部服务，如 Logstash、Sentry 等。

type MyCustomHook struct{}

func (hook *MyCustomHook) Levels() []logrus.Level {
    return logrus.AllLevels
}

func (hook *MyCustomHook) Fire(entry *logrus.Entry) error {
    // 处理日志条目
    fmt.Println("Custom hook executed for log:", entry.Message)
    return nil
}

logrus.AddHook(&MyCustomHook{})

5. 字段（Fields）

logrus 支持结构化日志，可以在日志中添加自定义字段，使用 WithFields 方法：

logrus.WithFields(logrus.Fields{
    "user_id": 12345,
    "event":   "user_login",
}).Info("User login event")

6. 其他配置

logrus.SetReportCaller(true): 启用该选项后，日志会记录产生日志的函数和文件位置。需要注意的是，这会增加一定的性能开销。
1

logrus.SetReportCaller(true)
logrus.SetNoLock(): 禁用日志记录时的锁，这在高并发环境中使用。需要确保你的代码中不会出现并发写日志的情况，否则可能会出现日志混乱的问题。
1

logrus.SetNoLock()

总结

logrus 提供了丰富的配置选项来满足各种日志需求。常用的配置包括设置日志级别、选择日志格式、指定日志输出目标以及添加钩子和自定义字段。合理利用这些参数，可以使你的日志系统更加灵活和高效。

Golang三色标记+混合写屏障GC模式全分析

Sun, 16 Jun 2024 00:50:00 +0800

出处：刘丹冰-Golang三色标记+混合写屏障GC模式全分析

垃圾回收(Garbage Collection，简称GC)是编程语言中提供的自动的内存管理机制，自动释放不需要的对象，让出存储器资源，无需程序员手动执行。

Golang中的垃圾回收主要应用三色标记法，GC过程和其他用户goroutine可并发运行，但需要一定时间的STW(stop the world)，STW的过程中，CPU不执行用户代码，全部用于垃圾回收，这个过程的影响很大，Golang进行了多次的迭代优化来解决这个问题。

一、Go V1.3之前的标记-清除(mark and sweep)算法

此算法主要有两个主要的步骤：

标记(Mark phase)
清除(Sweep phase)

第一步，暂停程序业务逻辑，分类出可达和不可达的对象，然后做上标记。

图中表示是程序与对象的可达关系，目前程序的可达对象有对象1-2-3，对象4-7等五个对象。

第二步, 开始标记，程序找出它所有可达的对象，并做上标记。如下图所示：所以对象1-2-3、对象4-7等五个对象被做上标记。

第三步, 标记完了之后，然后开始清除未标记的对象. 结果如下.

操作非常简单，但是有一点需要额外注意，Mark and Sweep算法在执行的时候，需要程序暂停，即 STW（Stop The World）。STW的过程中，CPU不执行用户代码，全部用于垃圾回收，这个过程的影响很大，所以STW也是一些回收机制最大的难题和希望优化的点。所以在执行第三步的这段时间，程序会暂定停止任何工作，卡在那等待回收执行完毕。

第四步, 停止暂停，让程序继续跑。然后循环重复这个过程，直到process程序生命周期结束。

以上便是标记清除回收的算法。

二、标记-清扫(mark and sweep)的缺点

STW，stop the world；让程序暂停，程序出现卡顿 (重要问题)。
标记需要扫描整个heap
清除数据会产生heap碎片

所以Go V1.3版本之前就是以上来实施的, 流程是

Go V1.3 做了简单的优化,将STW提前, 减少STW暂停的时间范围.如下所示

这里面最重要的问题就是：mark-and-sweep 算法会暂停整个程序 。

Go是如何面对并这个问题的呢？接下来G V1.5版本就用三色并发标记法来优化这个问题.

三、Go V1.5的三色并发标记法

三色标记法实际上就是通过三个阶段的标记来确定清楚的对象都有哪些. 我们来看一下具体的过程.

第一步 , 就是只要是新创建的对象,默认的颜色都是标记为“白色”.

这里面需要注意的是, 所谓“程序”, 则是一些对象的跟节点集合.

所以上图,可以转换如下的方式来表示.

第二步, 每次GC回收开始, 然后从根节点开始遍历所有对象，把遍历到的对象从白色集合放入“灰色”集合。

第三步, 遍历灰色集合，将灰色对象引用的对象从白色集合放入灰色集合，之后将此灰色对象放入黑色集合

第四步, 重复第三步, 直到灰色中无任何对象.

第五步: 回收所有的白色标记表的对象. 也就是回收垃圾.

以上便是三色并发标记法, 不难看出,我们上面已经清楚的体现三色的特性, 那么又是如何实现并行的呢?

Go是如何解决标记-清除(mark and sweep)算法中的卡顿(stw，stop the world)问题的呢？

四、没有STW的三色标记法

我们还是基于上述的三色并发标记法来说, 他是一定要依赖STW的. 因为如果不暂停程序, 程序的逻辑改变对象引用关系, 这种动作如果在标记阶段做了修改，会影响标记结果的正确性。我们举一个场景.

如果三色标记法, 标记过程不使用STW将会发生什么事情?

可以看出，有两个问题, 在三色标记法中,是不希望被发生的

条件1: 一个白色对象被黑色对象引用**(白色被挂在黑色下)**
条件2: 灰色对象与它之间的可达关系的白色对象遭到破坏**(灰色同时丢了该白色)**

当以上两个条件同时满足时, 就会出现对象丢失现象!

当然, 如果上述中的白色对象3, 如果他还有很多下游对象的话, 也会一并都清理掉.

为了防止这种现象的发生，最简单的方式就是STW，直接禁止掉其他用户程序对对象引用关系的干扰，但是STW的过程有明显的资源浪费，对所有的用户程序都有很大影响，如何能在保证对象不丢失的情况下合理的尽可能的提高GC效率，减少STW时间呢？

答案就是, 那么我们只要使用一个机制,来破坏上面的两个条件就可以了.

五、屏障机制

我们让GC回收器,满足下面两种情况之一时,可保对象不丢失. 所以引出两种方式.

(1) “强-弱” 三色不变式

强三色不变式

不存在黑色对象引用到白色对象的指针。

弱三色不变式

所有被黑色对象引用的白色对象都处于灰色保护状态.

为了遵循上述的两个方式,Golang团队初步得到了如下具体的两种屏障方式“插入屏障”, “删除屏障”.

(2) 插入屏障

具体操作: 在A对象引用B对象的时候，B对象被标记为灰色。(将B挂在A下游，B必须被标记为灰色)

满足: 强三色不变式. (不存在黑色对象引用白色对象的情况了，因为白色会强制变成灰色)

伪码如下:

添加下游对象(当前下游对象slot, 新下游对象ptr) {   
  //1
  标记灰色(新下游对象ptr)   
  
  //2
  当前下游对象slot = 新下游对象ptr  				  
}

场景：

1
2

A.添加下游对象(nil, B)   //A 之前没有下游， 新添加一个下游对象B， B被标记为灰色
A.添加下游对象(C, B)     //A 将下游对象C 更换为B，  B被标记为灰色

这段伪码逻辑就是写屏障,. 我们知道,黑色对象的内存槽有两种位置, 栈和堆. 栈空间的特点是容量小,但是要求相应速度快,因为函数调用弹出频繁使用, 所以“插入屏障”机制,在栈空间的对象操作中不使用. 而仅仅使用在堆空间对象的操作中.

接下来，我们用几张图，来模拟整个一个详细的过程，希望您能够更可观的看清晰整体流程。

但是如果栈不添加,当全部三色标记扫描之后,栈上有可能依然存在白色对象被引用的情况(如上图的对象9). 所以要对栈重新进行三色标记扫描, 但这次为了对象不丢失, 要对本次标记扫描启动STW暂停. 直到栈空间的三色标记结束.

最后将栈和堆空间扫描剩余的全部白色节点清除. 这次STW大约的时间在10~100ms间.

(3) 删除屏障

具体操作: 被删除的对象，如果自身为灰色或者白色，那么被标记为灰色。

满足: 弱三色不变式. (保护灰色对象到白色对象的路径不会断)

伪代码：

添加下游对象(当前下游对象slot， 新下游对象ptr) {
  //1
  if (当前下游对象slot是灰色 || 当前下游对象slot是白色) {
  		标记灰色(当前下游对象slot)     //slot为被删除对象， 标记为灰色
  }
  
  //2
  当前下游对象slot = 新下游对象ptr
}

场景：

1
2

A.添加下游对象(B, nil)   //A对象，删除B对象的引用。  B被A删除，被标记为灰(如果B之前为白)
A.添加下游对象(B, C)		 //A对象，更换下游B变成C。   B被A删除，被标记为灰(如果B之前为白)

接下来，我们用几张图，来模拟整个一个详细的过程，希望您能够更可观的看清晰整体流程。

这种方式的回收精度低，一个对象即使被删除了最后一个指向它的指针也依旧可以活过这一轮，在下一轮GC中被清理掉。

六、Go V1.8的混合写屏障(hybrid write barrier)机制

插入写屏障和删除写屏障的短板：

插入写屏障：结束时需要STW来重新扫描栈，标记栈上引用的白色对象的存活；
删除写屏障：回收精度低，GC开始时STW扫描堆栈来记录初始快照，这个过程会保护开始时刻的所有存活对象。

Go V1.8版本引入了混合写屏障机制（hybrid write barrier），避免了对栈re-scan的过程，极大的减少了STW的时间。结合了两者的优点。

(1) 混合写屏障规则

具体操作:

1、GC开始将栈上的对象全部扫描并标记为黑色(之后不再进行第二次重复扫描，无需STW)，

2、GC期间，任何在栈上创建的新对象，均为黑色。

3、被删除的对象标记为灰色。

4、被添加的对象标记为灰色。

满足: 变形的弱三色不变式.

伪代码：

添加下游对象(当前下游对象slot, 新下游对象ptr) {
  	//1 
		标记灰色(当前下游对象slot)    //只要当前下游对象被移走，就标记灰色
  	
  	//2 
  	标记灰色(新下游对象ptr)
  		
  	//3
  	当前下游对象slot = 新下游对象ptr
}

这里我们注意，屏障技术是不在栈上应用的，因为要保证栈的运行效率。

(2) 混合写屏障的具体场景分析

接下来，我们用几张图，来模拟整个一个详细的过程，希望您能够更可观的看清晰整体流程。

注意混合写屏障是Gc的一种屏障机制，所以只是当程序执行GC的时候，才会触发这种机制。

GC开始：扫描栈区，将可达对象全部标记为黑

场景一：对象被一个堆对象删除引用，成为栈对象的下游

伪代码

1
2
3

//前提：堆对象4->对象7 = 对象7；  //对象7 被 对象4引用
栈对象1->对象7 = 堆对象7；  //将堆对象7 挂在 栈对象1 下游
堆对象4->对象7 = null；    //对象4 删除引用 对象7

场景二：对象被一个栈对象删除引用，成为另一个栈对象的下游

伪代码

1
2
3

new 栈对象9；
对象8->对象3 = 对象3；      //将栈对象3 挂在 栈对象9 下游
对象2->对象3 = null；      //对象2 删除引用 对象3

场景三：对象被一个堆对象删除引用，成为另一个堆对象的下游

伪代码

1
2

堆对象10->对象7 = 堆对象7；       //将堆对象7 挂在 堆对象10 下游
堆对象4->对象7 = null；         //对象4 删除引用 对象7

场景四：对象从一个栈对象删除引用，成为另一个堆对象的下游

伪代码

1
2

堆对象10->对象7 = 堆对象7；       //将堆对象7 挂在 堆对象10 下游
堆对象4->对象7 = null；         //对象4 删除引用 对象7

Golang中的混合写屏障满足弱三色不变式，结合了删除写屏障和插入写屏障的优点，只需要在开始时并发扫描各个goroutine的栈，使其变黑并一直保持，这个过程不需要STW，而标记结束后，因为栈在扫描后始终是黑色的，也无需再进行re-scan操作了，减少了STW的时间。

七、总结

以上便是Golang的GC全部的标记-清除逻辑及场景演示全过程。

GoV1.3- 普通标记清除法，整体过程需要启动STW，效率极低。

GoV1.5- 三色标记法，堆空间启动写屏障，栈空间不启动，全部扫描之后，需要重新扫描一次栈(需要STW)，效率普通。

GoV1.8-三色标记法，混合写屏障机制，栈空间不启动，堆空间启动。整个过程几乎不需要STW，效率较高。

Hollis写字的地方

Gin渲染

HTML渲染

自定义模板函数

静态文件处理

使用模板继承

补充文件路径处理

返回Json

context组件

context组件

获取参数

1.query string参数

2.Form表单参数

3.路径参数

4.参数绑定

文件上传

重定向

重定向

1.HTTP 重定向

2.路由重定向

路由

路由

中间件

Go语言编程大全-学习笔记

go module依赖管理

介绍

🧱 一、Go Modules 基本概念

1. 什么是 Module？

2. Module 路径（module path）

3. go.mod 文件内容示例：

📁 二、常见文件说明

go.mod

go.sum

🛠️ 三、常用命令

🔁 四、replace 和私有模块

replace 示例：

私有模块支持（如 GitLab、Gitee 等）：

🌐 五、模块代理机制（GOPROXY）

默认值（Go 1.13+）：

修改为国内代理（推荐）：

🧭 六、依赖解析机制

🧪 七、Go Modules 开发中的常见场景

✅ 本地模块引用：

✅ 指定 Git commit：

✅ 忽略模块校验：

🧠 总结

模块代理机制

🧱 一、模块代理机制简介

🔗 什么是模块代理（Go Proxy）？

🌐 二、模块代理的工作流程

📦 三、Go Proxy 下载的三类文件

⚙️ 四、环境变量控制模块代理行为

✏️ 示例：配置中国用户常用的代理

🔒 五、私有模块处理（配合 GOPRIVATE）

🔧 六、开发中常见的代理配置方式

配置为全局代理 + fallback：

忽略某些模块的校验（如私有）：

🛠️ 七、如何搭建自己的 Go Proxy（高级）

🧠 总结

GOPRIVATE 详解

🧱 一、GOPRIVATE 的作用详解

✏️ 二、如何使用 GOPRIVATE

示例一：声明一个私有仓库前缀

示例二：支持多个私有路径（用逗号 , 分隔）

示例三：搭配 Go Proxy 一起使用（推荐）

🔍 三、GOPRIVATE 会影响哪些行为？

🔐 四、与私有 Git 仓库联合使用

步骤 1：配置 GOPRIVATE

步骤 2：配置 Git 凭证访问（SSH 或 HTTP 认证）

🧠 五、常见误区和注意事项

✅ 六、总结：GOPRIVATE 设置规范

go get详细流程

一、总体流程概览（以 go get github.com/user/repo 为例）

二、当 Go 不使用 Proxy（GOPROXY=direct）时怎么找源码？

三、常见环境变量

示例：go get 真实流程（不使用代理）

go get子模块

总结

模块版本控制规范

模块版本兼容

3. `go.mod` 文件内容示例：

`go.mod`

`go.sum`

`replace` 示例：

🧱 一、`GOPRIVATE` 的作用详解

✏️ 二、如何使用 `GOPRIVATE`

示例二：支持多个私有路径（用逗号 `,` 分隔）

步骤 1：配置 `GOPRIVATE`

✅ 六、总结：`GOPRIVATE` 设置规范

一、总体流程概览（以 `go get github.com/user/repo` 为例）

`logrus` 的基本使用

1. 安装 `logrus`

场景一：对象被一个堆对象删除引用，成为栈对象的下游

场景二：对象被一个栈对象删除引用，成为另一个栈对象的下游