重定向 · XB 现场笔记

先决定让 nginx 跳转客户端，还是在内部重写

Fri, 21 Jan 2028 00:00:00 +0000

nginx 跳转与内部重写改变请求流程的不同部分。跳转返回状态和 Location，由客户端决定是否发起新请求；内部重写则在处理现有请求时改变 nginx 当前 URI。两者的选择决定客户端是否看到新地址、location 是否重新搜索，以及最终处理器收到怎样的路径和查询。不能因为都能让某个 URL 得到内容，就把它们当成同一种操作。

坏掉的样子

本来需要内部映射，却改成跳转，会增加客户端往返并暴露新 URL；本来需要公开永久迁移，却只做内部重写，客户端仍会继续使用旧地址。return 和 rewrite 也不能被当成总是默认相同跳转行为的通用缩写。明确状态码与重写标志，才能让预期转换可审阅，避免一行看似简单的配置隐藏行为差异。

状态选择影响方法语义和缓存。307、308 在自动跳转时保留请求方法，301、302 则允许历史上的 POST 改为 GET。永久不意味着每个客户端立刻更新所有已保存链接，临时也不意味着响应绝对不能缓存。缓存指令、请求上下文和客户端行为仍然重要，不能用状态名称替代明确的复用策略。

内部重写还可能选择错误处理器，或反复匹配自己。last 会为改变后的 URI 开始新 location 搜索；break 结束当前重写序列后，继续在现有 location 处理。查询参数可以按替换语法追加或丢弃。把这些区别视为可以互换，可能导致读取错误文件、重复参数，或进入返回 HTTP 500 的循环。

快速验证

下文集成实验的结果保留自历史运行记录；本次修订没有重新执行该实验，不能将这些记录当成本次环境的新实测。

使用宿主 Python、Docker 和固定 nginx 镜像运行脚本。实测为 Linux arm64 上的 nginx 1.28.0、Docker 29.3.1。它构建并检查可丢弃配置，只发布回环端口，不自动跟随跳转地验证真实响应，最后清理自身资源。一个小型静态文件让 break 所用处理器可以与目标 location 清楚区分：

from contextlib import contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import http.client,json,socket,subprocess,time,uuid

NGINX='nginx@sha256:552e7481ca93ffccd046aa658dbbed22caefbc09c66fa7cd247cbb90b8a5c609'
PYTHON='python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84'
def docker(*args,check=True):
 result=subprocess.run(['docker',*args],capture_output=True,text=True,timeout=120)
 if check:assert result.returncode==0,result.stderr
 return result
def wait(predicate):
 deadline=time.monotonic()+15
 while time.monotonic()<deadline:
 try:
 if predicate():return
 except OSError:pass
 time.sleep(.1)
 raise AssertionError('fixture did not become ready')

@contextmanager
def lab(configuration,files=None,backend=None):
 name='xbcatm-nginx-'+uuid.uuid4().hex[:10];tags=[name+':proxy',name+':backend'];containers=[name+'-proxy',name+'-backend']
 try:
 with TemporaryDirectory(prefix=name+'-') as directory:
 root=Path(directory);(root/'files').mkdir();(root/'nginx.conf').write_text(configuration)
 for path,content in (files or {}).items():
 target=root/'files'/path;target.parent.mkdir(parents=True,exist_ok=True);target.write_text(content)
 docker('network','create',name)
 if backend is not None:
 (root/'backend.py').write_text(backend)
 (root/'backend.Dockerfile').write_text(f'FROM {PYTHON}\nCOPY backend.py /backend.py\nCMD ["python", "/backend.py"]\n')
 docker('build','--network','none','-f',str(root/'backend.Dockerfile'),'-t',tags[1],str(root))
 docker('run','-d','--name',containers[1],'--network',name,'--network-alias','backend',tags[1])
 wait(lambda:docker('exec',containers[1],'python','-c','import socket;s=socket.create_connection(("127.0.0.1",8081),timeout=.5);s.close()',check=False).returncode==0)
 (root/'Dockerfile').write_text(f'FROM {NGINX}\nCOPY nginx.conf /etc/nginx/nginx.conf\nCOPY files /srv\n')
 docker('build','--network','none','-t',tags[0],str(root))
 docker('run','--rm','--network',name,tags[0],'nginx','-t')
 docker('run','-d','--name',containers[0],'--network',name,'-p','127.0.0.1::8080',tags[0])
 details=json.loads(docker('inspect',containers[0]).stdout)[0]
 binding=details['NetworkSettings']['Ports']['8080/tcp'][0];assert binding['HostIp']=='127.0.0.1';port=int(binding['HostPort'])
 def ready():
 connection=socket.create_connection(('127.0.0.1',port),timeout=.5);connection.close();return True
 wait(ready)
 def request(path,method='GET',headers=None,body=None):
 connection=http.client.HTTPConnection('127.0.0.1',port,timeout=5)
 try:
 connection.request(method,path,body=body,headers=headers or {})
 response=connection.getresponse();return response.status,{k.lower():v for k,v in response.getheaders()},response.read()
 finally:connection.close()
 yield containers[0],request
 finally:
 docker('rm','-f',*containers,check=False);docker('image','rm',*tags,check=False);docker('network','rm',name,check=False)

