In Go language, HTTP middleware is implemented through functions, and its core answer is: the middleware is a function that receives and returns http.Handler, which is used to execute general logic before and after request processing. 1. The middleware function signature is like func(Middleware(next http.Handler) http.Handler), which achieves functional extension by wrapping the original processor; 2. The log middleware in the example records the request method, path, client address and processing time-consuming, which is convenient for monitoring and debugging; 3. The authentication middleware checks the Authorization header, and returns 401 or 403 errors when verification fails to ensure secure access; 4. Multiple middleware can be used in combination through nested calls, and the execution order is from outside to inside and from inside to outside, so the order is crucial; 5. A more elegant middleware chain combination can be achieved by defining Middleware types and chainMiddleware functions; 6. Common application scenarios include logging, authentication authorization, timeout control, cross-domain support (CORS), current limiting and panic Recovery, etc.; 7. All functions can be implemented based on net/http native packages, without relying on third-party frameworks, and are highly maintainable and scalable. Go's middleware pattern is simple, flexible and highly combinable, suitable for building clear-structured Web services.

In Go, HTTP middleware is a very common and powerful pattern for executing some common logic before or after the request reaches the processing function, such as logging, authentication, timeout control, cross-domain support, etc.

The following is a clear example of how to write and use HTTP middleware.

? What is HTTP middleware?

The middleware is essentially a function that receives an http.Handler and returns a new http.Handler . It can preprocess the request, call the next processor, and execute post-processing logic afterwards.

Function signatures are usually as follows:

 func Middleware(next http.Handler) http.Handler

? Example: Log Middleware

This middleware records the method, URL and processing time of each request.

 package main

import (
    "log"
    "net/http"
    "time"
)

// Log middleware func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()

        // Print request information log.Printf("Started %s %s from %s", r.Method, r.URL.Path, r.RemoteAddr)

        // Call next.ServeHTTP(w, r)

        // Printing time after the request processing is completed log.Printf("Completed %s in %v", r.URL.Path, time.Since(start))
    })
}

? Example: Authentication Middleware

This middleware checks whether there is a valid Authorization in the request header.

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

        // More complex verification logic (such as JWT) can be added here
        if token != "Bearer mysecret" {
            http.Error(w, "Invalid token", http.StatusForbidden)
            Return
        }

        // Verification is passed, call the next processor next.ServeHTTP(w, r)
    })
}

?? Use middleware to combine multiple functions

Go's http.Handler combination method is very flexible. You can "wrap" multiple middleware on the outer layer of the final processor.

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

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

    // Combination middleware: log first, then authenticate, and finally route handler:= loggingMiddleware(authMiddleware(mux))

    log.Println("Server starting on :8080...")
    http.ListenAndServe(":8080", handler)
}

Request process:
Request → loggingMiddleware → authMiddleware → mux → helloHandler → 返回

? The order of middleware is very important!

The execution order of middleware is to enter from outside to inside and return from inside to outside :

 // For example:
final := A(B(C(handler)))

Execution order:

• Enter: A → B → C
• Processing: handler
• Return: C → B → A

So the order will affect behavior. For example, log middleware is usually placed at the outermost layer to make the complete recording time-consuming.

? More elegant writing: middleware toolkit

You can define a type to facilitate combining middleware:

 type Middleware func(http.Handler) http.Handler

func chainMiddleware(mw ...Middleware) Middleware {
    return func(final http.Handler) http.Handler {
        result := final
        for i := len(mw) - 1; i >= 0; i-- {
            result = mw[i](result)
        }
        return result
    }
}

How to use:

 middlewareChain := chainMiddleware(loggingMiddleware, authMiddleware)
http.ListenAndServe(":8080", middlewareChain(mux))

? Summary of the key points

• Middleware is a function of type func(http.Handler) http.Handler .
• Use http.HandlerFunc to wrap it easily.
• Middleware can be combined, and the order affects the execution process.
• Common uses: logging, authentication, current limiting, CORS, Panic recovery, etc.
• It does not rely on third-party frameworks, and can be implemented in native net/http .

Basically that's it. Go's middleware pattern is simple, clear and comboable, making it ideal for building maintainable web services.

The above is the detailed content of go by example http middleware. For more information, please follow other related articles on the PHP Chinese website!