面试题集锦:TCP / HTTP / HTTPS

通识对照:WebSocket 实时系统三平面:连接、推送、状态

面试题集锦:TCP / HTTP / HTTPS

Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。


正文

一句话总结:TCP 通过状态机和滑动窗口实现了不可靠网络之上的可靠字节流传输,但连接建立的三次握手和拆除的四次挥手引入了显著延迟;HTTP 在 TCP 之上构建了无状态的请求-响应语义,从 HTTP/1.1 的串行管道到 HTTP/2 的二进制多路复用,再到 HTTP/3 基于 QUIC 将连接迁移和 0-RTT 握手内置于传输层;而 HTTPS 通过 TLS 在握手阶段协商出对称密钥,用证书链解决身份认证问题——在风控高并发交易场景中,TCP 的 TIME_WAIT 堆积和 TLS 的握手延迟往往是 P99 长尾的元凶。


1. 概念定义(是什么)

1.1 TCP:可靠传输的代价

TCP(Transmission Control Protocol) 是传输层协议,核心使命是在不可靠的 IP 网络之上提供面向连接、可靠、有序、基于字节流的通信能力。

可靠性机制:

  • 三次握手:同步双方初始序列号(ISN),交换窗口大小、MSS 等选项
  • 序列号与确认应答(ACK):每个字节都有编号,接收方累积确认
  • 滑动窗口:基于接收方通告窗口(rwnd)和拥塞窗口(cwnd)的动态流控
  • 重传机制:超时重传(RTO)+ 快速重传(3 个重复 ACK)
  • 四次挥手:全双工连接需要双方分别关闭自己的发送通道

1.2 HTTP:应用层协议的演进逻辑

HTTP(HyperText Transfer Protocol) 是应用层协议,核心语义是请求-响应、无状态、基于文本。

版本核心改进未解决的问题
HTTP/1.0短连接,每次请求新建 TCP连接开销大
HTTP/1.1Keep-Alive 长连接、Pipeline、Host 头、Range 请求队头阻塞(Head-of-Line Blocking)、明文传输
HTTP/2二进制分帧、多路复用、HPACK 头部压缩、Server PushTCP 层队头阻塞、握手延迟
HTTP/3基于 QUIC(UDP)、内置 TLS 1.3、0-RTT、连接迁移UDP 穿透企业防火墙/中间件困难

1.3 HTTPS = HTTP + TLS

TLS(Transport Layer Security) 解决三个问题:

  1. 机密性:对称加密传输应用数据
  2. 完整性:MAC(Message Authentication Code)防篡改
  3. 身份认证:证书链(Certificate Chain)验证服务端身份

TLS 演进:

  • TLS 1.2:2-RTT 握手,支持多种加密套件(CBC、GCM)
  • TLS 1.3:1-RTT(首次)/ 0-RTT(恢复),废弃不安全算法(MD5、SHA-1、RSA 密钥交换),强制前向保密(FS)

1.4 类比理解

类比:国际快递系统

  • IP = 国际邮政网络:把包裹从 A 国送到 B 国,但不保证一定送到、不保证顺序、不保证完好
  • TCP = 顺丰快递:> - 三次握手 = 寄件前打电话确认对方地址、约定包裹编号规则(ISN 同步)> - 滑动窗口 = 对方说"我仓库还能放 100 个包裹",你就最多发 100 个,等对方签收后再发下一批> - 四次挥手 = 寄件人说"我发完了",收件人说"我收到了";然后收件人说"我也发完了",寄件人说"我也收到了"——双方都要确认自己的通道关闭
  • HTTP = 快递单上的"物品清单格式":> - HTTP/1.1 = 每次发货前都要重新打电话确认(虽然可以约定"这批货都用这个电话"——Keep-Alive),而且必须等前一个包裹签收才能发下一个(队头阻塞)> - HTTP/2 = 把所有小包裹装进同一个集装箱,编上号,混装发货,到对方再按编号拆分(二进制分帧 + 多路复用)> - HTTP/3 = 不用顺丰了,改用无人机直飞(QUIC/UDP),而且无人机自带加密和身份验证
  • HTTPS = 顺丰快递的"保价 + 身份验证"服务:> - TLS 握手 = 双方交换身份证(证书),确认对方不是骗子,然后约定一个只有双方知道的密码箱密码(会话密钥)> - 证书链 = 你的身份证由公安局签发,公安局的资质由国务院认证——逐级追溯到根信任锚点

2. 核心原理与图解

2.1 TCP 状态机全景

2.2 三次握手与四次挥手详解

三次握手时序:

为什么不是两次握手?

假设只有两次握手:Client 发 SYN,Server 回 SYN+ACK 后立即认为连接建立。如果 SYN 在网络中延迟到达(已失效的连接请求报文段),Server 会为这个过期请求创建连接并等待数据,但 Client 早已放弃,导致 Server 资源被无效占用。第三次 ACK 确保双方都对初始序列号达成共识。

