很高兴看到你在探索Echo v4的ModifyResponse钩子的高效用法！用ioutil.ReadAll()确实会把整个响应加载到内存里，对于大响应来说很不友好，而流式处理才是更优的方案。下面我给你一套高效、低内存占用的实现思路和代码：

核心思路 #

要实现流式的内容替换，关键是自定义一个io.Reader包装原始响应的Body，在每次读取数据片段时，实时扫描并替换目标字符串，同时处理目标字符串被拆分在两次读取片段中的情况（比如第一次读取到class='bl，第二次读取到ue'）——这就需要一个小缓存来暂存可能的尾部内容，避免漏匹配。

具体实现 #

1. 定义自定义替换Reader #

这个结构体负责包装原始Reader、保存目标字符串/替换内容，以及缓存可能的跨段匹配内容：

import (
    "io"
    "bytes"
    "io/ioutil"
)

type replaceReader struct {
    src         io.Reader
    target      []byte
    replacement []byte
    buf         []byte // 缓存上次读取后剩下的、可能和下次内容拼接成目标字符串的部分
}

2. 实现io.Reader的Read方法（核心逻辑） #

这部分是流式处理的关键，每次读取数据时完成实时替换，并维护缓存：

func (r *replaceReader) Read(p []byte) (n int, err error) {
    // 先读取原始数据到p的剩余空间（留位置给缓存的内容）
    readN, err := r.src.Read(p[len(r.buf):])
    totalLen := len(r.buf) + readN

    if totalLen > 0 {
        // 将缓存内容和新读取的内容合并到p的前totalLen位
        copy(p, r.buf)
        // 处理替换，并返回处理后的有效长度、需要缓存的尾部内容
        processedLen, remaining := replaceInBytes(p[:totalLen], r.target, r.replacement)
        
        n = processedLen
        // 更新缓存：保存可能跨段的尾部（长度最多为目标字符串长度-1）
        r.buf = make([]byte, len(remaining))
        copy(r.buf, remaining)
    }

    // 处理EOF时剩余的缓存内容
    if err == io.EOF && len(r.buf) > 0 {
        processedBytes, _ := replaceInBytes(r.buf, r.target, r.replacement)
        copy(p[n:], processedBytes)
        n += len(processedBytes)
        r.buf = nil
        err = io.EOF
    }

    return
}

// 辅助函数：在字节片段中替换目标字符串，返回处理后的长度和需要缓存的尾部
func replaceInBytes(data []byte, target, replacement []byte) ([]byte, []byte) {
    targetLen := len(target)
    if targetLen == 0 {
        return data, nil
    }

    var result []byte
    currentPos := 0

    // 循环查找所有匹配的目标字符串
    for {
        matchIdx := bytes.Index(data[currentPos:], target)
        if matchIdx == -1 {
            break
        }
        // 追加匹配前的内容
        result = append(result, data[currentPos:currentPos+matchIdx]...)
        // 追加替换内容
        result = append(result, replacement...)
        // 移动指针到匹配后的位置
        currentPos += matchIdx + targetLen
    }

    // 处理剩余内容：保留可能和下一段拼接成目标字符串的尾部
    remainingStart := max(currentPos, len(data)-targetLen+1)
    result = append(result, data[currentPos:remainingStart]...)
    
    // 返回处理后的字节数组，以及需要缓存的尾部
    return result, data[remainingStart:]
}

func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}

3. 在ModifyResponse钩子中使用 #

把原始响应的Body替换成我们的自定义Reader，同时注意处理Content-Length头部：

func UpdateResponse(r *http.Response) error {
    target := []byte("class='blue'")
    replacement := []byte("class='blue-green'")

    // 包装原始Body为自定义的流式替换Reader
    r.Body = ioutil.NopCloser(&replaceReader{
        src:         r.Body,
        target:      target,
        replacement: replacement,
        buf:         make([]byte, 0, len(target)-1), // 缓存最大长度为目标字符串长度-1，避免冗余内存
    })

    // 流式处理下Content-Length不再准确，删除该头部，自动启用分块传输编码
    delete(r.Header, "Content-Length")

    return nil
}

为什么这个方案高效？ #

• 低内存占用：不需要加载整个响应体到内存，内存开销仅为目标字符串长度+单次读取缓冲区大小，适合大响应场景
• 实时处理：响应流过来就处理，不需要等待完整响应，延迟更低
• 无漏匹配：通过缓存尾部内容，解决了目标字符串跨读取片段的问题

注意事项 #

• 一定要删除Content-Length头部：因为流式替换会改变响应的总长度，原头部的值已经失效，删除后HTTP协议会自动使用分块传输编码（Chunked），客户端和浏览器都能正常处理
• 如果需要大小写不敏感的匹配，可以把bytes.Index替换为自定义的匹配逻辑，比如逐个字节用bytes.EqualFold检查
• 如果目标字符串特别长，可以适当调整缓存的初始大小，但一般场景下当前设置足够

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