下载任务已经保存了文件前半段,继续请求后半段时,服务端文件却换了版本。在本例的 MVC 静态资源路径上,带旧强 ETag 的续传请求在 Framework RC1 收到 206 新尾段,7.1.0-RC2 则收到 200 完整新文件。客户端收到这个 200 要替换旧片段,不能继续追加。

先把坏拼接跑出来

这次固定 Spring Boot 4.2.0-RC2,只切换 Spring Framework 7.1.0-RC1 和 RC2。两版实际依赖树都是 39 个 JAR 坐标,仅七个 Framework 模块的版本不同;Tomcat 均为 11.0.27。

为了直接核对字节,下载文件缩成 64 字节夹具。旧版是 32 个 A 加 32 个 a,新版是 32 个 B 加 32 个 b。它不是实际压缩包,所谓坏文件是指拼接结果既不等于旧文件,也不等于新文件,而不是观察到了解压异常。

客户端先请求 Range: bytes=0-31,保存收到的 32 字节、强 ETag 和 Last-Modified。文件不变时,带该 ETag 请求 bytes=32-63,两版都返回 206,拼回后的字节都与旧文件完全相等。

接着原子替换成不同的 64 字节新文件。测试另取一次完整新文件,只用于校验真值和取得当前验证器;恢复分支不会拿这份对照响应修补结果。它保留旧片段与旧 ETag,仍请求同一 URL 的后半段。RC1 的关键响应头摘录:

HTTP/1.1 206 
Last-Modified: Tue, 10 Nov 2026 00:00:10 GMT
ETag: "09a9678ed7897b5c646269b260ea7f5159281b94defdda0e78d0b085eccbebeb"
Content-Range: bytes 32-63/64
Content-Length: 32

它给的是新文件的后 32 字节。客户端按 206 追加后,长度虽然还是 64,内容却混了两版。RC2 对同一旧验证器返回:

HTTP/1.1 200 
Last-Modified: Tue, 10 Nov 2026 00:00:10 GMT
ETag: "09a9678ed7897b5c646269b260ea7f5159281b94defdda0e78d0b085eccbebeb"
Content-Length: 64

这里没有 Content-Range,响应体是完整的新文件。客户端分别按两种实际状态处理后的日志如下:

CLIENT {"framework": "7.1.0-RC1", "action": "append", "bytes": 64, "sha256": "bf6a6c45d2e89a310bc0250e6effb6713056db6a142735c403c179dc5337a411", "equalsOld": false, "equalsNew": false}
CLIENT {"framework": "7.1.0-RC2", "action": "replace", "bytes": 64, "sha256": "09a9678ed7897b5c646269b260ea7f5159281b94defdda0e78d0b085eccbebeb", "equalsOld": false, "equalsNew": true}

equalsNew 对比的是实际保存的客户端文件与新源文件的全部字节。旧版的拼接结果连旧文件也不等于;RC2 用本次 200 响应覆盖旧片段后,与新文件完全相等。不需要再发第二个全量请求,也不是等 304 或 412 来处理这次续传。

真正接请求的是静态资源处理器

7.1.0-RC2 发行说明把 Honor If-Range for resource range requests 列为新增项,对应 #37218。这不是新增 Range 支持,而是开始根据 If-Range 决定是否继续处理 Range。