def config(locations,extra=''):
 return 'worker_processes 1;\nerror_log /tmp/error.log notice;\nevents {}\nhttp {\naccess_log off;\n'+extra+'\nserver { listen 8080; root /srv;\n'+locations+'\n}\n}\n'

locations=r'''
location = /old { return 308 /destination$is_args$args; }
location = /destination { return 200 "$request_method|$uri|$args"; }
location /last/ { rewrite ^/last/(.*)$ /target/$1 last; }
location /break/ { rewrite ^/break/(.*)$ /target/$1 break; add_header X-Route break always; }
location /target/ { add_header X-Route target always; return 200 "$uri|$args"; }
location /append/ { rewrite ^/append/(.*)$ /target/$1?new=1 last; }
location /discard/ { rewrite ^/discard/(.*)$ /target/$1? last; }
location /loop/ { rewrite ^ /loop/again last; }
'''
with lab(config(locations,'absolute_redirect off;'),{'target/item':'static-file'}) as (container,request):
 status,headers,body=request('/old?x=1',method='POST',body='public-body')
 assert status==308 and headers['location']=='/destination?x=1'
 status,headers,body=request(headers['location'],method='POST',body='public-body');assert status==200 and body==b'POST|/destination|x=1'
 status,headers,body=request('/last/item?x=1');assert status==200 and headers['x-route']=='target' and body==b'/target/item|x=1'
 status,headers,body=request('/break/item?x=1');assert status==200 and headers['x-route']=='break' and body==b'static-file'
 status,headers,body=request('/append/item?old=2');assert status==200 and body==b'/target/item|new=1&old=2'
 status,headers,body=request('/discard/item?old=2');assert status==200 and body==b'/target/item|'
 assert request('/loop/start')[0]==500
 assert 'rewrite or internal redirection cycle' in docker('exec',container,'cat','/tmp/error.log').stdout
 print('return 308 creates a client-visible redirect; the explicit follow-up retains POST and the query')
 print('last restarts location selection; break keeps the location while changing the URI used by its static handler')
 print('rewrite appends old query arguments unless discarded explicitly; an internal rewrite cycle is stopped with HTTP 500')

向 /old?x=1 发送 POST，得到 308 和 Location: /destination?x=1。实验关闭绝对跳转生成，让本地目标保持相对形式，不依赖自动分配的宿主端口。任何后续请求之前，都会先检查原响应，从而明确 nginx 实际告诉客户端什么，不让自动跟随把第一跳隐藏起来。

随后，脚本显式向该 Location 再发送一次 POST，得到 POST|/destination|x=1。这验证按预期方法跟随时的目标和查询，但不声称覆盖所有浏览器的自动跳转或缓存行为。测试客户端有意控制第二次请求，而不是默默执行它。因此，实验结果应与 HTTP 状态契约结合理解，不能扩展成未经执行的客户端兼容性结论。