四次挥手时序:

为什么需要 TIME_WAIT(2MSL)?

  1. 可靠终止:如果 Client 最后的 ACK 丢失,Server 会重发 FIN,Client 必须能在 TIME_WAIT 状态下重发 ACK。2MSL(Maximum Segment Lifetime)确保最后一个 ACK 的往返时间。
  2. 防止旧连接报文干扰新连接:如果 Client 立即重用同一端口建立新连接,网络中延迟的旧报文可能被新连接误收。

风控场景警示:高并发短连接(如 Java 应用作为 Client 频繁调用外部风控 API)会导致客户端出现大量 TIME_WAIT 状态连接,耗尽本地端口(65535 个),引发 ConnectException: Cannot assign requested address。

2.3 HTTP 演进:从文本到二进制,从 TCP 到 UDP

HTTP/2 二进制帧结构:

HTTP/2 vs HTTP/1.1 核心差异:

特性HTTP/1.1HTTP/2
传输格式文本(ASCII)二进制分帧
并发多 TCP 连接(6-8 个/域名)单 TCP 连接 + 多 Stream
队头阻塞应用层(请求串行)应用层解决,但 TCP 层仍在
头部压缩无(重复发送完整 Header)HPACK(静态表 + 动态表 + Huffman)
流控无基于 Window Update 帧的 Stream 级 + Connection 级流控
Server Push无支持(但实践中较少使用)

HTTP/3 QUIC 的核心改进:

特性HTTP/2 over TCPHTTP/3 over QUIC
传输层TCPUDP + QUIC
握手延迟TCP 1-RTT + TLS 1-RTT = 2-RTTQUIC 内置 TLS 1.3 = 1-RTT(首次)/ 0-RTT(恢复)
队头阻塞TCP 丢包阻塞所有 StreamQUIC Stream 独立,单 Stream 丢包不影响其他
连接迁移四元组(源 IP/Port + 目 IP/Port)变化则断连Connection ID 标识连接,IP 变化不影响
拥塞控制TCP 内核实现,应用不可控用户空间实现,可自定义

2.4 TLS 握手深度对比

TLS 1.2 握手(2-RTT,不含 TCP):

TLS 1.3 握手(1-RTT):

0-RTT 恢复机制(基于 PSK):

0-RTT 的风险——重放攻击:

  • 攻击者截获 Client 的 0-RTT 数据包,重复发送给 Server
  • 如果 0-RTT 请求是"转账"或"修改配置",重放会导致严重后果
  • 防护:TLS 1.3 规范要求 0-RTT 数据必须是幂等的(如 GET 请求);非幂等操作(POST)不应在 0-RTT 中发送。服务端通过 Single-Use Ticket 或 Client Hello 随机数校验限制重放窗口。

2.5 证书链验证原理


3. 语法详解与代码示例(怎么用)

3.1 生产级 HTTP Client 配置(HTTP/2 + TLS 1.3 + 连接池)

import okhttp3.*;
import okhttp3.logging.HttpLoggingInterceptor;
import javax.net.ssl.*;
import java.net.InetSocketAddress;
import java.net.Proxy;
import java.security.cert.X509Certificate;
import java.time.Duration;
import java.util.Arrays;
import java.util.Collections;
import java.util.concurrent.TimeUnit;
 
/**
 * 风控服务间调用的 HTTP Client 配置
 * 要求:支持 HTTP/2、TLS 1.3、mTLS 双向认证、连接池复用
 */
public class RiskHttpClientFactory {
 
