WEB - connectTimeout / readTimeout 은 어디서 세팅되고, 어디서 적용되는가

@Component
public class ExternalLimitClient {

    private final RestTemplate restTemplate;

    public ExternalLimitClient(
            @Value("${external.api.base-url}") String baseUrl,
            @Value("${external.api.read-timeout-ms}") int readTimeoutMs) {
        SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
        factory.setReadTimeout(readTimeoutMs);     // ★ 여기서 뭐가 일어나는가?
        this.restTemplate = new RestTemplate(factory);
        this.baseUrl = baseUrl;
    }

    public LimitCheckResponse checkLimit(String orderNo, int amount) {
        return restTemplate.getForObject(
                baseUrl + "/limits/" + orderNo + "?amount=" + amount,
                LimitCheckResponse.class);
    }
}

// org.springframework.http.client.SimpleClientHttpRequestFactory
private int connectTimeout = -1;
private int readTimeout = -1;

protected void prepareConnection(HttpURLConnection connection, String httpMethod) throws IOException {
    if (this.connectTimeout >= 0) {
        connection.setConnectTimeout(this.connectTimeout);
    }
    if (this.readTimeout >= 0) {
        connection.setReadTimeout(this.readTimeout);
    }
    ...
}

// java.base/java/net/URLConnection.java
public void setConnectTimeout(int timeout) {
    if (timeout < 0) {
        throw new IllegalArgumentException("timeout can not be negative");
    }
    connectTimeout = timeout;      // 끝. 검증 + 대입.
}

// sun.net.www.protocol.http.HttpURLConnection#plainConnect0  (21.0.10 :1257~)
// (프록시 유무에 따라 분기가 여럿이지만 모든 분기가 이 두 줄 패턴이다)
http = getNewHttpClient(url, p, connectTimeout);   // ① connectTimeout 은 생성자 인자로
http.setReadTimeout(readTimeout);                  // ② readTimeout 은 소켓에 장전 (→ 4장)

// sun.net.NetworkClient#doConnect  (21.0.10 :152)
protected Socket doConnect (String server, int port)
        throws IOException, UnknownHostException {
    Socket s;
    ...
    s = createSocket();                    // FD 할당, TCP 는 아직 CLOSED

    if (connectTimeout >= 0) {
        s.connect(new InetSocketAddress(server, port), connectTimeout);   // :178 ★ 적용
    } else {
        if (defaultConnectTimeout > 0) {
            s.connect(new InetSocketAddress(server, port), defaultConnectTimeout);
        } else {
            s.connect(new InetSocketAddress(server, port));               // 무한 대기
        }
    }
    if (readTimeout >= 0)
        s.setSoTimeout(readTimeout);       // :187  readTimeout 을 소켓에 장전
    else if (defaultSoTimeout > 0) {
        s.setSoTimeout(defaultSoTimeout);
    }
    return s;
}

// sun.nio.ch.NioSocketImpl#connect(SocketAddress, int)  :561 발췌
configureNonBlockingIfNeeded(fd, millis > 0);        // :582  timeout>0 이면 FD를 논블로킹으로 전환
int n = Net.connect(fd, address, port);              // :583  native connect(2)
if (n > 0) {
    connected = true;                                // 즉시 성립 (루프백 등)
} else {
    assert IOStatus.okayToRetry(n);                  // EINPROGRESS — 연결은 백그라운드 진행 중
    if (millis > 0) {
        long nanos = MILLISECONDS.toNanos(millis);
        connected = timedFinishConnect(fd, nanos);   // :592 ★ 타임아웃 있는 대기
    } else {
        boolean polled = false;
        while (!polled && isOpen()) {                // FD가 논블로킹인데 timeout 0 인 경우만 (아래 참고)
            park(fd, Net.POLLOUT);                   // nanos 0 → poll(-1) = 무한 poll
            polled = Net.pollConnectNow(fd);
        }
        connected = polled && isOpen();
    }
}

// sun.nio.ch.NioSocketImpl:540
private boolean timedFinishConnect(FileDescriptor fd, long nanos) throws IOException {
    long startNanos = System.nanoTime();
    boolean polled = Net.pollConnectNow(fd);              // 논블로킹 즉시 확인
    while (!polled && isOpen()) {
        long remainingNanos = nanos - (System.nanoTime() - startNanos);
        if (remainingNanos <= 0) {
            throw new SocketTimeoutException("Connect timed out");   // ★ :546
        }
        park(fd, Net.POLLOUT, remainingNanos);            // 남은 시간만큼만 poll
        polled = Net.pollConnectNow(fd);
    }
    return polled && isOpen();
}