/last/item?x=1 被重写为 /target/item，并重新选择 location。目标块返回诊断 URI，X-Route 为 target。相比之下，/break/item?x=1 改变 URI 后仍留在原 location，其静态处理器读取 /srv/target/item，响应标记为 break。相同目标路径因此可以经过不同配置处理，不能只看重写后的字符串。

这些结果说明 break 不会停止全部请求处理，它只停止当前重写序列，内容处理仍继续。同样，last 不是外部跳转：客户端直接收到最终 200，不会先获得一条 Location 跳到内部目标。状态、响应头与正文共同证明转换类型，避免仅凭规则名字猜测。

/append/item?old=2 的替换包含 new=1，它与原参数组合成 new=1&old=2。丢弃示例在替换末尾使用问号，最终没有参数。两种情况都断言实际结果，避免跳转或重写测试漏掉重复、泄漏或意外删除的查询数据。路径正确不代表参数同样正确，两者应分别比较。

循环路径不断重写回自身匹配家族。nginx 最终以 HTTP 500 停止循环，并在错误日志记录内部跳转循环诊断。因此，语法检查成功不证明某个请求不会循环；只有实际执行相关匹配路径，才能验证转换按预期终止。错误日志还为区分后端故障与本地规则循环提供了直接证据。

测试客户端真正收到的转换

简单公开迁移可以使用带明确状态的 return，需要模式匹配时再采用对应 rewrite。目标路径和查询处理应清楚表达。避免让不可信输入任意决定跳转地址；绝对目标依赖传入主机信息时，还要验证规范主机策略。配置不应因为修复一个路径，顺便允许请求者选择完全无关的目标。

公开迁移在选择缓存策略前，应验证状态、Location、方法预期和最终目标。需要禁止复用时，临时状态不能替代明确缓存控制。内部映射则应检查最终 location、文件或上游路径、参数及错误情况。两类验证关注不同结果，不应把其中一种成功直接代替另一种。

回归应包含近似路径和已经规范化的目标。规则第一次工作，不代表不会再次跳转自己的目标，或与后续 location 冲突。保留原始响应和最终结果两侧证据，才能在部署后解释路由改变到底发生在哪一步，而不是只看到页面最终能打开就结束检查。

来源

nginx rewrite module，return 跳转、last 与 break、查询处理及重写次数限制，已核验 2026-10-15。
RFC 9110 HTTP semantics，跳转状态含义与方法保留要求，已核验 2026-10-15。
RFC 9111 HTTP caching，响应语义及缓存控制共同决定的缓存行为，已核验 2026-10-15。

重定向重新安排流向

Wed, 29 Sep 2027 00:00:00 +0000

重定向在命令执行前改变它的文件描述符。Shell 从左到右处理每一项，遇到打开文件或复制描述符的操作，就在那个位置完成相应变更。描述符零、一、二通常分别表示标准输入、标准输出和标准错误。把命令行读成对这些句柄的顺序操作，就能解释诊断为什么去了错误的位置，也能解释文件为什么还没有被程序读取就已经变空。

打开文件本身就可能改变数据

>output 打开输出文件，并且通常把已存在的普通文件截断为零长度；>>output 使用追加方式，<input 则打开文件供读取。这些动作由 Shell 完成，不是命令所指程序的内部行为。如果必须打开的目标失败，命令不会执行，但此前已经成功的重定向仍可能创建或截断其他文件。不能把“程序没有启动”理解成“整条命令完全没有副作用”。

因此，sed expression input >input 会在转换程序读取数据之前破坏原文件。即便先写 <input 打开输入，后续重定向截断同一个底层文件，也不能保住那些内容。应写入独立临时文件，检查转换状态与结果，再根据文件归属、权限和所在文件系统，明确执行替换步骤。输入输出恰好同名时，不能指望 Shell 自动替你实现安全的原地编辑。

复制记住的是当下的目标

>log 2>&1 先让描述符一指向日志，再让描述符二引用同一个已打开目标。2>&1 >log 则先复制原来的标准输出，之后只改变描述符一，因此标准错误仍留在原目标，例如终端或负责捕获输出的管道。这里复制的是描述符引用，不是文件内容，也不是给两个数字建立一个会随之后续变化的动态连接。