    /**
     * 创建生产级 OkHttpClient(调用外部风控 API)
     */
    public static OkHttpClient createSecureClient(RiskClientConfig config) {
        // 1. 连接池:复用 TCP 连接,避免高频短连接导致 TIME_WAIT 爆炸
        ConnectionPool connectionPool = new ConnectionPool(
            config.getMaxIdleConnections(),   // 如 50
            config.getKeepAliveDurationSec(), // 如 300s(5分钟)
            TimeUnit.SECONDS
        );
 
        // 2. TLS 配置:强制 TLS 1.3,禁用弱 cipher
        ConnectionSpec spec = new ConnectionSpec.Builder(ConnectionSpec.MODERN_TLS)
            .tlsVersions(TlsVersion.TLS_1_3, TlsVersion.TLS_1_2)
            .cipherSuites(
                CipherSuite.TLS_AES_256_GCM_SHA384,
                CipherSuite.TLS_AES_128_GCM_SHA256,
                CipherSuite.TLS_CHACHA20_POLY1305_SHA256
            )
            .build();
 
        // 3. 协议:优先 HTTP/2,降级 HTTP/1.1
        List<Protocol> protocols = Arrays.asList(Protocol.HTTP_2, Protocol.HTTP_1_1);
 
        // 4. 可选:mTLS 双向认证
        SSLContext sslContext = config.isMutualTls()
            ? createMutualTlsContext(config.getClientCertPath(), config.getClientKeyPath(), config.getCaCertPath())
            : createDefaultSslContext(config.getCaCertPath());
 
        // 5. 构建 Client
        OkHttpClient.Builder builder = new OkHttpClient.Builder()
            .connectionPool(connectionPool)
            .connectionSpecs(Collections.singletonList(spec))
            .protocols(protocols)
            .sslSocketFactory(sslContext.getSocketFactory(), defaultTrustManager())
            .hostnameVerifier(createStrictHostnameVerifier())
            .connectTimeout(Duration.ofSeconds(5))     // TCP 握手超时
            .readTimeout(Duration.ofSeconds(10))       // 响应读取超时
            .writeTimeout(Duration.ofSeconds(5))       // 请求发送超时
            .callTimeout(Duration.ofSeconds(15))       // 整次调用超时
            .retryOnConnectionFailure(true)
            .addInterceptor(new RequestIdInterceptor())   // 注入 traceId
            .addInterceptor(new HttpLoggingInterceptor(log::debug).setLevel(HttpLoggingInterceptor.Level.HEADERS));
 
        // 6. 可选:代理(如通过安全网关)
        if (config.getProxyHost() != null) {
            builder.proxy(new Proxy(Proxy.Type.HTTP,
                new InetSocketAddress(config.getProxyHost(), config.getProxyPort())));
        }
 
        return builder.build();
    }
 
    /**
     * mTLS 双向认证:风控内部服务间通信强制使用
     */
    private static SSLContext createMutualTlsContext(
            String clientCertPath, String clientKeyPath, String caCertPath) {
        try {
            // 加载客户端证书 + 私钥
            KeyStore keyStore = KeyStore.getInstance("PKCS12");
            keyStore.load(
                Files.newInputStream(Path.of(clientCertPath)),
                null  // 假设 cert 已包含 key,或单独加载
            );
 
            KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
            kmf.init(keyStore, new char[0]);
 
            // 加载 CA 证书(校验服务端)
            TrustManagerFactory tmf = loadCaTrustManager(caCertPath);
 
            SSLContext sslContext = SSLContext.getInstance("TLSv1.3");
            sslContext.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);
            return sslContext;
 
        } catch (Exception e) {
            throw new RuntimeException("Failed to create mTLS context", e);
        }
    }
 
    /**
     * 严格的 HostnameVerifier:防止 DNS 劫持下的证书伪造
     */
    private static HostnameVerifier createStrictHostnameVerifier() {
        return (hostname, session) -> {
            // 使用 OkHttp 内置的严格校验
            boolean ok = OkHostnameVerifier.INSTANCE.verify(hostname, session);
            if (!ok) {
                log.error("Hostname verification failed: expected={}, peer={}",
                    hostname, session.getPeerPrincipal());
            }
            return ok;
        };
    }
 
    /**
     * 发送风控查询请求(HTTP/2 多路复用示例)
     */
    public static void executeParallelQueries(OkHttpClient client, List<String> userIds) {
        String baseUrl = "https://risk-api.internal.大型加密货币交易所.com/v1/user-risk";
 
        // HTTP/2 下,这些请求共享同一 TCP 连接,Stream 多路复用
        List<Call> calls = userIds.stream().map(userId -> {
            Request request = new Request.Builder()
                .url(baseUrl + "?userId=" + userId)
                .header("X-Request-Id", UUID.randomUUID().toString())
                .header("Accept", "application/json")
                .build();
            return client.newCall(request);
        }).toList();
 
        // 并发执行(HTTP/2 下单连接并发,HTTP/1.1 下连接池多连接并发)
        List<CompletableFuture<Response>> futures = calls.stream()
            .map(call -> CompletableFuture.supplyAsync(() -> {
                try (Response response = call.execute()) {
                    if (!response.isSuccessful()) {
                        throw new IOException("Unexpected code " + response);
                    }
                    return response;
                }
            }))
            .toList();
 
        // 等待全部完成
        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();
    }
}

3.2 Netty HTTP/2 服务端实现(风控数据上报接口)

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.http2.*;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import io.netty.handler.ssl.*;
 
/**
 * 风控数据上报服务端:支持 HTTP/2,处理高并发设备指纹/行为数据上报
 */
public class RiskIngestionServer {
 
    private final int port;
    private final SslContext sslContext;
 
    public RiskIngestionServer(int port, SslContext sslContext) {
        this.port = port;
        this.sslContext = sslContext;
    }
 