// sun.net.NetworkClient#setReadTimeout  :259
public void setReadTimeout(int timeout) {
    if (timeout == DEFAULT_READ_TIMEOUT)
        timeout = defaultSoTimeout;

    if (serverSocket != null && timeout >= 0) {
        try {
            serverSocket.setSoTimeout(timeout);      // :265  결국 여기
        } catch(IOException e) {
            // We tried...
        }
    }
    readTimeout = timeout;
}

// sun.net.www.protocol.http.HttpURLConnection#checkReuseConnection
private boolean checkReuseConnection () {
    if (connected) {
        return true;
    }
    if (reuseClient != null) {
        http = reuseClient;
        http.setReadTimeout(getReadTimeout());   // ★ 재사용 소켓에도 이번 요청 값으로 덮어쓰기
        http.reuse = false;
        reuseClient = null;
        connected = true;
        return true;
    }
    return false;
}

// java.net.Socket#setSoTimeout  :1383
public void setSoTimeout(int timeout) throws SocketException {
    if (isClosed())
        throw new SocketException("Socket is closed");
    if (timeout < 0)
        throw new IllegalArgumentException("timeout can't be negative");
    getImpl().setOption(SocketOptions.SO_TIMEOUT, timeout);
}

// sun.nio.ch.NioSocketImpl  :119
private volatile int timeout;