Bash 的 &>log 可以简写同时重定向两条流，而 >log 2>&1 也适用于可移植 Shell。不要把它写成 >log 2>log：后者分别打开同一个文件，两份打开状态拥有独立偏移量，输出可能相互覆盖。即使描述符共享一个目标，应用程序自身的缓冲仍会影响消息真正写出的时间，所以合并日志也不自动保证业务事件严格按发生顺序排列。

管道会先把标准输出连接到下一阶段，然后才应用命令自己的重定向。因此 producer >file | consumer 的生产者把输出交给了文件，消费者反而读不到那些数据。相反，producer 2>&1 | consumer 会把诊断也送进管道。如果下游要求机器可解析的记录，把面向人的错误文本混进去，就可能破坏原本合法的输入格式。

坏掉的样子

文件名来自变量时应加引号，避免空格让目标展开成多个词。描述符编号必须紧贴操作符：2>errors 重定向标准错误，2 >errors 却把数字二作为普通参数传给命令，并重定向标准输出。一个空格就可能同时改变程序收到的输入参数和输出位置，排查时不能只看目标文件名有没有拼对。

Bash 的 set -C 启用禁止覆盖模式，通常会拒绝用普通输出重定向覆盖已存在的普通文件。这有助于防止误操作，但不是备份机制，也不是对所有文件类型的统一保护；>| 会明确绕过这个选项。还要区分单条命令的临时重定向与 exec >log：后者修改当前 Shell 的描述符，可能把后续所有命令的输出一起转走，不能在交互验证时无意间让整个会话失声。

快速验证

下面的完整实验使用 Bash 和常见 Unix 工具，只会截断、删除刚创建的专用临时文件。它比较两种重定向顺序，演示输入输出同文件时的数据丢失，并验证目标无法打开时函数体确实没有运行。清理步骤逐个列出实验文件，不使用递归删除，也不会触碰原有文件。

bash --noprofile --norc <<'BASH'
set -eu
demo_dir=$(mktemp -d)
trap 'rm -f "$demo_dir/both" "$demo_dir/out" "$demo_dir/input"; rmdir "$demo_dir"' EXIT
emit() { printf 'out\n'; printf 'err\n' >&2; }
emit > "$demo_dir/both" 2>&1
demo_captured=$(emit 2>&1 > "$demo_dir/out")
[ "$(cat "$demo_dir/both")" = "$(printf 'out\nerr')" ]
[ "$(cat "$demo_dir/out")" = out ]
[ "$demo_captured" = err ]
printf 'both:\n'
cat "$demo_dir/both"
printf 'out-file=[%s] captured=[%s]\n' \
 "$(cat "$demo_dir/out")" "$demo_captured"
printf 'seed\n' > "$demo_dir/input"
sed 's/seed/replaced/' "$demo_dir/input" > "$demo_dir/input"
[ ! -s "$demo_dir/input" ]
printf 'input truncated\n'
if (set -C; emit > "$demo_dir/both") 2>/dev/null; then
 printf 'unexpected overwrite\n' >&2
 exit 1
else
 printf 'noclobber rejected overwrite\n'
fi
demo_ran=no
mark_run() { demo_ran=yes; }
if mark_run 2>/dev/null > "$demo_dir/missing/output"; then
 printf 'unexpected redirection\n' >&2
 exit 1
else
 [ "$demo_ran" = no ]
 printf 'function-ran=%s\n' "$demo_ran"
fi
BASH

合并文件应打印 out 和 err。交换顺序后，输出文件只含 out，变量单独捕获到 err。转换实验报告输入已经变空，因为截断先于程序读取。最后两行分别证明禁止覆盖选项拒绝了替换，以及目标打开失败时仍为 function-ran=no，函数中的赋值没有执行。

