Golang HTTP中间件开发教程

如何在Golang中开发一个高效的HTTP中间件？最近在学习Golang的web开发，想了解中间件的具体实现方式和最佳实践。比如：

  1. 中间件的基本结构应该怎么设计？
  2. 如何实现链式调用多个中间件？
  3. 中间件中如何处理请求和响应？
  4. 有没有性能优化的技巧？
  5. 能否分享一些常见的应用场景和实际案例？

特别想知道gin框架和标准库net/http在中间件实现上的区别，以及如何编写可复用的中间件组件。

3 回复

开发Go语言的HTTP中间件非常简单。首先定义一个函数类型，接收http.Handler作为参数并返回一个新的http.Handler。以下是一个基本示例：

type Middleware func(http.Handler) http.Handler

func LoggingMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		log.Printf("Request: %s %s", r.Method, r.URL.Path)
		next.ServeHTTP(w, r)
	})
}

func MyHandler(w http.ResponseWriter, r *http.Request) {
	w.Write([]byte("Hello, world!"))
}

func main() {
	mux := http.NewServeMux()
	mux.HandleFunc("/", MyHandler)

	// 使用中间件
	middleware := LoggingMiddleware(mux)
	http.ListenAndServe(":8080", middleware)
}

上述代码中，LoggingMiddleware 是一个日志记录中间件，它会在每个请求处理前打印请求信息。你可以将多个中间件链式调用，形成更复杂的处理流程。记得按照“从外到内”的顺序组合中间件，确保它们按预期执行。

更多关于Golang HTTP中间件开发教程的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


开发Go语言的HTTP中间件非常简单。首先定义一个HandlerFunc类型，它接收一个http.Handler作为参数并返回一个新的http.Handler。

  1. 定义中间件：
func MyMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 在请求前执行的操作
        fmt.Println("请求开始")
        next.ServeHTTP(w, r)  // 调用下一个处理函数
        // 在响应后执行的操作
        fmt.Println("请求结束")
    })
}
  1. 使用中间件：
    将中间件应用到路由上：
func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("Hello World!"))
    })

    // 应用中间件
    handler := MyMiddleware(mux)
    http.ListenAndServe(":8080", handler)
}
  1. 链式中间件：
    支持多个中间件，只需逐层包装即可。例如：
func MiddlewareA(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Println("Middleware A")
        next.ServeHTTP(w, r)
    })
}

func MiddlewareB(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Println("Middleware B")
        next.ServeHTTP(w, r)
    })
}

func main() {
    mux := http.NewServeMux()
    handler := MyMiddleware(MiddlewareA(MiddlewareB(mux)))
    http.ListenAndServe(":8080", handler)
}

这样就实现了链式的中间件功能。

Golang HTTP中间件开发教程

HTTP中间件是一种非常有用的模式，它允许你在HTTP请求到达处理程序之前或之后执行一些逻辑。在Go中，中间件通常通过包装http.Handler来实现。

基本中间件结构

func middleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 请求前处理逻辑
        fmt.Println("Before handler")
        
        // 调用下一个处理程序
        next.ServeHTTP(w, r)
        
        // 请求后处理逻辑
        fmt.Println("After handler")
    })
}

常见中间件示例

1. 日志记录中间件

func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        
        next.ServeHTTP(w, r)
        
        log.Printf(
            "%s %s %s",
            r.Method,
            r.RequestURI,
            time.Since(start),
        )
    })
}

2. 认证中间件

func authMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        token := r.Header.Get("Authorization")
        if token != "valid-token" {
            http.Error(w, "Unauthorized", http.StatusUnauthorized)
            return
        }
        next.ServeHTTP(w, r)
    })
}

3. 跨域中间件

func corsMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Access-Control-Allow-Origin", "*")
        w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
        w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")
        
        if r.Method == "OPTIONS" {
            return
        }
        
        next.ServeHTTP(w, r)
    })
}

使用中间件

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("Hello, World!"))
    })
    
    // 应用中间件
    handler := corsMiddleware(loggingMiddleware(authMiddleware(mux)))
    
    http.ListenAndServe(":8080", handler)
}

中间件链

对于多个中间件，可以使用以下模式：

func applyMiddlewares(handler http.Handler, middlewares ...func(http.Handler) http.Handler) http.Handler {
    for i := len(middlewares) - 1; i >= 0; i-- {
        handler = middlewares[i](handler)
    }
    return handler
}

// 使用
handler := applyMiddlewares(mux, corsMiddleware, loggingMiddleware, authMiddleware)

中间件是Go web开发中非常强大的工具，合理使用可以大大提高代码的可维护性和复用性。

回到顶部