2. Handling HTTP Requests with Gin – Gin Routing

2.1 Gin Routing

    The routing in Gin is responsible for mapping incoming request paths to the corresponding handler functions. The handler function is the core part that processes the request and generates the response, typically defined as <span>func(c *gin.Context)</span>, where c provides access to the request and response interfaces. By coordinating routing and handler functions, Gin can efficiently handle HTTP requests, execute business logic, and return results.

2.1.1 Introduction to Routing

    Routing refers to guiding internet traffic from one place to another. It is crucial for determining how data is transmitted over the internet. Its characteristics are as follows:

• URL Mapping: In the context of web applications, routing typically involves mapping URLs to specific content or actions.

  When developers access a website, the server uses routing to determine which page or resource to serve based on the URL.

• Frameworks and Libraries: Many web frameworks and libraries have built-in routing capabilities, allowing developers to easily define routes and specify the behavior that should occur when users access those routes.
• HTTP Methods: Routing also involves different HTTP methods such as GET, POST, PUT, DELETE, etc., each with specific purposes.
• Dynamic Routing: Some routes are dynamic, meaning they can handle variable parts in the URL.

  For example, there is a route with a URL like /post/:id, where :id is a variable part that needs to be replaced with a specific ID at runtime.

    The following code serves as an example for analysis:

package main

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

func hello(c *gin.Context) {
 c.JSON(200, gin.H{
"message": "Hello world",
 })
}

func main() {

 r := gin.Default()
 r.GET("/hello", hello)
// Default listening on 0.0.0.0:8080
 r.Run()
}

    In the above code, the <span>r.GET()</span> method shows that the corresponding HTTP method is GET, and the path <span>/hello</span> defines the route. When a client sends a GET request to hello, Gin will call the provided function <span>hello</span>, which returns <span>"message": "Hello world"</span> as the response.

2.1.2 Route Parameters

    Gin supports route parameters in dynamic URLs, for example, by defining a <span>:id</span> parameter to match different IDs. For instance, <span>/user/123</span> and <span>/user/456</span>, the example code is as follows:

r.GET("/user/:id", func(ctx *gin.Context) {
  id := ctx.Param("id")
  ctx.String(http.StatusOK, "UserID is %s", id)
 })

The above code will return the corresponding ID information based on the requested id parameter.

2.1.3 Route Groups

    Gin provides the <span>Group()</span> method, which allows multiple routes to be grouped together, sharing common prefixes, middleware, or other configurations. For example, a route group with the <span>/api/v1</span> prefix.

apiGroup := r.Group("/api/v1")
{
    apiGroup.GET("/user", func(ctx *gin.Context) {
        log.Printf("%v %v", ctx.Request.Method, ctx.Request.URL)
    })

    apiGroup.POST("/user/", func(ctx *gin.Context) {
        log.Printf("%v %v", ctx.Request.Method, ctx.Request.URL)
    })

    apiGroup.PUT("/user/:id", func(ctx *gin.Context) {
        log.Printf("%v %v", ctx.Request.Method, ctx.Request.URL)
    })

    apiGroup.DELETE("/user/:Id", func(ctx *gin.Context) {
        log.Printf("%v %v", ctx.Request.Method, ctx.Request.URL)
    })
}

In this way, all routes under the <span>/api/v1</span> path can share the same prefix and configuration.

2.1.4 Custom Route Matching

    Using the <span>Handler()</span> method, custom routing matching rules can be defined. For example, to create a custom route that matches all URLs ending with .json.

r.Handle("GET", "/filepath", func(ctx *gin.Context) {
    if strings.HasSuffix(ctx.Param("filepath"), ".json") {
        ctx.String(http.StatusOK, "JSON Files Request：%s", ctx.Param("filepath"))
    } else {
        ctx.String(http.StatusNotFound, "File Not Found")
    }
})