Go语言中间件如何优雅地处理多个业务共用同一复杂逻辑？

在Go语言中，中间件（Middleware）是一种常见的模式，用于在处理HTTP请求时执行一些通用的逻辑，如身份验证、日志记录、错误处理等。当多个业务需要共用同一复杂逻辑时，可以通过中间件来优雅地处理这些共享逻辑。以下是一些实现这一目标的策略：

1. 使用函数式中间件

Go语言的中间件通常是一个函数，它接收一个http.Handler并返回一个新的http.Handler。通过这种方式，你可以在多个路由中复用同一个中间件。

package main

import (
    "fmt"
    "net/http"
)

// 复杂的共享逻辑
func complexLogicMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 在这里执行复杂的逻辑
        fmt.Println("Executing complex logic...")

        // 调用下一个处理器
        next.ServeHTTP(w, r)
    })
}

func main() {
    mux := http.NewServeMux()

    // 业务处理函数
    handler1 := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "Handling request for /route1")
    })

    handler2 := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "Handling request for /route2")
    })

    // 应用中间件
    mux.Handle("/route1", complexLogicMiddleware(handler1))
    mux.Handle("/route2", complexLogicMiddleware(handler2))

    http.ListenAndServe(":8080", mux)
}

2. 使用闭包传递参数

如果中间件需要根据不同的业务逻辑进行一些定制，可以使用闭包来传递参数。

package main

import (
    "fmt"
    "net/http"
)

// 复杂的共享逻辑，带参数
func complexLogicMiddleware(param string) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            // 在这里执行复杂的逻辑，使用传递的参数
            fmt.Printf("Executing complex logic with param: %s\n", param)

            // 调用下一个处理器
            next.ServeHTTP(w, r)
        })
    }
}

func main() {
    mux := http.NewServeMux()

    // 业务处理函数
    handler1 := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "Handling request for /route1")
    })

    handler2 := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "Handling request for /route2")
    })

    // 应用中间件，传递不同的参数
    mux.Handle("/route1", complexLogicMiddleware("param1")(handler1))
    mux.Handle("/route2", complexLogicMiddleware("param2")(handler2))

    http.ListenAndServe(":8080", mux)
}

3. 使用结构体和方法

如果中间件的逻辑非常复杂，或者需要维护一些状态，可以使用结构体和方法来实现中间件。

package main

import (
    "fmt"
    "net/http"
)

// 中间件结构体
type ComplexLogicMiddleware struct {
    Param string
}

// 中间件方法
func (m *ComplexLogicMiddleware) Middleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 在这里执行复杂的逻辑，使用结构体的字段
        fmt.Printf("Executing complex logic with param: %s\n", m.Param)

        // 调用下一个处理器
        next.ServeHTTP(w, r)
    })
}

func main() {
    mux := http.NewServeMux()

    // 业务处理函数
    handler1 := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "Handling request for /route1")
    })

    handler2 := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "Handling request for /route2")
    })

    // 创建中间件实例
    middleware1 := &ComplexLogicMiddleware{Param: "param1"}
    middleware2 := &ComplexLogicMiddleware{Param: "param2"}

    // 应用中间件
    mux.Handle("/route1", middleware1.Middleware(handler1))
    mux.Handle("/route2", middleware2.Middleware(handler2))

    http.ListenAndServe(":8080", mux)
}

4. 使用第三方库

如果你使用的是像Gin、Echo这样的Web框架，它们通常提供了更高级的中间件支持。你可以直接使用这些框架提供的中间件机制来复用复杂的逻辑。

例如，使用Gin框架：

package main

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

// 复杂的共享逻辑
func complexLogicMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        // 在这里执行复杂的逻辑
        fmt.Println("Executing complex logic...")

        // 继续处理请求
        c.Next()
    }
}

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

    // 应用中间件
    r.Use(complexLogicMiddleware())

    // 业务处理函数
    r.GET("/route1", func(c *gin.Context) {
        c.String(200, "Handling request for /route1")
    })

    r.GET("/route2", func(c *gin.Context) {
        c.String(200, "Handling request for /route2")
    })

    r.Run(":8080")
}

总结

通过使用函数式中间件、闭包传递参数、结构体和方法，或者借助第三方库，你可以优雅地在Go语言中处理多个业务共用同一复杂逻辑的问题。选择哪种方式取决于你的具体需求和项目的复杂度。