Make proxy autodetection the default via SystemDefaultRoutePlanner (ProxySelector first, then HTTP(S)_PROXY/NO_PROXY).

Add disableProxyAutodetection() to preserve legacy behavior.

Author: arturobernalg

httpclient5/src/main/java/org/apache/hc/client5/http/impl/classic/HttpClientBuilder.java

@@ -233,6 +233,7 @@ private ExecInterceptorEntry(
     private boolean authCachingDisabled;
     private boolean connectionStateDisabled;
     private boolean defaultUserAgentDisabled;
+    private boolean proxyAutodetectionDisabled;
     private ProxySelector proxySelector;
 
     private List<Closeable> closeables;
@@ -791,6 +792,19 @@ public final HttpClientBuilder disableDefaultUserAgent() {
         return this;
     }
 
+    /**
+     * Disables automatic proxy detection for clients created by this builder.
+     * <p>
+     * When disabled, and unless an explicit proxy or route planner is configured,
+     * the builder falls back to {@link org.apache.hc.client5.http.impl.routing.DefaultRoutePlanner}.
+     * </p>
+     * @return this instance.
+     */
+    public final HttpClientBuilder disableProxyAutodetection() {
+        this.proxyAutodetectionDisabled = true;
+        return this;
+    }
+
     /**
      * Sets the {@link ProxySelector} that will be used to select the proxies
      * to be used for establishing HTTP connections. If a non-null proxy selector is set,
@@ -1012,11 +1026,11 @@ public CloseableHttpClient build() {
             }
             if (proxy != null) {
                 routePlannerCopy = new DefaultProxyRoutePlanner(proxy, schemePortResolverCopy);
-            } else if (this.proxySelector != null) {
-                routePlannerCopy = new SystemDefaultRoutePlanner(schemePortResolverCopy, this.proxySelector);
-            } else if (systemProperties) {
-                final ProxySelector defaultProxySelector = AccessController.doPrivileged((PrivilegedAction<ProxySelector>) ProxySelector::getDefault);
-                routePlannerCopy = new SystemDefaultRoutePlanner(schemePortResolverCopy, defaultProxySelector);
+            } else if (!this.proxyAutodetectionDisabled) {
+                final ProxySelector effectiveSelector = this.proxySelector != null
+                        ? this.proxySelector
+                        : AccessController.doPrivileged((PrivilegedAction<ProxySelector>) ProxySelector::getDefault);
+                routePlannerCopy = new SystemDefaultRoutePlanner(schemePortResolverCopy, effectiveSelector);
             } else {
                 routePlannerCopy = new DefaultRoutePlanner(schemePortResolverCopy);
             }

httpclient5/src/test/java/org/apache/hc/client5/http/impl/classic/TestHttpClientBuilder.java

@@ -27,12 +27,22 @@
 package org.apache.hc.client5.http.impl.classic;
 
 import java.io.IOException;
+import java.lang.reflect.Field;
+import java.net.ProxySelector;
 
 import org.apache.hc.client5.http.classic.ExecChain;
 import org.apache.hc.client5.http.classic.ExecChainHandler;
+import org.apache.hc.client5.http.impl.routing.DefaultProxyRoutePlanner;
+import org.apache.hc.client5.http.impl.routing.DefaultRoutePlanner;
+import org.apache.hc.client5.http.impl.routing.SystemDefaultRoutePlanner;
+import org.apache.hc.client5.http.protocol.HttpClientContext;
+import org.apache.hc.client5.http.routing.HttpRoutePlanner;
 import org.apache.hc.core5.http.ClassicHttpRequest;
 import org.apache.hc.core5.http.ClassicHttpResponse;
 import org.apache.hc.core5.http.HttpException;
+import org.apache.hc.core5.http.HttpHost;
+import org.apache.hc.core5.http.protocol.HttpContext;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 class TestHttpClientBuilder {
@@ -66,4 +76,87 @@ public ClassicHttpResponse execute(
             return chain.proceed(request, scope);
         }
     }
+
+    @Test
+    void testDefaultUsesSystemDefaultRoutePlanner() throws Exception {
+        try (final InternalHttpClient client = (InternalHttpClient) HttpClients.custom().build()) {
+            final Object planner = getPrivateField(client, "routePlanner");
+            Assertions.assertNotNull(planner);
+            Assertions.assertInstanceOf(SystemDefaultRoutePlanner.class, planner, "Default should be SystemDefaultRoutePlanner (auto-detect proxies)");
+        }
+    }
+
+    @Test
+    void testDisableProxyAutodetectionFallsBackToDefaultRoutePlanner() throws Exception {
+        try (final InternalHttpClient client = (InternalHttpClient) HttpClients.custom()
+                .disableProxyAutodetection()
+                .build()) {
+            final Object planner = getPrivateField(client, "routePlanner");
+            Assertions.assertNotNull(planner);
+            Assertions.assertInstanceOf(DefaultRoutePlanner.class, planner, "disableProxyAutodetection() should restore DefaultRoutePlanner");
+        }
+    }
+
+    @Test
+    void testExplicitProxyWinsOverAutodetection() throws Exception {
+        try (final InternalHttpClient client = (InternalHttpClient) HttpClients.custom()
+                .setProxy(new HttpHost("http", "proxy.local", 8080))
+                .build()) {
+            final Object planner = getPrivateField(client, "routePlanner");
+            Assertions.assertNotNull(planner);
+            Assertions.assertInstanceOf(DefaultProxyRoutePlanner.class, planner, "Explicit proxy must take precedence");
+        }
+    }
+
+    @Test
+    void testCustomRoutePlannerIsRespected() throws Exception {
+        final HttpRoutePlanner custom = new HttpRoutePlanner() {
+            @Override
+            public org.apache.hc.client5.http.HttpRoute determineRoute(
+                    final HttpHost host, final HttpContext context) {
+                // trivial, never used in this test
+                return new org.apache.hc.client5.http.HttpRoute(host);
+            }
+        };
+        try (final InternalHttpClient client = (InternalHttpClient) HttpClients.custom()
+                .setRoutePlanner(custom)
+                .build()) {
+            final Object planner = getPrivateField(client, "routePlanner");
+            Assertions.assertSame(custom, planner, "Custom route planner must be used as-is");
+        }
+    }
+
+    @Test
+    void testProvidedProxySelectorIsUsedBySystemDefaultRoutePlanner() throws Exception {
+        class TouchProxySelector extends ProxySelector {
+            volatile boolean touched = false;
+            @Override
+            public java.util.List<java.net.Proxy> select(final java.net.URI uri) {
+                touched = true;
+                return java.util.Collections.singletonList(java.net.Proxy.NO_PROXY);
+            }
+            @Override
+            public void connectFailed(final java.net.URI uri, final java.net.SocketAddress sa, final IOException ioe) { }
+        }
+        final TouchProxySelector selector = new TouchProxySelector();
+
+        try (final InternalHttpClient client = (InternalHttpClient) HttpClients.custom()
+                .setProxySelector(selector)
+                .build()) {
+            final Object planner = getPrivateField(client, "routePlanner");
+            Assertions.assertInstanceOf(SystemDefaultRoutePlanner.class, planner);
+
+            // Call determineRoute on the planner directly to avoid making a real request
+            final SystemDefaultRoutePlanner sdrp = (SystemDefaultRoutePlanner) planner;
+            sdrp.determineRoute(new HttpHost("http", "example.com", 80), HttpClientContext.create());
+
+            Assertions.assertTrue(selector.touched, "Provided ProxySelector should be consulted");
+        }
+    }
+
+    private static Object getPrivateField(final Object target, final String name) throws Exception {
+        final Field f = target.getClass().getDeclaredField(name);
+        f.setAccessible(true);
+        return f.get(target);
+    }
 }