Chapter 6: Advanced Routing and URL Parameters in Gin

In this chapter, we delve into advanced routing and URL parameters using the Gin framework. We’ll cover how to create and use route groups, apply middleware, extract path parameters, work with query strings, handle static files, and use HTML templates.

Route Groups

Creating and Using Route Groups

Route groups allow you to organize your routes and apply common middleware. This can be particularly useful for grouping routes that share a common path prefix or require the same middleware.

Why Use Route Groups?

Using route groups helps in maintaining a clean and organized code structure. It becomes easier to manage and scale the application when routes are grouped logically. For example, you might have a set of routes related to user management and another set related to product management.

Example: Creating Route Groups

In this example, we create a group for API routes:

package main

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

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

    // Group: /api
    api := r.Group("/api")
    {
        api.GET("/users", getUsers)
        api.GET("/products", getProducts)
    }

    r.Run() // listen and serve on 0.0.0.0:8080
}

func getUsers(c *gin.Context) {
    c.JSON(200, gin.H{
        "message": "Fetching all users",
    })
}

func getProducts(c *gin.Context) {
    c.JSON(200, gin.H{
        "message": "Fetching all products",
    })
}

In this example, /api/users and /api/products are grouped under the /api path.

Applying Middleware to Route Groups

Middleware functions are essential for handling tasks such as authentication, logging, and more. By applying middleware to route groups, you ensure that all routes within the group are processed by the middleware.

Example: Applying Middleware

In this example, we apply an authentication middleware to an admin route group:

package main

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

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

    // Group: /admin
    admin := r.Group("/admin")
    admin.Use(AuthMiddleware())
    {
        admin.GET("/dashboard", adminDashboard)
        admin.GET("/settings", adminSettings)
    }

    r.Run()
}

func AuthMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        // Authentication logic
        if c.Request.Header.Get("Authorization") != "Bearer token" {
            c.AbortWithStatus(401)
            return
        }
        c.Next()
    }
}

func adminDashboard(c *gin.Context) {
    c.JSON(200, gin.H{
        "message": "Admin Dashboard",
    })
}

func adminSettings(c *gin.Context) {
    c.JSON(200, gin.H{
        "message": "Admin Settings",
    })
}

In this example, the AuthMiddleware function checks for an authorization token. If the token is not present or incorrect, the request is aborted with a 401 status.

Path Parameters and Query Strings

Extracting Path Parameters

Path parameters allow you to pass data within the URL, making your routes more dynamic. You can extract these parameters using the c.Param method in Gin.

Example: Extracting Path Parameters

package main

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

func main() {
    r := gin.Default()
    r.GET("/user/:id", getUser)
    r.Run()
}

func getUser(c *gin.Context) {
    userID := c.Param("id")
    c.JSON(200, gin.H{
        "user_id": userID,
    })
}

In this example, when a request is made to /user/123, the userID variable will be 123.

Working with Query Strings

Query strings are another way to pass data in the URL. They are commonly used for filtering, sorting, and pagination. You can retrieve query string parameters using the c.Query method.

Example: Working with Query Strings

package main

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

func main() {
    r := gin.Default()
    r.GET("/search", search)
    r.Run()
}

func search(c *gin.Context) {
    query := c.Query("q")
    c.JSON(200, gin.H{
        "query": query,
    })
}

In this example, when a request is made to /search?q=golang, the query variable will be golang.

Handling Static Files and Templates

Serving Static Files

Serving static files, such as images, CSS, and JavaScript files, is straightforward with Gin. Use the r.Static method to serve a directory of static files.

Example: Serving Static Files

package main

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

func main() {
    r := gin.Default()
    r.Static("/assets", "./assets")
    r.Run()
}

In this example, any request to /assets will serve files from the ./assets directory. For instance, a request to /assets/style.css will serve the style.css file from the ./assets directory.

Using HTML Templates with Gin

Gin supports rendering HTML templates using the HTML method. First, load your templates using LoadHTMLGlob or LoadHTMLFiles.

Example: Using HTML Templates

package main

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

func main() {
    r := gin.Default()
    r.LoadHTMLGlob("templates/*")
    
    r.GET("/index", func(c *gin.Context) {
        c.HTML(200, "index.tmpl", gin.H{
            "title": "Main website",
        })
    })
    
    r.Run()
}

Create an index.tmpl file in the templates directory:

<!DOCTYPE html>
<html>
<head>
    <title>{{ .title }}</title>
</head>
<body>
    <h1>{{ .title }}</h1>
</body>
</html>

In this example, a request to /index will render the index.tmpl template with the title “Main website”.

By following the examples in this article, you should be able to effectively utilize advanced routing and URL parameters in your Gin applications. Happy coding!