How to set data in gin request context?

In the Go language's Gin framework, gin.Context is used to handle all request-related information, including data exchange between middleware and handler functions. The gin.Context type provides multiple methods for setting and retrieving data, with Set and Get being the primary methods.

How to Use the Set Method to Set Data

The Set method is used to store a key-value pair in the current request context. This data remains valid throughout the request lifecycle and is accessible to subsequent middleware or handler functions.

Example:

Suppose we need to add user-related information during the processing of a user request, such as the user's role, to allow subsequent handler functions to apply different business logic based on this information.

go
func MiddlewareSetUserRole(c *gin.Context) {
    // Assume we obtain the user ID in some way
    userID := c.Param("userID")

    // Assume we know the user's role is "admin" for simplicity
    userRole := "admin"

    // Set the user role in the request context
    c.Set("userRole", userRole)

    // Continue processing the request
    c.Next()
}

func main() {
    r := gin.Default()
    r.Use(MiddlewareSetUserRole)
    r.GET("/user/:userID", func(c *gin.Context) {
        // Retrieve the user role from the context
        if role, exists := c.Get("userRole"); exists {
            c.JSON(200, gin.H{"userRole": role})
        } else {
            c.JSON(404, gin.H{"error": "user role not found"})
        }
    })
    r.Run()
}

In this example, the MiddlewareSetUserRole middleware first retrieves the userID from the request parameters, then assumes the user's role is "admin", and uses the Set method to store this role information in the request context. In the main handler function, we retrieve this information using the Get method and use it to construct the response.

Summary

Using the Set method of gin.Context to set data in the request context is an effective way to share data between middleware and handler functions. This approach is particularly useful for storing information such as user authentication details or request-specific metadata, which is crucial for building middleware functionality.