    public void start() throws InterruptedException {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup(Runtime.getRuntime().availableProcessors() * 2);
 
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
                .channel(NioServerSocketChannel.class)
                .handler(new LoggingHandler(LogLevel.INFO))
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) {
                        ChannelPipeline p = ch.pipeline();
 
                        // 1. TLS Handler(ALPN 协商 HTTP/2 vs HTTP/1.1)
                        if (sslContext != null) {
                            p.addLast(sslContext.newHandler(ch.alloc()));
                        }
 
                        // 2. ALPN 协议协商
                        p.addLast(new ApplicationProtocolNegotiationHandler("http/1.1") {
                            @Override
                            protected void configurePipeline(ChannelHandlerContext ctx, String protocol) {
                                if (ApplicationProtocolNames.HTTP_2.equals(protocol)) {
                                    // HTTP/2 管道
                                    Http2FrameCodec frameCodec = Http2FrameCodecBuilder.forServer().build();
                                    Http2MultiplexHandler multiplexHandler = new Http2MultiplexHandler(
                                        new ChannelInitializer<Channel>() {
                                            @Override
                                            protected void initChannel(Channel ch) {
                                                ch.pipeline().addLast(new RiskDataHttp2Handler());
                                            }
                                        });
                                    ctx.pipeline().addLast(frameCodec, multiplexHandler);
                                } else if (ApplicationProtocolNames.HTTP_1_1.equals(protocol)) {
                                    // HTTP/1.1 降级管道
                                    ctx.pipeline().addLast(
                                        new io.netty.handler.codec.http.HttpServerCodec(),
                                        new RiskDataHttp1Handler()
                                    );
                                } else {
                                    ctx.close();
                                }
                            }
                        });
                    }
                })
                .option(ChannelOption.SO_BACKLOG, 1024)
                .childOption(ChannelOption.SO_KEEPALIVE, true)
                .childOption(ChannelOption.TCP_NODELAY, true);  // 禁用 Nagle,降低风控数据上报延迟
 
            ChannelFuture f = b.bind(port).sync();
            f.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}
 
/**
 * HTTP/2 Stream 处理器:处理单条数据上报
 */
public class RiskDataHttp2Handler extends ChannelDuplexHandler {
 
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        if (msg instanceof Http2HeadersFrame headersFrame) {
            Http2Headers headers = headersFrame.headers();
            String path = headers.path().toString();
 
            if ("/v1/risk/ingest".equals(path) && headersFrame.isEndStream()) {
                // 处理无 body 的请求(如 GET)
                sendResponse(ctx, headersFrame.stream().id(), 200);
            }
        } else if (msg instanceof Http2DataFrame dataFrame) {
            ByteBuf content = dataFrame.content();
            // 解析设备指纹/行为数据 JSON
            RiskIngestionEvent event = parseEvent(content);
 
            // 异步写入 Kafka(不阻塞 I/O 线程)
            event.getExecutor().execute(() -> {
                KafkaProducer.send("risk.device.events", event);
            });
 
            if (dataFrame.isEndStream()) {
                sendResponse(ctx, dataFrame.stream().id(), 202);
            }
        }
    }
 
    private void sendResponse(ChannelHandlerContext ctx, int streamId, int status) {
        Http2Headers headers = new DefaultHttp2Headers().status(String.valueOf(status));
        ctx.write(new DefaultHttp2HeadersFrame(headers, true).stream(
            ctx.channel().attr(Http2StreamChannelBootstrap.HTTP2_STREAM_CHANNEL_KEY).get()));
    }
}

3.3 TCP 参数调优与 TIME_WAIT 治理(Linux + Java)

/**
 * 风控高并发场景下的 TCP 参数配置
 * 适用于:Java 服务作为 Client 高频调用外部 API(如第三方风控数据源)
 */
@Component
public class TcpTuningService {
 
    /**
     * 方案 1:连接池复用(根本解决)
     * 避免短连接,复用长连接
     */
    @Bean
    public OkHttpClient pooledRiskClient() {
        return new OkHttpClient.Builder()
            .connectionPool(new ConnectionPool(100, 5, TimeUnit.MINUTES))
            .build();
    }
 
    /**
     * 方案 2:JVM 启动参数 + Linux Kernel 调参
     *
     * /etc/sysctl.conf 推荐配置:
     * # 允许端口复用(针对主动关闭方的 TIME_WAIT)
     * net.ipv4.tcp_tw_reuse = 1
     *
     * # 不建议开启 tcp_tw_recycle(Linux 4.12+ 已移除,NAT 环境下会导致连接异常)
     * # net.ipv4.tcp_tw_recycle = 0
     *
     * # 增大本地端口范围
     * net.ipv4.ip_local_port_range = 1024 65535
     *
     * # 增大 TIME_WAIT 队列
     * net.ipv4.tcp_max_tw_buckets = 500000
     *
     * # 开启 SYN Cookies,防 SYN Flood
     * net.ipv4.tcp_syncookies = 1
     *
     * # 缩短 FIN_WAIT_2 超时(默认 60s)
     * net.ipv4.tcp_fin_timeout = 30
     *
     * # 增大文件描述符限制
     * fs.file-max = 2097152
     */
 