明确比较与失败分支让异常结果以失败状态退出，不会只打印意外信息后继续成功结束。这些检查同时观察文件内容与命令是否真正执行，而不是只依赖最后一条打印命令成功。在真实脚本中，还要把生产者退出状态与日志一起保留下来：错误消息即使准确进入了日志，也不能把失败操作变成成功。只有分别保留流向和状态两类证据，后续恢复判断才有可靠依据。

来源

Bash 参考手册：重定向，从左到右的描述符变更及禁止覆盖行为，已核验 2026-09-07。
POSIX Shell 重定向，可移植的重定向运算符及文件打开语义，已核验 2026-09-07。

重定向是对「去哪」的一份承诺

Tue, 28 Jul 2026 00:00:00 +0000

重定向是一份响应，要求客户端在另一个目标上发起新请求。Location 字段和状态码共同描述去哪以及方法怎样变化。浏览器通常会自动跟随，但客户端库也可以停下、检查或拒绝后续跳转。每一跳都应当作为协议数据记录：只看最终页面，无法知道 POST 是否变成了 GET、凭据是否越过了源边界，或是否有循环消耗了重试预算。

永久和临时表达不同承诺

301 与 308 表示永久迁移，302 与 307 表示临时绕行；303 明确要求用 GET（原请求为 HEAD 时用 HEAD）取得表示。永久状态可能被缓存、写入书签和搜索索引，所以维护窗口不能随意使用永久码。临时状态告诉客户端下次仍应访问旧地址。RFC 9111 的缓存规则和资源策略仍然有效，“永久”不是忘记授权、信任任意主机或跳过证书检查的指令。

方法是否保留要看状态码

出于历史兼容，许多客户端在 301、302 或 303 后把 POST 改为 GET 并丢掉正文；307 和 308 则要求保留原方法与正文，但前提是客户端能够重新读取该正文。重定向不会把非幂等动作变得安全，保留方法也不等于源站已经接受了重放。服务端应选择与操作语义相符的状态，客户端则应确认请求体可重放并匹配合适的重试策略。

相对 Location 要根据有效请求 URI 解析；客户端应记录解析后的每一跳并设置最大跳数。缺少 Location 时没有可跟随的新目标，自循环和过长链是服务器缺陷，不是无限提高上限的理由。跳转也可能改变 scheme、端口或 origin，转发 Cookie、Bearer token 和客户端证书前必须执行显式允许列表；指向另一源的链接不是发送凭据的授权。

Location 的相对写法还会受到路径末尾斜杠和查询串影响。?page=2、/page=2 与 ../page=2 不是同一个目标，重定向后的有效 URI 也可能已经经过规范化。实现应保存原始值、解析后的绝对值和每一跳的源，出现异常时才能解释为何访问了某个地址。不要使用字符串拼接判断是否同源，应比较解析后的 scheme、主机和端口，并明确是否允许 HTTP 降级、跨端口或经过代理的内部地址。

坏掉的样子

登录代理可能把 API POST 重定向到 HTML 页面，方便的客户端又悄悄把它改成 GET。边缘节点缓存了永久跳转后，回滚时仍会把流量送去已经下线的主机。307 遇到一次性或流式正文时可能无法重放，客户端应返回原响应或清晰错误，不能凭空构造空请求。重定向中间件若盲目接受外部绝对地址，还可能把 Authorization 头泄露出去；循环则会拖到超时才暴露。

排查时逐跳观察状态码、Location、方法、正文长度、最终源和响应内容，先关闭自动跟随。最终 200 不证明原始动作发生，因为最后一个资源可能只是另一种表示。对同源跳转可以有明确的自动策略，跨源跳转则应更严格。日志不要包含凭据；发布永久跳转之前，必须先验证回滚地址、缓存失效和客户端行为。

重定向策略还要和缓存策略一起发布。永久跳转缓存寿命过长，会让已经修好的目标继续被访问；临时跳转若没有合适缓存头，也可能被中间层保存得比维护窗口更久。部署前用真实客户端检查冷缓存和热缓存，再验证旧地址、目标地址和回滚地址的证书、权限及监控。对于写请求，记录源站实际收到的每一跳方法和正文摘要，比只统计最终 200 数量更能发现重复提交或方法丢失。