// sun.nio.ch.NioSocketImpl#setOption  :1015
public void setOption(int opt, Object value) throws SocketException {
    synchronized (stateLock) {
        ensureOpen();
        try {
            switch (opt) {
            case SO_LINGER: {
                ...
                Net.setSocketOption(fd, StandardSocketOptions.SO_LINGER, i);   // ← 커널로 내려감
                break;
            }
            case SO_TIMEOUT: {                          // :1031
                int i = intValue(value, "SO_TIMEOUT");
                if (i < 0)
                    throw new IllegalArgumentException("timeout < 0");
                timeout = i;                            // ★ 자바 필드 대입이 전부. Net.setSocketOption 호출이 없다
                break;
            }
            case TCP_NODELAY: {
                boolean b = booleanValue(value, "TCP_NODELAY");
                Net.setSocketOption(fd, StandardSocketOptions.TCP_NODELAY, b); // ← 커널로 내려감
                break;
            }
            ...

// sun.nio.ch.NioSocketImpl#getOption  :1100
public Object getOption(int opt) throws SocketException {
    synchronized (stateLock) {
        ensureOpen();
        try {
            switch (opt) {
            case SO_TIMEOUT:
                return timeout;              // :1105  커널에 안 물어본다. 방금 넣은 값을 그대로 돌려줄 뿐
            ...

// java.net.SocketOptions  :273
@Native public static final int SO_TIMEOUT = 0x1006;

// sun.nio.ch.NioSocketImpl#implRead  :292
int timeout = this.timeout;
configureNonBlockingIfNeeded(fd, timeout > 0);   // :301  ← timeout>0 이면 fd 를 O_NONBLOCK 으로
if (timeout > 0) {
    n = timedRead(fd, b, off, len, MILLISECONDS.toNanos(timeout));   // :304
} else {
    n = tryRead(fd, b, off, len);                // 타임아웃 없으면 그냥 블로킹 read
    while (IOStatus.okayToRetry(n) && isOpen()) {
        park(fd, Net.POLLIN);
        n = tryRead(fd, b, off, len);
    }
}

// sun.nio.ch.NioSocketImpl#configureNonBlockingIfNeeded  :209
private void configureNonBlockingIfNeeded(FileDescriptor fd, boolean timed) throws IOException {
    if (!nonBlocking
        && (timed || Thread.currentThread().isVirtual())) {
        IOUtil.configureBlocking(fd, false);     // ← 여기는 진짜 fcntl(2) syscall
        nonBlocking = true;                      // ★ 한 번 켜지면 되돌리는 코드가 없다
    }
}

// sun.net.www.http.HttpClient#parseHTTP  :742~
try {
    serverInput = serverSocket.getInputStream();        // :754  소켓의 InputStream
    if (capture != null) {
        serverInput = new HttpCaptureInputStream(serverInput, capture);
    }
    serverInput = new BufferedInputStream(serverInput); // :758
    return (parseHTTPHeader(responses, httpuc));        // :759
} catch (SocketTimeoutException stex) {
    // We don't want to retry the request when the app. sets a timeout
    if (ignoreContinue) {
        closeServer();
    }
    throw stex;                                         // ★ 타임아웃은 재시도 없이 그대로 올린다
} catch (IOException e) {
    closeServer();
    cachedHttpClient = false;
    if (!failedOnce && requests != null) {              // 그 외 IOException 은 한 번 재시도 대상
        ...

// sun.net.www.http.HttpClient#parseHTTPHeader  :806~
byte[] b = new byte[8];
try {
    int nread = 0;
    serverInput.mark(10);
    while (nread < 8) {
        int r = serverInput.read(b, nread, 8 - nread);   // :827  ★ 4-3 스택트레이스에 찍히는 프레임
        if (r < 0) {
            break;
        }
        nread += r;
    }
    ...
    ret = b[0] == 'H' && b[1] == 'T'
            && b[2] == 'T' && b[3] == 'P' && b[4] == '/' &&
        b[5] == '1' && b[6] == '.';
    serverInput.reset();

// java.net.Socket$SocketInputStream#read  :1097
public int read(byte[] b, int off, int len) throws IOException {
    try {
        return in.read(b, off, len);                     // :1099  in = SocketImpl 이 준 InputStream
    } catch (SocketTimeoutException e) {
        throw e;                                         // 그대로 통과
    } catch (InterruptedIOException e) {
        ...
    }
}

// sun.nio.ch.NioSocketImpl#getInputStream  :791
protected InputStream getInputStream() {
    return new InputStream() {
        ...
        @Override
        public int read(byte[] b, int off, int len) throws IOException {
            return NioSocketImpl.this.read(b, off, len); // :796
        }
        ...
    };
}

// sun.nio.ch.NioSocketImpl#read  :334
private int read(byte[] b, int off, int len) throws IOException {
    Objects.checkFromIndexSize(off, len, b.length);
    if (len == 0) {
        return 0;
    } else {
        readLock.lock();                                 // ★ 같은 소켓에 동시 read 는 직렬화된다
        try {
            if (readEOF)
                return -1;
            int size = Math.min(len, MAX_BUFFER_SIZE);
            int n = implRead(b, off, size);              // :346  → 4-1 의 implRead → timedRead
            if (n == -1)
                readEOF = true;
            return n;
        } finally {
            readLock.unlock();
        }
    }
}

// sun.net.www.http.HttpClient#parseHTTPHeader  :1062~1080
/* wrap a KeepAliveStream/MeteredStream around it if appropriate */
if (cl > 0) {
    boolean useKeepAliveStream = isKeepingAlive() || disableKeepAlive;
    if (useKeepAliveStream) {
        serverInput = new KeepAliveStream(serverInput, cl, this);   // :1075
        failedOnce = false;
    } else {
        serverInput = new MeteredStream(serverInput, cl);           // :1079
    }
}

// sun.nio.ch.NioSocketImpl#timedRead  :270
private int timedRead(FileDescriptor fd, byte[] b, int off, int len, long nanos) throws IOException {
    long startNanos = System.nanoTime();        // ★ 호출될 때마다 새로 찍힘
    int n = tryRead(fd, b, off, len);
    while (n == IOStatus.UNAVAILABLE && isOpen()) {
        long remainingNanos = nanos - (System.nanoTime() - startNanos);
        if (remainingNanos <= 0) {
            throw new SocketTimeoutException("Read timed out");    // :278
        }
        park(fd, Net.POLLIN, remainingNanos);
        n = tryRead(fd, b, off, len);
    }
    return n;
}

PoolingHttpClientConnectionManager cm = PoolingHttpClientConnectionManagerBuilder.create()
        .setDefaultConnectionConfig(ConnectionConfig.custom()
                .setConnectTimeout(Timeout.ofMilliseconds(1_000))   // 커넥션 수립 단계
                .setSocketTimeout(Timeout.ofMilliseconds(1_000))    // SO_TIMEOUT 초기값
                .build())
        .setMaxConnTotal(50)
        .setMaxConnPerRoute(20)
        .build();

RequestConfig requestConfig = RequestConfig.custom()
        .setConnectionRequestTimeout(Timeout.ofMilliseconds(500))   // 풀에서 커넥션 빌리는 대기
        .setResponseTimeout(Timeout.ofMilliseconds(1_000))          // 응답 대기
        .build();

CloseableHttpClient client = HttpClients.custom()
        .setConnectionManager(cm)
        .setDefaultRequestConfig(requestConfig)
        .build();

RestTemplate restTemplate = new RestTemplate(new HttpComponentsClientHttpRequestFactory(client));

// org.springframework.http.client.HttpComponentsClientHttpRequestFactory#mergeRequestConfig
RequestConfig.Builder builder = RequestConfig.copy(clientConfig);
if (this.connectTimeout >= 0) {
    builder.setConnectTimeout(this.connectTimeout, TimeUnit.MILLISECONDS);
}
if (this.connectionRequestTimeout >= 0) {
    builder.setConnectionRequestTimeout(this.connectionRequestTimeout, TimeUnit.MILLISECONDS);
}
if (this.readTimeout >= 0) {
    builder.setResponseTimeout(this.readTimeout, TimeUnit.MILLISECONDS);   // ★ readTimeout → responseTimeout
}

// org.apache.hc.client5.http.impl.classic.InternalExecRuntime#connectEndpoint  (5.4.2 :160)
final Timeout connectTimeout = requestConfig.getConnectTimeout();
manager.connect(endpoint, connectTimeout, context);                     // :164

// org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManager#connect  :485
final Timeout connectTimeout = timeout != null
        ? Timeout.of(timeout.getDuration(), timeout.getTimeUnit())
        : connectionConfig.getConnectTimeout();                         // RequestConfig 에 없을 때만 ConnectionConfig

// org.apache.hc.client5.http.impl.classic.InternalExecRuntime#acquireEndpoint  (5.4.2 :105)
final LeaseRequest connRequest = manager.lease(id, route, connectionRequestTimeout, object);
try {
    final ConnectionEndpoint connectionEndpoint = connRequest.get(connectionRequestTimeout);  // :111 ★ 대기 지점
    ...
} catch (final TimeoutException ex) {
    connRequest.cancel();
    throw new ConnectionRequestTimeoutException(ex.getMessage());                             // :122
}

// org.apache.hc.client5.http.impl.io.DefaultHttpClientConnectionOperator#connect  (5.4.2)
for (int i = 0; i < remoteAddresses.length; i++) {                        // ★ DNS 가 준 주소마다 반복
    final InetSocketAddress remoteAddress = new InetSocketAddress(address, port);
    final Socket socket = detachedSocketFactory.create(socksProxy);       // new Socket()
    try {
        if (soTimeout != null) {
            socket.setSoTimeout(soTimeout.toMillisecondsIntBound());      // :196  SocketConfig.soTimeout 장전
        }
        ...
        socket.connect(remoteAddress,
                TimeValue.isPositive(connectTimeout) ? connectTimeout.toMillisecondsIntBound() : 0);  // :216 ★ 적용
        ...

// DefaultHttpClientConnectionOperator#connect  (5.4.2 :161~177)
final InetAddress[] remoteAddresses;
if (endpointHost.getAddress() != null) {
    remoteAddresses = new InetAddress[] { endpointHost.getAddress() };   // IP 를 직접 준 경우만 1개
} else {
    remoteAddresses = this.dnsResolver.resolve(endpointHost.getHostName());   // → InetAddress.getAllByName(host)
    if (remoteAddresses == null || remoteAddresses.length == 0) {
        throw new UnknownHostException(endpointHost.getHostName());
    }
}

// :239~253
} catch (final IOException ex) {
    Closer.closeQuietly(socket);
    if (last) {
        throw ConnectExceptionSupport.enhance(ex, endpointHost, remoteAddresses);
    }
    // "retrying connection to the next address"  ← 남은 시간을 깎는 게 아니라 다음 주소에 full connectTimeout 을 새로 쓴다
}

// sun.net.NetworkClient#doConnect  :177~179
if (connectTimeout >= 0) {
    s.connect(new InetSocketAddress(server, port), connectTimeout);   // getByName — 첫 주소 하나
}

// InternalExecRuntime#execute  (5.4.2 :215~228)
final RequestConfig requestConfig = context.getRequestConfigOrDefault();   // ← 요청별 컨텍스트
final Timeout responseTimeout = requestConfig.getResponseTimeout();
if (responseTimeout != null) {
    endpoint.setSocketTimeout(responseTimeout);
}

// org.apache.hc.client5.http.impl.classic.ConnectExec#execute  (5.4.2 :130~198)
if (!execRuntime.isEndpointConnected()) {
    ...
    case HttpRouteDirector.CONNECT_TARGET:
        execRuntime.connectEndpoint(context);   // :144  TCP connect + TLS handshake 가 전부 이 안
        ...
}
return chain.proceed(request, scope);           // :198  ← 이제야 요청 실행 단계로

// DefaultHttpClientConnectionOperator#connect  (5.4.2 :180~231)
final Timeout soTimeout = socketConfig.getSoTimeout();      // :180  ConnectionConfig 아님, SocketConfig
...
if (soTimeout != null) {
    socket.setSoTimeout(soTimeout.toMillisecondsIntBound());               // :196  raw 소켓에 장전
}
...
socket.connect(remoteAddress, connectTimeout.toMillisecondsIntBound());    // :216
conn.setSocketTimeout(soTimeout);                                          // :223
final SSLSocket sslSocket = tlsSocketStrategy.upgrade(socket, ...);        // :231  ★ 이 read 를 :196 값이 지킨다

// org.apache.hc.core5.http.io.SocketConfig  (5.3.3 :48)
private static final Timeout DEFAULT_SOCKET_TIMEOUT = Timeout.ofMinutes(3);

RequestConfig base = RequestConfig.custom()
        .setConnectionRequestTimeout(Timeout.ofMilliseconds(200))   // 풀 lease 대기
        .setResponseTimeout(Timeout.ofSeconds(3))                   // 기본 응답
        .build();

CloseableHttpClient client = HttpClients.custom()
        .setConnectionManager(cm)
        .setDefaultRequestConfig(base)
        .build();

// 잔액 조회 — 빨리 포기해야 한다
HttpGet balance = new HttpGet("https://api.example.com/balance");
balance.setConfig(RequestConfig.copy(base)
        .setResponseTimeout(Timeout.ofMilliseconds(300))
        .build());

// 정산 리포트 — 오래 걸리는 게 정상이다
HttpGet report = new HttpGet("https://api.example.com/settlement/report");
report.setConfig(RequestConfig.copy(base)
        .setResponseTimeout(Timeout.ofSeconds(10))
        .build());

// InternalHttpClient#doExecute  (5.4.2 :153~160)
RequestConfig config = null;
if (request instanceof Configurable) {
    config = ((Configurable) request).getConfig();
}
if (config != null) {
    localcontext.setRequestConfig(config);   // ★ 교체. defaultConfig 와 merge 하지 않는다
}
setupContext(localcontext);                  // getRequestConfig() == null 일 때만 defaultConfig 를 넣는다

// 잔액 조회 — 빨리 포기해야 한다
HttpClientContext balanceCtx = HttpClientContext.create();
balanceCtx.setRequestConfig(RequestConfig.copy(base)
        .setResponseTimeout(Timeout.ofMilliseconds(300))
        .build());

String balance = client.execute(
        new HttpGet("https://api.example.com/balance"), balanceCtx,
        response -> EntityUtils.toString(response.getEntity()));

// 정산 리포트 — 오래 걸리는 게 정상이다
HttpClientContext reportCtx = HttpClientContext.create();
reportCtx.setRequestConfig(RequestConfig.copy(base)
        .setResponseTimeout(Timeout.ofSeconds(10))
        .build());

String report = client.execute(
        new HttpGet("https://api.example.com/settlement/report"), reportCtx,
        response -> EntityUtils.toString(response.getEntity()));

// HttpComponentsClientHttpRequestFactory#mergeRequestConfig
RequestConfig.Builder builder = RequestConfig.copy(clientConfig);
...
if (this.readTimeout >= 0) {
    builder.setResponseTimeout(this.readTimeout, TimeUnit.MILLISECONDS);   // ← readTimeout → responseTimeout
}

@Configuration
public class SettlementHttpClientConfig {

    // 요청별로 갈아끼울 때의 기준값. 요청 config 는 병합이 아니라 교체라 (A) 여기서 copy 해서 쓴다
    private static final RequestConfig BASE_REQUEST_CONFIG = RequestConfig.custom()
            .setConnectionRequestTimeout(Timeout.ofMilliseconds(200))    // 풀 lease 대기 (5장)
            .setResponseTimeout(Timeout.ofSeconds(5))                    // 기본 응답 상한
            .build();

    @Bean
    public PoolingHttpClientConnectionManager connectionManager() {
        return PoolingHttpClientConnectionManagerBuilder.create()
                .setMaxConnTotal(200)
                .setMaxConnPerRoute(50)
                // 소켓 생성 직후 깔리는 바닥값 — TLS handshake 를 지킨다 (안 잡으면 3분)
                .setDefaultSocketConfig(SocketConfig.custom()
                        .setSoTimeout(Timeout.ofSeconds(2))
                        .setTcpNoDelay(true)
                        .build())
                // 커넥션 수립 직후 1회 적용 — responseTimeout 이 없는 요청의 read 상한
                .setDefaultConnectionConfig(ConnectionConfig.custom()
                        .setConnectTimeout(Timeout.ofMilliseconds(1000))  // 주소마다 full (6-3)
                        .setSocketTimeout(Timeout.ofSeconds(3))
                        .setTimeToLive(TimeValue.ofMinutes(5))
                        .setValidateAfterInactivity(TimeValue.ofSeconds(2))
                        .build())
                .build();
    }

    @Bean
    public CloseableHttpClient httpClient(PoolingHttpClientConnectionManager cm) {
        return HttpClients.custom()
                .setConnectionManager(cm)
                .setDefaultRequestConfig(BASE_REQUEST_CONFIG)
                .evictIdleConnections(TimeValue.ofSeconds(30))
                .build();
    }

    // 경로별 응답 상한. 여기 없는 요청은 BASE_REQUEST_CONFIG 의 5s 를 그대로 쓴다
    private static final Map<String, Timeout> RESPONSE_TIMEOUTS = Map.of(
            "/balance",           Timeout.ofMilliseconds(300),   // 잔액 조회 — 빨리 포기해야 한다
            "/settlement/report", Timeout.ofSeconds(10)          // 정산 리포트 — 오래 걸리는 게 정상이다
    );

    @Bean
    public RestTemplate settlementRestTemplate(CloseableHttpClient httpClient) {
        var factory = new HttpComponentsClientHttpRequestFactory(httpClient);
        // factory.setReadTimeout(...) 은 팩토리 전역값이라 안 쓴다. 요청별로 갈라야 하므로 컨텍스트로 준다
        factory.setHttpContextFactory((method, uri) -> {
            HttpClientContext ctx = HttpClientContext.create();
            Timeout responseTimeout = RESPONSE_TIMEOUTS.get(uri.getPath());
            if (responseTimeout != null) {
                ctx.setRequestConfig(RequestConfig.copy(BASE_REQUEST_CONFIG)
                        .setResponseTimeout(responseTimeout)
                        .build());
            }
            return ctx;   // config 를 안 넣으면 createRequest 가 클라이언트 기본값(BASE)을 채운다
        });
        return new RestTemplate(factory);
    }
}

// URI 를 보고 팩토리가 갈라 준다
restTemplate.getForObject("https://api.example.com/balance", Balance.class);            // → 300ms
restTemplate.getForObject("https://api.example.com/settlement/report", Report.class);   // → 10s
restTemplate.getForObject("https://api.example.com/merchants/1", Merchant.class);       // → 5s (BASE)

// HttpComponentsClientHttpRequestFactory  (spring-web 6.2.5 :252~291)
if (!(context instanceof HttpClientContext clientContext && clientContext.getRequestConfig() != null) && ...) {
    ...
    config = createRequestConfig(client);        // :260
}
...
protected RequestConfig createRequestConfig(Object client) {
    if (client instanceof Configurable configurableClient) {
        RequestConfig clientRequestConfig = configurableClient.getConfig();   // ★ setDefaultRequestConfig 로 넣은 BASE
        return mergeRequestConfig(clientRequestConfig);
    }
    ...
}

// HttpComponentsClientHttpRequestFactory#createRequest  (spring-web 6.2.5)
HttpContext context = createHttpContext(httpMethod, uri);   // ← 등록한 httpContextFactory 가 호출된다
if (context == null) {
    context = HttpClientContext.create();
}

// Request configuration not set in the context
if (!(context instanceof HttpClientContext clientContext && clientContext.getRequestConfig() != null) &&
        context.getAttribute(HttpClientContext.REQUEST_CONFIG) == null) {    // ★ 이미 있으면 통째로 건너뛴다
    ...
    config = createRequestConfig(client);      // factory.setReadTimeout 이 반영되는 자리
    ...
}

// DefaultManagedHttpClientConnection  (5.4.2 :162~223)
@Override
public void setSocketTimeout(final Timeout timeout) {
    super.setSocketTimeout(timeout);
    socketTimeout = timeout;          // ★ 기억해 두는 값까지 갱신된다
}

@Override
public void passivate() {
    super.setSocketTimeout(Timeout.ZERO_MILLISECONDS);   // :218  풀 반납 시 0(무한)으로. 기억값은 안 건드린다
}

@Override
public void activate() {
    super.setSocketTimeout(socketTimeout);               // :223  풀에서 꺼낼 때 기억값으로 복원
}