    /**
     * 方案 3:Java Socket 选项调优
     */
    public static void configureSocket(Socket socket) throws SocketException {
        // SO_KEEPALIVE:探测死连接,避免僵尸 Socket 占用资源
        socket.setKeepAlive(true);
 
        // TCP_NODELAY:禁用 Nagle 算法,立即发送小数据包(风控数据上报延迟敏感)
        socket.setTcpNoDelay(true);
 
        // SO_REUSEADDR:允许重用本地地址(服务端快速重启时使用)
        // 注意:SO_REUSEADDR 不等同于 tcp_tw_reuse,不能解决 TIME_WAIT 客户端问题
        socket.setReuseAddress(true);
 
        // SO_LINGER:close() 时立即发送 RST 而非 FIN,避免 TIME_WAIT(慎用,可能导致数据丢失)
        // socket.setSoLinger(true, 0);
    }
 
    /**
     * 方案 4:连接预热(避免冷启动时的 TCP + TLS 握手延迟)
     */
    @Scheduled(fixedDelay = 30000)
    public void warmupConnections() {
        // 定期发送心跳请求,保持连接池中的连接处于 ESTABLISHED 状态
        for (String endpoint : riskEndpoints) {
            try {
                Request heartbeat = new Request.Builder()
                    .url(endpoint + "/health")
                    .head()
                    .build();
                pooledClient.newCall(heartbeat).execute().close();
            } catch (IOException e) {
                log.warn("Connection warmup failed for {}", endpoint);
            }
        }
    }
}

3.4 TLS 证书链加载与 OCSP Stapling

/**
 * TLS 证书链校验与 OCSP Stapling 配置
 * OCSP Stapling:服务端在 TLS 握手时直接附带证书吊销状态,避免客户端实时查询 CA
 */
public class TlsCertificateManager {
 
    /**
     * 加载证书链(叶子证书 + 中间 CA)
     */
    public static X509Certificate[] loadCertificateChain(String certPath) throws Exception {
        String pem = Files.readString(Path.of(certPath));
        CertificateFactory factory = CertificateFactory.getInstance("X.509");
 
        List<X509Certificate> certs = new ArrayList<>();
        try (StringReader reader = new StringReader(pem);
             PEMParser parser = new PEMParser(reader)) {
 
            Object obj;
            while ((obj = parser.readObject()) != null) {
                if (obj instanceof X509CertificateHolder holder) {
                    certs.add(new JcaX509CertificateConverter()
                        .setProvider("BC")
                        .getCertificate(holder));
                }
            }
        }
        return certs.toArray(new X509Certificate[0]);
    }
 
    /**
     * 校验证书链完整性
     */
    public static void validateChain(X509Certificate[] chain, X509Certificate rootCa) throws Exception {
        // 1. 构建证书路径
        CertPathBuilder builder = CertPathBuilder.getInstance("PKIX");
        PKIXBuilderParameters params = new PKIXBuilderParameters(
            loadTrustStore(rootCa), new X509CertSelector());
        params.setRevocationEnabled(true);  // 启用 CRL/OCSP 校验
 
        CertStore certStore = CertStore.getInstance("Collection",
            new CollectionCertStoreParameters(Arrays.asList(chain)));
        params.addCertStore(certStore);
 
        // 2. 构建并校验路径
        PKIXCertPathBuilderResult result = (PKIXCertPathBuilderResult) builder.build(params);
        log.info("Certificate chain validated: {}", result.getCertPath());
    }
 
    /**
     * Netty 服务端启用 OCSP Stapling
     */
    public static SslContext createServerSslContextWithOcsp(
            String certChainPath, String privateKeyPath) throws Exception {
 
        // 使用 BouncyCastle 生成 OCSP 响应
        OCSPResp ocspResponse = fetchOcspResponse(certChainPath);
 
        return SslContextBuilder.forServer(
                new File(privateKeyPath),
                new File(certChainPath))
            .sslProvider(SslProvider.OPENSSL)  // OpenSSL 支持 OCSP Stapling
            .ocspResponse(ocspResponse.getEncoded())
            .build();
    }
 
    private static OCSPResp fetchOcspResponse(String certPath) throws Exception {
        X509Certificate[] chain = loadCertificateChain(certPath);
        X509Certificate leaf = chain[0];
 
        // 从证书 AIA 扩展获取 OCSP Responder URL
        byte[] aiaExt = leaf.getExtensionValue(Extension.authorityInfoAccess.getId());
        String ocspUrl = extractOcspUrl(aiaExt);
 
        // 构建 OCSP Request
        OCSPReqBuilder reqBuilder = new OCSPReqBuilder();
        reqBuilder.addRequest(new JcaCertificateID(
            new SHA1DigestCalculator(),
            chain[1],  // Issuer
            leaf.getSerialNumber()
        ));
        OCSPReq ocspReq = reqBuilder.build();
 
        // 发送 OCSP 查询
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(ocspUrl))
            .header("Content-Type", "application/ocsp-request")
            .POST(HttpRequest.BodyPublishers.ofByteArray(ocspReq.getEncoded()))
            .build();
 
