Golang请求响应拦截与处理插件库mediary的使用

mediary是一个轻量级的Golang中间件库，专门用于HTTP请求和响应的拦截与处理。它提供了一种简单的方式来在HTTP客户端请求前后添加处理逻辑，类似于中间件模式。

基本概念

mediary的核心思想是允许你在HTTP请求发出前和收到响应后插入自定义处理逻辑，这些逻辑被称为"中间件"。每个中间件都可以修改请求或响应，或者执行其他操作如日志记录、认证等。

安装

go get github.com/HereMobilityDevelopers/mediary

基本用法

1. 创建带有中间件的HTTP客户端

package main

import (
	"fmt"
	"net/http"
	"log"

	"github.com/HereMobilityDevelopers/mediary"
)

func main() {
	// 创建带有中间件的客户端
	client := mediary.Init().WithDefaultClient()

	// 添加请求前中间件
	client.AddRequestInterceptors(func(req *http.Request) error {
		fmt.Println("请求URL:", req.URL)
		req.Header.Add("X-Custom-Header", "my-value")
		return nil
	})

	// 添加响应后中间件
	client.AddResponseInterceptors(func(resp *http.Response, err error) error {
		if err != nil {
			fmt.Println("请求出错:", err)
			return err
		}
		fmt.Println("响应状态码:", resp.StatusCode)
		return nil
	})

	// 使用客户端发送请求
	resp, err := client.Get("https://httpbin.org/get")
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()

	fmt.Println("最终响应状态:", resp.Status)
}

2. 链式调用

mediary支持链式调用，使代码更简洁：

client := mediary.Init().
	WithDefaultClient().
	AddRequestInterceptors(logRequest).
	AddResponseInterceptors(logResponse)

高级用法

1. 自定义HTTP客户端

client := mediary.Init().
	WithClient(&http.Client{
		Timeout: 30 * time.Second,
	}).
	AddRequestInterceptors(authMiddleware)

2. 多个中间件

可以添加多个中间件，它们会按照添加顺序执行：

client := mediary.Init().
	WithDefaultClient().
	AddRequestInterceptors(logRequest).
	AddRequestInterceptors(addAuthHeader).
	AddResponseInterceptors(logResponse).
	AddResponseInterceptors(checkStatusCode)

3. 错误处理

中间件可以返回错误，如果请求前中间件返回错误，请求将不会发送；如果响应后中间件返回错误，会传递给调用者：

client.AddRequestInterceptors(func(req *http.Request) error {
	if req.URL.Host == "blocked.com" {
		return fmt.Errorf("访问被阻止的域名")
	}
	return nil
})

实际应用示例

1. 认证中间件

func authMiddleware(req *http.Request) error {
	token := getAuthToken() // 实现获取token的逻辑
	req.Header.Set("Authorization", "Bearer "+token)
	return nil
}

client := mediary.Init().
	WithDefaultClient().
	AddRequestInterceptors(authMiddleware)

2. 日志中间件

func logRequest(req *http.Request) error {
	log.Printf("请求: %s %s", req.Method, req.URL)
	return nil
}

func logResponse(resp *http.Response, err error) error {
	if err != nil {
		log.Printf("请求错误: %v", err)
		return err
	}
	log.Printf("响应: %s %s - %d", resp.Request.Method, resp.Request.URL, resp.StatusCode)
	return nil
}

client := mediary.Init().
	WithDefaultClient().
	AddRequestInterceptors(logRequest).
	AddResponseInterceptors(logResponse)

3. 重试中间件

func retryMiddleware(resp *http.Response, err error) error {
	if err != nil || resp.StatusCode >= 500 {
		// 实现重试逻辑
		return fmt.Errorf("需要重试")
	}
	return nil
}

client := mediary.Init().
	WithDefaultClient().
	AddResponseInterceptors(retryMiddleware)

注意事项

1. 中间件的执行顺序很重要，先添加的中间件会先执行
2. 请求前中间件可以修改请求，响应后中间件可以修改响应
3. 如果中间件返回错误，处理链会中断
4. 对于复杂的中间件链，考虑将中间件拆分为单独的函数以提高可读性

mediary是一个轻量但功能强大的库，特别适合需要对HTTP请求和响应进行统一处理的场景，如API客户端库的开发。通过中间件模式，你可以将横切关注点（如认证、日志、错误处理等）与业务逻辑分离，使代码更加清晰和可维护。