本例通过 ResourceHandlerRegistry 将外部目录映射到 /files/**,实际处理器为 ResourceHttpRequestHandler。拦截器只记录处理器类名、路径和状态,不修改响应。没有用自写下载控制器模拟这项修复,也没有自己实现 If-Range 判断。

两版都显式配置 setEtagGenerator,对当前资源字节算 SHA-256,返回带双引号、不带 W/ 的强 ETag。这个配置入口不是 RC2 新增的;同一目录的 /plain/** 对照不配置生成器,两版响应都没有 ETag,不能把本文的强 ETag 当成默认自动生成。

文件位置不变,资源链缓存关闭。替换使用先写临时文件、设置 mtime、再原子改名的方式,所有 HTTP 请求串行完成;不会一边生成 ETag,一边在应用外覆盖文件。两版夹具的 mtime 相差 10 秒,且明确设置为整秒。If-Range 使用前次真实响应的 ETag 或 Last-Modified,不按预想编造验证器。

匹配才取片段,不匹配取完整表示

下面全部针对替换后的新文件,Range 都是 bytes=32-63。旧 ETag 和旧日期来自替换前真实响应,新值来自替换后的真实响应。

If-Range 条件 RC1 RC2
不带 If-Range 206,32 字节 206,32 字节
匹配当前强 ETag 206,32 字节 206,32 字节
替换前的强 ETag 206,32 字节 200,64 字节
当前 ETag 加 W/ 前缀 206,32 字节 200,64 字节
旧 ETag 加 W/ 前缀 206,32 字节 200,64 字节
与当前 Last-Modified 完全一致 206,32 字节 206,32 字节
替换前的 Last-Modified 206,32 字节 200,64 字节
比当前 Last-Modified 早 1 秒 206,32 字节 200,64 字节
比当前 Last-Modified 晚 1 秒 206,32 字节 200,64 字节

表中所有 206 的 Content-Range 都是 bytes 32-63/64,Content-Length 为 32;所有 200 都没有 Content-Range,Content-Length 为 64。响应体也逐字节验证为新文件的尾段或整份文件,不只看状态码。

日期对照用的当前 Last-Modified 是 Tue, 10 Nov 2026 00:00:10 GMT;前后 1 秒分别是 Tue, 10 Nov 2026 00:00:09 GMT 和 Tue, 10 Nov 2026 00:00:11 GMT。这些是原样保留的协议日期,早晚是相对 Last-Modified,不是相对运行时钟。日期分支是精确匹配,不是“晚于文件修改时间也算通过”。

RFC 9110 第 13.1.5 节要求 If-Range 使用强比较;客户端不应发送弱 ETag。本例故意发送 W/ 形式,是验证服务端如何处理这种输入,不是把它写成合法续传方案。客户端已有 ETag 时应使用 ETag;只有没有 ETag、且日期满足强验证器条件时,才应选择日期。

日期的秒精度也不是内容指纹。这里用整秒 mtime 和顺序替换排除竞态,没有验证同一秒内多次更新。RC2 标签源码中的 HttpRange.resolveRanges 会先检查 If-Range,不匹配就不再应用 Range;静态处理器随后发送完整资源。补丁还涉及其他资源响应链路,本文没有实测 ResponseEntity、WebMvc.fn 或 WebFlux,不能把这组静态资源结果当成它们的测试结论。

可复制的完整最小工程

需要 JDK 21、Maven 3.9、Python 3、curl,以及支持原子改名和设置文件时间的本地文件系统。以下代码在 Linux 上验证。先创建目录,再按相对路径保存四个文件:

mkdir -p src/main/java/example src/main/resources

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>4.2.0-RC2</version><relativePath/></parent>
  <groupId>example</groupId><artifactId>ifrange-demo</artifactId><version>1.0.0</version>
  <properties><java.version>21</java.version><spring-framework.version>7.1.0-RC2</spring-framework.version></properties>
  <dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-webmvc</artifactId></dependency></dependencies>
  <build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build>
</project>

src/main/resources/application.properties

spring.main.banner-mode=off
spring.web.resources.add-mappings=false
server.address=127.0.0.1
server.port=18932

src/main/java/example/DownloadApp.java

package example;

import java.io.InputStream;
import java.io.UncheckedIOException;
import java.io.IOException;
import java.nio.file.Path;
import java.security.MessageDigest;
import java.security.GeneralSecurityException;
import java.util.HexFormat;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.SpringBootVersion;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.core.SpringVersion;
import org.springframework.core.env.Environment;
import org.springframework.core.io.Resource;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@SpringBootApplication
@RestController
public class DownloadApp implements WebMvcConfigurer {
    private final Environment environment;
    public DownloadApp(Environment environment) { this.environment = environment; }
    public static void main(String[] args) { SpringApplication.run(DownloadApp.class, args); }

    @GetMapping("/ready")
    String ready() { return "READY boot=" + SpringBootVersion.getVersion()
            + " framework=" + SpringVersion.getVersion() + "\n"; }

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        String location = Path.of(environment.getProperty("demo.files", "public-files"))
                .toAbsolutePath().toUri().toString();
        if (!location.endsWith("/")) location += "/";
        registry.addResourceHandler("/files/**").addResourceLocations(location)
                .setEtagGenerator(DownloadApp::etag).resourceChain(false);
        registry.addResourceHandler("/plain/**").addResourceLocations(location).resourceChain(false);
    }

    static String etag(Resource resource) {
        try (InputStream stream = resource.getInputStream()) {
            var digest = MessageDigest.getInstance("SHA-256");
            byte[] buffer = new byte[8192];
            for (int n; (n = stream.read(buffer)) != -1;) digest.update(buffer, 0, n);
            return "\"" + HexFormat.of().formatHex(digest.digest()) + "\"";
        }
        catch (IOException ex) { throw new UncheckedIOException(ex); }
        catch (GeneralSecurityException ex) { throw new IllegalStateException(ex); }
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new HandlerInterceptor() {
            @Override
            public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
                    Object handler, Exception exception) {
                System.out.println("HANDLER " + handler.getClass().getName()
                        + " path=" + request.getRequestURI() + " status=" + response.getStatus());
            }
        });
    }
}

run.py

from pathlib import Path
from datetime import datetime, timezone, timedelta
from email.utils import parsedate_to_datetime, format_datetime
import hashlib, json, os, shlex, signal, socket, subprocess, time, urllib.request

ROOT = Path.cwd()
LOG = ROOT / datetime.now().strftime('run-logs-%Y%m%d-%H%M%S')
LOG.mkdir()
OLD, NEW = b'A' * 32 + b'a' * 32, b'B' * 32 + b'b' * 32
STAMP = int(datetime(2026, 11, 10, tzinfo=timezone.utc).timestamp())
sha = lambda data: hashlib.sha256(data).hexdigest()
all_rows = []

def replace_file(folder, data, stamp):
    staged = folder / 'package.next'
    staged.write_bytes(data)
    os.utime(staged, ns=(stamp * 10**9, stamp * 10**9))
    staged.replace(folder / 'package.bin')
    assert (folder / 'package.bin').read_bytes() == data
    assert (folder / 'package.bin').stat().st_mtime_ns == stamp * 10**9

for version in ['7.1.0-RC1', '7.1.0-RC2']:
    work = LOG / version
    files = work / 'public-files'
    files.mkdir(parents=True)
    replace_file(files, OLD, STAMP)
    (work / 'v1.bin').write_bytes(OLD)
    (work / 'v2.bin').write_bytes(NEW)
    for name, args in [('build', ['clean', 'package', '-q']), ('dependencies', ['dependency:tree'])]:
        command = ['mvn', '-Dspring-framework.version=' + version, *args]
        with (work / (name + '.log')).open('w') as out:
            result = subprocess.run(command, stdout=out, stderr=subprocess.STDOUT, timeout=180)
        (work / (name + '-exit.txt')).write_text(str(result.returncode) + '\n')
        assert result.returncode == 0
    with socket.socket() as check:
        check.bind(('127.0.0.1', 18932))
    command = ['java', '-XX:ActiveProcessorCount=2', '-Xmx256m', '-jar',
               'target/ifrange-demo-1.0.0.jar', '--demo.files=' + str(files)]
    (work / 'server-command.txt').write_text(shlex.join(command) + '\n')
    with (work / 'server.log').open('w') as out:
        server = subprocess.Popen(command, stdout=out, stderr=subprocess.STDOUT, start_new_session=True)
        (work / 'server-pid.txt').write_text(str(server.pid) + '\n')
        try:
            deadline = time.monotonic() + 40
            while time.monotonic() < deadline:
                assert server.poll() is None, 'Own server exited'
                try:
                    ready = urllib.request.urlopen('http://127.0.0.1:18932/ready', timeout=1).read().decode()
                    if 'boot=4.2.0-RC2 framework=' + version in ready:
                        break
                except OSError:
                    pass
                time.sleep(0.1)
            else:
                raise TimeoutError('Server not ready')
            (work / 'ready.txt').write_text(ready)

            def get(name, path='/files/package.bin', byte_range=None, validator=None):
                case = work / name
                case.mkdir()
                command = ['curl', '--http1.1', '--noproxy', '*', '--silent', '--show-error',
                           '--fail-with-body', '--trace-ascii', str(case / 'curl.trace'),
                           '-D', str(case / 'headers.txt'), '-o', str(case / 'body.bin'),
                           '-w', '%{http_code}', '-H', 'Accept-Encoding: identity']
                if byte_range:
                    command += ['-H', 'Range: ' + byte_range]
                if validator is not None:
                    command += ['-H', 'If-Range: ' + validator]
                command += ['http://127.0.0.1:18932' + path]
                (case / 'command.txt').write_text(shlex.join(command) + '\n')
                result = subprocess.run(command, capture_output=True, text=True, timeout=15)
                (case / 'curl-exit.txt').write_text(str(result.returncode) + '\n')
                (case / 'status.txt').write_text(result.stdout + '\n')
                (case / 'stderr.txt').write_text(result.stderr)
                assert result.returncode == 0
                headers = {}
                for line in (case / 'headers.txt').read_text().splitlines():
                    if ':' in line:
                        key, value = line.split(':', 1)
                        headers[key.lower()] = value.strip()
                body = (case / 'body.bin').read_bytes()
                row = {'framework': version, 'case': name, 'range': byte_range, 'ifRange': validator,
                       'status': int(result.stdout), 'contentRange': headers.get('content-range'),
                       'contentLength': headers.get('content-length'), 'etag': headers.get('etag'),
                       'lastModified': headers.get('last-modified'), 'bytes': len(body), 'sha256': sha(body)}
                assert int(row['contentLength']) == len(body)
                (case / 'result.json').write_text(json.dumps(row, indent=2) + '\n')
                all_rows.append(row)
                print(json.dumps(row), flush=True)
                return row, body

            initial, initial_body = get('initial')
            assert initial['status'] == 200 and initial_body == OLD
            plain, _ = get('no-etag-control', path='/plain/package.bin')
            assert plain['etag'] is None
            prefix, prefix_body = get('prefix', byte_range='bytes=0-31')
            old_tag, old_date = prefix['etag'], prefix['lastModified']
            assert old_tag and not old_tag.startswith('W/') and prefix_body == OLD[:32]
            same, same_body = get('unchanged', byte_range='bytes=32-63', validator=old_tag)
            assert same['status'] == 206 and prefix_body + same_body == OLD
            replace_file(files, NEW, STAMP + 10)
            current, current_body = get('updated')
            assert current['status'] == 200 and current_body == NEW and current['etag'] != old_tag
            date = parsedate_to_datetime(current['lastModified'])
            cases = [('range-only', None), ('strong-current', current['etag']), ('strong-old', old_tag),
                     ('weak-current', 'W/' + current['etag']), ('weak-old', 'W/' + old_tag),
                     ('date-exact', current['lastModified']), ('date-old', old_date),
                     ('date-past', format_datetime(date - timedelta(seconds=1), usegmt=True)),
                     ('date-future', format_datetime(date + timedelta(seconds=1), usegmt=True))]
            for name, validator in cases:
                row, body = get(name, byte_range='bytes=32-63', validator=validator)
                partial = version.endswith('RC1') or name in ['range-only', 'strong-current', 'date-exact']
                assert row['status'] == (206 if partial else 200)
                assert body == (NEW[32:] if partial else NEW)
                assert row['contentRange'] == ('bytes 32-63/64' if partial else None)
                if name == 'strong-old':
                    downloaded = prefix_body + body if row['status'] == 206 else body
                    (work / 'client-result.bin').write_bytes(downloaded)
                    client = {'framework': version, 'action': 'append' if row['status'] == 206 else 'replace',
                              'bytes': len(downloaded), 'sha256': sha(downloaded),
                              'equalsOld': downloaded == OLD, 'equalsNew': downloaded == NEW}
                    (work / 'client-result.json').write_text(json.dumps(client, indent=2) + '\n')
                    assert client['equalsNew'] == version.endswith('RC2')
                    print('CLIENT ' + json.dumps(client), flush=True)
        finally:
            if server.poll() is None:
                os.killpg(server.pid, signal.SIGTERM)
                try:
                    server.wait(timeout=15)
                except subprocess.TimeoutExpired:
                    os.killpg(server.pid, signal.SIGKILL)
                    server.wait()
            (work / 'server-exit.txt').write_text(str(server.returncode) + '\n')
(LOG / 'matrix.json').write_text(json.dumps(all_rows, indent=2) + '\n')
(ROOT / 'logs').mkdir(exist_ok=True)
(ROOT / 'logs/LATEST_RUN.txt').write_text(LOG.name + '\n')
print('PASS: real static handlers, validators, ranges and updated-file recovery; owned servers stopped')

在工程根目录运行:

python3 run.py

入口会真实构建两版、启动各自的本地服务、执行未修改和已替换文件的请求,并保存 28 份静态资源响应。原始 HTTP 头、响应字节、curl 轨迹、验证器、哈希和依赖树分别写入新建的 run-logs-* 目录;服务只监听 127.0.0.1:18932,端口占用时直接退出,不停止其他服务。

通过时输出:

PASS: real static handlers, validators, ranges and updated-file recovery; owned servers stopped

入口在每版测试结束后只停止自己启动的 Java 进程。它没有测试代理缓存、压缩表示、多区间、HEAD、非法 Range 或文件被并发修改的情况。

— 感谢阅读 —
广告

一起交流

分享你的思考,让讨论更进一步。