leaf golang routing implementation

With the popularity of Go language in web development, more and more developers are trying to use Go language to develop web applications. In the development of web applications, the implementation of routing is a very important part. Today, we will introduce a routing framework based on Go language – leaf.

1. What is Leaf?

Leaf is a lightweight Go language routing library that is flexible, easy to use, and efficient. Leaf can not only be used for HTTP services, but also for routing implementation of various network protocols such as WebSocket and FTP.

Leaf can support RESTful style API implementation, and provides middleware functions to support the development and use of custom middleware. In addition, Leaf also supports customized processing of HTTP request and response data, which can cope with various special business needs.

Leaf’s source code is hosted on GitHub and is open source under the MIT license, which is free to use, modify and distribute.

2. Leaf’s routing implementation

The routing implementation in Leaf is very simple. You only need to create a routing object and then add routing rules. The following is a simple example:

package main

import (
    "fmt"
    "github.com/vardius/leaf"
)

func main() {
    r := leaf.NewRouter()
    r.GET("/", func(c *leaf.Context) {
        fmt.Fprintln(c.Writer, "Hello, Leaf!")
    })

    r.Run(":8080")
}

In the above code, we created a routing object through the NewRouter function and added a GET request routing rule to the routing object. The requested path is specified in the rule as the root path /. When a GET request accesses the server, the anonymous function corresponding to the routing rule will be executed. The matching method of routing rules uses a prefix matching algorithm, so we can cover different request paths by defining multiple rules.

In Leaf, routing rules support parameter passing. You can use :param to define a parameter, as shown below:

r.GET("/user/:id", func(c *leaf.Context) {
    id := c.Params["id"]
    fmt.Fprintf(c.Writer, "User ID: %s", id)
})

In this example, we define a routing rule for a GET request, using the parameter :id. When there is a GET request to access /user/123, Leaf will automatically match the routing rule and pass the parameter 123 to the id variable in the anonymous function. We can get the parameter values ​​passed to the routing rules through c.Params.

Leaf also supports handling routing groups. A routing group is a group of routing rules with the same prefix, which can be implemented through the Group function. The following is an example:

r.Group("/api/v1", func() {
    r.GET("/user/:id", func(c *leaf.Context) {
        id := c.Params["id"]
        fmt.Fprintf(c.Writer, "User ID: %s", id)
    })
    r.POST("/user", func(c *leaf.Context) {
        fmt.Fprintln(c.Writer, "Create User")
    })
    r.PUT("/user/:id", func(c *leaf.Context) {
        id := c.Params["id"]
        fmt.Fprintf(c.Writer, "Update User: %s", id)
    })
    r.DELETE("/user/:id", func(c *leaf.Context) {
        id := c.Params["id"]
        fmt.Fprintf(c.Writer, "Delete User: %s", id)
    })
})

In the above example, we use the Group function to create a routing group that contains all routes starting with /api/v1## The request path starting with #. Within the routing group, we define some routing rules for HTTP requests, including parameter passing, GET, POST, PUT and DELETE requests.

3. Leaf’s middleware support

Leaf also supports the development and use of middleware. In Leaf, middleware is a piece of program code that handles requests and responses. Middleware can perform various processing on requests and responses, such as adding request headers, verifying authentication information, processing request parameters and response results, etc. Leaf adds middleware through the

Use method, for example:

r.Use(func(c *leaf.Context) {
    // do something before request
    c.Next() // 执行下一个中间件或匿名函数
    // do something after request
})

In this example, we define a middleware, and the code in the function body will be executed before the request is matched by the routing rules. In middleware, we can execute the next middleware or anonymous function in routing rules by calling

c.Next(). After executing the anonymous function, it will return to the current middleware to execute subsequent code.

Of course, Leaf also supports chain calling of multiple middlewares. You can add multiple middlewares through the

AppendMiddleware method, for example:

r.AppendMiddleware(A)
r.AppendMiddleware(B)
r.AppendMiddleware(C)

In the above example, we pass

AppendMiddleware The method adds three middlewares A, B, and C in sequence. As requests come in, they will be executed sequentially.

4. Leaf’s MVC pattern support

Leaf also provides development support based on the MVC pattern. In Leaf, we can define a controller through

Controller, and multiple processing methods can be defined in the controller. The controller can implement any business logic, and Leaf automatically matches the methods in the controller through routing rules and executes them. The following is a simple example:

type UserController struct {
    leaf.Controller
}

func (c *UserController) GetUser() {
    id := c.Params["id"]
    fmt.Fprintf(c.Writer, "User ID: %s", id)
}

func (c *UserController) CreateUser() {
    fmt.Fprintln(c.Writer, "Create User")
}

func (c *UserController) UpdateUser() {
    id := c.Params["id"]
    fmt.Fprintf(c.Writer, "Update User: %s", id)
}

func (c *UserController) DeleteUser() {
    id := c.Params["id"]
    fmt.Fprintf(c.Writer, "Delete User: %s", id)
}

func main() {
    r := leaf.NewRouter()
    userController := &UserController{}
    r.Group("/api/v1", func() {
        r.GET("/user/:id", userController.GetUser)
        r.POST("/user", userController.CreateUser)
        r.PUT("/user/:id", userController.UpdateUser)
        r.DELETE("/user/:id", userController.DeleteUser)
    })
    r.Run(":8080")
}

In this example, we define a

UserController controller and implement GetUser, CreateUser in it The four methods , UpdateUser and DeleteUser are used to handle GET, POST, PUT and DELETE requests respectively. In the routing group, we map these methods to the corresponding requests and specify the prefix of the routing rule as /api/v1.

5. Leaf’s HTTP request and response processing

In Leaf, we can process HTTP request and response data according to business needs. Leaf provides a wealth of methods to process request and response data, such as:

c.SetHeader(key, value) // 设置响应头
c.GetHeader(key) // 获取请求头
c.SetCookie(cookie) // 设置 Cookie
c.GetCookie(name) // 获取 Cookie
c.SetStatusCode(code int) // 设置响应状态码
c.WriteJSON(v interface{}) // 响应 JSON 数据
c.WriteFile(file string) // 响应文件
c.String(code int, s string) // 响应字符串

Through these methods, we can easily process request and response data.

6. Summary

Leaf is a very excellent Go language routing library. It is not only lightweight, efficient, and easy to use, but also provides a variety of functions such as middleware, MVC mode, and HTTP request and response processing. It can Meet our various needs for developing web applications. If you are looking for an excellent routing implementation in Go, Leaf is definitely worth a try.

The above is the detailed content of leaf golang routing implementation. For more information, please follow other related articles on the PHP Chinese website!