快速验证

把下面程序保存为 redirect_probe.go，用 Go 1.23 或更新版本运行。两个回环服务记录每次请求。客户端只跟随同源跳转，含初始请求在内最多允许三次请求，拒绝另一源，并在请求体不能重放时停下；目标会回显实际收到的方法与正文。

package main

import (
 "encoding/json"
 "errors"
 "fmt"
 "io"
 "net/http"
 "net/http/httptest"
 "net/url"
 "runtime"
 "strconv"
 "strings"
 "sync"
 "sync/atomic"
 "time"
)

type visit struct {
 Path, Method, Body string
}

func must(err error) {
 if err != nil {
 panic(err)
 }
}

func check(ok bool, message string) {
 if !ok {
 panic(message)
 }
}

func main() {
 var foreignCalls atomic.Int64
 foreign := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 foreignCalls.Add(1)
 w.WriteHeader(http.StatusNoContent)
 }))
 defer foreign.Close()
 var mu sync.Mutex
 var visits []visit
 server := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 defer r.Body.Close()
 body, err := io.ReadAll(http.MaxBytesReader(w, r.Body, 1024))
 must(err)
 seen := visit{r.URL.Path, r.Method, string(body)}
 mu.Lock()
 visits = append(visits, seen)
 mu.Unlock()
 if r.URL.Path == "/destination" {
 w.Header().Set("Content-Type", "application/json")
 must(json.NewEncoder(w).Encode(seen))
 return
 }
 status, location := http.StatusFound, ""
 switch r.URL.Path {
 case "/loop":
 location = "/loop"
 case "/foreign":
 location = foreign.URL + "/destination"
 case "/missing":
 default:
 status, err = strconv.Atoi(strings.TrimPrefix(r.URL.Path, "/r/"))
 must(err)
 location = "/destination"
 }
 if location != "" {
 w.Header().Set("Location", location)
 }
 w.Header().Set("Cache-Control", "no-store")
 w.WriteHeader(status)
 fmt.Fprint(w, "redirect")
 }))
 server.Config.ReadHeaderTimeout = time.Second
 server.Config.ReadTimeout = 2 * time.Second
 server.Start()
 defer server.Close()
 origin, err := url.Parse(server.URL)
 must(err)
 errOrigin := errors.New("redirect changes origin")
 errBudget := errors.New("redirect budget exhausted")
 transport := &http.Transport{}
 defer transport.CloseIdleConnections()
 client := &http.Client{Transport: transport, Timeout: 3 * time.Second,
 CheckRedirect: func(request *http.Request, via []*http.Request) error {
 if request.URL.Scheme != origin.Scheme || request.URL.Host != origin.Host {
 return errOrigin
 }
 if len(via) >= 3 {
 return errBudget
 }
 return nil
 },
 }
 read := func(response *http.Response) []byte {
 body, readError := io.ReadAll(response.Body)
 closeError := response.Body.Close()
 must(readError)
 must(closeError)
 check(response.Proto == "HTTP/1.1", "HTTP/1.1 fixture required")
 return body
 }
 request := func(route string, body io.Reader) *http.Request {
 req, err := http.NewRequest(http.MethodPost, server.URL+route, body)
 must(err)
 return req
 }
 snapshot := func() []visit {
 mu.Lock()
 defer mu.Unlock()
 return append([]visit(nil), visits...)
 }
 const payload = "action=replace"
 follow := func(status int) {
 route := "/r/" + strconv.Itoa(status)
 req := request(route, strings.NewReader(payload))
 check(req.GetBody != nil, "fixture body must be replayable")
 before := len(snapshot())
 response, err := client.Do(req)
 must(err)
 var final visit
 must(json.Unmarshal(read(response), &final))
 method, body := "POST", payload
 if status == 301 || status == 302 || status == 303 {
 method, body = "GET", ""
 }
 check(response.StatusCode == 200 && response.Request.URL.Path == "/destination", "wrong final response")
 check(final == (visit{"/destination", method, body}), "wrong redirected method/body")
 actual := snapshot()[before:]
 check(len(actual) == 2 && actual[0] == (visit{route, "POST", payload}) && actual[1] == final, "both wire hops must match")
 fmt.Printf("%d: POST -> %s body=%q\n", status, method, body)
 }
 for _, status := range []int{301, 302, 303, 307, 308} {
 follow(status)
 }
 stopped := *client
 stopped.CheckRedirect = func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }
 before := len(snapshot())
 response, err := stopped.Do(request("/r/307", strings.NewReader(payload)))
 must(err)
 check(string(read(response)) == "redirect" && response.StatusCode == 307, "inspect original redirect")
 check(response.Header.Get("Location") == "/destination" && len(snapshot()) == before+1, "no-follow must stop before target")
 fmt.Println("no-follow: 307 with relative Location; target not requested")

 before = len(snapshot())
 unreplayable := request("/r/307", io.NopCloser(strings.NewReader(payload)))
 unreplayable.ContentLength = int64(len(payload))
 check(unreplayable.GetBody == nil, "fixture must not support replay")
 response, err = client.Do(unreplayable)
 must(err)
 check(string(read(response)) == "redirect" && response.StatusCode == 307, "Go must retain the unreplayable redirect")
 check(len(snapshot()) == before+1, "unreplayable body must not reach target")
 fmt.Println("unreplayable: 307 returned without following")

 for _, test := range []struct {
 route string
 err error
 hops int
 }{{"/foreign", errOrigin, 1}, {"/loop", errBudget, 3}} {
 before = len(snapshot())
 response, err = client.Do(request(test.route, strings.NewReader(payload)))
 check(errors.Is(err, test.err), "wrong redirect policy error")
 if response != nil {
 _ = response.Body.Close() // Already closed by Client.Do on policy rejection.
 }
 check(len(snapshot()) == before+test.hops, "wrong number of admitted hops")
 fmt.Println(test.route, test.err)
 }
 check(foreignCalls.Load() == 0, "different-origin target must never be contacted")
 before = len(snapshot())
 response, err = client.Do(request("/missing", strings.NewReader(payload)))
 must(err)
 check(string(read(response)) == "redirect" && response.StatusCode == 302, "missing Location must retain 302")
 check(len(snapshot()) == before+1, "missing Location cannot select a target")
 fmt.Println("missing Location: original 302 returned")
 follow(307)
 check(len(snapshot()) == 19 && foreignCalls.Load() == 0, "wrong final request counts")
 fmt.Println("nineteen same-origin requests; zero different-origin requests")
 fmt.Println(runtime.Version())
}