        HttpResponse<byte[]> response = HttpClient.newHttpClient()
            .send(request, HttpResponse.BodyHandlers.ofByteArray());
 
        return new OCSPResp(response.body());
    }
}

4. 业界案例

4.1 Google:QUIC / HTTP/3 在 YouTube 的全球部署

Google 从 2012 年开始研发 QUIC(Quick UDP Internet Connections),2015 年在 Chrome 和 Google 服务端全面启用 gQUIC(Google QUIC 版本)。

核心痛点:

  • YouTube 视频流对连接迁移需求极高:用户从 Wi-Fi 切换到 4G,TCP 连接因四元组变化而断开,视频需要重新缓冲
  • 移动网络下 TCP 队头阻塞严重:一个丢包阻塞所有 HTTP/2 Stream,导致视频卡顿

技术方案:

  • 连接迁移:QUIC 使用 64-bit Connection ID 标识连接,IP/Port 变化不影响连接状态。用户切换网络时,视频流无缝继续
  • 0-RTT 恢复:用户重新打开 App 时,第一个数据包即可携带请求,无需等待握手
  • 用户空间拥塞控制:QUIC 跑在用户态,可以快速迭代拥塞控制算法(如 BBR v2),不受内核 TCP 栈更新周期限制

量化效果:

  • YouTube 移动端视频重缓冲率降低 30%
  • 搜索延迟(移动端)降低 2%(看似小,但 Google 搜索量巨大,用户体验提升显著)

踩过的坑:

  • 中间件拦截 UDP:企业防火墙、运营商 NAT 对 UDP 限制严格(如限速、丢包、阻断)。Google 的解决方案是连接竞速(Connection Racing):同时尝试 QUIC 和 TCP 连接,哪个先通就用哪个
  • QUIC 放大攻击:UDP 无连接特性可被用于 DDoS 放大攻击。IETF QUIC 通过要求 Client Hello 最小包大小(1200 bytes)和 Token 机制缓解

4.2 阿里巴巴:淘宝大促全链路 HTTP/2 升级与 HTTP/3 试点

淘宝在 2016-2018 年间完成了全站 HTTP/2 升级,支撑了双十一亿级 QPS。

HTTP/2 部署经验:

  1. 多路复用收益:淘宝详情页需要加载 100+ 资源(图片、JS、CSS)。HTTP/1.1 下需要 6-8 个 TCP 连接,HTTP/2 下单连接即可,TCP 连接数减少 80%
  2. HPACK 头部压缩:电商请求 Header 极大(Cookie、个性化参数),HPACK 动态表将 Header 大小压缩 60-70%
  3. Server Push 的教训:早期尝试 Server Push 推送商品推荐资源,但命中率低、浪费带宽。最终方案:用 Link: <...>; rel=preload 替代原生 Server Push,让浏览器自主决策

HTTP/3 试点:

  • 2021 年起在淘宝 App 内试点 HTTP/3(基于 Cronet,Chromium 网络库)
  • 核心收益:弱网环境下的请求成功率提升。移动网络下 TCP 丢包导致重传超时(RTO)往往 200ms+,QUIC 的 Stream 级丢包恢复将影响隔离到单个请求
  • 挑战:Android/iOS 系统的 UDP 套接字权限和后台限制,导致 HTTP/3 在 App 后台切前台时需要重新握手

4.3 Cloudflare:TLS 1.3 0-RTT 的全球边缘节点实践

Cloudflare 在 2019 年全面启用 TLS 1.3,并支持 0-RTT Early Data。

架构背景:

  • Cloudflare 有 300+ 边缘节点,用户首次访问某节点时需要完整 TLS 握手(1-RTT)
  • 对于重复访问(如刷新页面),0-RTT 可以将首包延迟从 ~200ms 降到 ~50ms

安全防护措施:

  1. Early Data 白名单:只有 GET 和 HEAD 请求允许 0-RTT,POST/PUT/DELETE 必须等待握手完成
  2. Anti-Replay Token:每个 0-RTT 请求附带 Client Hello 随机数,服务端在 5 秒窗口内去重
  3. Origin 隔离:0-RTT 数据不直接透传到源站(Origin),由边缘节点缓存或代理,防止重放攻击穿透到源站数据库

效果:

  • TLS 握手延迟中位数降低 40%
  • 0-RTT 使用率占全部 HTTPS 流量的 35%

5. 业务场景对照与注意事项

5.1 风控场景下的网络层考量

