Mastering interceptors in Golang

Interceptors allow the insertion of custom logic into Go applications without modifying existing code. They can be used for authentication, logging, error handling, performance monitoring, etc. Creating an interceptor requires implementing the Handler interface, which defines the ServeHTTP() method for handling HTTP requests and the Next() method for passing control. Practical examples show how to use logging interceptors to log the URL paths of all incoming requests, and how to chain multiple interceptors (such as authentication interceptors) together to create complex application logic.

Managing interceptors in Golang

Introduction

Interceptor is a A powerful and flexible mechanism that allows us to embed custom logic in Golang applications without having to modify existing code. They can be used for a variety of purposes, including authentication, logging, error handling, and performance monitoring.

Create an interceptor

To create an interceptor, we need to implement the Handler interface. This interface defines two methods:

• ServeHTTP(ResponseWriter, *Request): Process HTTP requests and generate responses.
• Next(ResponseWriter, *Request): Pass control to the next handler or interceptor.

The following is an example of creating an interceptor:

package main

import (
    "fmt"
    "net/http"
)

func main() {
    // 创建一个简单的日志拦截器
    logger := func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            fmt.Printf("收到请求：%s\n", r.URL.Path)
            next.ServeHTTP(w, r)
        })
    }

    // 创建一个 HTTP 路由器并使用拦截器
    mux := http.NewServeMux()
    mux.Handle("/", logger(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Hello, world!")
    })))

    // 启动 HTTP 服务器
    http.ListenAndServe(":8080", mux)
}

Practical case

In this example, we created a simple Log interceptor, which is responsible for printing the URL path of all incoming requests to the console.

Using multiple interceptors

We can chain multiple interceptors together to create complex application logic. For example, we can create an authentication interceptor that is responsible for ensuring that only authenticated users can access certain endpoints:

// 身份验证拦截器
func auth(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 检查请求头中是否存在身份验证令牌
        if r.Header.Get("Authorization") == "" {
            http.Error(w, "未经授权", http.StatusUnauthorized)
            return
        }

        next.ServeHTTP(w, r)
    })
}

We can add this interceptor to our router as follows:

mux.Handle("/private", auth(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    // 私有区域的逻辑
})))

The above is the detailed content of Mastering interceptors in Golang. For more information, please follow other related articles on the PHP Chinese website!