程序会打印五组方法比较：301、302、303 后变成无正文 GET，307、308 则保留带 action=replace 的 POST。关闭自动跟随后，客户端看到原始 307，不请求目标；一次性正文也会让 Go 返回原响应而不跟随。跨源策略在真正访问第二台服务器前拒绝请求，循环发出三次请求后停止，即只跟随两次重定向，缺少 Location 则保留原始 302。最后一次 307 成功，证明失败路径之后仍能恢复。这只隔离客户端重定向行为，不证明浏览器 Cookie 策略、缓存存储或业务动作可以安全重试。

来源

RFC 9110：HTTP 语义，重定向状态码、Location 解析和方法语义，已核验 2026-09-09。
RFC 9111：HTTP 缓存，新鲜度、显式缓存控制和已存响应行为，已核验 2026-09-09。
MDN：HTTP 重定向，浏览器行为与状态码区别，已核验 2026-09-09。
Go net/http，CheckRedirect、可重放正文和 ErrUseLastResponse，已核验 2026-09-09。

重定向 · XB 现场笔记

先决定让 nginx 跳转客户端，还是在内部重写

坏掉的样子

快速验证

测试客户端真正收到的转换

延伸阅读

来源

重定向重新安排流向

打开文件本身就可能改变数据

复制记住的是当下的目标

坏掉的样子

快速验证

延伸阅读

来源

重定向是对「去哪」的一份承诺

永久和临时表达不同承诺

方法是否保留要看状态码

坏掉的样子

快速验证

延伸阅读

来源