场景网络层挑战解决方案
实时交易拦截TLS 握手延迟 200ms+ 拖垮 P99TLS Session Ticket 复用、连接预热、0-RTT
高并发设备上报百万设备同时 TCP 连接,服务端端口耗尽TCP Fast Open、SYN Cookie、连接池复用
风控微服务 mTLS双向证书管理复杂,证书过期导致服务中断自动化证书轮换( cert-manager)、SPIFFE/SPIRE 身份框架
跨地域风控数据同步跨境网络高延迟、丢包QUIC 连接迁移、多路复用、前向纠错(FEC)
第三方风控 API 调用客户端 TIME_WAIT 堆积连接池长连接、tcp_tw_reuse、端口范围调大

5.2 常见误区 vs 正确做法

❌ 误区 1:HTTP/2 一定比 HTTP/1.1 快
    - 认为升级 HTTP/2 后所有请求都会加速
✅ 正确做法:HTTP/2 的优势在"高并发小请求"和"多资源并行加载"。如果业务是低频大文件传输,HTTP/2 的收益有限,且二进制分帧的 CPU 开销可能抵消收益
 
❌ 误区 2:开启 tcp_tw_recycle 解决 TIME_WAIT
    - Linux 旧版本用 tcp_tw_recycle 快速回收 TIME_WAIT
✅ 正确做法:tcp_tw_recycle 在 NAT 环境下会导致连接异常(时间戳校验问题),Linux 4.12+ 已移除。应使用 tcp_tw_reuse + 连接池复用
 
❌ 误区 3:TLS 1.3 0-RTT 可以随意使用
    - 为了降低延迟,所有请求都走 0-RTT
✅ 正确做法:0-RTT 存在重放攻击风险。仅对幂等请求(GET/HEAD)启用,非幂等请求(POST 转账)必须等待完整握手
 
❌ 误区 4:忽略证书过期监控
    - 证书到期前没有预警,导致服务突然不可用
