如何在Go Echo框架单入口整合两个处理器的响应数据？

针对你遇到的问题——需要合并中间件和处理器（或两个API）的响应数据，以下是两种可行的解决方案：

方案一：通过上下文临时存储数据（推荐） #

这种方式无需拦截响应，直接在中间件和处理器中分别获取各自的API数据，通过上下文传递后合并输出，逻辑更直观且性能更好。

修改后的代码 #

type RespObject struct {
    Message string `json:"message"`
}

// 自定义上下文键，避免键名冲突
type middlewareDataKey struct{}

func main() {
    e := echo.New()
    e.GET("/hello", handler, middle)
    e.Logger.Fatal(e.Start(":3000"))
}

func middle(next echo.HandlerFunc) echo.HandlerFunc {
    return func(c echo.Context) error {
        // 模拟调用第一个SCIM API获取数据
        middleResp := RespObject{Message: "World"}
        // 将数据存入上下文
        c.Set(middlewareDataKey{}, middleResp)
        // 执行后续处理器逻辑
        return next(c)
    }
}

func handler(c echo.Context) error {
    // 模拟调用第二个SCIM API获取数据
    handlerResp := RespObject{Message: "Hello"}
    // 从上下文取出中间件返回的数据
    middleResp := c.Get(middlewareDataKey{}).(RespObject)
    // 合并两个响应
    mergedResp := RespObject{
        Message: handlerResp.Message + " " + middleResp.Message,
    }
    // 统一输出合并后的结果
    return c.JSON(http.StatusOK, mergedResp)
}

方案二：拦截响应并合并（适配无法修改处理器的场景） #

如果无法修改原有处理器的输出逻辑，可以通过自定义ResponseWriter缓冲所有输出，解析后合并再发送给客户端。同时Echo的Response结构体提供了Reset方法，可以清空已有响应数据。

第一步：定义自定义ResponseRecorder #

import (
    "bytes"
    "net/http"
    "github.com/labstack/echo/v4"
)

type ResponseRecorder struct {
    echo.ResponseWriter
    body   *bytes.Buffer
    status int
}

func NewResponseRecorder(w echo.ResponseWriter) *ResponseRecorder {
    return &ResponseRecorder{
        ResponseWriter: w,
        body:           bytes.NewBuffer(nil),
        status:         http.StatusOK,
    }
}

func (r *ResponseRecorder) Write(b []byte) (int, error) {
    // 将响应内容写入缓冲，而非直接发送给客户端
    return r.body.Write(b)
}

func (r *ResponseRecorder) WriteHeader(code int) {
    r.status = code
}

func (r *ResponseRecorder) Body() []byte {
    return r.body.Bytes()
}

func (r *ResponseRecorder) Status() int {
    return r.status
}

第二步：修改中间件实现拦截合并 #

import "encoding/json"

func middle(next echo.HandlerFunc) echo.HandlerFunc {
    return func(c echo.Context) error {
        // 替换原有ResponseWriter为自定义缓冲实例
        recorder := NewResponseRecorder(c.Response())
        c.Response().Writer = recorder

        // 执行处理器，此时处理器的输出会被缓冲
        if err := next(c); err != nil {
            return err
        }

        // 解析处理器的响应内容
        var handlerResp RespObject
        if err := json.Unmarshal(recorder.Body(), &handlerResp); err != nil {
            return err
        }

        // 模拟中间件调用SCIM API获取的数据
        middleResp := RespObject{Message: "World"}

        // 合并响应
        mergedResp := RespObject{
            Message: handlerResp.Message + " " + middleResp.Message,
        }

        // 重置原有响应，清空已写入的内容
        c.Response().Reset(recorder.ResponseWriter)
        // 写入合并后的最终响应
        return c.JSON(recorder.Status(), mergedResp)
    }
}

// 保持原有handler不变
func handler(c echo.Context) error {
    return c.JSON(http.StatusOK, RespObject{
        Message: "Hello",
    })
}

关于ResponseWriter的修改问题 #

Echo的Response结构体实现了http.ResponseWriter，并且提供了Reset(w http.ResponseWriter)方法，可以重置响应的状态码、头部和body内容，从而允许你擦除已有数据并重新写入新的响应。配合自定义缓冲的ResponseWriter，就能实现拦截、合并响应的需求。

内容的提问来源于stack exchange，提问作者DeYuro