Ktor拦截Multipart请求并修改参数重发的技术问题

核心问题分析 #

Ktor中Multipart请求的StreamRequestBody是一次性流，读取后无法重复使用，因此重发时必须提前缓存请求体的所有内容（包括文件和文本参数），才能基于原请求添加新参数后重新发送。

实现步骤 #

1. 定义缓存相关的属性键 #

用于在请求上下文中存储缓存的Multipart内容和重发标记，避免循环拦截：

// 存储缓存的Multipart部件列表
val CACHED_MULTIPART_CONTENT = AttributeKey<List<PartData>>("CachedMultipartContent")
// 标记当前请求是否是重发请求
val IS_RETRY_REQUEST = AttributeKey<Boolean>("IsRetryRequest")

2. 实现Multipart内容缓存逻辑 #

将Multipart的所有部件转换为可重复读取的形式，确保重发时能正常复用：

suspend fun cacheMultipartParts(parts: List<PartData>): List<PartData> {
    return parts.map { part ->
        when (part) {
            is PartData.FormItem -> part // 文本参数直接复用
            is PartData.FileItem -> {
                // 读取文件内容到内存，生成可重复读取的FileItem
                val fileBytes = part.stream().readBytes()
                PartData.FileItem(
                    streamProvider = { fileBytes.inputStream() },
                    headers = part.headers,
                    filename = part.filename,
                    contentType = part.contentType
                )
            }
            is PartData.BinaryItem -> {
                val binaryBytes = part.stream().readBytes()
                PartData.BinaryItem(
                    streamProvider = { binaryBytes.inputStream() },
                    headers = part.headers
                )
            }
        }
    }
}

3. 配置HttpClient拦截器 #

添加两个拦截器：一个负责缓存Multipart请求体，另一个负责判断响应状态并重发请求：

val httpClient = HttpClient(OkHttp) {
    // 缓存Multipart请求体的拦截器
    intercept(HttpRequestPipeline.Transform) {
        // 跳过重发请求，仅处理首次请求
        if (context.attributes.getOrNull(IS_RETRY_REQUEST) == true) {
            proceed()
            return@intercept
        }

        // 仅处理Multipart类型的请求
        val multipartContent = context.request.content as? MultipartFormDataContent ?: run {
            proceed()
            return@intercept
        }

        // 读取所有部件并缓存
        val originalParts = multipartContent.readAllParts()
        val cachedParts = cacheMultipartParts(originalParts)
        context.attributes.put(CACHED_MULTIPART_CONTENT, cachedParts)

        // 重置请求体，保证首次请求能正常发送
        context.request.content = MultipartFormDataContent(originalParts)
        proceed()
    }

    // 响应拦截器：判断状态码并重发请求
    intercept(HttpResponsePipeline.Receive) {
        val response = context.response
        // 替换为你需要触发重发的特定状态码，比如401、403等
        val targetStatusCode = 401

        if (response.status.value != targetStatusCode) {
            proceed()
            return@intercept
        }

        // 获取缓存的Multipart部件
        val cachedParts = context.request.attributes.getOrNull(CACHED_MULTIPART_CONTENT) ?: run {
            proceed()
            return@intercept
        }

        // 添加额外的type参数
        val newParts = cachedParts.toMutableList().apply {
            add(PartData.FormItem(
                value = "your_extra_type_value",
                headers = Headers.build { append(HttpHeaders.ContentDisposition, "form-data; name=\"type\"") }
            ))
        }

        // 构建新的请求体
        val newContent = MultipartFormDataContent(newParts)

        // 复制原请求，标记为已重发，避免再次缓存
        val newRequest = context.request.copy(content = newContent).apply {
            attributes.put(IS_RETRY_REQUEST, true)
        }

        // 重发请求并替换当前响应
        val retryResponse = httpClient.send(newRequest)
        context.response = retryResponse

        proceed()
    }
}

4. 注意事项 #

• 大文件处理：如果上传大文件，缓存到内存会占用过多资源，可改为将文件缓存到临时文件中，替换内存缓存逻辑。
• 重发次数控制：建议添加重发次数限制，避免因状态码持续异常导致无限循环。
• 请求头调整：重发时会复用原请求的所有请求头，若需要修改请求头，可在构建newRequest时直接调整。

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