✅ 正确做法:自动化证书管理(Let's Encrypt + cert-manager),过期前 30/15/7 天多级告警,支持自动轮换
 
❌ 误区 5:HTTP/2 Server Push 万能论
    - 认为 Server Push 可以主动推送所有资源,减少 RTT
✅ 正确做法:Server Push 命中率难以保证,且会浪费带宽(推送了客户端缓存中已有的资源)。Chrome 已逐步废弃 Server Push,推荐用 HTTP 103 Early Hints + Preload 替代

6. FAQ 与高频追问

Q1:为什么 TCP 握手是三次,不是两次或四次?

答:

  • 两次不够:无法防止已失效的连接请求报文突然又传送到服务端,造成服务端错误建立连接(资源浪费)。三次握手的第三次 ACK 让 Client 确认 Server 已收到自己的 SYN
  • 四次没必要:三次已经能同步双方的初始序列号(ISN)并确认收发能力。四次会增加一个 RTT 延迟,没有额外收益

追问:SYN Flood 攻击怎么防御?

  • SYN Cookie:Server 收到 SYN 后不分配资源,而是将连接信息编码到 SYN-ACK 的序列号中。只有收到合法的 ACK 后才重建连接状态
  • SYN Proxy:前置代理完成三次握手后再与后端建立连接
  • 限制 SYN 速率:iptables / nftables 限制单 IP 的 SYN 包速率

Q2:TIME_WAIT 状态为什么要等待 2MSL?大量 TIME_WAIT 怎么解决?

答:

  1. 确保最后的 ACK 被对方收到:如果 ACK 丢失,对方会重发 FIN,TIME_WAIT 状态下的连接能够重发 ACK
  2. 让旧连接的报文在网络中消散:防止下一个使用相同四元组的新连接收到旧连接的延迟报文

大量 TIME_WAIT 的解决方案(从优到劣):

  1. 连接池复用(根本解决):避免频繁创建/销毁连接
  2. tcp_tw_reuse = 1:允许将 TIME_WAIT 状态的连接用于新的出站连接(仅 Client 侧有效,安全)
  3. 增大 ip_local_port_range:扩大可用端口范围
  4. tcp_tw_recycle = 1:不推荐,NAT 环境下会导致连接异常,已废弃
  5. SO_LINGER = 0:close() 时发 RST 直接销毁连接,不推荐,可能丢数据

Q3:HTTP/2 解决了应用层队头阻塞,为什么说还有 TCP 层队头阻塞?HTTP/3 是怎么解决的?

答:

  • HTTP/1.1 应用层队头阻塞:一个 TCP 连接上请求必须串行发送,Response 2 必须等 Response 1 返回
  • HTTP/2 解决应用层 HOL:二进制分帧 + Stream 多路复用,不同 Stream 的帧可以交替发送
  • HTTP/2 的 TCP 层队头阻塞:所有 Stream 共享同一个 TCP 连接,TCP 是字节流协议,必须保证有序。如果 Stream 1 的数据包丢失,TCP 滑动窗口阻塞,即使 Stream 3 的数据包已到达也无法递交给应用层

HTTP/3 的解决:QUIC 基于 UDP,每个 Stream 有独立的帧序列号和确认机制。Stream 1 丢包只会阻塞 Stream 1 的数据,Stream 3 的数据可以独立递交。

Q4:TLS 1.3 相比 1.2 的核心改进是什么?0-RTT 的原理和安全风险?

答:

核心改进:

  1. 握手简化:1-RTT(首次)vs TLS 1.2 的 2-RTT,减少一次往返
  2. 移除不安全算法:废弃 RSA 密钥交换(无前向保密)、RC4、3DES、SHA-1、MD5、CBC 模式
  3. 前向保密强制:所有握手都使用 ECDHE,即使长期私钥泄露,历史会话也无法解密
  4. 加密范围扩大:Server Hello 之后的所有消息(包括证书)都加密,减少中间人窥探面

0-RTT 原理:

  • 首次握手后,Server 发给 Client 一个 PSK(Pre-Shared Key)Ticket
  • 下次连接时,Client 直接用 PSK + 新 ECDHE 参数派生密钥,并在第一个包携带应用数据

安全风险:

  • 重放攻击:攻击者截获 0-RTT 数据包重复发送。如果请求是非幂等的(如 POST 转账),重放会造成实际损失
  • 防护:只允许幂等请求走 0-RTT;服务端使用 Single-Use Ticket 或 Client Hello 随机数去重窗口

Q5:证书链验证失败常见原因有哪些?OCSP Stapling 解决了什么问题?

答:

常见失败原因:

  1. 证书过期:notAfter 时间已过
  2. 域名不匹配:证书 SAN(Subject Alternative Name)不包含请求域名
  3. 中间 CA 缺失:Server 只发送了叶子证书,未发送中间 CA,客户端本地也没有缓存
  4. 证书被吊销:CA 已将该证书标记为无效(私钥泄露、域名所有权变更)
  5. 系统时间错误:客户端时间不对,导致有效期校验失败
  6. 自签名证书/私有 CA:未将根证书导入客户端 Trust Store

OCSP Stapling:

  • 问题:传统 OCSP 需要客户端在 TLS 握手后实时向 CA 的 OCSP Responder 查询证书状态,增加一次网络往返,且 CA 的可用性影响服务可用性
  • 解决:服务端在 TLS 握手时直接附带 OCSP Response(由 CA 签发,有有效期,通常 7 天)。客户端无需额外查询,且 OCSP Response 有 CA 数字签名,不可伪造

Q6:TCP 的 Keep-Alive 和 HTTP 的 Keep-Alive 有什么区别?

答:

维度TCP Keep-AliveHTTP Keep-Alive
层级传输层(内核实现)应用层(HTTP 协议头)
机制空闲一段时间后发送探测包(ACK)复用同一 TCP 连接发送多个 HTTP 请求
默认通常关闭(Linux net.ipv4.tcp_keepalive_time = 7200s)HTTP/1.1 默认开启
作用探测死连接,及时释放资源减少 TCP 连接建立开销
风控建议服务端开启 TCP Keep-Alive(60s),及时清理僵尸连接连接池配置 HTTP Keep-Alive 超时(如 5min),平衡复用与资源回收

7. 关联知识

文档关联点
G2 - WebSocket 实时通信WebSocket 基于 TCP 长连接,HTTP Upgrade 机制是其握手基础
G3 - 安全基础TLS 证书、HTTPS 攻击面(降级攻击、证书伪造)深入展开
A7 - Netty 线程模型Netty 是高性能 TCP/HTTP 服务端的核心框架,EventLoop 模型与 HTTP/2 多路复用协同
B1 - Dubbo 深度解析Dubbo 默认基于 Netty 的 TCP 长连接,序列化协议和连接管理与本章紧密相关
B5 - 限流与熔断HTTP 连接池耗尽是一种隐式熔断,需与显式 Sentinel/RateLimiter 配合
E8 - 风控一致性与性能风控系统的 CAP 权衡中,网络延迟(RTT)是同步决策 < 50ms 的核心约束条件

记忆口诀:

  • 三次握手 = 打电话确认:"喂,你听得到吗?" → "我听得到,你听得到吗?" → "我也听得到,开始说吧!"——两次不够确认双方都能收发,四次浪费时间
  • 四次挥手 = 挂电话:"我说完了" → "知道了" → "我也说完了" → "知道了"——因为全双工,双方的发送通道要分别关闭
  • TIME_WAIT = 等快递确认:你签收了对方的最后一件货,但还要等一会儿,防止快递系统里还有你这件货的旧记录飘过来,被新订单误收
  • HTTP 演进 = 修路:HTTP/1.1 是单车道(队头阻塞)→ HTTP/2 是多车道高架(多路复用但共用一座桥,桥堵了都堵)→ HTTP/3 是无人机送货(QUIC/UDP,每架无人机独立飞行)