From d35844792079b737295b190bdd4b80bc9a40e7a1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Arnaud=20Cogolu=C3=A8gnes?=
 <514737+acogoluegnes@users.noreply.github.com>
Date: Mon, 4 Aug 2025 15:59:15 +0200
Subject: [PATCH] Add Netty-based frame handler

This commit adds a Netty-based frame handler. All network IO are based
on Netty when this frame handler is in use. The client library can
benefit of all the flexibility and advantages of Netty: simple API,
pluggable IO layer (Java NIO by default, or e.g. native Epoll on Linux).

The Netty frame handler deprecates the internal one using Java NIO.

The blocking IO frame handler is still the default one in 5.x. The
Netty frame handler should be the only one in 6.x.

Fixes #1664

(cherry picked from commit 74f538dd629c83ac846b9d2b97f3d11c421c2186)

Conflicts:
	pom.xml
	src/main/java/com/rabbitmq/client/ConnectionFactory.java
	src/main/java/com/rabbitmq/client/impl/AMQConnection.java
	src/main/java/com/rabbitmq/client/impl/HeartbeatSender.java
	src/main/java/com/rabbitmq/client/impl/Utils.java
	src/test/java/com/rabbitmq/client/test/ClientTestSuite.java
	src/test/java/com/rabbitmq/client/test/TestUtils.java
	src/test/java/com/rabbitmq/client/test/functional/Heartbeat.java
	src/test/java/com/rabbitmq/client/test/ssl/SslContextFactoryTest.java
	src/test/java/com/rabbitmq/client/test/ssl/VerifiedConnection.java
---
 .github/workflows/test-rabbitmq-alphas.yml    |    6 +-
 .../test-supported-java-versions-main.yml     |    6 +-
 .github/workflows/test.yml                    |    7 +-
 pom.xml                                       |   59 +-
 .../rabbitmq/client/ConnectionFactory.java    | 3141 +++++++++--------
 .../client/SocketChannelConfigurator.java     |    5 +
 .../client/SocketChannelConfigurators.java    |    2 +
 .../client/SslEngineConfigurator.java         |    5 +
 .../client/SslEngineConfigurators.java        |    2 +
 .../rabbitmq/client/impl/AMQConnection.java   |   19 +-
 .../client/impl/DefaultHeartbeatSender.java   |  147 +
 .../java/com/rabbitmq/client/impl/Frame.java  |   30 +-
 .../rabbitmq/client/impl/FrameHandler.java    |    9 +
 .../rabbitmq/client/impl/HeartbeatSender.java |  137 +-
 .../client/impl/NettyFrameHandlerFactory.java |  532 +++
 .../java/com/rabbitmq/client/impl/Utils.java  |   45 +-
 .../rabbitmq/client/impl/nio/NioContext.java  |    2 +
 .../rabbitmq/client/impl/nio/NioParams.java   |    4 +
 .../rabbitmq/client/impl/nio/NioQueue.java    |    2 +
 .../client/AmqpClientTestExtension.java       |  119 +-
 .../AMQConnectionRefreshCredentialsTest.java  |    5 +-
 .../client/test/BlockedConnectionTest.java    |   13 +-
 .../rabbitmq/client/test/BrokerTestCase.java  |    2 +-
 .../rabbitmq/client/test/ClientTestSuite.java |    5 +-
 .../com/rabbitmq/client/test/FrameTest.java   |    9 +-
 .../com/rabbitmq/client/test/NettyTest.java   |  143 +
 ...NoAutoRecoveryWhenTcpWindowIsFullTest.java |    2 +-
 .../client/test/ProtocolVersionMismatch.java  |   92 +
 .../com/rabbitmq/client/test/TestUtils.java   |  980 ++---
 .../client/test/functional/FrameMax.java      |   86 +-
 .../test/functional/FunctionalTestSuite.java  |  112 +-
 .../client/test/functional/Heartbeat.java     |   71 +-
 .../test/functional/UnexpectedFrames.java     |    6 +-
 .../test/ssl/BadVerifiedConnection.java       |    2 +
 .../client/test/ssl/HostnameVerification.java |   19 +-
 .../test/{ => ssl}/SslContextFactoryTest.java |   46 +-
 .../client/test/ssl/SslTestSuite.java         |    2 -
 .../client/test/ssl/TlsConnectionLogging.java |   43 +-
 .../client/test/ssl/TlsTestUtils.java         |   45 +
 .../client/test/ssl/UnverifiedConnection.java |    3 +
 .../client/test/ssl/VerifiedConnection.java   |   53 +-
 src/test/resources/logback-test.xml           |    3 +-
 42 files changed, 3666 insertions(+), 2355 deletions(-)
 create mode 100644 src/main/java/com/rabbitmq/client/impl/DefaultHeartbeatSender.java
 create mode 100644 src/main/java/com/rabbitmq/client/impl/NettyFrameHandlerFactory.java
 create mode 100644 src/test/java/com/rabbitmq/client/test/NettyTest.java
 create mode 100644 src/test/java/com/rabbitmq/client/test/ProtocolVersionMismatch.java
 rename src/test/java/com/rabbitmq/client/test/{ => ssl}/SslContextFactoryTest.java (76%)

diff --git a/.github/workflows/test-rabbitmq-alphas.yml b/.github/workflows/test-rabbitmq-alphas.yml
index 692ed30679..359696bbeb 100644
--- a/.github/workflows/test-rabbitmq-alphas.yml
+++ b/.github/workflows/test-rabbitmq-alphas.yml
@@ -43,9 +43,9 @@ jobs:
           RABBITMQ_IMAGE: ${{ matrix.rabbitmq-image }}
       - name: Get dependencies
         run: make deps
-      - name: Test with NIO
+      - name: Test with Netty
         run: |
-          ./mvnw verify -P use-nio -Drabbitmqctl.bin=DOCKER:rabbitmq0 \
+          ./mvnw verify -Dio.layer=netty -Drabbitmqctl.bin=DOCKER:rabbitmq0 \
             -Dtest-broker.A.nodename=rabbit@node0 -Dtest-broker.B.nodename=rabbit@node1 \
             -Dca.certificate=./tls-gen/basic/result/ca_certificate.pem \
             -Dclient.certificate=./tls-gen/basic/result/client_$(hostname)_certificate.pem \
@@ -53,7 +53,7 @@ jobs:
             --no-transfer-progress
       - name: Test with blocking IO
         run: |
-          ./mvnw verify -Drabbitmqctl.bin=DOCKER:rabbitmq0 \
+          ./mvnw verify -Dio.layer=socket -Drabbitmqctl.bin=DOCKER:rabbitmq0 \
             -Dtest-broker.A.nodename=rabbit@node0 -Dtest-broker.B.nodename=rabbit@node1 \
             -Dca.certificate=./tls-gen/basic/result/ca_certificate.pem \
             -Dclient.certificate=./tls-gen/basic/result/client_$(hostname)_certificate.pem \
diff --git a/.github/workflows/test-supported-java-versions-main.yml b/.github/workflows/test-supported-java-versions-main.yml
index a5428233eb..24ad14034c 100644
--- a/.github/workflows/test-supported-java-versions-main.yml
+++ b/.github/workflows/test-supported-java-versions-main.yml
@@ -39,9 +39,9 @@ jobs:
         run: make deps
       - name: Show version
         run: ./mvnw --version
-      - name: Test with NIO
+      - name: Test with Netty
         run: |
-          ./mvnw verify -P use-nio -Drabbitmqctl.bin=DOCKER:rabbitmq \
+          ./mvnw verify -Dio.layer=netty -Drabbitmqctl.bin=DOCKER:rabbitmq \
             -Dtest-broker.A.nodename=rabbit@$(hostname) -Dmaven.javadoc.skip=true \
             -Dca.certificate=./tls-gen/basic/result/ca_certificate.pem \
             -Dclient.certificate=./tls-gen/basic/result/client_$(hostname)_certificate.pem \
@@ -49,7 +49,7 @@ jobs:
             --no-transfer-progress
       - name: Test with blocking IO
         run: |
-          ./mvnw verify -Drabbitmqctl.bin=DOCKER:rabbitmq \
+          ./mvnw verify -Dio.layer=socket -Drabbitmqctl.bin=DOCKER:rabbitmq \
             -Dtest-broker.A.nodename=rabbit@$(hostname) -Dmaven.javadoc.skip=true \
             -Dca.certificate=./tls-gen/basic/result/ca_certificate.pem \
             -Dclient.certificate=./tls-gen/basic/result/client_$(hostname)_certificate.pem \
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 97c0ab4361..dd50be0bfe 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -39,9 +39,9 @@ jobs:
         run: ci/start-cluster.sh
       - name: Get dependencies
         run: make deps
-      - name: Test with NIO
+      - name: Test with Netty
         run: |
-          ./mvnw verify -P use-nio -Drabbitmqctl.bin=DOCKER:rabbitmq0 \
+          ./mvnw verify -Dio.layer=netty -Drabbitmqctl.bin=DOCKER:rabbitmq0 \
             -Dtest-broker.A.nodename=rabbit@node0 -Dtest-broker.B.nodename=rabbit@node1 \
             -Dca.certificate=./tls-gen/basic/result/ca_certificate.pem \
             -Dclient.certificate=./tls-gen/basic/result/client_$(hostname)_certificate.pem \
@@ -49,12 +49,11 @@ jobs:
             --no-transfer-progress
       - name: Test with blocking IO
         run: |
-          ./mvnw verify -Drabbitmqctl.bin=DOCKER:rabbitmq0 \
+          ./mvnw verify -Dio.layer=socket -Drabbitmqctl.bin=DOCKER:rabbitmq0 \
             -Dtest-broker.A.nodename=rabbit@node0 -Dtest-broker.B.nodename=rabbit@node1 \
             -Dca.certificate=./tls-gen/basic/result/ca_certificate.pem \
             -Dclient.certificate=./tls-gen/basic/result/client_$(hostname)_certificate.pem \
             -Dmaven.javadoc.skip=true \
-            -Dtest-client-cert.password= -Dtest-tls-certs.dir=rabbitmq-configuration/tls \
             --no-transfer-progress
       - name: Stop cluster
         run: docker compose --file ci/cluster/docker-compose.yml down
diff --git a/pom.xml b/pom.xml
index fb92222c22..531e6837b4 100644
--- a/pom.xml
+++ b/pom.xml
@@ -56,6 +56,7 @@
 
     <spotless.check.skip>true</spotless.check.skip>
     <slf4j.version>1.7.36</slf4j.version>
+    <netty.version>4.2.3.Final</netty.version>
     <metrics.version>4.2.33</metrics.version>
     <micrometer.version>1.15.2</micrometer.version>
     <opentelemetry.version>1.52.0</opentelemetry.version>
@@ -245,30 +246,6 @@
       </build>
     </profile>
 
-    <!--
-      Profile to activate the NIO mode in the test suite:
-      mvn verify -P use-nio
-    -->
-    <profile>
-      <id>use-nio</id>
-      <build>
-        <plugins>
-          <plugin>
-            <groupId>org.apache.maven.plugins</groupId>
-            <artifactId>maven-failsafe-plugin</artifactId>
-            <version>${maven.failsafe.plugin.version}</version>
-            <configuration>
-              <systemPropertyVariables>
-                <net.bytebuddy.experimental>true</net.bytebuddy.experimental>
-                <use.nio>true</use.nio>
-              </systemPropertyVariables>
-              <argLine>${test-arguments}</argLine>
-            </configuration>
-          </plugin>
-        </plugins>
-      </build>
-    </profile>
-
     <profile>
       <!--
       The "snapshots" Maven profile is used to push release artifacts to a
@@ -401,6 +378,21 @@
       <artifactId>slf4j-api</artifactId>
       <version>${slf4j.version}</version>
     </dependency>
+    <dependency>
+      <groupId>io.netty</groupId>
+      <artifactId>netty-transport</artifactId>
+      <version>${netty.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>io.netty</groupId>
+      <artifactId>netty-codec</artifactId>
+      <version>${netty.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>io.netty</groupId>
+      <artifactId>netty-handler</artifactId>
+      <version>${netty.version}</version>
+    </dependency>
     <dependency>
       <groupId>io.dropwizard.metrics</groupId>
       <artifactId>metrics-core</artifactId>
@@ -509,6 +501,20 @@
       <scope>test</scope>
       <optional>true</optional>
     </dependency>
+    <dependency>
+      <groupId>io.netty</groupId>
+      <artifactId>netty-transport-native-kqueue</artifactId>
+      <version>${netty.version}</version>
+      <classifier>osx-aarch_64</classifier>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>io.netty</groupId>
+      <artifactId>netty-transport-native-epoll</artifactId>
+      <version>${netty.version}</version>
+      <classifier>linux-x86_64</classifier>
+      <scope>test</scope>
+    </dependency>
 
   </dependencies>
 
@@ -768,8 +774,13 @@
         <configuration>
           <java>
             <includes>
+              <include>src/main/java/com/rabbitmq/client/ConnectionFactory.java</include>
+              <include>src/main/java/com/rabbitmq/client/impl/NettyFrameHandlerFactory.java</include>
               <include>src/main/java/com/rabbitmq/client/observation/**/*.java</include>
               <include>src/test/java/com/rabbitmq/client/test/functional/MicrometerObservationCollectorMetrics.java</include>
+              <include>src/test/java/com/rabbitmq/client/test/NettyTest.java</include>
+              <include>src/test/java/com/rabbitmq/client/test/ProtocolVersionMismatch.java</include>
+              <include>src/test/java/com/rabbitmq/client/test/TestUtils.java</include>
             </includes>
             <googleJavaFormat>
               <version>${google-java-format.version}</version>
diff --git a/src/main/java/com/rabbitmq/client/ConnectionFactory.java b/src/main/java/com/rabbitmq/client/ConnectionFactory.java
index b6a6ffbfa9..4439824267 100644
--- a/src/main/java/com/rabbitmq/client/ConnectionFactory.java
+++ b/src/main/java/com/rabbitmq/client/ConnectionFactory.java
@@ -1,4 +1,5 @@
-// Copyright (c) 2007-2023 Broadcom. All Rights Reserved. The term "Broadcom" refers to Broadcom Inc. and/or its subsidiaries.
+// Copyright (c) 2007-2025 Broadcom. All Rights Reserved.
+// The term "Broadcom" refers to Broadcom Inc. and/or its subsidiaries.
 //
 // This software, the RabbitMQ Java client library, is triple-licensed under the
 // Mozilla Public License 2.0 ("MPL"), the GNU General Public License version 2
@@ -12,9 +13,10 @@
 //
 // If you have any questions regarding licensing, please contact us at
 // info@rabbitmq.com.
-
 package com.rabbitmq.client;
 
+import static java.util.concurrent.TimeUnit.MINUTES;
+
 import com.rabbitmq.client.impl.*;
 import com.rabbitmq.client.impl.nio.NioParams;
 import com.rabbitmq.client.impl.nio.SocketChannelFrameHandlerFactory;
@@ -23,15 +25,10 @@
 import com.rabbitmq.client.impl.recovery.RetryHandler;
 import com.rabbitmq.client.impl.recovery.TopologyRecoveryFilter;
 import com.rabbitmq.client.observation.ObservationCollector;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.Map.Entry;
-import java.util.function.BiConsumer;
-import javax.net.SocketFactory;
-import javax.net.ssl.SSLContext;
-import javax.net.ssl.SSLSocketFactory;
-import javax.net.ssl.TrustManager;
+import io.netty.bootstrap.Bootstrap;
+import io.netty.channel.EventLoopGroup;
+import io.netty.handler.ssl.SslContext;
+import io.netty.handler.ssl.SslContextBuilder;
 import java.io.IOException;
 import java.net.URI;
 import java.net.URISyntaxException;
@@ -39,920 +36,988 @@
 import java.security.KeyManagementException;
 import java.security.NoSuchAlgorithmException;
 import java.util.*;
+import java.util.Map.Entry;
 import java.util.concurrent.*;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Function;
 import java.util.function.Predicate;
-
-import static java.util.concurrent.TimeUnit.MINUTES;
+import javax.net.SocketFactory;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLSocketFactory;
+import javax.net.ssl.TrustManager;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
  * Convenience factory class to facilitate opening a {@link Connection} to a RabbitMQ node.
  *
- * Most connection and socket settings are configured using this factory.
- * Some settings that apply to connections can also be configured here
- * and will apply to all connections produced by this factory.
+ * <p>Most connection and socket settings are configured using this factory. Some settings that
+ * apply to connections can also be configured here and will apply to all connections produced by
+ * this factory.
  */
 public class ConnectionFactory implements Cloneable {
 
-    private static final Logger LOGGER = LoggerFactory.getLogger(ConnectionFactory.class);
-
-    private static final int MAX_UNSIGNED_SHORT = 65535;
-
-    /** Default user name */
-    public static final String DEFAULT_USER = "guest";
-    /** Default password */
-    public static final String DEFAULT_PASS = "guest";
-    /** Default virtual host */
-    public static final String DEFAULT_VHOST = "/";
-    /** Default maximum channel number;
-     *  2047 because it's 2048 on the server side minus channel 0,
-     *  which each connection uses for negotiation
-     *  and error communication */
-    public static final int    DEFAULT_CHANNEL_MAX = 2047;
-    /** Default maximum frame size;
-     *  zero means no limit */
-    public static final int    DEFAULT_FRAME_MAX = 0;
-    /** Default heart-beat interval;
-     *  60 seconds */
-    public static final int    DEFAULT_HEARTBEAT = 60;
-    /** The default host */
-    public static final String DEFAULT_HOST = "localhost";
-    /** 'Use the default port' port */
-    public static final int    USE_DEFAULT_PORT = -1;
-    /** The default non-ssl port */
-    public static final int    DEFAULT_AMQP_PORT = AMQP.PROTOCOL.PORT;
-    /** The default ssl port */
-    public static final int    DEFAULT_AMQP_OVER_SSL_PORT = 5671;
-    /** The default TCP connection timeout: 60 seconds */
-    public static final int    DEFAULT_CONNECTION_TIMEOUT = 60000;
-    /**
-     * The default AMQP 0-9-1 connection handshake timeout. See DEFAULT_CONNECTION_TIMEOUT
-     * for TCP (socket) connection timeout.
-     */
-    public static final int    DEFAULT_HANDSHAKE_TIMEOUT = 10000;
-    /** The default shutdown timeout;
-     *  zero means wait indefinitely */
-    public static final int    DEFAULT_SHUTDOWN_TIMEOUT = 10000;
-
-    /** The default continuation timeout for RPC calls in channels: 10 minutes */
-    public static final int    DEFAULT_CHANNEL_RPC_TIMEOUT = (int) MINUTES.toMillis(10);
-    
-    /** The default network recovery interval: 5000 millis */
-    public static final long   DEFAULT_NETWORK_RECOVERY_INTERVAL = 5000;
-
-    /** The default timeout for work pool enqueueing: no timeout */
-    public static final int    DEFAULT_WORK_POOL_TIMEOUT = -1;
-
-    private static final String PREFERRED_TLS_PROTOCOL = "TLSv1.2";
-
-    private static final String FALLBACK_TLS_PROTOCOL = "TLSv1";
-
-    private String virtualHost                    = DEFAULT_VHOST;
-    private String host                           = DEFAULT_HOST;
-    private int port                              = USE_DEFAULT_PORT;
-    private int requestedChannelMax               = DEFAULT_CHANNEL_MAX;
-    private int requestedFrameMax                 = DEFAULT_FRAME_MAX;
-    private int requestedHeartbeat                = DEFAULT_HEARTBEAT;
-    private int connectionTimeout                 = DEFAULT_CONNECTION_TIMEOUT;
-    private int handshakeTimeout                  = DEFAULT_HANDSHAKE_TIMEOUT;
-    private int shutdownTimeout                   = DEFAULT_SHUTDOWN_TIMEOUT;
-    private Map<String, Object> _clientProperties = AMQConnection.defaultClientProperties();
-    private SocketFactory socketFactory           = null;
-    private SaslConfig saslConfig                 = DefaultSaslConfig.PLAIN;
-
-    private ExecutorService sharedExecutor;
-    private ThreadFactory threadFactory             = Executors.defaultThreadFactory();
-    // minimises the number of threads rapid closure of many
-    // connections uses, see rabbitmq/rabbitmq-java-client#86
-    private ExecutorService shutdownExecutor;
-    private ScheduledExecutorService heartbeatExecutor;
-    private SocketConfigurator socketConf           = SocketConfigurators.defaultConfigurator();
-    private ExceptionHandler exceptionHandler       = new DefaultExceptionHandler();
-    private CredentialsProvider credentialsProvider = new DefaultCredentialsProvider(DEFAULT_USER, DEFAULT_PASS);
-
-    private boolean automaticRecovery               = true;
-    private boolean topologyRecovery                = true;
-    private ExecutorService topologyRecoveryExecutor;
-    
-    // long is used to make sure the users can use both ints
-    // and longs safely. It is unlikely that anybody'd need
-    // to use recovery intervals > Integer.MAX_VALUE in practice.
-    private long networkRecoveryInterval          = DEFAULT_NETWORK_RECOVERY_INTERVAL;
-    private RecoveryDelayHandler recoveryDelayHandler;
-
-    private MetricsCollector metricsCollector;
-    private ObservationCollector observationCollector = ObservationCollector.NO_OP;
-
-    private boolean nio = false;
-    private FrameHandlerFactory frameHandlerFactory;
-    private NioParams nioParams = new NioParams();
-
-    private SslContextFactory sslContextFactory;
+  private static final Logger LOGGER = LoggerFactory.getLogger(ConnectionFactory.class);
 
-    /**
-     * Continuation timeout on RPC calls.
-     * @since 4.1.0
-     */
-    private int channelRpcTimeout = DEFAULT_CHANNEL_RPC_TIMEOUT;
+  private static final int MAX_UNSIGNED_SHORT = 65535;
 
-    /**
-     * Whether or not channels check the reply type of an RPC call.
-     * Default is false.
-     * @since 4.2.0
-     */
-    private boolean channelShouldCheckRpcResponseType = false;
+  /** Default user name */
+  public static final String DEFAULT_USER = "guest";
 
-    /**
-     * Listener called when a connection gets an IO error trying to write on the socket.
-     * Default listener triggers connection recovery asynchronously and propagates
-     * the exception.
-     * @since 4.5.0
-     */
-    private ErrorOnWriteListener errorOnWriteListener;
+  /** Default password */
+  public static final String DEFAULT_PASS = "guest";
 
-    /**
-     * Timeout in ms for work pool enqueuing.
-     * @since 4.5.0
-     */
-    private int workPoolTimeout = DEFAULT_WORK_POOL_TIMEOUT;
+  /** Default virtual host */
+  public static final String DEFAULT_VHOST = "/";
 
-    /**
-     * Filter to include/exclude entities from topology recovery.
-     * @since 4.8.0
-     */
-    private TopologyRecoveryFilter topologyRecoveryFilter;
+  /**
+   * Default maximum channel number; 2047 because it's 2048 on the server side minus channel 0,
+   * which each connection uses for negotiation and error communication
+   */
+  public static final int DEFAULT_CHANNEL_MAX = 2047;
 
-    /**
-     * Condition to trigger automatic connection recovery.
-     * @since 5.4.0
-     */
-    private Predicate<ShutdownSignalException> connectionRecoveryTriggeringCondition;
+  /** Default maximum frame size; zero means no limit */
+  public static final int DEFAULT_FRAME_MAX = 0;
 
-    /**
-     * Retry handler for topology recovery.
-     * Default is no retry.
-     * @since 5.4.0
-     */
-    private RetryHandler topologyRecoveryRetryHandler;
-    
-    private RecoveredQueueNameSupplier recoveredQueueNameSupplier;
+  /** Default heart-beat interval; 60 seconds */
+  public static final int DEFAULT_HEARTBEAT = 60;
 
-    /**
-     * Traffic listener notified of inbound and outbound {@link Command}s.
-     * <p>
-     * Useful for debugging purposes. Default is no-op.
-     *
-     * @since 5.5.0
-     */
-    private TrafficListener trafficListener = TrafficListener.NO_OP;
+  /** The default host */
+  public static final String DEFAULT_HOST = "localhost";
 
-    private CredentialsRefreshService credentialsRefreshService;
+  /** 'Use the default port' port */
+  public static final int USE_DEFAULT_PORT = -1;
 
-    /**
-     * Maximum body size of inbound (received) messages in bytes.
-     *
-     * <p>Default value is 67,108,864 (64 MiB).
-     */
-    private int maxInboundMessageBodySize = 1_048_576 * 64;
+  /** The default non-ssl port */
+  public static final int DEFAULT_AMQP_PORT = AMQP.PROTOCOL.PORT;
 
-    /** @return the default host to use for connections */
-    public String getHost() {
-        return host;
-    }
+  /** The default ssl port */
+  public static final int DEFAULT_AMQP_OVER_SSL_PORT = 5671;
 
-    /** @param host the default host to use for connections */
-    public void setHost(String host) {
-        this.host = host;
-    }
+  /** The default TCP connection timeout: 60 seconds */
+  public static final int DEFAULT_CONNECTION_TIMEOUT = 60000;
 
-    public static int portOrDefault(int port, boolean ssl) {
-        if (port != USE_DEFAULT_PORT) return port;
-        else if (ssl) return DEFAULT_AMQP_OVER_SSL_PORT;
-        else return DEFAULT_AMQP_PORT;
-    }
+  /**
+   * The default AMQP 0-9-1 connection handshake timeout. See DEFAULT_CONNECTION_TIMEOUT for TCP
+   * (socket) connection timeout.
+   */
+  public static final int DEFAULT_HANDSHAKE_TIMEOUT = 10000;
+
+  /** The default shutdown timeout; zero means wait indefinitely */
+  public static final int DEFAULT_SHUTDOWN_TIMEOUT = 10000;
+
+  /** The default continuation timeout for RPC calls in channels: 10 minutes */
+  public static final int DEFAULT_CHANNEL_RPC_TIMEOUT = (int) MINUTES.toMillis(10);
+
+  /** The default network recovery interval: 5000 millis */
+  public static final long DEFAULT_NETWORK_RECOVERY_INTERVAL = 5000;
+
+  /** The default timeout for work pool enqueueing: no timeout */
+  public static final int DEFAULT_WORK_POOL_TIMEOUT = -1;
+
+  private static final String PREFERRED_TLS_PROTOCOL = "TLSv1.2";
+
+  private static final String FALLBACK_TLS_PROTOCOL = "TLSv1";
+
+  private String virtualHost = DEFAULT_VHOST;
+  private String host = DEFAULT_HOST;
+  private int port = USE_DEFAULT_PORT;
+  private int requestedChannelMax = DEFAULT_CHANNEL_MAX;
+  private int requestedFrameMax = DEFAULT_FRAME_MAX;
+  private int requestedHeartbeat = DEFAULT_HEARTBEAT;
+  private int connectionTimeout = DEFAULT_CONNECTION_TIMEOUT;
+  private int handshakeTimeout = DEFAULT_HANDSHAKE_TIMEOUT;
+  private int shutdownTimeout = DEFAULT_SHUTDOWN_TIMEOUT;
+  private Map<String, Object> _clientProperties = AMQConnection.defaultClientProperties();
+  private SocketFactory socketFactory = null;
+  private SaslConfig saslConfig = DefaultSaslConfig.PLAIN;
+
+  private ExecutorService sharedExecutor;
+  private ThreadFactory threadFactory = Executors.defaultThreadFactory();
+  // minimises the number of threads rapid closure of many
+  // connections uses, see rabbitmq/rabbitmq-java-client#86
+  private ExecutorService shutdownExecutor;
+  private ScheduledExecutorService heartbeatExecutor;
+  private SocketConfigurator socketConf = SocketConfigurators.defaultConfigurator();
+  private ExceptionHandler exceptionHandler = new DefaultExceptionHandler();
+  private CredentialsProvider credentialsProvider =
+      new DefaultCredentialsProvider(DEFAULT_USER, DEFAULT_PASS);
+
+  private boolean automaticRecovery = true;
+  private boolean topologyRecovery = true;
+  private ExecutorService topologyRecoveryExecutor;
+
+  // long is used to make sure the users can use both ints
+  // and longs safely. It is unlikely that anybody'd need
+  // to use recovery intervals > Integer.MAX_VALUE in practice.
+  private long networkRecoveryInterval = DEFAULT_NETWORK_RECOVERY_INTERVAL;
+  private RecoveryDelayHandler recoveryDelayHandler;
+
+  private MetricsCollector metricsCollector;
+  private ObservationCollector observationCollector = ObservationCollector.NO_OP;
+
+  private boolean nio = false;
+
+  private boolean netty = true;
+  private FrameHandlerFactory frameHandlerFactory;
+  private final NettyConfiguration nettyConf = new NettyConfiguration(this);
+  private NioParams nioParams = new NioParams();
+
+  private SslContextFactory sslContextFactory;
 
-    /** @return the default port to use for connections */
-    public int getPort() {
-        return portOrDefault(port, isSSL());
-    }
+  /**
+   * Continuation timeout on RPC calls.
+   *
+   * @since 4.1.0
+   */
+  private int channelRpcTimeout = DEFAULT_CHANNEL_RPC_TIMEOUT;
 
-    /**
-     * Set the target port.
-     * @param port the default port to use for connections
-     */
-    public void setPort(int port) {
-        this.port = port;
-    }
+  /**
+   * Whether or not channels check the reply type of an RPC call. Default is false.
+   *
+   * @since 4.2.0
+   */
+  private boolean channelShouldCheckRpcResponseType = false;
 
-    /**
-     * Retrieve the user name.
-     * @return the AMQP user name to use when connecting to the broker
-     */
-    public String getUsername() {
-        return credentialsProvider.getUsername();
-    }
+  /**
+   * Listener called when a connection gets an IO error trying to write on the socket. Default
+   * listener triggers connection recovery asynchronously and propagates the exception.
+   *
+   * @since 4.5.0
+   */
+  private ErrorOnWriteListener errorOnWriteListener;
 
-    /**
-     * Set the user name.
-     * @param username the AMQP user name to use when connecting to the broker
-     */
-    public void setUsername(String username) {
-        this.credentialsProvider = new DefaultCredentialsProvider(
-            username,
-            this.credentialsProvider.getPassword()
-        );
-    }
+  /**
+   * Timeout in ms for work pool enqueuing.
+   *
+   * @since 4.5.0
+   */
+  private int workPoolTimeout = DEFAULT_WORK_POOL_TIMEOUT;
 
-    /**
-     * Retrieve the password.
-     * @return the password to use when connecting to the broker
-     */
-    public String getPassword() {
-        return credentialsProvider.getPassword();
-    }
+  /**
+   * Filter to include/exclude entities from topology recovery.
+   *
+   * @since 4.8.0
+   */
+  private TopologyRecoveryFilter topologyRecoveryFilter;
 
-    /**
-     * Set the password.
-     * @param password the password to use when connecting to the broker
-     */
-    public void setPassword(String password) {
-        this.credentialsProvider = new DefaultCredentialsProvider(
-            this.credentialsProvider.getUsername(),
-            password
-        );
-    }
+  /**
+   * Condition to trigger automatic connection recovery.
+   *
+   * @since 5.4.0
+   */
+  private Predicate<ShutdownSignalException> connectionRecoveryTriggeringCondition;
 
-    /**
-     * Set a custom credentials provider.
-     * Default implementation uses static username and password.
-     * @param credentialsProvider The custom implementation of CredentialsProvider to use when connecting to the broker.
-     * @see com.rabbitmq.client.impl.DefaultCredentialsProvider
-     * @since 4.5.0
-     */
-    public void setCredentialsProvider(CredentialsProvider credentialsProvider) {
-        this.credentialsProvider = credentialsProvider;
-    }
-    
-    /**
-     * Retrieve the virtual host.
-     * @return the virtual host to use when connecting to the broker
-     */
-    public String getVirtualHost() {
-        return this.virtualHost;
-    }
+  /**
+   * Retry handler for topology recovery. Default is no retry.
+   *
+   * @since 5.4.0
+   */
+  private RetryHandler topologyRecoveryRetryHandler;
 
-    /**
-     * Set the virtual host.
-     * @param virtualHost the virtual host to use when connecting to the broker
-     */
-    public void setVirtualHost(String virtualHost) {
-        this.virtualHost = virtualHost;
-    }
+  private RecoveredQueueNameSupplier recoveredQueueNameSupplier;
 
+  /**
+   * Traffic listener notified of inbound and outbound {@link Command}s.
+   *
+   * <p>Useful for debugging purposes. Default is no-op.
+   *
+   * @since 5.5.0
+   */
+  private TrafficListener trafficListener = TrafficListener.NO_OP;
 
-    /**
-     * Convenience method for setting the fields in an AMQP URI: host,
-     * port, username, password and virtual host.  If any part of the
-     * URI is omitted, the ConnectionFactory's corresponding variable
-     * is left unchanged.
-     * @param uri is the AMQP URI containing the data
-     */
-    public void setUri(URI uri)
-        throws URISyntaxException, NoSuchAlgorithmException, KeyManagementException
-    {
-        if ("amqp".equals(uri.getScheme().toLowerCase())) {
-            // nothing special to do
-        } else if ("amqps".equals(uri.getScheme().toLowerCase())) {
-            setPort(DEFAULT_AMQP_OVER_SSL_PORT);
-            // SSL context factory not set yet, we use the default one
-            if (this.sslContextFactory == null) {
-                useSslProtocol();
-            }
-        } else {
-            throw new IllegalArgumentException("Wrong scheme in AMQP URI: " +
-                                               uri.getScheme());
-        }
+  private CredentialsRefreshService credentialsRefreshService;
 
-        String host = uri.getHost();
-        if (host != null) {
-            setHost(host);
-        }
+  /**
+   * Maximum body size of inbound (received) messages in bytes.
+   *
+   * <p>Default value is 67,108,864 (64 MiB).
+   */
+  private int maxInboundMessageBodySize = 1_048_576 * 64;
 
-        int port = uri.getPort();
-        if (port != -1) {
-            setPort(port);
-        }
+  /**
+   * @return the default host to use for connections
+   */
+  public String getHost() {
+    return host;
+  }
 
-        String userInfo = uri.getRawUserInfo();
-        if (userInfo != null) {
-            String userPass[] = userInfo.split(":");
-            if (userPass.length > 2) {
-                throw new IllegalArgumentException("Bad user info in AMQP " +
-                                                   "URI: " + userInfo);
-            }
+  /**
+   * @param host the default host to use for connections
+   */
+  public void setHost(String host) {
+    this.host = host;
+  }
 
-            setUsername(uriDecode(userPass[0]));
-            if (userPass.length == 2) {
-                setPassword(uriDecode(userPass[1]));
-            }
-        }
+  public static int portOrDefault(int port, boolean ssl) {
+    if (port != USE_DEFAULT_PORT) return port;
+    else if (ssl) return DEFAULT_AMQP_OVER_SSL_PORT;
+    else return DEFAULT_AMQP_PORT;
+  }
 
-        String path = uri.getRawPath();
-        if (path != null && path.length() > 0) {
-            if (path.indexOf('/', 1) != -1) {
-                throw new IllegalArgumentException("Multiple segments in " +
-                                                   "path of AMQP URI: " +
-                                                   path);
-            }
+  /**
+   * @return the default port to use for connections
+   */
+  public int getPort() {
+    return portOrDefault(port, isSSL());
+  }
 
-            setVirtualHost(uriDecode(uri.getPath().substring(1)));
-        }
-        
-        String rawQuery = uri.getRawQuery();
-        if (rawQuery != null && rawQuery.length() > 0) {
-            setQuery(rawQuery);
-        }
-    }
+  /**
+   * Set the target port.
+   *
+   * @param port the default port to use for connections
+   */
+  public void setPort(int port) {
+    this.port = port;
+  }
 
-    /**
-     * Convenience method for setting the fields in an AMQP URI: host,
-     * port, username, password and virtual host.  If any part of the
-     * URI is omitted, the ConnectionFactory's corresponding variable
-     * is left unchanged.  Note that not all valid AMQP URIs are
-     * accepted; in particular, the hostname must be given if the
-     * port, username or password are given, and escapes in the
-     * hostname are not permitted.
-     * @param uriString is the AMQP URI containing the data
-     */
-    public void setUri(String uriString)
-        throws URISyntaxException, NoSuchAlgorithmException, KeyManagementException
-    {
-        setUri(new URI(uriString));
-    }
+  /**
+   * Retrieve the user name.
+   *
+   * @return the AMQP user name to use when connecting to the broker
+   */
+  public String getUsername() {
+    return credentialsProvider.getUsername();
+  }
 
-    private static String uriDecode(String s) {
-        try {
-            // URLDecode decodes '+' to a space, as for
-            // form encoding.  So protect plus signs.
-            return URLDecoder.decode(s.replace("+", "%2B"), "US-ASCII");
-        }
-        catch (IOException e) {
-            throw new RuntimeException(e);
-        }
-    }
+  /**
+   * Set the user name.
+   *
+   * @param username the AMQP user name to use when connecting to the broker
+   */
+  public void setUsername(String username) {
+    this.credentialsProvider =
+        new DefaultCredentialsProvider(username, this.credentialsProvider.getPassword());
+  }
 
-  private static final Map<String, BiConsumer<String, ConnectionFactory>> URI_QUERY_PARAMETER_HANDLERS =
-      new HashMap<String, BiConsumer<String, ConnectionFactory>>() {
-        {
-            put("heartbeat", (value, cf) -> {
-                try {
-                    int heartbeatInt = Integer.parseInt(value);
-                    cf.setRequestedHeartbeat(heartbeatInt);
-                } catch (NumberFormatException e) {
-                    throw new IllegalArgumentException("Requested heartbeat must an integer");
-                }
-            });
-            put("connection_timeout", (value, cf) -> {
-              try {
-                int connectionTimeoutInt = Integer.parseInt(value);
-                cf.setConnectionTimeout(connectionTimeoutInt);
-              } catch (NumberFormatException e) {
-                throw new IllegalArgumentException("TCP connection timeout must an integer");
-              }
-            });
-            put("channel_max", (value, cf) -> {
-                try {
-                    int channelMaxInt = Integer.parseInt(value);
-                    cf.setRequestedChannelMax(channelMaxInt);
-                } catch (NumberFormatException e) {
-                    throw new IllegalArgumentException("Requested channel max must an integer");
-                }
-            });
-        }
-      };
+  /**
+   * Retrieve the password.
+   *
+   * @return the password to use when connecting to the broker
+   */
+  public String getPassword() {
+    return credentialsProvider.getPassword();
+  }
 
-    /**
-     * Convenience method for setting some fields from query parameters
-     * Will handle only a subset of the query parameters supported by the
-     * official erlang client
-     * https://www.rabbitmq.com/uri-query-parameters.html
-     * @param rawQuery is the string containing the raw query parameters part from a URI
-     */
-    private void setQuery(String rawQuery) {
-        Map<String, String> parameters = new HashMap<>();
-        // parsing the query parameters
-        try {
-            for (String param : rawQuery.split("&")) {
-                String[] pair = param.split("=");
-                String key = URLDecoder.decode(pair[0], "US-ASCII");
-                String value = null;
-                if (pair.length > 1) {
-                    value = URLDecoder.decode(pair[1], "US-ASCII");
-                }
-                parameters.put(key, value);
-            }
-        } catch (IOException e) {
-            throw new IllegalArgumentException("Cannot parse the query parameters", e);
-        }
+  /**
+   * Set the password.
+   *
+   * @param password the password to use when connecting to the broker
+   */
+  public void setPassword(String password) {
+    this.credentialsProvider =
+        new DefaultCredentialsProvider(this.credentialsProvider.getUsername(), password);
+  }
 
-        for (Entry<String, String> entry : parameters.entrySet()) {
-            BiConsumer<String, ConnectionFactory> handler = URI_QUERY_PARAMETER_HANDLERS
-                .get(entry.getKey());
-            if (handler != null) {
-                handler.accept(entry.getValue(), this);
-            } else {
-                processUriQueryParameter(entry.getKey(), entry.getValue());
-            }
-        }
-    }
+  /**
+   * Set a custom credentials provider. Default implementation uses static username and password.
+   *
+   * @param credentialsProvider The custom implementation of CredentialsProvider to use when
+   *     connecting to the broker.
+   * @see com.rabbitmq.client.impl.DefaultCredentialsProvider
+   * @since 4.5.0
+   */
+  public void setCredentialsProvider(CredentialsProvider credentialsProvider) {
+    this.credentialsProvider = credentialsProvider;
+  }
 
-    /**
-     * Hook to process query parameters not handled natively.
-     * Handled natively: <code>heartbeat</code>, <code>connection_timeout</code>,
-     * <code>channel_max</code>.
-     * @param key
-     * @param value
-     */
-    protected void processUriQueryParameter(String key, String value) {
+  /**
+   * Retrieve the virtual host.
+   *
+   * @return the virtual host to use when connecting to the broker
+   */
+  public String getVirtualHost() {
+    return this.virtualHost;
+  }
 
-    }
+  /**
+   * Set the virtual host.
+   *
+   * @param virtualHost the virtual host to use when connecting to the broker
+   */
+  public void setVirtualHost(String virtualHost) {
+    this.virtualHost = virtualHost;
+  }
 
-    /**
-     * Retrieve the requested maximum channel number
-     * @return the initially requested maximum channel number; zero for unlimited
-     */
-    public int getRequestedChannelMax() {
-        return this.requestedChannelMax;
+  /**
+   * Convenience method for setting the fields in an AMQP URI: host, port, username, password and
+   * virtual host. If any part of the URI is omitted, the ConnectionFactory's corresponding variable
+   * is left unchanged.
+   *
+   * @param uri is the AMQP URI containing the data
+   */
+  public void setUri(URI uri)
+      throws URISyntaxException, NoSuchAlgorithmException, KeyManagementException {
+    if ("amqp".equals(uri.getScheme().toLowerCase())) {
+      // nothing special to do
+    } else if ("amqps".equals(uri.getScheme().toLowerCase())) {
+      setPort(DEFAULT_AMQP_OVER_SSL_PORT);
+      // SSL context factory not set yet, we use the default one
+      if (this.sslContextFactory == null) {
+        useSslProtocol();
+      }
+    } else {
+      throw new IllegalArgumentException("Wrong scheme in AMQP URI: " + uri.getScheme());
     }
 
-    /**
-     * Set the requested maximum channel number.
-     * <p>
-     * Note the value must be between 0 and 65535 (unsigned short in AMQP 0-9-1).
-     *
-     * @param requestedChannelMax initially requested maximum channel number; zero for unlimited
-     */
-    public void setRequestedChannelMax(int requestedChannelMax) {
-        this.requestedChannelMax = ensureUnsignedShort(requestedChannelMax);
-        if (this.requestedChannelMax != requestedChannelMax) {
-            LOGGER.warn("Requested channel max must be between 0 and {}, value has been set to {} instead of {}",
-                    MAX_UNSIGNED_SHORT, this.requestedChannelMax, requestedChannelMax);
-        }
+    String host = uri.getHost();
+    if (host != null) {
+      setHost(host);
     }
 
-    /**
-     * Retrieve the requested maximum frame size
-     * @return the initially requested maximum frame size, in octets; zero for unlimited
-     */
-    public int getRequestedFrameMax() {
-        return this.requestedFrameMax;
+    int port = uri.getPort();
+    if (port != -1) {
+      setPort(port);
     }
 
-    /**
-     * Set the requested maximum frame size
-     * @param requestedFrameMax initially requested maximum frame size, in octets; zero for unlimited
-     */
-    public void setRequestedFrameMax(int requestedFrameMax) {
-        this.requestedFrameMax = requestedFrameMax;
-    }
+    String userInfo = uri.getRawUserInfo();
+    if (userInfo != null) {
+      String userPass[] = userInfo.split(":");
+      if (userPass.length > 2) {
+        throw new IllegalArgumentException("Bad user info in AMQP " + "URI: " + userInfo);
+      }
 
-    /**
-     * Retrieve the requested heartbeat interval.
-     * @return the initially requested heartbeat interval, in seconds; zero for none
-     */
-    public int getRequestedHeartbeat() {
-        return this.requestedHeartbeat;
+      setUsername(uriDecode(userPass[0]));
+      if (userPass.length == 2) {
+        setPassword(uriDecode(userPass[1]));
+      }
     }
 
-    /**
-     * Set the TCP connection timeout.
-     * @param timeout connection TCP establishment timeout in milliseconds; zero for infinite
-     */
-    public void setConnectionTimeout(int timeout) {
-        if(timeout < 0) {
-            throw new IllegalArgumentException("TCP connection timeout cannot be negative");
-        }
-        this.connectionTimeout = timeout;
-    }
+    String path = uri.getRawPath();
+    if (path != null && path.length() > 0) {
+      if (path.indexOf('/', 1) != -1) {
+        throw new IllegalArgumentException("Multiple segments in " + "path of AMQP URI: " + path);
+      }
 
-    /**
-     * Retrieve the TCP connection timeout.
-     * @return the TCP connection timeout, in milliseconds; zero for infinite
-     */
-    public int getConnectionTimeout() {
-        return this.connectionTimeout;
+      setVirtualHost(uriDecode(uri.getPath().substring(1)));
     }
 
-    /**
-     * Retrieve the AMQP 0-9-1 protocol handshake timeout.
-     * @return the AMQP0-9-1 protocol handshake timeout, in milliseconds
-     */
-    public int getHandshakeTimeout() {
-        return handshakeTimeout;
+    String rawQuery = uri.getRawQuery();
+    if (rawQuery != null && rawQuery.length() > 0) {
+      setQuery(rawQuery);
     }
+  }
 
-    /**
-     * Set the AMQP0-9-1 protocol handshake timeout.
-     * @param timeout the AMQP0-9-1 protocol handshake timeout, in milliseconds
-     */
-    public void setHandshakeTimeout(int timeout) {
-        if(timeout < 0) {
-            throw new IllegalArgumentException("handshake timeout cannot be negative");
+  /**
+   * Convenience method for setting the fields in an AMQP URI: host, port, username, password and
+   * virtual host. If any part of the URI is omitted, the ConnectionFactory's corresponding variable
+   * is left unchanged. Note that not all valid AMQP URIs are accepted; in particular, the hostname
+   * must be given if the port, username or password are given, and escapes in the hostname are not
+   * permitted.
+   *
+   * @param uriString is the AMQP URI containing the data
+   */
+  public void setUri(String uriString)
+      throws URISyntaxException, NoSuchAlgorithmException, KeyManagementException {
+    setUri(new URI(uriString));
+  }
+
+  private static String uriDecode(String s) {
+    try {
+      // URLDecode decodes '+' to a space, as for
+      // form encoding.  So protect plus signs.
+      return URLDecoder.decode(s.replace("+", "%2B"), "US-ASCII");
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  private static final Map<String, BiConsumer<String, ConnectionFactory>>
+      URI_QUERY_PARAMETER_HANDLERS =
+          new HashMap<String, BiConsumer<String, ConnectionFactory>>() {
+            {
+              put(
+                  "heartbeat",
+                  (value, cf) -> {
+                    try {
+                      int heartbeatInt = Integer.parseInt(value);
+                      cf.setRequestedHeartbeat(heartbeatInt);
+                    } catch (NumberFormatException e) {
+                      throw new IllegalArgumentException("Requested heartbeat must an integer");
+                    }
+                  });
+              put(
+                  "connection_timeout",
+                  (value, cf) -> {
+                    try {
+                      int connectionTimeoutInt = Integer.parseInt(value);
+                      cf.setConnectionTimeout(connectionTimeoutInt);
+                    } catch (NumberFormatException e) {
+                      throw new IllegalArgumentException("TCP connection timeout must an integer");
+                    }
+                  });
+              put(
+                  "channel_max",
+                  (value, cf) -> {
+                    try {
+                      int channelMaxInt = Integer.parseInt(value);
+                      cf.setRequestedChannelMax(channelMaxInt);
+                    } catch (NumberFormatException e) {
+                      throw new IllegalArgumentException("Requested channel max must an integer");
+                    }
+                  });
+            }
+          };
+
+  /**
+   * Convenience method for setting some fields from query parameters Will handle only a subset of
+   * the query parameters supported by the official erlang client
+   * https://www.rabbitmq.com/uri-query-parameters.html
+   *
+   * @param rawQuery is the string containing the raw query parameters part from a URI
+   */
+  private void setQuery(String rawQuery) {
+    Map<String, String> parameters = new HashMap<>();
+    // parsing the query parameters
+    try {
+      for (String param : rawQuery.split("&")) {
+        String[] pair = param.split("=");
+        String key = URLDecoder.decode(pair[0], "US-ASCII");
+        String value = null;
+        if (pair.length > 1) {
+          value = URLDecoder.decode(pair[1], "US-ASCII");
         }
-        this.handshakeTimeout = timeout;
+        parameters.put(key, value);
+      }
+    } catch (IOException e) {
+      throw new IllegalArgumentException("Cannot parse the query parameters", e);
     }
 
-    /**
-     * Set the shutdown timeout. This is the amount of time that Consumer implementations have to
-     * continue working through deliveries (and other Consumer callbacks) <b>after</b> the connection
-     * has closed but before the ConsumerWorkService is torn down. If consumers exceed this timeout
-     * then any remaining queued deliveries (and other Consumer callbacks, <b>including</b>
-     * the Consumer's handleShutdownSignal() invocation) will be lost.
-     * @param shutdownTimeout shutdown timeout in milliseconds; zero for infinite; default 10000
-     */
-    public void setShutdownTimeout(int shutdownTimeout) {
-        this.shutdownTimeout = shutdownTimeout;
+    for (Entry<String, String> entry : parameters.entrySet()) {
+      BiConsumer<String, ConnectionFactory> handler =
+          URI_QUERY_PARAMETER_HANDLERS.get(entry.getKey());
+      if (handler != null) {
+        handler.accept(entry.getValue(), this);
+      } else {
+        processUriQueryParameter(entry.getKey(), entry.getValue());
+      }
     }
+  }
 
-    /**
-     * Retrieve the shutdown timeout.
-     * @return the shutdown timeout, in milliseconds; zero for infinite
-     */
-    public int getShutdownTimeout() {
-        return shutdownTimeout;
-    }
+  /**
+   * Hook to process query parameters not handled natively. Handled natively: <code>heartbeat</code>
+   * , <code>connection_timeout</code>, <code>channel_max</code>.
+   *
+   * @param key
+   * @param value
+   */
+  protected void processUriQueryParameter(String key, String value) {}
 
-    /**
-     * Set the requested heartbeat timeout. Heartbeat frames will be sent at about 1/2 the timeout interval.
-     * If server heartbeat timeout is configured to a non-zero value, this method can only be used
-     * to lower the value; otherwise any value provided by the client will be used.
-     * <p>
-     * Note the value must be between 0 and 65535 (unsigned short in AMQP 0-9-1).
-     *
-     * @param requestedHeartbeat the initially requested heartbeat timeout, in seconds; zero for none
-     * @see <a href="https://rabbitmq.com/heartbeats.html">RabbitMQ Heartbeats Guide</a>
-     */
-    public void setRequestedHeartbeat(int requestedHeartbeat) {
-        this.requestedHeartbeat = ensureUnsignedShort(requestedHeartbeat);
-        if (this.requestedHeartbeat != requestedHeartbeat) {
-            LOGGER.warn("Requested heartbeat must be between 0 and {}, value has been set to {} instead of {}",
-                    MAX_UNSIGNED_SHORT, this.requestedHeartbeat, requestedHeartbeat);
-        }
-    }
+  /**
+   * Retrieve the requested maximum channel number
+   *
+   * @return the initially requested maximum channel number; zero for unlimited
+   */
+  public int getRequestedChannelMax() {
+    return this.requestedChannelMax;
+  }
 
-    /**
-     * Retrieve the currently-configured table of client properties
-     * that will be sent to the server during connection
-     * startup. Clients may add, delete, and alter keys in this
-     * table. Such changes will take effect when the next new
-     * connection is started using this factory.
-     * @return the map of client properties
-     * @see #setClientProperties
-     */
-    public Map<String, Object> getClientProperties() {
-        return _clientProperties;
+  /**
+   * Set the requested maximum channel number.
+   *
+   * <p>Note the value must be between 0 and 65535 (unsigned short in AMQP 0-9-1).
+   *
+   * @param requestedChannelMax initially requested maximum channel number; zero for unlimited
+   */
+  public void setRequestedChannelMax(int requestedChannelMax) {
+    this.requestedChannelMax = ensureUnsignedShort(requestedChannelMax);
+    if (this.requestedChannelMax != requestedChannelMax) {
+      LOGGER.warn(
+          "Requested channel max must be between 0 and {}, value has been set to {} instead of {}",
+          MAX_UNSIGNED_SHORT,
+          this.requestedChannelMax,
+          requestedChannelMax);
     }
+  }
 
-    /**
-     * Replace the table of client properties that will be sent to the
-     * server during subsequent connection startups.
-     * @param clientProperties the map of extra client properties
-     * @see #getClientProperties
-     */
-    public void setClientProperties(Map<String, Object> clientProperties) {
-        _clientProperties = clientProperties;
-    }
+  /**
+   * Retrieve the requested maximum frame size
+   *
+   * @return the initially requested maximum frame size, in octets; zero for unlimited
+   */
+  public int getRequestedFrameMax() {
+    return this.requestedFrameMax;
+  }
 
-    /**
-     * Gets the sasl config to use when authenticating
-     * @return the sasl config
-     * @see com.rabbitmq.client.SaslConfig
-     */
-    public SaslConfig getSaslConfig() {
-        return saslConfig;
-    }
+  /**
+   * Set the requested maximum frame size
+   *
+   * @param requestedFrameMax initially requested maximum frame size, in octets; zero for unlimited
+   */
+  public void setRequestedFrameMax(int requestedFrameMax) {
+    this.requestedFrameMax = requestedFrameMax;
+  }
 
-    /**
-     * Sets the sasl config to use when authenticating
-     * @param saslConfig
-     * @see com.rabbitmq.client.SaslConfig
-     */
-    public void setSaslConfig(SaslConfig saslConfig) {
-        this.saslConfig = saslConfig;
-    }
+  /**
+   * Retrieve the requested heartbeat interval.
+   *
+   * @return the initially requested heartbeat interval, in seconds; zero for none
+   */
+  public int getRequestedHeartbeat() {
+    return this.requestedHeartbeat;
+  }
 
-    /**
-     * Retrieve the socket factory used to make connections with.
-     */
-    public SocketFactory getSocketFactory() {
-        return this.socketFactory;
+  /**
+   * Set the TCP connection timeout.
+   *
+   * @param timeout connection TCP establishment timeout in milliseconds; zero for infinite
+   */
+  public void setConnectionTimeout(int timeout) {
+    if (timeout < 0) {
+      throw new IllegalArgumentException("TCP connection timeout cannot be negative");
     }
+    this.connectionTimeout = timeout;
+  }
 
-    /**
-     * Set the socket factory used to create sockets for new connections. Can be
-     * used to customize TLS-related settings by passing in a
-     * javax.net.ssl.SSLSocketFactory instance.
-     * Note this applies only to blocking IO, not to
-     * NIO, as the NIO API doesn't use the SocketFactory API.
-     * @see #useSslProtocol
-     */
-    public void setSocketFactory(SocketFactory factory) {
-        this.socketFactory = factory;
-    }
+  /**
+   * Retrieve the TCP connection timeout.
+   *
+   * @return the TCP connection timeout, in milliseconds; zero for infinite
+   */
+  public int getConnectionTimeout() {
+    return this.connectionTimeout;
+  }
 
-    /**
-     * Get the socket configurator.
-     *
-     * @see #setSocketConfigurator(SocketConfigurator)
-     */
-    public SocketConfigurator getSocketConfigurator() {
-        return socketConf;
-    }
+  /**
+   * Retrieve the AMQP 0-9-1 protocol handshake timeout.
+   *
+   * @return the AMQP0-9-1 protocol handshake timeout, in milliseconds
+   */
+  public int getHandshakeTimeout() {
+    return handshakeTimeout;
+  }
 
-    /**
-     * Set the socket configurator. This gets a chance to "configure" a socket
-     * before it has been opened. The default socket configurator disables
-     * Nagle's algorithm.
-     *
-     * @param socketConfigurator the configurator to use
-     */
-    public void setSocketConfigurator(SocketConfigurator socketConfigurator) {
-        this.socketConf = socketConfigurator;
+  /**
+   * Set the AMQP0-9-1 protocol handshake timeout.
+   *
+   * @param timeout the AMQP0-9-1 protocol handshake timeout, in milliseconds
+   */
+  public void setHandshakeTimeout(int timeout) {
+    if (timeout < 0) {
+      throw new IllegalArgumentException("handshake timeout cannot be negative");
     }
+    this.handshakeTimeout = timeout;
+  }
 
-    /**
-     * Set the executor to use for consumer operation dispatch
-     * by default for newly created connections.
-     * All connections that use this executor share it.
-     *
-     * It's developer's responsibility to shut down the executor
-     * when it is no longer needed.
-     *
-     * @param executor executor service to be used for
-     *                 consumer operation
-     */
-    public void setSharedExecutor(ExecutorService executor) {
-        this.sharedExecutor = executor;
-    }
+  /**
+   * Set the shutdown timeout. This is the amount of time that Consumer implementations have to
+   * continue working through deliveries (and other Consumer callbacks) <b>after</b> the connection
+   * has closed but before the ConsumerWorkService is torn down. If consumers exceed this timeout
+   * then any remaining queued deliveries (and other Consumer callbacks, <b>including</b> the
+   * Consumer's handleShutdownSignal() invocation) will be lost.
+   *
+   * @param shutdownTimeout shutdown timeout in milliseconds; zero for infinite; default 10000
+   */
+  public void setShutdownTimeout(int shutdownTimeout) {
+    this.shutdownTimeout = shutdownTimeout;
+  }
 
-    /**
-     * Set the executor to use for connection shutdown.
-     * All connections that use this executor share it.
-     *
-     * It's developer's responsibility to shut down the executor
-     * when it is no longer needed.
-     *
-     * @param executor executor service to be used for
-     *                 connection shutdown
-     */
-    public void setShutdownExecutor(ExecutorService executor) {
-        this.shutdownExecutor = executor;
-    }
+  /**
+   * Retrieve the shutdown timeout.
+   *
+   * @return the shutdown timeout, in milliseconds; zero for infinite
+   */
+  public int getShutdownTimeout() {
+    return shutdownTimeout;
+  }
 
-    /**
-     * Set the executor to use to send heartbeat frames.
-     * All connections that use this executor share it.
-     *
-     * It's developer's responsibility to shut down the executor
-     * when it is no longer needed.
-     *
-     * @param executor executor service to be used to send heartbeat 
-     */
-    public void setHeartbeatExecutor(ScheduledExecutorService executor) {
-        this.heartbeatExecutor = executor;
-    }
-    
-    /**
-     * Retrieve the thread factory used to instantiate new threads.
-     * @see ThreadFactory
-     */
-    public ThreadFactory getThreadFactory() {
-        return threadFactory;
+  /**
+   * Set the requested heartbeat timeout. Heartbeat frames will be sent at about 1/2 the timeout
+   * interval. If server heartbeat timeout is configured to a non-zero value, this method can only
+   * be used to lower the value; otherwise any value provided by the client will be used.
+   *
+   * <p>Note the value must be between 0 and 65535 (unsigned short in AMQP 0-9-1).
+   *
+   * @param requestedHeartbeat the initially requested heartbeat timeout, in seconds; zero for none
+   * @see <a href="https://rabbitmq.com/heartbeats.html">RabbitMQ Heartbeats Guide</a>
+   */
+  public void setRequestedHeartbeat(int requestedHeartbeat) {
+    this.requestedHeartbeat = ensureUnsignedShort(requestedHeartbeat);
+    if (this.requestedHeartbeat != requestedHeartbeat) {
+      LOGGER.warn(
+          "Requested heartbeat must be between 0 and {}, value has been set to {} instead of {}",
+          MAX_UNSIGNED_SHORT,
+          this.requestedHeartbeat,
+          requestedHeartbeat);
     }
+  }
 
-    /**
-     * Set the thread factory used to instantiate new threads.
-     * @see ThreadFactory
-     */
-    public void setThreadFactory(ThreadFactory threadFactory) {
-        this.threadFactory = threadFactory;
-    }
+  /**
+   * Retrieve the currently-configured table of client properties that will be sent to the server
+   * during connection startup. Clients may add, delete, and alter keys in this table. Such changes
+   * will take effect when the next new connection is started using this factory.
+   *
+   * @return the map of client properties
+   * @see #setClientProperties
+   */
+  public Map<String, Object> getClientProperties() {
+    return _clientProperties;
+  }
 
-    /**
-    * Get the exception handler.
-    *
-    * @see com.rabbitmq.client.ExceptionHandler
-    */
-    public ExceptionHandler getExceptionHandler() {
-        return exceptionHandler;
-    }
+  /**
+   * Replace the table of client properties that will be sent to the server during subsequent
+   * connection startups.
+   *
+   * @param clientProperties the map of extra client properties
+   * @see #getClientProperties
+   */
+  public void setClientProperties(Map<String, Object> clientProperties) {
+    _clientProperties = clientProperties;
+  }
 
-    /**
-     * Set the exception handler to use for newly created connections.
-     * @see com.rabbitmq.client.ExceptionHandler
-     */
-    public void setExceptionHandler(ExceptionHandler exceptionHandler) {
-        if (exceptionHandler == null) {
-          throw new IllegalArgumentException("exception handler cannot be null!");
-        }
-        this.exceptionHandler = exceptionHandler;
-    }
+  /**
+   * Gets the sasl config to use when authenticating
+   *
+   * @return the sasl config
+   * @see com.rabbitmq.client.SaslConfig
+   */
+  public SaslConfig getSaslConfig() {
+    return saslConfig;
+  }
 
-    public boolean isSSL(){
-        return getSocketFactory() instanceof SSLSocketFactory || sslContextFactory != null;
-    }
+  /**
+   * Sets the sasl config to use when authenticating
+   *
+   * @param saslConfig
+   * @see com.rabbitmq.client.SaslConfig
+   */
+  public void setSaslConfig(SaslConfig saslConfig) {
+    this.saslConfig = saslConfig;
+  }
 
-    /**
-     * Convenience method for configuring TLS using
-     * the default set of TLS protocols and a trusting TrustManager.
-     * This setup is <strong>only suitable for development
-     * and QA environments</strong>.
-     * The trust manager will <strong>trust every server certificate presented</strong>
-     * to it, this is convenient for local development but
-     * <strong>not recommended to use in production</strong> as it provides no protection
-     * against man-in-the-middle attacks. Prefer {@link #useSslProtocol(SSLContext)}.
-     */
-    public void useSslProtocol()
-        throws NoSuchAlgorithmException, KeyManagementException
-    {
-        useSslProtocol(computeDefaultTlsProtocol(SSLContext.getDefault().getSupportedSSLParameters().getProtocols()));
-    }
+  /** Retrieve the socket factory used to make connections with. */
+  public SocketFactory getSocketFactory() {
+    return this.socketFactory;
+  }
 
-    /**
-     * Convenience method for configuring TLS using
-     * the supplied protocol and a very trusting TrustManager. This setup is <strong>only suitable for development
-     * and QA environments</strong>.
-     * The trust manager <strong>will trust every server certificate presented</strong>
-     * to it, this is convenient for local development but
-     * not recommended to use in production as it <strong>provides no protection
-     * against man-in-the-middle attacks</strong>.
-     *
-     * Use {@link #useSslProtocol(SSLContext)} in production environments.
-     * The produced {@link SSLContext} instance will be shared by all
-     * the connections created by this connection factory.
-     *
-     * Use {@link #setSslContextFactory(SslContextFactory)} for more flexibility.
-     * @see #setSslContextFactory(SslContextFactory)
-     */
-    public void useSslProtocol(String protocol)
-        throws NoSuchAlgorithmException, KeyManagementException
-    {
-        useSslProtocol(protocol, new TrustEverythingTrustManager());
-    }
+  /**
+   * Set the socket factory used to create sockets for new connections. Can be used to customize
+   * TLS-related settings by passing in a javax.net.ssl.SSLSocketFactory instance. Note this applies
+   * only to blocking IO, not to NIO, as the NIO API doesn't use the SocketFactory API.
+   *
+   * @see #useSslProtocol
+   */
+  public void setSocketFactory(SocketFactory factory) {
+    this.socketFactory = factory;
+  }
 
-    /**
-     * Convenience method for configuring TLS.
-     * Pass in the TLS protocol version to use, e.g. "TLSv1.2" or "TLSv1.1", and
-     * a desired {@link TrustManager}.
-     *
-     *
-     * The produced {@link SSLContext} instance will be shared with all
-     * the connections created by this connection factory. Use
-     * {@link #setSslContextFactory(SslContextFactory)} for more flexibility.
-     * @param protocol the TLS protocol to use.
-     * @param trustManager the {@link TrustManager} implementation to use.
-     * @see #setSslContextFactory(SslContextFactory)
-     * @see #useSslProtocol(SSLContext)
-     */
-    public void useSslProtocol(String protocol, TrustManager trustManager)
-        throws NoSuchAlgorithmException, KeyManagementException
-    {
-        SSLContext c = SSLContext.getInstance(protocol);
-        c.init(null, new TrustManager[] { trustManager }, null);
-        useSslProtocol(c);
-    }
+  /**
+   * Get the socket configurator.
+   *
+   * @see #setSocketConfigurator(SocketConfigurator)
+   */
+  public SocketConfigurator getSocketConfigurator() {
+    return socketConf;
+  }
 
-    /**
-     * Sets up TLS with an initialized {@link SSLContext}. The caller is responsible
-     * for setting up the context with a {@link TrustManager} with suitable security guarantees,
-     * e.g. peer verification.
-     *
-     *
-     * The {@link SSLContext} instance will be shared with all
-     * the connections created by this connection factory. Use
-     * {@link #setSslContextFactory(SslContextFactory)} for more flexibility.
-     * @param context An initialized SSLContext
-     * @see #setSslContextFactory(SslContextFactory)
-     */
-    public void useSslProtocol(SSLContext context) {
-        this.sslContextFactory = name -> context;
-        setSocketFactory(context.getSocketFactory());
-    }
+  /**
+   * Set the socket configurator. This gets a chance to "configure" a socket before it has been
+   * opened. The default socket configurator disables Nagle's algorithm.
+   *
+   * @param socketConfigurator the configurator to use
+   */
+  public void setSocketConfigurator(SocketConfigurator socketConfigurator) {
+    this.socketConf = socketConfigurator;
+  }
 
-    /**
-     * Enable server hostname verification for TLS connections.
-     * <p>
-     * This enables hostname verification regardless of the IO mode
-     * used (blocking or non-blocking IO).
-     * <p>
-     * This can be called typically after setting the {@link SSLContext}
-     * with one of the <code>useSslProtocol</code> methods.
-     *
-     * @see NioParams#enableHostnameVerification()
-     * @see NioParams#setSslEngineConfigurator(SslEngineConfigurator)
-     * @see SslEngineConfigurators#ENABLE_HOSTNAME_VERIFICATION
-     * @see SocketConfigurators#ENABLE_HOSTNAME_VERIFICATION
-     * @see ConnectionFactory#useSslProtocol(String)
-     * @see ConnectionFactory#useSslProtocol(SSLContext)
-     * @see ConnectionFactory#useSslProtocol()
-     * @see ConnectionFactory#useSslProtocol(String, TrustManager)
-     * @since 5.4.0
-     */
-    public void enableHostnameVerification() {
-        enableHostnameVerificationForNio();
-        enableHostnameVerificationForBlockingIo();
-    }
+  /**
+   * Set the executor to use for consumer operation dispatch by default for newly created
+   * connections. All connections that use this executor share it.
+   *
+   * <p>It's developer's responsibility to shut down the executor when it is no longer needed.
+   *
+   * @param executor executor service to be used for consumer operation
+   */
+  public void setSharedExecutor(ExecutorService executor) {
+    this.sharedExecutor = executor;
+  }
 
-    protected void enableHostnameVerificationForNio() {
-        if (this.nioParams == null) {
-            this.nioParams = new NioParams();
-        }
-        this.nioParams = this.nioParams.enableHostnameVerification();
-    }
+  /**
+   * Set the executor to use for connection shutdown. All connections that use this executor share
+   * it.
+   *
+   * <p>It's developer's responsibility to shut down the executor when it is no longer needed.
+   *
+   * @param executor executor service to be used for connection shutdown
+   */
+  public void setShutdownExecutor(ExecutorService executor) {
+    this.shutdownExecutor = executor;
+  }
 
-    protected void enableHostnameVerificationForBlockingIo() {
-        if (this.socketConf == null) {
-            this.socketConf = SocketConfigurators.builder().defaultConfigurator().enableHostnameVerification().build();
-        } else {
-            this.socketConf = this.socketConf.andThen(SocketConfigurators.enableHostnameVerification());
-        }
+  /**
+   * Set the executor to use to send heartbeat frames. All connections that use this executor share
+   * it.
+   *
+   * <p>It's developer's responsibility to shut down the executor when it is no longer needed.
+   *
+   * <p>Note there is no need to set a heartbeat executor when using Netty.
+   *
+   * @param executor executor service to be used to send heartbeat
+   */
+  public void setHeartbeatExecutor(ScheduledExecutorService executor) {
+    this.heartbeatExecutor = executor;
+  }
+
+  /**
+   * Retrieve the thread factory used to instantiate new threads.
+   *
+   * @see ThreadFactory
+   */
+  public ThreadFactory getThreadFactory() {
+    return threadFactory;
+  }
+
+  /**
+   * Set the thread factory used to instantiate new threads.
+   *
+   * @see ThreadFactory
+   */
+  public void setThreadFactory(ThreadFactory threadFactory) {
+    this.threadFactory = threadFactory;
+  }
+
+  /**
+   * Get the exception handler.
+   *
+   * @see com.rabbitmq.client.ExceptionHandler
+   */
+  public ExceptionHandler getExceptionHandler() {
+    return exceptionHandler;
+  }
+
+  /**
+   * Set the exception handler to use for newly created connections.
+   *
+   * @see com.rabbitmq.client.ExceptionHandler
+   */
+  public void setExceptionHandler(ExceptionHandler exceptionHandler) {
+    if (exceptionHandler == null) {
+      throw new IllegalArgumentException("exception handler cannot be null!");
     }
+    this.exceptionHandler = exceptionHandler;
+  }
 
-    public static String computeDefaultTlsProtocol(String[] supportedProtocols) {
-        if(supportedProtocols != null) {
-            for (String supportedProtocol : supportedProtocols) {
-                if(PREFERRED_TLS_PROTOCOL.equalsIgnoreCase(supportedProtocol)) {
-                    return supportedProtocol;
-                }
-            }
+  public boolean isSSL() {
+    return getSocketFactory() instanceof SSLSocketFactory
+        || sslContextFactory != null
+        || this.nettyConf.isTls();
+  }
+
+  /**
+   * Convenience method for configuring TLS using the default set of TLS protocols and a trusting
+   * TrustManager. This setup is <strong>only suitable for development and QA environments</strong>.
+   * The trust manager will <strong>trust every server certificate presented</strong> to it, this is
+   * convenient for local development but <strong>not recommended to use in production</strong> as
+   * it provides no protection against man-in-the-middle attacks. Prefer {@link
+   * #useSslProtocol(SSLContext)}.
+   *
+   * <p>Note this method has NO effect when using Netty, use {@link
+   * com.rabbitmq.client.ConnectionFactory.NettyConfiguration#sslContext(io.netty.handler.ssl.SslContext)}
+   * instead.
+   */
+  public void useSslProtocol() throws NoSuchAlgorithmException, KeyManagementException {
+    useSslProtocol(computeDefaultTlsProtocol(
+            SSLContext.getDefault().getSupportedSSLParameters().getProtocols()));
+  }
+
+  /**
+   * Convenience method for configuring TLS using the supplied protocol and a very trusting
+   * TrustManager. This setup is <strong>only suitable for development and QA environments</strong>.
+   * The trust manager <strong>will trust every server certificate presented</strong> to it, this is
+   * convenient for local development but not recommended to use in production as it
+   * <strong>provides no protection against man-in-the-middle attacks</strong>.
+   *
+   * <p>Use {@link #useSslProtocol(SSLContext)} in production environments. The produced {@link
+   * SSLContext} instance will be shared by all the connections created by this connection factory.
+   *
+   * <p>Use {@link #setSslContextFactory(SslContextFactory)} for more flexibility.
+   *
+   * <p>Note this method has NO effect when using Netty, use {@link
+   * com.rabbitmq.client.ConnectionFactory.NettyConfiguration#sslContext(io.netty.handler.ssl.SslContext)}
+   *  instead.
+   *
+   * @see #setSslContextFactory(SslContextFactory)
+   */
+  public void useSslProtocol(String protocol)
+      throws NoSuchAlgorithmException, KeyManagementException {
+    useSslProtocol(protocol, new TrustEverythingTrustManager());
+  }
+
+  /**
+   * Convenience method for configuring TLS. Pass in the TLS protocol version to use, e.g. "TLSv1.2"
+   * or "TLSv1.1", and a desired {@link TrustManager}.
+   *
+   * <p>The produced {@link SSLContext} instance will be shared with all the connections created by
+   * this connection factory. Use {@link #setSslContextFactory(SslContextFactory)} for more
+   * flexibility.
+   *
+   * <p>Note this method has NO effect when using Netty, use {@link
+   * com.rabbitmq.client.ConnectionFactory.NettyConfiguration#sslContext(io.netty.handler.ssl.SslContext)}
+   * instead.
+   *
+   * @param protocol the TLS protocol to use.
+   * @param trustManager the {@link TrustManager} implementation to use.
+   * @see #setSslContextFactory(SslContextFactory)
+   * @see #useSslProtocol(SSLContext)
+   */
+  public void useSslProtocol(String protocol, TrustManager trustManager)
+      throws NoSuchAlgorithmException, KeyManagementException {
+    SSLContext c = SSLContext.getInstance(protocol);
+    c.init(null, new TrustManager[] {trustManager}, null);
+    useSslProtocol(c);
+  }
+
+  /**
+   * Sets up TLS with an initialized {@link SSLContext}. The caller is responsible for setting up
+   * the context with a {@link TrustManager} with suitable security guarantees, e.g. peer
+   * verification.
+   *
+   * <p>The {@link SSLContext} instance will be shared with all the connections created by this
+   * connection factory. Use {@link #setSslContextFactory(SslContextFactory)} for more flexibility.
+   *
+   * <p>Note this method has NO effect when using Netty, use {@link
+   * com.rabbitmq.client.ConnectionFactory.NettyConfiguration#sslContext(io.netty.handler.ssl.SslContext)}
+   * instead.
+   *
+   * @param context An initialized SSLContext
+   * @see #setSslContextFactory(SslContextFactory)
+   */
+  public void useSslProtocol(SSLContext context) {
+    this.sslContextFactory = name -> context;
+    setSocketFactory(context.getSocketFactory());
+  }
+
+  /**
+   * Enable server hostname verification for TLS connections.
+   *
+   * <p>This enables hostname verification regardless of the IO mode used (blocking or non-blocking
+   * IO).
+   *
+   * <p>This can be called typically after setting the {@link SSLContext} with one of the <code>
+   * useSslProtocol</code> methods.
+   *
+   * <p>Note this method has NO effect when using Netty, use {@link
+   * com.rabbitmq.client.ConnectionFactory.NettyConfiguration#sslContext(io.netty.handler.ssl.SslContext)}
+   * instead.
+   *
+   * @see NioParams#enableHostnameVerification()
+   * @see NioParams#setSslEngineConfigurator(SslEngineConfigurator)
+   * @see SslEngineConfigurators#ENABLE_HOSTNAME_VERIFICATION
+   * @see SocketConfigurators#ENABLE_HOSTNAME_VERIFICATION
+   * @see ConnectionFactory#useSslProtocol(String)
+   * @see ConnectionFactory#useSslProtocol(SSLContext)
+   * @see ConnectionFactory#useSslProtocol()
+   * @see ConnectionFactory#useSslProtocol(String, TrustManager)
+   * @since 5.4.0
+   */
+  public void enableHostnameVerification() {
+    enableHostnameVerificationForNio();
+    enableHostnameVerificationForBlockingIo();
+  }
+
+  protected void enableHostnameVerificationForNio() {
+    if (this.nioParams == null) {
+      this.nioParams = new NioParams();
+    }
+    this.nioParams = this.nioParams.enableHostnameVerification();
+  }
+
+  protected void enableHostnameVerificationForBlockingIo() {
+    if (this.socketConf == null) {
+      this.socketConf =
+          SocketConfigurators.builder().defaultConfigurator().enableHostnameVerification().build();
+    } else {
+      this.socketConf = this.socketConf.andThen(SocketConfigurators.enableHostnameVerification());
+    }
+  }
+
+  public static String computeDefaultTlsProtocol(String[] supportedProtocols) {
+    if (supportedProtocols != null) {
+      for (String supportedProtocol : supportedProtocols) {
+        if (PREFERRED_TLS_PROTOCOL.equalsIgnoreCase(supportedProtocol)) {
+          return supportedProtocol;
         }
-        return FALLBACK_TLS_PROTOCOL;
+      }
     }
+    return FALLBACK_TLS_PROTOCOL;
+  }
 
-    /**
-     * Returns true if <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection recovery</a>
-     * is enabled, false otherwise
-     * @return true if automatic connection recovery is enabled, false otherwise
-     * @see <a href="https://www.rabbitmq.com/api-guide.html#recovery">Automatic Recovery</a>
-     */
-    public boolean isAutomaticRecoveryEnabled() {
-        return automaticRecovery;
-    }
+  /**
+   * Returns true if <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection
+   * recovery</a> is enabled, false otherwise
+   *
+   * @return true if automatic connection recovery is enabled, false otherwise
+   * @see <a href="https://www.rabbitmq.com/api-guide.html#recovery">Automatic Recovery</a>
+   */
+  public boolean isAutomaticRecoveryEnabled() {
+    return automaticRecovery;
+  }
 
-    /**
-     * Enables or disables <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection recovery</a>.
-     * @param automaticRecovery if true, enables connection recovery
-     * @see <a href="https://www.rabbitmq.com/api-guide.html#recovery">Automatic Recovery</a>
-     */
-    public void setAutomaticRecoveryEnabled(boolean automaticRecovery) {
-        this.automaticRecovery = automaticRecovery;
-    }
+  /**
+   * Enables or disables <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic
+   * connection recovery</a>.
+   *
+   * @param automaticRecovery if true, enables connection recovery
+   * @see <a href="https://www.rabbitmq.com/api-guide.html#recovery">Automatic Recovery</a>
+   */
+  public void setAutomaticRecoveryEnabled(boolean automaticRecovery) {
+    this.automaticRecovery = automaticRecovery;
+  }
 
-    /**
-     * Returns true if topology recovery is enabled, false otherwise
-     * @return true if topology recovery is enabled, false otherwise
-     * @see <a href="https://www.rabbitmq.com/api-guide.html#recovery">Automatic Recovery</a>
-     */
-    public boolean isTopologyRecoveryEnabled() {
-        return topologyRecovery;
-    }
+  /**
+   * Returns true if topology recovery is enabled, false otherwise
+   *
+   * @return true if topology recovery is enabled, false otherwise
+   * @see <a href="https://www.rabbitmq.com/api-guide.html#recovery">Automatic Recovery</a>
+   */
+  public boolean isTopologyRecoveryEnabled() {
+    return topologyRecovery;
+  }
 
-    /**
-     * Enables or disables topology recovery
-     * @param topologyRecovery if true, enables topology recovery
-     * @see <a href="https://www.rabbitmq.com/api-guide.html#recovery">Automatic Recovery</a>
-     */
-    public void setTopologyRecoveryEnabled(boolean topologyRecovery) {
-        this.topologyRecovery = topologyRecovery;
-    }
-    
-    /**
-     * Get the executor to use for parallel topology recovery. If null (the default), recovery is done single threaded on the main connection thread.
-     * @return thread pool executor
-     * @since 4.7.0
-     */
-    public ExecutorService getTopologyRecoveryExecutor() {
-        return topologyRecoveryExecutor;
-    }
-    
-    /**
-     * Set the executor to use for parallel topology recovery. If null (the default), recovery is done single threaded on the main connection thread.
-     * It is recommended to pass a ThreadPoolExecutor that will allow its core threads to timeout so these threads can die when recovery is complete.
-     * It's developer's responsibility to shut down the executor when it is no longer needed.
-     * Note: your {@link ExceptionHandler#handleTopologyRecoveryException(Connection, Channel, TopologyRecoveryException)} method should be thread-safe.
-     * @param topologyRecoveryExecutor thread pool executor
-     * @since 4.7.0
-     */
-    public void setTopologyRecoveryExecutor(final ExecutorService topologyRecoveryExecutor) {
-        this.topologyRecoveryExecutor = topologyRecoveryExecutor;
-    }
+  /**
+   * Enables or disables topology recovery
+   *
+   * @param topologyRecovery if true, enables topology recovery
+   * @see <a href="https://www.rabbitmq.com/api-guide.html#recovery">Automatic Recovery</a>
+   */
+  public void setTopologyRecoveryEnabled(boolean topologyRecovery) {
+    this.topologyRecovery = topologyRecovery;
+  }
 
-    public void setMetricsCollector(MetricsCollector metricsCollector) {
-        this.metricsCollector = metricsCollector;
-    }
+  /**
+   * Get the executor to use for parallel topology recovery. If null (the default), recovery is done
+   * single threaded on the main connection thread.
+   *
+   * @return thread pool executor
+   * @since 4.7.0
+   */
+  public ExecutorService getTopologyRecoveryExecutor() {
+    return topologyRecoveryExecutor;
+  }
 
-    public MetricsCollector getMetricsCollector() {
-        return metricsCollector;
-    }
+  /**
+   * Set the executor to use for parallel topology recovery. If null (the default), recovery is done
+   * single threaded on the main connection thread. It is recommended to pass a ThreadPoolExecutor
+   * that will allow its core threads to timeout so these threads can die when recovery is complete.
+   * It's developer's responsibility to shut down the executor when it is no longer needed. Note:
+   * your {@link ExceptionHandler#handleTopologyRecoveryException(Connection, Channel,
+   * TopologyRecoveryException)} method should be thread-safe.
+   *
+   * @param topologyRecoveryExecutor thread pool executor
+   * @since 4.7.0
+   */
+  public void setTopologyRecoveryExecutor(final ExecutorService topologyRecoveryExecutor) {
+    this.topologyRecoveryExecutor = topologyRecoveryExecutor;
+  }
+
+  public void setMetricsCollector(MetricsCollector metricsCollector) {
+    this.metricsCollector = metricsCollector;
+  }
+
+  public MetricsCollector getMetricsCollector() {
+    return metricsCollector;
+  }
 
   /**
    * Set observation collector.
@@ -963,310 +1028,536 @@ public MetricsCollector getMetricsCollector() {
    * @see com.rabbitmq.client.observation.micrometer.MicrometerObservationCollectorBuilder
    */
   public void setObservationCollector(ObservationCollector observationCollector) {
-        this.observationCollector = observationCollector;
-    }
-
-    /**
-     * Set a {@link CredentialsRefreshService} instance to handle credentials refresh if appropriate.
-     * <p>
-     * Each created connection will register to the refresh service to send an AMQP <code>update.secret</code>
-     * frame when credentials are about to expire. This is the refresh service responsibility to schedule
-     * credentials refresh and <code>udpate.secret</code> frame sending, based on the information provided
-     * by the {@link CredentialsProvider}.
-     * <p>
-     * Note the {@link CredentialsRefreshService} is used only when the {@link CredentialsProvider}
-     * signals credentials can expire, by returning a non-null value from {@link CredentialsProvider#getTimeBeforeExpiration()}.
-     *
-     * @param credentialsRefreshService the refresh service to use
-     * @see #setCredentialsProvider(CredentialsProvider)
-     * @see DefaultCredentialsRefreshService
-     */
-    public void setCredentialsRefreshService(CredentialsRefreshService credentialsRefreshService) {
-        this.credentialsRefreshService = credentialsRefreshService;
-    }
+    this.observationCollector = observationCollector;
+  }
 
-    protected synchronized FrameHandlerFactory createFrameHandlerFactory() throws IOException {
-        if(nio) {
-            if(this.frameHandlerFactory == null) {
-                if(this.nioParams.getNioExecutor() == null && this.nioParams.getThreadFactory() == null) {
-                    this.nioParams.setThreadFactory(getThreadFactory());
-                }
-                this.frameHandlerFactory = new SocketChannelFrameHandlerFactory(
-                    connectionTimeout, nioParams, isSSL(), sslContextFactory,
-                    this.maxInboundMessageBodySize);
-            }
-            return this.frameHandlerFactory;
-        } else {
-            return new SocketFrameHandlerFactory(connectionTimeout, socketFactory,
-                socketConf, isSSL(), this.shutdownExecutor, sslContextFactory,
-                this.maxInboundMessageBodySize);
+  /**
+   * Set a {@link CredentialsRefreshService} instance to handle credentials refresh if appropriate.
+   *
+   * <p>Each created connection will register to the refresh service to send an AMQP <code>
+   * update.secret</code> frame when credentials are about to expire. This is the refresh service
+   * responsibility to schedule credentials refresh and <code>udpate.secret</code> frame sending,
+   * based on the information provided by the {@link CredentialsProvider}.
+   *
+   * <p>Note the {@link CredentialsRefreshService} is used only when the {@link CredentialsProvider}
+   * signals credentials can expire, by returning a non-null value from {@link
+   * CredentialsProvider#getTimeBeforeExpiration()}.
+   *
+   * @param credentialsRefreshService the refresh service to use
+   * @see #setCredentialsProvider(CredentialsProvider)
+   * @see DefaultCredentialsRefreshService
+   */
+  public void setCredentialsRefreshService(CredentialsRefreshService credentialsRefreshService) {
+    this.credentialsRefreshService = credentialsRefreshService;
+  }
+
+  protected synchronized FrameHandlerFactory createFrameHandlerFactory() throws IOException {
+    if (nio) {
+      if (this.frameHandlerFactory == null) {
+        if (this.nioParams.getNioExecutor() == null && this.nioParams.getThreadFactory() == null) {
+          this.nioParams.setThreadFactory(getThreadFactory());
         }
+        this.frameHandlerFactory =
+            new SocketChannelFrameHandlerFactory(
+                connectionTimeout,
+                nioParams,
+                isSSL(),
+                sslContextFactory,
+                this.maxInboundMessageBodySize);
+      }
+      return this.frameHandlerFactory;
+    } else if (netty) {
+      if (this.frameHandlerFactory == null) {
+        this.frameHandlerFactory =
+            new NettyFrameHandlerFactory(
+                this.nettyConf.eventLoopGroup,
+                this.nettyConf.channelCustomizer,
+                this.nettyConf.bootstrapCustomizer,
+                this.nettyConf.sslContextFactory,
+                connectionTimeout,
+                socketConf,
+                maxInboundMessageBodySize);
+      }
+      return this.frameHandlerFactory;
+    } else {
+      return new SocketFrameHandlerFactory(
+          connectionTimeout,
+          socketFactory,
+          socketConf,
+          isSSL(),
+          this.shutdownExecutor,
+          sslContextFactory,
+          this.maxInboundMessageBodySize);
+    }
+  }
 
-    }
+  /**
+   * Create a new broker connection, picking the first available address from the list.
+   *
+   * <p>If <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection
+   * recovery</a> is enabled, the connection returned by this method will be {@link Recoverable}.
+   * Future reconnection attempts will pick a random accessible address from the provided list.
+   *
+   * @param addrs an array of known broker addresses (hostname/port pairs) to try in order
+   * @return an interface to the connection
+   * @throws IOException if it encounters a problem
+   */
+  public Connection newConnection(Address[] addrs) throws IOException, TimeoutException {
+    return newConnection(this.sharedExecutor, Arrays.asList(addrs), null);
+  }
 
-    /**
-     * Create a new broker connection, picking the first available address from
-     * the list.
-     *
-     * If <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection recovery</a>
-     * is enabled, the connection returned by this method will be {@link Recoverable}. Future
-     * reconnection attempts will pick a random accessible address from the provided list.
-     *
-     * @param addrs an array of known broker addresses (hostname/port pairs) to try in order
-     * @return an interface to the connection
-     * @throws IOException if it encounters a problem
-     */
-    public Connection newConnection(Address[] addrs) throws IOException, TimeoutException {
-        return newConnection(this.sharedExecutor, Arrays.asList(addrs), null);
-    }
+  /**
+   * Create a new broker connection, picking the first available address from the list provided by
+   * the {@link AddressResolver}.
+   *
+   * <p>If <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection
+   * recovery</a> is enabled, the connection returned by this method will be {@link Recoverable}.
+   * Future reconnection attempts will pick a random accessible address provided by the {@link
+   * AddressResolver}.
+   *
+   * @param addressResolver discovery service to list potential addresses (hostname/port pairs) to
+   *     connect to
+   * @return an interface to the connection
+   * @throws IOException if it encounters a problem
+   * @see <a href="https://www.rabbitmq.com/api-guide.html#recovery">Automatic Recovery</a>
+   */
+  public Connection newConnection(AddressResolver addressResolver)
+      throws IOException, TimeoutException {
+    return newConnection(this.sharedExecutor, addressResolver, null);
+  }
 
-    /**
-     * Create a new broker connection, picking the first available address from
-     * the list provided by the {@link AddressResolver}.
-     *
-     * If <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection recovery</a>
-     * is enabled, the connection returned by this method will be {@link Recoverable}. Future
-     * reconnection attempts will pick a random accessible address provided by the {@link AddressResolver}.
-     *
-     * @param addressResolver discovery service to list potential addresses (hostname/port pairs) to connect to
-     * @return an interface to the connection
-     * @throws IOException if it encounters a problem
-     * @see <a href="https://www.rabbitmq.com/api-guide.html#recovery">Automatic Recovery</a>
-     */
-    public Connection newConnection(AddressResolver addressResolver) throws IOException, TimeoutException {
-        return newConnection(this.sharedExecutor, addressResolver, null);
-    }
+  /**
+   * Create a new broker connection with a client-provided name, picking the first available address
+   * from the list.
+   *
+   * <p>If <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection
+   * recovery</a> is enabled, the connection returned by this method will be {@link Recoverable}.
+   * Future reconnection attempts will pick a random accessible address from the provided list.
+   *
+   * @param addrs an array of known broker addresses (hostname/port pairs) to try in order
+   * @param clientProvidedName application-specific connection name, will be displayed in the
+   *     management UI if RabbitMQ server supports it. This value doesn't have to be unique and
+   *     cannot be used as a connection identifier e.g. in HTTP API requests. This value is supposed
+   *     to be human-readable.
+   * @return an interface to the connection
+   * @throws IOException if it encounters a problem
+   */
+  public Connection newConnection(Address[] addrs, String clientProvidedName)
+      throws IOException, TimeoutException {
+    return newConnection(this.sharedExecutor, Arrays.asList(addrs), clientProvidedName);
+  }
 
+  /**
+   * Create a new broker connection, picking the first available address from the list.
+   *
+   * <p>If <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection
+   * recovery</a> is enabled, the connection returned by this method will be {@link Recoverable}.
+   * Future reconnection attempts will pick a random accessible address from the provided list.
+   *
+   * @param addrs a List of known broker addresses (hostname/port pairs) to try in order
+   * @return an interface to the connection
+   * @throws IOException if it encounters a problem
+   */
+  public Connection newConnection(List<Address> addrs) throws IOException, TimeoutException {
+    return newConnection(this.sharedExecutor, addrs, null);
+  }
 
-    /**
-     * Create a new broker connection with a client-provided name, picking the first available address from
-     * the list.
-     *
-     * If <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection recovery</a>
-     * is enabled, the connection returned by this method will be {@link Recoverable}. Future
-     * reconnection attempts will pick a random accessible address from the provided list.
-     *
-     * @param addrs an array of known broker addresses (hostname/port pairs) to try in order
-     * @param clientProvidedName application-specific connection name, will be displayed
-     *                           in the management UI if RabbitMQ server supports it.
-     *                           This value doesn't have to be unique and cannot be used
-     *                           as a connection identifier e.g. in HTTP API requests.
-     *                           This value is supposed to be human-readable.
-     * @return an interface to the connection
-     * @throws IOException if it encounters a problem
-     */
-    public Connection newConnection(Address[] addrs, String clientProvidedName) throws IOException, TimeoutException {
-        return newConnection(this.sharedExecutor, Arrays.asList(addrs), clientProvidedName);
-    }
+  /**
+   * Create a new broker connection with a client-provided name, picking the first available address
+   * from the list.
+   *
+   * <p>If <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection
+   * recovery</a> is enabled, the connection returned by this method will be {@link Recoverable}.
+   * Future reconnection attempts will pick a random accessible address from the provided list.
+   *
+   * @param addrs a List of known broker addresses (hostname/port pairs) to try in order
+   * @param clientProvidedName application-specific connection name, will be displayed in the
+   *     management UI if RabbitMQ server supports it. This value doesn't have to be unique and
+   *     cannot be used as a connection identifier e.g. in HTTP API requests. This value is supposed
+   *     to be human-readable.
+   * @return an interface to the connection
+   * @throws IOException if it encounters a problem
+   */
+  public Connection newConnection(List<Address> addrs, String clientProvidedName)
+      throws IOException, TimeoutException {
+    return newConnection(this.sharedExecutor, addrs, clientProvidedName);
+  }
 
-    /**
-     * Create a new broker connection, picking the first available address from
-     * the list.
-     *
-     * If <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection recovery</a>
-     * is enabled, the connection returned by this method will be {@link Recoverable}. Future
-     * reconnection attempts will pick a random accessible address from the provided list.
-     *
-     * @param addrs a List of known broker addresses (hostname/port pairs) to try in order
-     * @return an interface to the connection
-     * @throws IOException if it encounters a problem
-     */
-    public Connection newConnection(List<Address> addrs) throws IOException, TimeoutException {
-        return newConnection(this.sharedExecutor, addrs, null);
+  /**
+   * Create a new broker connection, picking the first available address from the list.
+   *
+   * <p>If <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection
+   * recovery</a> is enabled, the connection returned by this method will be {@link Recoverable}.
+   * Future reconnection attempts will pick a random accessible address from the provided list.
+   *
+   * @param executor thread execution service for consumers on the connection
+   * @param addrs an array of known broker addresses (hostname/port pairs) to try in order
+   * @return an interface to the connection
+   * @throws java.io.IOException if it encounters a problem
+   * @see <a href="https://www.rabbitmq.com/api-guide.html#recovery">Automatic Recovery</a>
+   */
+  public Connection newConnection(ExecutorService executor, Address[] addrs)
+      throws IOException, TimeoutException {
+    return newConnection(executor, Arrays.asList(addrs), null);
+  }
+
+  /**
+   * Create a new broker connection with a client-provided name, picking the first available address
+   * from the list.
+   *
+   * <p>If <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection
+   * recovery</a> is enabled, the connection returned by this method will be {@link Recoverable}.
+   * Future reconnection attempts will pick a random accessible address from the provided list.
+   *
+   * @param executor thread execution service for consumers on the connection
+   * @param addrs an array of known broker addresses (hostname/port pairs) to try in order
+   * @param clientProvidedName application-specific connection name, will be displayed in the
+   *     management UI if RabbitMQ server supports it. This value doesn't have to be unique and
+   *     cannot be used as a connection identifier e.g. in HTTP API requests. This value is supposed
+   *     to be human-readable.
+   * @return an interface to the connection
+   * @throws java.io.IOException if it encounters a problem
+   * @see <a href="https://www.rabbitmq.com/api-guide.html#recovery">Automatic Recovery</a>
+   */
+  public Connection newConnection(
+      ExecutorService executor, Address[] addrs, String clientProvidedName)
+      throws IOException, TimeoutException {
+    return newConnection(executor, Arrays.asList(addrs), clientProvidedName);
+  }
+
+  /**
+   * Create a new broker connection, picking the first available address from the list.
+   *
+   * <p>If <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection
+   * recovery</a> is enabled, the connection returned by this method will be {@link Recoverable}.
+   * Future reconnection attempts will pick a random accessible address from the provided list.
+   *
+   * @param executor thread execution service for consumers on the connection
+   * @param addrs a List of known broker addrs (hostname/port pairs) to try in order
+   * @return an interface to the connection
+   * @throws java.io.IOException if it encounters a problem
+   * @see <a href="https://www.rabbitmq.com/api-guide.html#recovery">Automatic Recovery</a>
+   */
+  public Connection newConnection(ExecutorService executor, List<Address> addrs)
+      throws IOException, TimeoutException {
+    return newConnection(executor, addrs, null);
+  }
+
+  /**
+   * Create a new broker connection, picking the first available address from the list provided by
+   * the {@link AddressResolver}.
+   *
+   * <p>If <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection
+   * recovery</a> is enabled, the connection returned by this method will be {@link Recoverable}.
+   * Future reconnection attempts will pick a random accessible address provided by the {@link
+   * AddressResolver}.
+   *
+   * @param executor thread execution service for consumers on the connection
+   * @param addressResolver discovery service to list potential addresses (hostname/port pairs) to
+   *     connect to
+   * @return an interface to the connection
+   * @throws java.io.IOException if it encounters a problem
+   * @see <a href="https://www.rabbitmq.com/api-guide.html#recovery">Automatic Recovery</a>
+   */
+  public Connection newConnection(ExecutorService executor, AddressResolver addressResolver)
+      throws IOException, TimeoutException {
+    return newConnection(executor, addressResolver, null);
+  }
+
+  /**
+   * Create a new broker connection with a client-provided name, picking the first available address
+   * from the list.
+   *
+   * <p>If <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection
+   * recovery</a> is enabled, the connection returned by this method will be {@link Recoverable}.
+   * Future reconnection attempts will pick a random accessible address from the provided list.
+   *
+   * @param executor thread execution service for consumers on the connection
+   * @param addrs a List of known broker addrs (hostname/port pairs) to try in order
+   * @param clientProvidedName application-specific connection name, will be displayed in the
+   *     management UI if RabbitMQ server supports it. This value doesn't have to be unique and
+   *     cannot be used as a connection identifier e.g. in HTTP API requests. This value is supposed
+   *     to be human-readable.
+   * @return an interface to the connection
+   * @throws java.io.IOException if it encounters a problem
+   * @see <a href="https://www.rabbitmq.com/api-guide.html#recovery">Automatic Recovery</a>
+   */
+  public Connection newConnection(
+      ExecutorService executor, List<Address> addrs, String clientProvidedName)
+      throws IOException, TimeoutException {
+    return newConnection(executor, createAddressResolver(addrs), clientProvidedName);
+  }
+
+  /**
+   * Create a new broker connection with a client-provided name, picking the first available address
+   * from the list provided by the {@link AddressResolver}.
+   *
+   * <p>If <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection
+   * recovery</a> is enabled, the connection returned by this method will be {@link Recoverable}.
+   * Future reconnection attempts will pick a random accessible address provided by the {@link
+   * AddressResolver}.
+   *
+   * @param executor thread execution service for consumers on the connection
+   * @param addressResolver discovery service to list potential addresses (hostname/port pairs) to
+   *     connect to
+   * @param clientProvidedName application-specific connection name, will be displayed in the
+   *     management UI if RabbitMQ server supports it. This value doesn't have to be unique and
+   *     cannot be used as a connection identifier e.g. in HTTP API requests. This value is supposed
+   *     to be human-readable.
+   * @return an interface to the connection
+   * @throws java.io.IOException if it encounters a problem
+   * @see <a href="https://www.rabbitmq.com/api-guide.html#recovery">Automatic Recovery</a>
+   */
+  public Connection newConnection(
+      ExecutorService executor, AddressResolver addressResolver, String clientProvidedName)
+      throws IOException, TimeoutException {
+    if (this.metricsCollector == null) {
+      this.metricsCollector = new NoOpMetricsCollector();
+    }
+    // make sure we respect the provided thread factory
+    FrameHandlerFactory fhFactory = createFrameHandlerFactory();
+    ConnectionParams params = params(executor);
+    // set client-provided via a client property
+    if (clientProvidedName != null) {
+      Map<String, Object> properties = new HashMap<String, Object>(params.getClientProperties());
+      properties.put("connection_name", clientProvidedName);
+      params.setClientProperties(properties);
+    }
+
+    if (isAutomaticRecoveryEnabled()) {
+      // see com.rabbitmq.client.impl.recovery.RecoveryAwareAMQConnectionFactory#newConnection
+      // No Sonar: no need to close this resource because we're the one that creates it
+      // and hands it over to the user
+      AutorecoveringConnection conn =
+          new AutorecoveringConnection(
+              params,
+              fhFactory,
+              addressResolver,
+              metricsCollector,
+              observationCollector); // NOSONAR
+
+      conn.init();
+      return conn;
+    } else {
+      List<Address> addrs = addressResolver.getAddresses();
+      Exception lastException = null;
+      for (Address addr : addrs) {
+        try {
+          FrameHandler handler = fhFactory.create(addr, clientProvidedName);
+          AMQConnection conn = createConnection(params, handler, metricsCollector);
+          conn.start();
+          this.metricsCollector.newConnection(conn);
+          return conn;
+        } catch (IOException e) {
+          lastException = e;
+        } catch (TimeoutException te) {
+          lastException = te;
+        }
+      }
+      if (lastException != null) {
+        if (lastException instanceof IOException) {
+          throw (IOException) lastException;
+        } else if (lastException instanceof TimeoutException) {
+          throw (TimeoutException) lastException;
+        }
+      }
+      throw new IOException("failed to connect");
     }
+  }
 
-    /**
-     * Create a new broker connection with a client-provided name, picking the first available address from
-     * the list.
-     *
-     * If <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection recovery</a>
-     * is enabled, the connection returned by this method will be {@link Recoverable}. Future
-     * reconnection attempts will pick a random accessible address from the provided list.
-     *
-     * @param addrs a List of known broker addresses (hostname/port pairs) to try in order
-     * @param clientProvidedName application-specific connection name, will be displayed
-     *                           in the management UI if RabbitMQ server supports it.
-     *                           This value doesn't have to be unique and cannot be used
-     *                           as a connection identifier e.g. in HTTP API requests.
-     *                           This value is supposed to be human-readable.
-     * @return an interface to the connection
-     * @throws IOException if it encounters a problem
-     */
-    public Connection newConnection(List<Address> addrs, String clientProvidedName) throws IOException, TimeoutException {
-        return newConnection(this.sharedExecutor, addrs, clientProvidedName);
-    }
+  /**
+   * Sets the parameters when using NIO.
+   *
+   * @param nioParams
+   * @see NioParams
+   * @deprecated user {@link #netty()} instead
+   */
+  @Deprecated
+  public ConnectionFactory setNioParams(NioParams nioParams) {
+    this.nioParams = nioParams;
+    return this;
+  }
 
-    /**
-     * Create a new broker connection, picking the first available address from
-     * the list.
-     *
-     * If <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection recovery</a>
-     * is enabled, the connection returned by this method will be {@link Recoverable}. Future
-     * reconnection attempts will pick a random accessible address from the provided list.
-     *
-     * @param executor thread execution service for consumers on the connection
-     * @param addrs an array of known broker addresses (hostname/port pairs) to try in order
-     * @return an interface to the connection
-     * @throws java.io.IOException if it encounters a problem
-     * @see <a href="https://www.rabbitmq.com/api-guide.html#recovery">Automatic Recovery</a>
-     */
-    public Connection newConnection(ExecutorService executor, Address[] addrs) throws IOException, TimeoutException {
-        return newConnection(executor, Arrays.asList(addrs), null);
-    }
+  /**
+   * Retrieve the parameters for NIO mode.
+   *
+   * @return
+   * @deprecated Use {@link #netty()}
+   */
+  @Deprecated
+  public NioParams getNioParams() {
+    return nioParams;
+  }
 
+  /**
+   * Use non-blocking IO (NIO) for communication with the server. With NIO, several connections
+   * created from the same {@link ConnectionFactory} can use the same IO thread.
+   *
+   * <p>A client process using a lot of not-so-active connections can benefit from NIO, as it would
+   * use fewer threads than with the traditional, blocking IO mode.
+   *
+   * <p>Use {@link NioParams} to tune NIO and a {@link SocketChannelConfigurator} to configure the
+   * underlying {@link java.nio.channels.SocketChannel}s for connections.
+   *
+   * @see NioParams
+   * @see SocketChannelConfigurator
+   * @see java.nio.channels.SocketChannel
+   * @see java.nio.channels.Selector
+   * @deprecated Use {@link #netty()} instead
+   */
+  @Deprecated
+  public ConnectionFactory useNio() {
+    this.nio = true;
+    this.netty = false;
+    return this;
+  }
 
-    /**
-     * Create a new broker connection with a client-provided name, picking the first available address from
-     * the list.
-     *
-     * If <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection recovery</a>
-     * is enabled, the connection returned by this method will be {@link Recoverable}. Future
-     * reconnection attempts will pick a random accessible address from the provided list.
-     *
-     * @param executor thread execution service for consumers on the connection
-     * @param addrs an array of known broker addresses (hostname/port pairs) to try in order
-     * @param clientProvidedName application-specific connection name, will be displayed
-     *                           in the management UI if RabbitMQ server supports it.
-     *                           This value doesn't have to be unique and cannot be used
-     *                           as a connection identifier e.g. in HTTP API requests.
-     *                           This value is supposed to be human-readable.
-     * @return an interface to the connection
-     * @throws java.io.IOException if it encounters a problem
-     * @see <a href="https://www.rabbitmq.com/api-guide.html#recovery">Automatic Recovery</a>
-     */
-    public Connection newConnection(ExecutorService executor, Address[] addrs, String clientProvidedName) throws IOException, TimeoutException {
-        return newConnection(executor, Arrays.asList(addrs), clientProvidedName);
-    }
+  /**
+   * Use blocking IO for communication with the server. With blocking IO, each connection creates
+   * its own thread to read data from the server.
+   */
+  public ConnectionFactory useBlockingIo() {
+    this.nio = false;
+    this.netty = false;
+    return this;
+  }
 
-    /**
-     * Create a new broker connection, picking the first available address from
-     * the list.
-     *
-     * If <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection recovery</a>
-     * is enabled, the connection returned by this method will be {@link Recoverable}. Future
-     * reconnection attempts will pick a random accessible address from the provided list.
-     *
-     * @param executor thread execution service for consumers on the connection
-     * @param addrs a List of known broker addrs (hostname/port pairs) to try in order
-     * @return an interface to the connection
-     * @throws java.io.IOException if it encounters a problem
-     * @see <a href="https://www.rabbitmq.com/api-guide.html#recovery">Automatic Recovery</a>
-     */
-    public Connection newConnection(ExecutorService executor, List<Address> addrs) throws IOException, TimeoutException {
-        return newConnection(executor, addrs, null);
+  /**
+   * Maximum body size of inbound (received) messages in bytes.
+   *
+   * <p>Default value is 67,108,864 (64 MiB).
+   *
+   * @param maxInboundMessageBodySize the maximum size of inbound messages
+   */
+  public void setMaxInboundMessageBodySize(int maxInboundMessageBodySize) {
+    if (maxInboundMessageBodySize <= 0) {
+      throw new IllegalArgumentException(
+          "Max inbound message body size must be greater than 0: " + maxInboundMessageBodySize);
     }
+    this.maxInboundMessageBodySize = maxInboundMessageBodySize;
+  }
 
-    /**
-     * Create a new broker connection, picking the first available address from
-     * the list provided by the {@link AddressResolver}.
-     *
-     * If <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection recovery</a>
-     * is enabled, the connection returned by this method will be {@link Recoverable}. Future
-     * reconnection attempts will pick a random accessible address provided by the {@link AddressResolver}.
-     *
-     * @param executor thread execution service for consumers on the connection
-     * @param addressResolver discovery service to list potential addresses (hostname/port pairs) to connect to
-     * @return an interface to the connection
-     * @throws java.io.IOException if it encounters a problem
-     * @see <a href="https://www.rabbitmq.com/api-guide.html#recovery">Automatic Recovery</a>
-     */
-    public Connection newConnection(ExecutorService executor, AddressResolver addressResolver) throws IOException, TimeoutException {
-        return newConnection(executor, addressResolver, null);
+  /**
+   * Use Netty with the default configuration.
+   *
+   * @return the connection factory
+   * @see #netty()
+   */
+  public ConnectionFactory useNetty() {
+    this.netty = true;
+    this.nio = false;
+    return this;
+  }
+
+  /**
+   * Activate and configure Netty for the IO layer.
+   *
+   * @return Netty configuration
+   * @since 5.27.0
+   */
+  public NettyConfiguration netty() {
+    useNetty();
+    return this.nettyConf;
+  }
+
+  /**
+   * Helper class to configure Netty.
+   *
+   * @since 5.27.0
+   */
+  public static final class NettyConfiguration {
+
+    private final ConnectionFactory cf;
+    private EventLoopGroup eventLoopGroup;
+    private Consumer<io.netty.channel.Channel> channelCustomizer = ch -> {};
+    private Consumer<Bootstrap> bootstrapCustomizer = b -> {};
+    private Function<String, SslContext> sslContextFactory;
+
+    private NettyConfiguration(ConnectionFactory cf) {
+      this.cf = cf;
     }
 
     /**
-     * Create a new broker connection with a client-provided name, picking the first available address from
-     * the list.
+     * Set the {@link io.netty.channel.EventLoopGroup} shared by all the connections created with
+     * this connection factory.
      *
-     * If <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection recovery</a>
-     * is enabled, the connection returned by this method will be {@link Recoverable}. Future
-     * reconnection attempts will pick a random accessible address from the provided list.
+     * <p>A connection uses a one-thread NIO event loop group if none is provided. It disposes it
+     * when it closes itself.
      *
-     * @param executor thread execution service for consumers on the connection
-     * @param addrs a List of known broker addrs (hostname/port pairs) to try in order
-     * @param clientProvidedName application-specific connection name, will be displayed
-     *                           in the management UI if RabbitMQ server supports it.
-     *                           This value doesn't have to be unique and cannot be used
-     *                           as a connection identifier e.g. in HTTP API requests.
-     *                           This value is supposed to be human-readable.
-     * @return an interface to the connection
-     * @throws java.io.IOException if it encounters a problem
-     * @see <a href="https://www.rabbitmq.com/api-guide.html#recovery">Automatic Recovery</a>
-     */
-    public Connection newConnection(ExecutorService executor, List<Address> addrs, String clientProvidedName)
-            throws IOException, TimeoutException {
-        return newConnection(executor, createAddressResolver(addrs), clientProvidedName);
-    }
-
-    /**
-     * Create a new broker connection with a client-provided name, picking the first available address from
-     * the list provided by the {@link AddressResolver}.
+     * <p>It is recommended to set an event loop group with an appropriate number of threads if
+     * connection factory is meant to create a significant number of connections.
      *
-     * If <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection recovery</a>
-     * is enabled, the connection returned by this method will be {@link Recoverable}. Future
-     * reconnection attempts will pick a random accessible address provided by the {@link AddressResolver}.
+     * <p>It is the developer's responsibility to close the event loop group they provide.
      *
-     * @param executor thread execution service for consumers on the connection
-     * @param addressResolver discovery service to list potential addresses (hostname/port pairs) to connect to
-     * @param clientProvidedName application-specific connection name, will be displayed
-     *                           in the management UI if RabbitMQ server supports it.
-     *                           This value doesn't have to be unique and cannot be used
-     *                           as a connection identifier e.g. in HTTP API requests.
-     *                           This value is supposed to be human-readable.
-     * @return an interface to the connection
-     * @throws java.io.IOException if it encounters a problem
-     * @see <a href="https://www.rabbitmq.com/api-guide.html#recovery">Automatic Recovery</a>
-     */
-    public Connection newConnection(ExecutorService executor, AddressResolver addressResolver, String clientProvidedName)
-        throws IOException, TimeoutException {
-        if(this.metricsCollector == null) {
-            this.metricsCollector = new NoOpMetricsCollector();
-        }
-        // make sure we respect the provided thread factory
-        FrameHandlerFactory fhFactory = createFrameHandlerFactory();
-        ConnectionParams params = params(executor);
-        // set client-provided via a client property
-        if (clientProvidedName != null) {
-            Map<String, Object> properties = new HashMap<String, Object>(params.getClientProperties());
-            properties.put("connection_name", clientProvidedName);
-            params.setClientProperties(properties);
-        }
-
-        if (isAutomaticRecoveryEnabled()) {
-            // see com.rabbitmq.client.impl.recovery.RecoveryAwareAMQConnectionFactory#newConnection
-            // No Sonar: no need to close this resource because we're the one that creates it
-            // and hands it over to the user
-            AutorecoveringConnection conn = new AutorecoveringConnection(
-                params, fhFactory, addressResolver, metricsCollector, observationCollector); //NOSONAR
-
-            conn.init();
-            return conn;
-        } else {
-            List<Address> addrs = addressResolver.getAddresses();
-            Exception lastException = null;
-            for (Address addr : addrs) {
-                try {
-                    FrameHandler handler = fhFactory.create(addr, clientProvidedName);
-                    AMQConnection conn = createConnection(params, handler, metricsCollector);
-                    conn.start();
-                    this.metricsCollector.newConnection(conn);
-                    return conn;
-                } catch (IOException e) {
-                    lastException = e;
-                } catch (TimeoutException te) {
-                    lastException = te;
-                }
-            }
-            if (lastException != null) {
-                if (lastException instanceof IOException) {
-                    throw (IOException) lastException;
-                } else if (lastException instanceof TimeoutException) {
-                    throw (TimeoutException) lastException;
-                }
-            }
-            throw new IOException("failed to connect");
-        }
-    }
+     * @param eventLoopGroup the event loop group to use
+     * @return this configuration instance
+     */
+    public NettyConfiguration eventLoopGroup(EventLoopGroup eventLoopGroup) {
+      this.eventLoopGroup = eventLoopGroup;
+      return this;
+    }
+
+      /**
+       * An extension point to customize Netty's {@link io.netty.channel.Channel}s used for
+       * connections.
+       *
+       * @param channelCustomizer the customization callback
+       * @return this configuration instance
+       */
+      public NettyConfiguration channelCustomizer(
+          Consumer<io.netty.channel.Channel> channelCustomizer) {
+          this.channelCustomizer = channelCustomizer;
+          return this;
+  }
+
+      /**
+       * An extension point to customize Netty's {@link Bootstrap}s used to configure connections.
+       *
+       * @param bootstrapCustomizer the bootstrap customization callback
+       * @return this configuration instance
+       */
+      public NettyConfiguration bootstrapCustomizer(Consumer<Bootstrap> bootstrapCustomizer) {
+          this.bootstrapCustomizer = bootstrapCustomizer;
+          return this;
+      }
+
+      /**
+       * Netty {@link SslContext} for TLS connections.
+       *
+       * <p>Use {@link SslContextBuilder#forClient()} to configure and create an instance.
+       *
+       * @param sslContext the SSL context
+       * @return this configuration instance
+       */
+      public NettyConfiguration sslContext(SslContext sslContext) {
+          this.sslContextFactory = name -> sslContext;
+          return this;
+      }
+
+      /**
+       * A factory to create {@link io.netty.handler.ssl.SslContext} depending on the connection name.
+       *
+       * @param sslContextFactory the factory
+       * @return this configuration instance
+       */
+      public NettyConfiguration sslContextFactory(Function<String, SslContext> sslContextFactory) {
+          this.sslContextFactory = sslContextFactory;
+          return this;
+      }
+
+      /**
+       * Go back to the connection factory.
+       *
+       * @return the connection factory
+       */
+      public ConnectionFactory connectionFactory() {
+          return this.cf;
+      }
+
+      private boolean isTls() {
+          return this.sslContextFactory != null;
+          }
+  }
 
     public ConnectionParams params(ExecutorService consumerWorkServiceExecutor) {
         ConnectionParams result = new ConnectionParams();
@@ -1303,46 +1594,51 @@ public ConnectionParams params(ExecutorService consumerWorkServiceExecutor) {
         return result;
     }
 
-    protected AMQConnection createConnection(ConnectionParams params, FrameHandler frameHandler, MetricsCollector metricsCollector) {
+    protected AMQConnection createConnection(
+        ConnectionParams params, FrameHandler frameHandler, MetricsCollector metricsCollector) {
         return new AMQConnection(params, frameHandler, metricsCollector, observationCollector);
     }
 
     /**
      * Create a new broker connection.
      *
-     * If <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection recovery</a>
-     * is enabled, the connection returned by this method will be {@link Recoverable}. Reconnection
-     * attempts will always use the address configured on {@link ConnectionFactory}.
+     * <p>If <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection
+     * recovery</a> is enabled, the connection returned by this method will be {@link Recoverable}.
+     * Reconnection attempts will always use the address configured on {@link ConnectionFactory}.
      *
      * @return an interface to the connection
      * @throws IOException if it encounters a problem
      */
     public Connection newConnection() throws IOException, TimeoutException {
-        return newConnection(this.sharedExecutor, Collections.singletonList(new Address(getHost(), getPort())));
+        return newConnection(
+            this.sharedExecutor, Collections.singletonList(new Address(getHost(), getPort())));
     }
 
     /**
      * Create a new broker connection.
      *
-     * If <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection recovery</a>
-     * is enabled, the connection returned by this method will be {@link Recoverable}. Reconnection
-     * attempts will always use the address configured on {@link ConnectionFactory}.
+     * <p>If <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection
+     * recovery</a> is enabled, the connection returned by this method will be {@link Recoverable}.
+     * Reconnection attempts will always use the address configured on {@link ConnectionFactory}.
      *
-     * @param connectionName client-provided connection name (an arbitrary string). Will
-     *                       be displayed in management UI if the server supports it.
+     * @param connectionName client-provided connection name (an arbitrary string). Will be displayed
+     *     in management UI if the server supports it.
      * @return an interface to the connection
      * @throws IOException if it encounters a problem
      */
     public Connection newConnection(String connectionName) throws IOException, TimeoutException {
-        return newConnection(this.sharedExecutor, Collections.singletonList(new Address(getHost(), getPort())), connectionName);
+        return newConnection(
+            this.sharedExecutor,
+            Collections.singletonList(new Address(getHost(), getPort())),
+            connectionName);
     }
 
     /**
      * Create a new broker connection.
      *
-     * If <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection recovery</a>
-     * is enabled, the connection returned by this method will be {@link Recoverable}. Reconnection
-     * attempts will always use the address configured on {@link ConnectionFactory}.
+     * <p>If <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection
+     * recovery</a> is enabled, the connection returned by this method will be {@link Recoverable}.
+     * Reconnection attempts will always use the address configured on {@link ConnectionFactory}.
      *
      * @param executor thread execution service for consumers on the connection
      * @return an interface to the connection
@@ -1355,18 +1651,20 @@ public Connection newConnection(ExecutorService executor) throws IOException, Ti
     /**
      * Create a new broker connection.
      *
-     * If <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection recovery</a>
-     * is enabled, the connection returned by this method will be {@link Recoverable}. Reconnection
-     * attempts will always use the address configured on {@link ConnectionFactory}.
+     * <p>If <a href="https://www.rabbitmq.com/api-guide.html#recovery">automatic connection
+     * recovery</a> is enabled, the connection returned by this method will be {@link Recoverable}.
+     * Reconnection attempts will always use the address configured on {@link ConnectionFactory}.
      *
      * @param executor thread execution service for consumers on the connection
-     * @param connectionName client-provided connection name (an arbitrary string). Will
-     *                       be displayed in management UI if the server supports it.
+     * @param connectionName client-provided connection name (an arbitrary string). Will be displayed
+     *     in management UI if the server supports it.
      * @return an interface to the connection
      * @throws IOException if it encounters a problem
      */
-    public Connection newConnection(ExecutorService executor, String connectionName) throws IOException, TimeoutException {
-        return newConnection(executor, Collections.singletonList(new Address(getHost(), getPort())), connectionName);
+    public Connection newConnection(ExecutorService executor, String connectionName)
+        throws IOException, TimeoutException {
+        return newConnection(
+            executor, Collections.singletonList(new Address(getHost(), getPort())), connectionName);
     }
 
     protected AddressResolver createAddressResolver(List<Address> addresses) {
@@ -1379,355 +1677,298 @@ protected AddressResolver createAddressResolver(List<Address> addresses) {
         }
     }
 
-    @Override public ConnectionFactory clone(){
-        try {
-            ConnectionFactory clone = (ConnectionFactory)super.clone();
-            return clone;
-        } catch (CloneNotSupportedException e) {
-            throw new RuntimeException(e);
-        }
-    }
-
-    /**
-     * Load settings from a property file.
-     * Keys must be prefixed with <code>rabbitmq.</code>,
-     * use {@link ConnectionFactory#load(String, String)} to
-     * specify your own prefix.
-     * @param propertyFileLocation location of the property file to use
-     * @throws IOException when something goes wrong reading the file
-     * @since 4.4.0
-     * @see ConnectionFactoryConfigurator
-     */
-    public ConnectionFactory load(String propertyFileLocation) throws IOException {
-        ConnectionFactoryConfigurator.load(this, propertyFileLocation);
-        return this;
-    }
-
-    /**
-     * Load settings from a property file.
-     * @param propertyFileLocation location of the property file to use
-     * @param prefix key prefix for the entries in the file
-     * @throws IOException when something goes wrong reading the file
-     * @since 4.4.0
-     * @see ConnectionFactoryConfigurator
-     */
-    public ConnectionFactory load(String propertyFileLocation, String prefix) throws IOException {
-        ConnectionFactoryConfigurator.load(this, propertyFileLocation, prefix);
-        return this;
-    }
-
-    /**
-     * Load settings from a {@link Properties} instance.
-     * Keys must be prefixed with <code>rabbitmq.</code>,
-     * use {@link ConnectionFactory#load(Properties, String)} to
-     * specify your own prefix.
-     * @param properties source for settings
-     * @since 4.4.0
-     * @see ConnectionFactoryConfigurator
-     */
-    public ConnectionFactory load(Properties properties) {
-        ConnectionFactoryConfigurator.load(this, properties);
-        return this;
+  @Override
+  public ConnectionFactory clone() {
+    try {
+      ConnectionFactory clone = (ConnectionFactory) super.clone();
+      return clone;
+    } catch (CloneNotSupportedException e) {
+      throw new RuntimeException(e);
     }
+  }
 
-    /**
-     * Load settings from a {@link Properties} instance.
-     * @param properties source for settings
-     * @param prefix key prefix for properties entries
-     * @since 4.4.0
-     * @see ConnectionFactoryConfigurator
-     */
-    @SuppressWarnings("unchecked")
-    public ConnectionFactory load(Properties properties, String prefix) {
-        ConnectionFactoryConfigurator.load(this, (Map) properties, prefix);
-        return this;
-    }
+  /**
+   * Load settings from a property file. Keys must be prefixed with <code>rabbitmq.</code>, use
+   * {@link ConnectionFactory#load(String, String)} to specify your own prefix.
+   *
+   * @param propertyFileLocation location of the property file to use
+   * @throws IOException when something goes wrong reading the file
+   * @since 4.4.0
+   * @see ConnectionFactoryConfigurator
+   */
+  public ConnectionFactory load(String propertyFileLocation) throws IOException {
+    ConnectionFactoryConfigurator.load(this, propertyFileLocation);
+    return this;
+  }
 
-    /**
-     * Load settings from a {@link Map} instance.
-     * Keys must be prefixed with <code>rabbitmq.</code>,
-     * use {@link ConnectionFactory#load(Map, String)} to
-     * specify your own prefix.
-     * @param properties source for settings
-     * @since 4.4.0
-     * @see ConnectionFactoryConfigurator
-     */
-    public ConnectionFactory load(Map<String, String> properties) {
-        ConnectionFactoryConfigurator.load(this, properties);
-        return this;
-    }
+  /**
+   * Load settings from a property file.
+   *
+   * @param propertyFileLocation location of the property file to use
+   * @param prefix key prefix for the entries in the file
+   * @throws IOException when something goes wrong reading the file
+   * @since 4.4.0
+   * @see ConnectionFactoryConfigurator
+   */
+  public ConnectionFactory load(String propertyFileLocation, String prefix) throws IOException {
+    ConnectionFactoryConfigurator.load(this, propertyFileLocation, prefix);
+    return this;
+  }
 
-    /**
-     * Load settings from a {@link Map} instance.
-     * @param properties source for settings
-     * @param prefix key prefix for map entries
-     * @since 4.4.0
-     * @see ConnectionFactoryConfigurator
-     */
-    public ConnectionFactory load(Map<String, String> properties, String prefix) {
-        ConnectionFactoryConfigurator.load(this, properties, prefix);
-        return this;
-    }
+  /**
+   * Load settings from a {@link Properties} instance. Keys must be prefixed with <code>rabbitmq.
+   * </code>, use {@link ConnectionFactory#load(Properties, String)} to specify your own prefix.
+   *
+   * @param properties source for settings
+   * @since 4.4.0
+   * @see ConnectionFactoryConfigurator
+   */
+  public ConnectionFactory load(Properties properties) {
+    ConnectionFactoryConfigurator.load(this, properties);
+    return this;
+  }
 
-    /**
-     * Returns automatic connection recovery interval in milliseconds.
-     * @return how long will automatic recovery wait before attempting to reconnect, in ms; default is 5000
-     */
-    public long getNetworkRecoveryInterval() {
-        return networkRecoveryInterval;
-    }
+  /**
+   * Load settings from a {@link Properties} instance.
+   *
+   * @param properties source for settings
+   * @param prefix key prefix for properties entries
+   * @since 4.4.0
+   * @see ConnectionFactoryConfigurator
+   */
+  @SuppressWarnings("unchecked")
+  public ConnectionFactory load(Properties properties, String prefix) {
+    ConnectionFactoryConfigurator.load(this, (Map) properties, prefix);
+    return this;
+  }
 
-    /**
-     * Sets connection recovery interval. Default is 5000.
-     * Uses {@link com.rabbitmq.client.RecoveryDelayHandler.DefaultRecoveryDelayHandler} by default.
-     * Use another {@link RecoveryDelayHandler} implementation for more flexibility.
-     * @param networkRecoveryInterval how long will automatic recovery wait before attempting to reconnect, in ms
-     * @see RecoveryDelayHandler
-     */
-    public void setNetworkRecoveryInterval(int networkRecoveryInterval) {
-        this.networkRecoveryInterval = networkRecoveryInterval;
-    }
+  /**
+   * Load settings from a {@link Map} instance. Keys must be prefixed with <code>rabbitmq.</code>,
+   * use {@link ConnectionFactory#load(Map, String)} to specify your own prefix.
+   *
+   * @param properties source for settings
+   * @since 4.4.0
+   * @see ConnectionFactoryConfigurator
+   */
+  public ConnectionFactory load(Map<String, String> properties) {
+    ConnectionFactoryConfigurator.load(this, properties);
+    return this;
+  }
 
-    /**
-     * Sets connection recovery interval. Default is 5000.
-     * Uses {@link com.rabbitmq.client.RecoveryDelayHandler.DefaultRecoveryDelayHandler} by default.
-     * Use another {@link RecoveryDelayHandler} implementation for more flexibility.
-     * @param networkRecoveryInterval how long will automatic recovery wait before attempting to reconnect, in ms
-     * @see RecoveryDelayHandler
-     */
-    public void setNetworkRecoveryInterval(long networkRecoveryInterval) {
-        this.networkRecoveryInterval = networkRecoveryInterval;
-    }
-    
-    /**
-     * Returns automatic connection recovery delay handler.
-     * @return recovery delay handler. May be null if not set.
-     * @since 4.3.0
-     */
-    public RecoveryDelayHandler getRecoveryDelayHandler() {
-        return recoveryDelayHandler;
-    }
-    
-    /**
-     * Sets the automatic connection recovery delay handler.
-     * @param recoveryDelayHandler the recovery delay handler
-     * @since 4.3.0
-     */
-    public void setRecoveryDelayHandler(final RecoveryDelayHandler recoveryDelayHandler) {
-        this.recoveryDelayHandler = recoveryDelayHandler;
-    }
+  /**
+   * Load settings from a {@link Map} instance.
+   *
+   * @param properties source for settings
+   * @param prefix key prefix for map entries
+   * @since 4.4.0
+   * @see ConnectionFactoryConfigurator
+   */
+  public ConnectionFactory load(Map<String, String> properties, String prefix) {
+    ConnectionFactoryConfigurator.load(this, properties, prefix);
+    return this;
+  }
 
-    /**
-     * Sets the parameters when using NIO.
-     *
-     *
-     * @param nioParams
-     * @see NioParams
-     */
-    public void setNioParams(NioParams nioParams) {
-        this.nioParams = nioParams;
-    }
+  /**
+   * Returns automatic connection recovery interval in milliseconds.
+   *
+   * @return how long will automatic recovery wait before attempting to reconnect, in ms; default is
+   *     5000
+   */
+  public long getNetworkRecoveryInterval() {
+    return networkRecoveryInterval;
+  }
 
-    /**
-     * Retrieve the parameters for NIO mode.
-     * @return
-     */
-    public NioParams getNioParams() {
-        return nioParams;
-    }
+  /**
+   * Sets connection recovery interval. Default is 5000. Uses {@link
+   * com.rabbitmq.client.RecoveryDelayHandler.DefaultRecoveryDelayHandler} by default. Use another
+   * {@link RecoveryDelayHandler} implementation for more flexibility.
+   *
+   * @param networkRecoveryInterval how long will automatic recovery wait before attempting to
+   *     reconnect, in ms
+   * @see RecoveryDelayHandler
+   */
+  public void setNetworkRecoveryInterval(int networkRecoveryInterval) {
+    this.networkRecoveryInterval = networkRecoveryInterval;
+  }
 
-    /**
-     * Use non-blocking IO (NIO) for communication with the server.
-     * With NIO, several connections created from the same {@link ConnectionFactory}
-     * can use the same IO thread.
-     *
-     * A client process using a lot of not-so-active connections can benefit
-     * from NIO, as it would use fewer threads than with the traditional, blocking IO mode.
-     *
-     * Use {@link NioParams} to tune NIO and a {@link SocketChannelConfigurator} to
-     * configure the underlying {@link java.nio.channels.SocketChannel}s for connections.
-     *
-     * @see NioParams
-     * @see SocketChannelConfigurator
-     * @see java.nio.channels.SocketChannel
-     * @see java.nio.channels.Selector
-     */
-    public void useNio() {
-        this.nio = true;
-    }
+  /**
+   * Sets connection recovery interval. Default is 5000. Uses {@link
+   * com.rabbitmq.client.RecoveryDelayHandler.DefaultRecoveryDelayHandler} by default. Use another
+   * {@link RecoveryDelayHandler} implementation for more flexibility.
+   *
+   * @param networkRecoveryInterval how long will automatic recovery wait before attempting to
+   *     reconnect, in ms
+   * @see RecoveryDelayHandler
+   */
+  public void setNetworkRecoveryInterval(long networkRecoveryInterval) {
+    this.networkRecoveryInterval = networkRecoveryInterval;
+  }
 
-    /**
-     * Use blocking IO for communication with the server.
-     * With blocking IO, each connection creates its own thread
-     * to read data from the server.
-     */
-    public void useBlockingIo() {
-        this.nio = false;
-    }
+  /**
+   * Returns automatic connection recovery delay handler.
+   *
+   * @return recovery delay handler. May be null if not set.
+   * @since 4.3.0
+   */
+  public RecoveryDelayHandler getRecoveryDelayHandler() {
+    return recoveryDelayHandler;
+  }
 
-    /**
-     * Set the continuation timeout for RPC calls in channels.
-     * Default is 10 minutes. 0 means no timeout.
-     * @param channelRpcTimeout
-     */
-    public void setChannelRpcTimeout(int channelRpcTimeout) {
-        if(channelRpcTimeout < 0) {
-            throw new IllegalArgumentException("Timeout cannot be less than 0");
-        }
-        this.channelRpcTimeout = channelRpcTimeout;
-    }
+  /**
+   * Sets the automatic connection recovery delay handler.
+   *
+   * @param recoveryDelayHandler the recovery delay handler
+   * @since 4.3.0
+   */
+  public void setRecoveryDelayHandler(final RecoveryDelayHandler recoveryDelayHandler) {
+    this.recoveryDelayHandler = recoveryDelayHandler;
+  }
 
-    /**
-     * Get the timeout for RPC calls in channels.
-     * @return
-     */
-    public int getChannelRpcTimeout() {
-        return channelRpcTimeout;
+  /**
+   * Set the continuation timeout for RPC calls in channels. Default is 10 minutes. 0 means no
+   * timeout.
+   *
+   * @param channelRpcTimeout
+   */
+  public void setChannelRpcTimeout(int channelRpcTimeout) {
+    if (channelRpcTimeout < 0) {
+      throw new IllegalArgumentException("Timeout cannot be less than 0");
     }
+    this.channelRpcTimeout = channelRpcTimeout;
+  }
 
-    /**
-     * Maximum body size of inbound (received) messages in bytes.
-     *
-     * <p>Default value is 67,108,864 (64 MiB).
-     *
-     * @param maxInboundMessageBodySize the maximum size of inbound messages
-     */
-    public void setMaxInboundMessageBodySize(int maxInboundMessageBodySize) {
-        if (maxInboundMessageBodySize <= 0) {
-            throw new IllegalArgumentException("Max inbound message body size must be greater than 0: "
-                + maxInboundMessageBodySize);
-        }
-        this.maxInboundMessageBodySize = maxInboundMessageBodySize;
-    }
+  /**
+   * Get the timeout for RPC calls in channels.
+   *
+   * @return
+   */
+  public int getChannelRpcTimeout() {
+    return channelRpcTimeout;
+  }
 
-    /**
-     * The factory to create SSL contexts.
-     * This provides more flexibility to create {@link SSLContext}s
-     * for different connections than sharing the {@link SSLContext}
-     * with all the connections produced by the connection factory
-     * (which is the case with the {@link #useSslProtocol()} methods).
-     * This way, different connections with a different certificate
-     * for each of them is a possible scenario.
-     * @param sslContextFactory
-     * @see #useSslProtocol(SSLContext)
-     * @since 5.0.0
-     */
-    public void setSslContextFactory(SslContextFactory sslContextFactory) {
-        this.sslContextFactory = sslContextFactory;
-    }
+  /**
+   * The factory to create SSL contexts. This provides more flexibility to create {@link
+   * SSLContext}s for different connections than sharing the {@link SSLContext} with all the
+   * connections produced by the connection factory (which is the case with the {@link
+   * #useSslProtocol()} methods). This way, different connections with a different certificate for
+   * each of them is a possible scenario.
+   *
+   * @param sslContextFactory
+   * @see #useSslProtocol(SSLContext)
+   * @since 5.0.0
+   */
+  public void setSslContextFactory(SslContextFactory sslContextFactory) {
+    this.sslContextFactory = sslContextFactory;
+  }
 
-    /**
-     * When set to true, channels will check the response type (e.g. queue.declare
-     * expects a queue.declare-ok response) of RPC calls
-     * and ignore those that do not match.
-     * Default is false.
-     * @param channelShouldCheckRpcResponseType
-     */
-    public void setChannelShouldCheckRpcResponseType(boolean channelShouldCheckRpcResponseType) {
-        this.channelShouldCheckRpcResponseType = channelShouldCheckRpcResponseType;
-    }
+  /**
+   * When set to true, channels will check the response type (e.g. queue.declare expects a
+   * queue.declare-ok response) of RPC calls and ignore those that do not match. Default is false.
+   *
+   * @param channelShouldCheckRpcResponseType
+   */
+  public void setChannelShouldCheckRpcResponseType(boolean channelShouldCheckRpcResponseType) {
+    this.channelShouldCheckRpcResponseType = channelShouldCheckRpcResponseType;
+  }
 
-    public boolean isChannelShouldCheckRpcResponseType() {
-        return channelShouldCheckRpcResponseType;
-    }
+  public boolean isChannelShouldCheckRpcResponseType() {
+    return channelShouldCheckRpcResponseType;
+  }
 
-    /**
-     * Timeout (in ms) for work pool enqueueing.
-     * The {@link com.rabbitmq.client.impl.WorkPool} dispatches several types of responses
-     * from the broker (e.g. deliveries). A high-traffic
-     * client with slow consumers can exhaust the work pool and
-     * compromise the whole connection (by e.g. letting the broker
-     * saturate the receive TCP buffers). Setting a timeout
-     * would make the connection fail early and avoid hard-to-diagnose
-     * TCP connection failure. Note this shouldn't happen
-     * with clients that set appropriate QoS values.
-     * Default is no timeout.
-     *
-     * @param workPoolTimeout timeout in ms
-     * @since 4.5.0
-     */
-    public void setWorkPoolTimeout(int workPoolTimeout) {
-        this.workPoolTimeout = workPoolTimeout;
-    }
+  /**
+   * Timeout (in ms) for work pool enqueueing. The {@link com.rabbitmq.client.impl.WorkPool}
+   * dispatches several types of responses from the broker (e.g. deliveries). A high-traffic client
+   * with slow consumers can exhaust the work pool and compromise the whole connection (by e.g.
+   * letting the broker saturate the receive TCP buffers). Setting a timeout would make the
+   * connection fail early and avoid hard-to-diagnose TCP connection failure. Note this shouldn't
+   * happen with clients that set appropriate QoS values. Default is no timeout.
+   *
+   * @param workPoolTimeout timeout in ms
+   * @since 4.5.0
+   */
+  public void setWorkPoolTimeout(int workPoolTimeout) {
+    this.workPoolTimeout = workPoolTimeout;
+  }
 
-    public int getWorkPoolTimeout() {
-        return workPoolTimeout;
-    }
+  public int getWorkPoolTimeout() {
+    return workPoolTimeout;
+  }
 
-    /**
-     * Set a listener to be called when connection gets an IO error trying to write on the socket.
-     * Default listener triggers connection recovery asynchronously and propagates
-     * the exception. Override the default listener to disable or
-     * customise automatic connection triggering on write operations.
-     *
-     * @param errorOnWriteListener the listener
-     * @since 4.5.0
-     */
-    public void setErrorOnWriteListener(ErrorOnWriteListener errorOnWriteListener) {
-        this.errorOnWriteListener = errorOnWriteListener;
-    }
+  /**
+   * Set a listener to be called when connection gets an IO error trying to write on the socket.
+   * Default listener triggers connection recovery asynchronously and propagates the exception.
+   * Override the default listener to disable or customise automatic connection triggering on write
+   * operations.
+   *
+   * @param errorOnWriteListener the listener
+   * @since 4.5.0
+   */
+  public void setErrorOnWriteListener(ErrorOnWriteListener errorOnWriteListener) {
+    this.errorOnWriteListener = errorOnWriteListener;
+  }
 
-    /**
-     * Set filter to include/exclude entities from topology recovery.
-     *
-     * @since 4.8.0
-     */
-    public void setTopologyRecoveryFilter(TopologyRecoveryFilter topologyRecoveryFilter) {
-        this.topologyRecoveryFilter = topologyRecoveryFilter;
-    }
+  /**
+   * Set filter to include/exclude entities from topology recovery.
+   *
+   * @since 4.8.0
+   */
+  public void setTopologyRecoveryFilter(TopologyRecoveryFilter topologyRecoveryFilter) {
+    this.topologyRecoveryFilter = topologyRecoveryFilter;
+  }
 
-    /**
-     * Allows to decide on automatic connection recovery is triggered.
-     * Default is for shutdown not initiated by application or missed heartbeat errors.
-     *
-     * @param connectionRecoveryTriggeringCondition
-     */
-    public void setConnectionRecoveryTriggeringCondition(Predicate<ShutdownSignalException> connectionRecoveryTriggeringCondition) {
-        this.connectionRecoveryTriggeringCondition = connectionRecoveryTriggeringCondition;
-    }
+  /**
+   * Allows to decide on automatic connection recovery is triggered. Default is for shutdown not
+   * initiated by application or missed heartbeat errors.
+   *
+   * @param connectionRecoveryTriggeringCondition
+   */
+  public void setConnectionRecoveryTriggeringCondition(
+      Predicate<ShutdownSignalException> connectionRecoveryTriggeringCondition) {
+    this.connectionRecoveryTriggeringCondition = connectionRecoveryTriggeringCondition;
+  }
 
-    /**
-     * Set retry handler for topology recovery.
-     * Default is no retry.
-     *
-     * @param topologyRecoveryRetryHandler
-     * @since 5.4.0
-     */
-    public void setTopologyRecoveryRetryHandler(RetryHandler topologyRecoveryRetryHandler) {
-        this.topologyRecoveryRetryHandler = topologyRecoveryRetryHandler;
-    }
-    
-    /**
-     * Set the recovered queue name supplier. Default is use the same queue name when recovering queues.
-     * 
-     * @param recoveredQueueNameSupplier queue name supplier
-     */
-    public void setRecoveredQueueNameSupplier(RecoveredQueueNameSupplier recoveredQueueNameSupplier) {
-        this.recoveredQueueNameSupplier = recoveredQueueNameSupplier;
-    }
+  /**
+   * Set retry handler for topology recovery. Default is no retry.
+   *
+   * @param topologyRecoveryRetryHandler
+   * @since 5.4.0
+   */
+  public void setTopologyRecoveryRetryHandler(RetryHandler topologyRecoveryRetryHandler) {
+    this.topologyRecoveryRetryHandler = topologyRecoveryRetryHandler;
+  }
 
-    /**
-     * Traffic listener notified of inbound and outbound {@link Command}s.
-     * <p>
-     * Useful for debugging purposes, e.g. logging all sent and received messages.
-     * Default is no-op.
-     *
-     * @param trafficListener
-     * @see TrafficListener
-     * @see com.rabbitmq.client.impl.LogTrafficListener
-     * @since 5.5.0
-     */
-    public void setTrafficListener(TrafficListener trafficListener) {
-        this.trafficListener = trafficListener;
-    }
+  /**
+   * Set the recovered queue name supplier. Default is use the same queue name when recovering
+   * queues.
+   *
+   * @param recoveredQueueNameSupplier queue name supplier
+   */
+  public void setRecoveredQueueNameSupplier(RecoveredQueueNameSupplier recoveredQueueNameSupplier) {
+    this.recoveredQueueNameSupplier = recoveredQueueNameSupplier;
+  }
 
-    public static int ensureUnsignedShort(int value) {
-        if (value < 0) {
-            return 0;
-        } else if (value > MAX_UNSIGNED_SHORT) {
-            return MAX_UNSIGNED_SHORT;
-        } else {
-            return value;
-        }
-    }
+  /**
+   * Traffic listener notified of inbound and outbound {@link Command}s.
+   *
+   * <p>Useful for debugging purposes, e.g. logging all sent and received messages. Default is
+   * no-op.
+   *
+   * @param trafficListener
+   * @see TrafficListener
+   * @see com.rabbitmq.client.impl.LogTrafficListener
+   * @since 5.5.0
+   */
+  public void setTrafficListener(TrafficListener trafficListener) {
+    this.trafficListener = trafficListener;
+  }
+
+  public static int ensureUnsignedShort(int value) {
+    if (value < 0) {
+      return 0;
+    } else if (value > MAX_UNSIGNED_SHORT) {
+      return MAX_UNSIGNED_SHORT;
+    } else {
+      return value;
+    }
+  }
 }
diff --git a/src/main/java/com/rabbitmq/client/SocketChannelConfigurator.java b/src/main/java/com/rabbitmq/client/SocketChannelConfigurator.java
index ffbb919c56..f4070451d5 100644
--- a/src/main/java/com/rabbitmq/client/SocketChannelConfigurator.java
+++ b/src/main/java/com/rabbitmq/client/SocketChannelConfigurator.java
@@ -19,7 +19,12 @@
 import java.nio.channels.SocketChannel;
 import java.util.Objects;
 
+/**
+ *
+ * @deprecated Use {@link ConnectionFactory#netty()} with a channel customizer instead.
+ */
 @FunctionalInterface
+@Deprecated
 public interface SocketChannelConfigurator {
 
     /**
diff --git a/src/main/java/com/rabbitmq/client/SocketChannelConfigurators.java b/src/main/java/com/rabbitmq/client/SocketChannelConfigurators.java
index 95d96c4fad..a4b35b92f6 100644
--- a/src/main/java/com/rabbitmq/client/SocketChannelConfigurators.java
+++ b/src/main/java/com/rabbitmq/client/SocketChannelConfigurators.java
@@ -22,7 +22,9 @@
  * {@link SocketChannelConfigurator#andThen(SocketChannelConfigurator)}.
  *
  * @since 5.4.0
+ * @deprecated Use {@link ConnectionFactory#netty()} with a channel customizer instead.
  */
+@Deprecated
 public abstract class SocketChannelConfigurators {
 
     /**
diff --git a/src/main/java/com/rabbitmq/client/SslEngineConfigurator.java b/src/main/java/com/rabbitmq/client/SslEngineConfigurator.java
index 78b2b2eae9..e98087fe5b 100644
--- a/src/main/java/com/rabbitmq/client/SslEngineConfigurator.java
+++ b/src/main/java/com/rabbitmq/client/SslEngineConfigurator.java
@@ -19,7 +19,12 @@
 import java.io.IOException;
 import java.util.Objects;
 
+/**
+ *
+ * @deprecated use {@link com.rabbitmq.client.ConnectionFactory.NettyConfiguration#sslContext(io.netty.handler.ssl.SslContext)} instead
+ */
 @FunctionalInterface
+@Deprecated
 public interface SslEngineConfigurator {
 
     /**
diff --git a/src/main/java/com/rabbitmq/client/SslEngineConfigurators.java b/src/main/java/com/rabbitmq/client/SslEngineConfigurators.java
index 929fd507d4..33032f8ffe 100644
--- a/src/main/java/com/rabbitmq/client/SslEngineConfigurators.java
+++ b/src/main/java/com/rabbitmq/client/SslEngineConfigurators.java
@@ -24,7 +24,9 @@
  * {@link SslEngineConfigurator#andThen(SslEngineConfigurator)}.
  *
  * @since 5.4.0
+ * @deprecated use {@link com.rabbitmq.client.ConnectionFactory.NettyConfiguration#sslContext(io.netty.handler.ssl.SslContext)} instead
  */
+@Deprecated
 public abstract class SslEngineConfigurators {
 
     /**
diff --git a/src/main/java/com/rabbitmq/client/impl/AMQConnection.java b/src/main/java/com/rabbitmq/client/impl/AMQConnection.java
index 40a57f774b..6225522250 100644
--- a/src/main/java/com/rabbitmq/client/impl/AMQConnection.java
+++ b/src/main/java/com/rabbitmq/client/impl/AMQConnection.java
@@ -25,6 +25,7 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import javax.net.ssl.SSLHandshakeException;
 import java.io.EOFException;
 import java.io.IOException;
 import java.net.InetAddress;
@@ -278,11 +279,15 @@ AMQChannel createChannel0() {
     }
 
     private void initializeConsumerWorkService() {
-        this._workService  = new ConsumerWorkService(consumerWorkServiceExecutor, threadFactory, workPoolTimeout, shutdownTimeout);
+        this._workService = new ConsumerWorkService(consumerWorkServiceExecutor, threadFactory, workPoolTimeout, shutdownTimeout);
     }
 
     private void initializeHeartbeatSender() {
-        this._heartbeatSender = new HeartbeatSender(_frameHandler, heartbeatExecutor, threadFactory);
+        if (_frameHandler.internalHearbeat()) {
+            this._heartbeatSender = HeartbeatSender.NO_OP;
+        } else {
+            this._heartbeatSender = new DefaultHeartbeatSender(_frameHandler, heartbeatExecutor, threadFactory);
+        }
     }
 
     /**
@@ -403,10 +408,11 @@ public void start()
             throw te;
         } catch (ShutdownSignalException sse) {
             _frameHandler.close();
-            throw AMQChannel.wrap(sse);
-        } catch(IOException ioe) {
-            _frameHandler.close();
-            throw ioe;
+            if (sse.getCause() instanceof SSLHandshakeException) {
+                throw (SSLHandshakeException) sse.getCause();
+            } else {
+                throw AMQChannel.wrap(sse);
+            }
         }
 
         try {
@@ -493,6 +499,7 @@ public void start()
 
         // We can now respond to errors having finished tailoring the connection
         this._inConnectionNegotiation = false;
+        this._frameHandler.finishConnectionNegotiation();
     }
 
     protected ChannelManager instantiateChannelManager(int channelMax, ThreadFactory threadFactory) {
diff --git a/src/main/java/com/rabbitmq/client/impl/DefaultHeartbeatSender.java b/src/main/java/com/rabbitmq/client/impl/DefaultHeartbeatSender.java
new file mode 100644
index 0000000000..8bfee96ebd
--- /dev/null
+++ b/src/main/java/com/rabbitmq/client/impl/DefaultHeartbeatSender.java
@@ -0,0 +1,147 @@
+// Copyright (c) 2007-2025 Broadcom. All Rights Reserved. The term "Broadcom" refers to Broadcom Inc. and/or its subsidiaries.
+//
+// This software, the RabbitMQ Java client library, is triple-licensed under the
+// Mozilla Public License 2.0 ("MPL"), the GNU General Public License version 2
+// ("GPL") and the Apache License version 2 ("ASL"). For the MPL, please see
+// LICENSE-MPL-RabbitMQ. For the GPL, please see LICENSE-GPL2.  For the ASL,
+// please see LICENSE-APACHE2.
+//
+// This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND,
+// either express or implied. See the LICENSE file for specific language governing
+// rights and limitations of this software.
+//
+// If you have any questions regarding licensing, please contact us at
+// info@rabbitmq.com.
+
+
+package com.rabbitmq.client.impl;
+
+import com.rabbitmq.client.AMQP;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.ScheduledFuture;
+import java.io.IOException;
+
+import static java.util.concurrent.TimeUnit.SECONDS;
+
+/**
+ * Manages heartbeat sending for a {@link AMQConnection}.
+ * <p/>
+ * Heartbeats are sent in a dedicated thread that is separate
+ * from the main loop thread used for the connection.
+ */
+final class DefaultHeartbeatSender implements HeartbeatSender {
+
+    private final Object monitor = new Object();
+
+    private final FrameHandler frameHandler;
+    private final ThreadFactory threadFactory;
+
+    private ScheduledExecutorService executor;
+    private final boolean privateExecutor;
+
+    private ScheduledFuture<?> future;
+
+    private boolean shutdown = false;
+
+    private volatile long lastActivityTime;
+
+    DefaultHeartbeatSender(FrameHandler frameHandler, ScheduledExecutorService heartbeatExecutor, ThreadFactory threadFactory) {
+        this.frameHandler = frameHandler;
+        this.privateExecutor = (heartbeatExecutor == null);
+        this.executor = heartbeatExecutor;
+        this.threadFactory = threadFactory;
+    }
+
+    public void signalActivity() {
+        this.lastActivityTime = System.nanoTime();
+    }
+
+    /**
+     * Sets the heartbeat in seconds.
+     */
+    public void setHeartbeat(int heartbeatSeconds) {
+        synchronized(this.monitor) {
+            if(this.shutdown) {
+                return;
+            }
+
+            // cancel any existing heartbeat task
+            if(this.future != null) {
+                this.future.cancel(true);
+                this.future = null;
+            }
+
+            if (heartbeatSeconds > 0) {
+                // wake every heartbeatSeconds / 2 to avoid the worst case
+                // where the last activity comes just after the last heartbeat
+                long interval = SECONDS.toNanos(heartbeatSeconds) / 2;
+                ScheduledExecutorService executor = createExecutorIfNecessary();
+                Runnable task = new HeartbeatRunnable(interval);
+                this.future = executor.scheduleAtFixedRate(
+                    task, interval, interval, TimeUnit.NANOSECONDS);
+            }
+        }
+    }
+
+    private ScheduledExecutorService createExecutorIfNecessary() {
+        synchronized (this.monitor) {
+            if (this.executor == null) {
+                this.executor = Executors.newSingleThreadScheduledExecutor(threadFactory);
+            }
+            return this.executor;
+        }
+    }
+
+    /**
+     * Shutdown the heartbeat process, if any.
+     */
+    public void shutdown() {
+        ExecutorService executorToShutdown = null;
+        synchronized (this.monitor) {
+            if (this.future != null) {
+                this.future.cancel(true);
+                this.future = null;
+            }
+
+            if (this.privateExecutor) {
+                // to be safe, we shouldn't call shutdown holding the
+                // monitor.
+                executorToShutdown = this.executor;
+            }
+
+            this.executor = null;
+            this.shutdown = true;
+        }
+        if(executorToShutdown != null) {
+            executorToShutdown.shutdown();
+        }
+    }
+
+    private final class HeartbeatRunnable implements Runnable {
+
+        private final long heartbeatNanos;
+
+        private HeartbeatRunnable(long heartbeatNanos) {
+            this.heartbeatNanos = heartbeatNanos;
+        }
+
+        @Override
+        public void run() {
+            try {
+                long now = System.nanoTime();
+
+                if (now > (lastActivityTime + this.heartbeatNanos)) {
+                    frameHandler.writeFrame(new Frame(AMQP.FRAME_HEARTBEAT, 0));
+                    frameHandler.flush();
+                }
+            } catch (IOException e) {
+                // ignore
+            }
+        }
+    }
+}
diff --git a/src/main/java/com/rabbitmq/client/impl/Frame.java b/src/main/java/com/rabbitmq/client/impl/Frame.java
index 0395680bbb..40aac21f64 100644
--- a/src/main/java/com/rabbitmq/client/impl/Frame.java
+++ b/src/main/java/com/rabbitmq/client/impl/Frame.java
@@ -18,6 +18,7 @@
 import com.rabbitmq.client.AMQP;
 import com.rabbitmq.client.LongString;
 import com.rabbitmq.client.MalformedFrameException;
+import io.netty.buffer.ByteBuf;
 
 import java.io.*;
 import java.math.BigDecimal;
@@ -90,7 +91,6 @@ public static Frame readFrom(DataInputStream is, int maxPayloadSize) throws IOEx
         try {
             type = is.readUnsignedByte();
         } catch (SocketTimeoutException ste) {
-            // System.err.println("Timed out waiting for a frame.");
             return null; // failed
         }
 
@@ -202,6 +202,34 @@ public void writeTo(DataOutputStream os) throws IOException {
         os.write(AMQP.FRAME_END);
     }
 
+    void writeToByteBuf(ByteBuf buf) throws IOException {
+        buf.writeByte(type);
+        buf.writeShort(channel);
+        if (accumulator != null) {
+            buf.writeInt(accumulator.size());
+            accumulator.writeTo(new OutputStream() {
+                @Override
+                public void write(int b) {
+                    buf.writeInt(b);
+                }
+
+                @Override
+                public void write(byte[] b) {
+                    buf.writeBytes(buf);
+                }
+
+                @Override
+                public void write(byte[] b, int off, int len) {
+                    buf.writeBytes(b, off, len);
+                }
+            });
+        } else {
+            buf.writeInt(payload.length);
+            buf.writeBytes(payload);
+        }
+        buf.writeByte(AMQP.FRAME_END);
+    }
+
     public int size() {
         if(accumulator != null) {
             return accumulator.size() + NON_BODY_SIZE;
diff --git a/src/main/java/com/rabbitmq/client/impl/FrameHandler.java b/src/main/java/com/rabbitmq/client/impl/FrameHandler.java
index 0e3cf71819..ced05cd160 100644
--- a/src/main/java/com/rabbitmq/client/impl/FrameHandler.java
+++ b/src/main/java/com/rabbitmq/client/impl/FrameHandler.java
@@ -27,6 +27,10 @@
 
 public interface FrameHandler extends NetworkConnection {
 
+    default boolean internalHearbeat() {
+        return false;
+    }
+
     /**
      * Set the underlying socket's read timeout in milliseconds, if applicable.
      * @param timeoutMs The timeout in milliseconds
@@ -50,6 +54,10 @@ public interface FrameHandler extends NetworkConnection {
 
     void initialize(AMQConnection connection);
 
+    default void finishConnectionNegotiation() {
+
+    }
+
     /**
      * Read a {@link Frame} from the underlying data connection.
      * @return an incoming Frame, or null if there is none
@@ -73,4 +81,5 @@ public interface FrameHandler extends NetworkConnection {
 
     /** Close the underlying data connection (complaint not permitted). */
     void close();
+
 }
diff --git a/src/main/java/com/rabbitmq/client/impl/HeartbeatSender.java b/src/main/java/com/rabbitmq/client/impl/HeartbeatSender.java
index 3d28d6ee21..37cb094bf0 100644
--- a/src/main/java/com/rabbitmq/client/impl/HeartbeatSender.java
+++ b/src/main/java/com/rabbitmq/client/impl/HeartbeatSender.java
@@ -12,136 +12,25 @@
 //
 // If you have any questions regarding licensing, please contact us at
 // info@rabbitmq.com.
-
-
 package com.rabbitmq.client.impl;
 
-import com.rabbitmq.client.AMQP;
-
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ThreadFactory;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.ScheduledFuture;
-import java.io.IOException;
-
-import static java.util.concurrent.TimeUnit.SECONDS;
-
-/**
- * Manages heartbeat sending for a {@link AMQConnection}.
- * <p/>
- * Heartbeats are sent in a dedicated thread that is separate
- * from the main loop thread used for the connection.
- */
-final class HeartbeatSender {
-
-    private final Object monitor = new Object();
-
-    private final FrameHandler frameHandler;
-    private final ThreadFactory threadFactory;
-
-    private ScheduledExecutorService executor;
-    private final boolean privateExecutor;
-
-    private ScheduledFuture<?> future;
-
-    private boolean shutdown = false;
-
-    private volatile long lastActivityTime;
-
-    HeartbeatSender(FrameHandler frameHandler, ScheduledExecutorService heartbeatExecutor, ThreadFactory threadFactory) {
-        this.frameHandler = frameHandler;
-        this.privateExecutor = (heartbeatExecutor == null);
-        this.executor = heartbeatExecutor;
-        this.threadFactory = threadFactory;
-    }
+interface HeartbeatSender {
 
-    public void signalActivity() {
-        this.lastActivityTime = System.nanoTime();
-    }
-
-    /**
-     * Sets the heartbeat in seconds.
-     */
-    public void setHeartbeat(int heartbeatSeconds) {
-        synchronized(this.monitor) {
-            if(this.shutdown) {
-                return;
-            }
-
-            // cancel any existing heartbeat task
-            if(this.future != null) {
-                this.future.cancel(true);
-                this.future = null;
-            }
-
-            if (heartbeatSeconds > 0) {
-                // wake every heartbeatSeconds / 2 to avoid the worst case
-                // where the last activity comes just after the last heartbeat
-                long interval = SECONDS.toNanos(heartbeatSeconds) / 2;
-                ScheduledExecutorService executor = createExecutorIfNecessary();
-                Runnable task = new HeartbeatRunnable(interval);
-                this.future = executor.scheduleAtFixedRate(
-                    task, interval, interval, TimeUnit.NANOSECONDS);
-            }
-        }
-    }
-
-    private ScheduledExecutorService createExecutorIfNecessary() {
-        synchronized (this.monitor) {
-            if (this.executor == null) {
-                this.executor = Executors.newSingleThreadScheduledExecutor(threadFactory);
-            }
-            return this.executor;
-        }
-    }
-
-    /**
-     * Shutdown the heartbeat process, if any.
-     */
-    public void shutdown() {
-        ExecutorService executorToShutdown = null;
-        synchronized (this.monitor) {
-            if (this.future != null) {
-                this.future.cancel(true);
-                this.future = null;
-            }
-
-            if (this.privateExecutor) {
-                // to be safe, we shouldn't call shutdown holding the
-                // monitor.
-                executorToShutdown = this.executor;
-            }
-
-            this.executor = null;
-            this.shutdown = true;
-        }
-        if(executorToShutdown != null) {
-            executorToShutdown.shutdown();
-        }
-    }
+  HeartbeatSender NO_OP =
+      new HeartbeatSender() {
+        @Override
+        public void setHeartbeat(int heartbeat) {}
 
-    private final class HeartbeatRunnable implements Runnable {
+        @Override
+        public void signalActivity() {}
 
-        private final long heartbeatNanos;
+        @Override
+        public void shutdown() {}
+      };
 
-        private HeartbeatRunnable(long heartbeatNanos) {
-            this.heartbeatNanos = heartbeatNanos;
-        }
+  void setHeartbeat(int heartbeat);
 
-        @Override
-        public void run() {
-            try {
-                long now = System.nanoTime();
+  void signalActivity();
 
-                if (now > (lastActivityTime + this.heartbeatNanos)) {
-                    frameHandler.writeFrame(new Frame(AMQP.FRAME_HEARTBEAT, 0));
-                    frameHandler.flush();
-                }
-            } catch (IOException e) {
-                // ignore
-            }
-        }
-    }
+  void shutdown();
 }
diff --git a/src/main/java/com/rabbitmq/client/impl/NettyFrameHandlerFactory.java b/src/main/java/com/rabbitmq/client/impl/NettyFrameHandlerFactory.java
new file mode 100644
index 0000000000..1e60b5013c
--- /dev/null
+++ b/src/main/java/com/rabbitmq/client/impl/NettyFrameHandlerFactory.java
@@ -0,0 +1,532 @@
+// Copyright (c) 2025 Broadcom. All Rights Reserved.
+// The term "Broadcom" refers to Broadcom Inc. and/or its subsidiaries.
+//
+// This software, the RabbitMQ Java client library, is triple-licensed under the
+// Mozilla Public License 2.0 ("MPL"), the GNU General Public License version 2
+// ("GPL") and the Apache License version 2 ("ASL"). For the MPL, please see
+// LICENSE-MPL-RabbitMQ. For the GPL, please see LICENSE-GPL2.  For the ASL,
+// please see LICENSE-APACHE2.
+//
+// This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND,
+// either express or implied. See the LICENSE file for specific language governing
+// rights and limitations of this software.
+//
+// If you have any questions regarding licensing, please contact us at
+// info@rabbitmq.com.
+package com.rabbitmq.client.impl;
+
+import static java.lang.String.format;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static java.util.concurrent.TimeUnit.SECONDS;
+
+import com.rabbitmq.client.AMQP;
+import com.rabbitmq.client.Address;
+import com.rabbitmq.client.ConnectionFactory;
+import com.rabbitmq.client.MalformedFrameException;
+import com.rabbitmq.client.SocketConfigurator;
+import io.netty.bootstrap.Bootstrap;
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+import io.netty.channel.ChannelInitializer;
+import io.netty.channel.ChannelOption;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.socket.SocketChannel;
+import io.netty.channel.socket.nio.NioSocketChannel;
+import io.netty.handler.codec.DecoderException;
+import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
+import io.netty.handler.flush.FlushConsolidationHandler;
+import io.netty.handler.ssl.SslContext;
+import io.netty.handler.ssl.SslHandler;
+import io.netty.handler.timeout.IdleState;
+import io.netty.handler.timeout.IdleStateEvent;
+import io.netty.handler.timeout.IdleStateHandler;
+import io.netty.handler.timeout.ReadTimeoutHandler;
+import java.io.ByteArrayInputStream;
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.time.Duration;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import javax.net.ssl.SSLHandshakeException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public final class NettyFrameHandlerFactory extends AbstractFrameHandlerFactory {
+
+  private static final Logger LOGGER = LoggerFactory.getLogger(NettyFrameHandlerFactory.class);
+  private final EventLoopGroup eventLoopGroup;
+  private final Function<String, SslContext> sslContextFactory;
+  private final Consumer<Channel> channelCustomizer;
+  private final Consumer<Bootstrap> bootstrapCustomizer;
+
+  public NettyFrameHandlerFactory(
+      EventLoopGroup eventLoopGroup,
+      Consumer<Channel> channelCustomizer,
+      Consumer<Bootstrap> bootstrapCustomizer,
+      Function<String, SslContext> sslContextFactory,
+      int connectionTimeout,
+      SocketConfigurator configurator,
+      int maxInboundMessageBodySize) {
+    super(connectionTimeout, configurator, sslContextFactory != null, maxInboundMessageBodySize);
+    this.eventLoopGroup = eventLoopGroup;
+    this.sslContextFactory = sslContextFactory == null ? connName -> null : sslContextFactory;
+    this.channelCustomizer = channelCustomizer == null ? Utils.noOpConsumer() : channelCustomizer;
+    this.bootstrapCustomizer =
+        bootstrapCustomizer == null ? Utils.noOpConsumer() : bootstrapCustomizer;
+  }
+
+  private static void closeNettyState(Channel channel, EventLoopGroup eventLoopGroup) {
+    try {
+      if (channel != null && channel.isOpen()) {
+        LOGGER.debug("Closing Netty channel");
+        channel.close().get(10, TimeUnit.SECONDS);
+      } else {
+        LOGGER.debug("No Netty channel to close");
+      }
+    } catch (InterruptedException e) {
+      LOGGER.info("Channel closing has been interrupted");
+      Thread.currentThread().interrupt();
+    } catch (ExecutionException e) {
+      LOGGER.info("Channel closing failed", e);
+    } catch (TimeoutException e) {
+      LOGGER.info("Could not close channel in 10 seconds");
+    }
+    try {
+      if (eventLoopGroup != null
+          && (!eventLoopGroup.isShuttingDown() || !eventLoopGroup.isShutdown())) {
+        LOGGER.debug("Closing Netty event loop group");
+        eventLoopGroup.shutdownGracefully(1, 10, SECONDS).get(10, SECONDS);
+      }
+    } catch (InterruptedException e) {
+      LOGGER.info("Event loop group closing has been interrupted");
+      Thread.currentThread().interrupt();
+    } catch (ExecutionException e) {
+      LOGGER.info("Event loop group closing failed", e);
+    } catch (TimeoutException e) {
+      LOGGER.info("Could not close event loop group in 10 seconds");
+    }
+  }
+
+  @Override
+  public FrameHandler create(Address addr, String connectionName) throws IOException {
+    SslContext sslContext = this.sslContextFactory.apply(connectionName);
+    return new NettyFrameHandler(
+        this.maxInboundMessageBodySize,
+        addr,
+        sslContext,
+        this.eventLoopGroup,
+        this.channelCustomizer,
+        this.bootstrapCustomizer);
+  }
+
+  private static final class NettyFrameHandler implements FrameHandler {
+
+    private static final String HANDLER_FLUSH_CONSOLIDATION =
+        FlushConsolidationHandler.class.getSimpleName();
+    private static final String HANDLER_FRAME_DECODER =
+        LengthFieldBasedFrameDecoder.class.getSimpleName();
+    private static final String HANDLER_READ_TIMEOUT = ReadTimeoutHandler.class.getSimpleName();
+    private static final String HANDLER_IDLE_STATE = IdleStateHandler.class.getSimpleName();
+    private static final String HANDLER_PROTOCOL_VERSION_MISMATCH =
+        ProtocolVersionMismatchHandler.class.getSimpleName();
+    private static final byte[] HEADER =
+        new byte[] {
+          'A', 'M', 'Q', 'P', 0, AMQP.PROTOCOL.MAJOR, AMQP.PROTOCOL.MINOR, AMQP.PROTOCOL.REVISION
+        };
+    private final EventLoopGroup eventLoopGroup;
+    private final Channel channel;
+    private final AmqpHandler handler;
+    private final AtomicBoolean closed = new AtomicBoolean(false);
+
+    private NettyFrameHandler(
+        int maxInboundMessageBodySize,
+        Address addr,
+        SslContext sslContext,
+        EventLoopGroup elg,
+        Consumer<Channel> channelCustomizer,
+        Consumer<Bootstrap> bootstrapCustomizer)
+        throws IOException {
+      Bootstrap b = new Bootstrap();
+      bootstrapCustomizer.accept(b);
+      if (b.config().group() == null) {
+        if (elg == null) {
+          elg = Utils.eventLoopGroup();
+          this.eventLoopGroup = elg;
+        } else {
+          this.eventLoopGroup = null;
+        }
+        b.group(elg);
+      } else {
+        this.eventLoopGroup = null;
+      }
+      if (b.config().channelFactory() == null) {
+        b.channel(NioSocketChannel.class);
+      }
+      if (!b.config().options().containsKey(ChannelOption.SO_KEEPALIVE)) {
+        b.option(ChannelOption.SO_KEEPALIVE, true);
+      }
+      if (!b.config().options().containsKey(ChannelOption.ALLOCATOR)) {
+        b.option(ChannelOption.ALLOCATOR, Utils.byteBufAllocator());
+      }
+
+      // type + channel + payload size + payload + frame end marker
+      int maxFrameLength = 1 + 2 + 4 + maxInboundMessageBodySize + 1;
+      int lengthFieldOffset = 3;
+      int lengthFieldLength = 4;
+      int lengthAdjustement = 1;
+      AmqpHandler amqpHandler = new AmqpHandler(maxInboundMessageBodySize, this::close);
+      int port = ConnectionFactory.portOrDefault(addr.getPort(), sslContext != null);
+      b.handler(
+          new ChannelInitializer<SocketChannel>() {
+            @Override
+            public void initChannel(SocketChannel ch) {
+              ch.pipeline()
+                  .addFirst(
+                      HANDLER_FLUSH_CONSOLIDATION,
+                      new FlushConsolidationHandler(
+                          FlushConsolidationHandler.DEFAULT_EXPLICIT_FLUSH_AFTER_FLUSHES, true));
+              ch.pipeline()
+                  .addLast(HANDLER_PROTOCOL_VERSION_MISMATCH, new ProtocolVersionMismatchHandler());
+              ch.pipeline()
+                  .addLast(
+                      HANDLER_FRAME_DECODER,
+                      new LengthFieldBasedFrameDecoder(
+                          maxFrameLength,
+                          lengthFieldOffset,
+                          lengthFieldLength,
+                          lengthAdjustement,
+                          0));
+              ch.pipeline().addLast(AmqpHandler.class.getSimpleName(), amqpHandler);
+              if (sslContext != null) {
+                SslHandler sslHandler = sslContext.newHandler(ch.alloc(), addr.getHost(), port);
+                ch.pipeline().addFirst("ssl", sslHandler);
+              }
+              if (channelCustomizer != null) {
+                channelCustomizer.accept(ch);
+              }
+            }
+          });
+      ChannelFuture cf = null;
+      try {
+        cf = b.connect(addr.getHost(), port).sync();
+      } catch (InterruptedException e) {
+        Thread.currentThread().interrupt();
+        throw new IOException("Error when opening network connection", e);
+      } catch (Exception e) {
+        if (e.getCause() instanceof IOException) {
+          throw (IOException) e.getCause();
+        } else {
+          throw new IOException("Error when opening network connection", e);
+        }
+      }
+      this.channel = cf.channel();
+      this.handler = amqpHandler;
+    }
+
+    @Override
+    public boolean internalHearbeat() {
+      return true;
+    }
+
+    @Override
+    public int getTimeout() {
+      return this.channel.getOption(ChannelOption.SO_TIMEOUT);
+    }
+
+    @Override
+    public void setTimeout(int timeoutMs) {
+      this.maybeRemoveHandler(HANDLER_READ_TIMEOUT);
+      timeoutMs = Math.max(1000, timeoutMs * 4);
+      this.channel
+          .pipeline()
+          .addBefore(
+              HANDLER_FRAME_DECODER,
+              HANDLER_READ_TIMEOUT,
+              new ReadTimeoutHandler(timeoutMs, MILLISECONDS));
+      if (handler.connection != null) {
+        Duration heartbeat = Duration.ofSeconds(handler.connection.getHeartbeat());
+        maybeRemoveHandler(HANDLER_IDLE_STATE);
+        if (heartbeat.toMillis() > 0) {
+          this.channel
+              .pipeline()
+              .addBefore(
+                  HANDLER_FRAME_DECODER,
+                  HANDLER_IDLE_STATE,
+                  new IdleStateHandler(
+                      (int) heartbeat.multipliedBy(2).getSeconds(),
+                      (int) heartbeat.getSeconds(),
+                      0));
+        }
+      }
+    }
+
+    private void maybeRemoveHandler(String name) {
+      if (this.channel.pipeline().get(name) != null) {
+        this.channel.pipeline().remove(name);
+      }
+    }
+
+    @Override
+    public void sendHeader() {
+      ByteBuf bb = this.channel.alloc().buffer(HEADER.length);
+      bb.writeBytes(HEADER);
+      this.channel.writeAndFlush(bb);
+    }
+
+    @Override
+    public void initialize(AMQConnection connection) {
+      this.handler.connection = connection;
+    }
+
+    @Override
+    public void finishConnectionNegotiation() {
+      maybeRemoveHandler(HANDLER_PROTOCOL_VERSION_MISMATCH);
+    }
+
+    @Override
+    public Frame readFrame() {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void writeFrame(Frame frame) throws IOException {
+      if (this.handler.isWritable()) {
+        this.doWriteFrame(frame);
+      } else {
+        if (this.channel.eventLoop().inEventLoop()) {
+          // we do not wait in the event loop
+          this.doWriteFrame(frame);
+        } else {
+          try {
+            boolean canWriteNow = this.handler.writableLatch().await(10, SECONDS);
+            if (canWriteNow) {
+              this.doWriteFrame(frame);
+            } else {
+              throw new IOException("Frame enqueuing failed");
+            }
+          } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+          }
+        }
+      }
+    }
+
+    private void doWriteFrame(Frame frame) throws IOException {
+      ByteBuf bb = this.channel.alloc().buffer(frame.size());
+      frame.writeToByteBuf(bb);
+      this.channel.writeAndFlush(bb);
+    }
+
+    @Override
+    public void flush() {
+      this.channel.flush();
+    }
+
+    @Override
+    public void close() {
+      if (this.closed.compareAndSet(false, true)) {
+        Runnable closing = () -> closeNettyState(this.channel, this.eventLoopGroup);
+        if (this.channel.eventLoop().inEventLoop()) {
+          this.channel.eventLoop().submit(closing);
+        } else {
+          closing.run();
+        }
+      }
+    }
+
+    @Override
+    public InetAddress getLocalAddress() {
+      InetSocketAddress addr = maybeInetSocketAddress(this.channel.localAddress());
+      return addr == null ? null : addr.getAddress();
+    }
+
+    @Override
+    public int getLocalPort() {
+      InetSocketAddress addr = maybeInetSocketAddress(this.channel.localAddress());
+      return addr == null ? -1 : addr.getPort();
+    }
+
+    @Override
+    public InetAddress getAddress() {
+      InetSocketAddress addr = maybeInetSocketAddress(this.channel.remoteAddress());
+      return addr == null ? null : addr.getAddress();
+    }
+
+    @Override
+    public int getPort() {
+      InetSocketAddress addr = maybeInetSocketAddress(this.channel.remoteAddress());
+      return addr == null ? -1 : addr.getPort();
+    }
+
+    InetSocketAddress maybeInetSocketAddress(SocketAddress socketAddress) {
+      if (socketAddress instanceof InetSocketAddress) {
+        return (InetSocketAddress) socketAddress;
+      } else {
+        return null;
+      }
+    }
+  }
+
+  private static class AmqpHandler extends ChannelInboundHandlerAdapter {
+
+    private final int maxPayloadSize;
+    private final Runnable closeSequence;
+    private volatile AMQConnection connection;
+    private final AtomicBoolean writable = new AtomicBoolean(true);
+    private final AtomicReference<CountDownLatch> writableLatch =
+        new AtomicReference<>(new CountDownLatch(1));
+
+    private AmqpHandler(int maxPayloadSize, Runnable closeSequence) {
+      this.maxPayloadSize = maxPayloadSize;
+      this.closeSequence = closeSequence;
+    }
+
+    @Override
+    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
+      ByteBuf m = (ByteBuf) msg;
+      try {
+        int type = m.readUnsignedByte();
+        int channel = m.readUnsignedShort();
+        int payloadSize = m.readInt();
+        if (payloadSize >= maxPayloadSize) {
+          throw new IllegalStateException(
+              format(
+                  "Frame body is too large (%d), maximum configured size is %d. "
+                      + "See ConnectionFactory#setMaxInboundMessageBodySize "
+                      + "if you need to increase the limit.",
+                  payloadSize, maxPayloadSize));
+        }
+
+        byte[] payload = new byte[payloadSize];
+        m.readBytes(payload);
+
+        int frameEndMarker = m.readUnsignedByte();
+        if (frameEndMarker != AMQP.FRAME_END) {
+          throw new MalformedFrameException("Bad frame end marker: " + frameEndMarker);
+        }
+
+        Frame frame = new Frame(type, channel, payload);
+        this.connection.ioLoopThread(Thread.currentThread());
+        boolean noProblem = this.connection.handleReadFrame(frame);
+        if (noProblem
+            && (!this.connection.isRunning() || this.connection.hasBrokerInitiatedShutdown())) {
+          // looks like the frame was Close-Ok or Close
+          ctx.executor().submit(() -> this.connection.doFinalShutdown());
+        }
+      } finally {
+        m.release();
+      }
+    }
+
+    @Override
+    public void channelWritabilityChanged(ChannelHandlerContext ctx) throws Exception {
+      boolean canWrite = ctx.channel().isWritable();
+      if (this.writable.compareAndSet(!canWrite, canWrite)) {
+        if (canWrite) {
+          CountDownLatch latch = writableLatch.getAndSet(new CountDownLatch(1));
+          latch.countDown();
+        } else {
+          ctx.channel().flush();
+        }
+      }
+      super.channelWritabilityChanged(ctx);
+    }
+
+    @Override
+    public void channelInactive(ChannelHandlerContext ctx) {
+      if (needToDispatchIoError()) {
+        AMQConnection c = this.connection;
+        if (c.isOpen()) {
+          // it is likely to be an IO exception
+          c.handleIoError(null);
+        } else {
+          // just in case, the call is idempotent anyway
+          c.doFinalShutdown();
+        }
+      }
+    }
+
+    @Override
+    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
+      if (cause instanceof DecoderException && cause.getCause() instanceof SSLHandshakeException) {
+        LOGGER.debug("Error during TLS handshake");
+        this.handleIoError(cause.getCause());
+      } else {
+        this.handleIoError(cause);
+      }
+    }
+
+    @Override
+    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
+      if (evt instanceof IdleStateEvent) {
+        IdleStateEvent e = (IdleStateEvent) evt;
+        if (e.state() == IdleState.READER_IDLE) {
+          LOGGER.info(
+              "Closing connection {} on {}:{} because it's been idle for too long",
+              this.connection.getClientProvidedName(),
+              this.connection.getAddress().getHostName(),
+              this.connection.getPort());
+          if (needToDispatchIoError()) {
+            this.connection.handleHeartbeatFailure();
+          }
+        } else if (e.state() == IdleState.WRITER_IDLE) {
+          this.connection.writeFrame(new Frame(AMQP.FRAME_HEARTBEAT, 0));
+          this.connection.flush();
+        }
+      }
+      super.userEventTriggered(ctx, evt);
+    }
+
+    private void handleIoError(Throwable cause) {
+      if (needToDispatchIoError()) {
+        this.connection.handleIoError(cause);
+      } else {
+        this.closeSequence.run();
+      }
+    }
+
+    private boolean needToDispatchIoError() {
+      AMQConnection c = this.connection;
+      return c != null && c.isOpen();
+    }
+
+    private boolean isWritable() {
+      return this.writable.get();
+    }
+
+    private CountDownLatch writableLatch() {
+      return this.writableLatch.get();
+    }
+  }
+
+  private static final class ProtocolVersionMismatchHandler extends ChannelInboundHandlerAdapter {
+
+    @Override
+    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
+      ByteBuf b = (ByteBuf) msg;
+      if (b.readByte() == 'A') {
+        // likely an AMQP header that indicates a protocol version mismatch
+        // the header is small, we read everything in memory and use the Frame class
+        int toRead = Math.min(b.readableBytes(), NettyFrameHandler.HEADER.length - 1);
+        byte[] header = new byte[toRead];
+        b.readBytes(header);
+        Frame.protocolVersionMismatch(new DataInputStream(new ByteArrayInputStream(header)));
+      } else {
+        b.readerIndex(0);
+        ctx.fireChannelRead(msg);
+      }
+    }
+  }
+}
diff --git a/src/main/java/com/rabbitmq/client/impl/Utils.java b/src/main/java/com/rabbitmq/client/impl/Utils.java
index c306647e34..d6b86480c5 100644
--- a/src/main/java/com/rabbitmq/client/impl/Utils.java
+++ b/src/main/java/com/rabbitmq/client/impl/Utils.java
@@ -1,4 +1,5 @@
-// Copyright (c) 2023 Broadcom. All Rights Reserved. The term "Broadcom" refers to Broadcom Inc. and/or its subsidiaries.
+// Copyright (c) 2007-2025 Broadcom. All Rights Reserved. The term "Broadcom" refers to Broadcom
+// Inc. and/or its subsidiaries.
 //
 // This software, the RabbitMQ Java client library, is triple-licensed under the
 // Mozilla Public License 2.0 ("MPL"), the GNU General Public License version 2
@@ -15,17 +16,57 @@
 
 package com.rabbitmq.client.impl;
 
+import io.netty.buffer.ByteBufAllocator;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.MultiThreadIoEventLoopGroup;
+import io.netty.channel.nio.NioIoHandler;
+
+import java.util.function.Consumer;
+
 final class Utils {
 
+  @SuppressWarnings("rawtypes")
+  private static final Consumer NO_OP_CONSUMER = o -> {};
+
+  static final boolean IS_NETTY_4_2;
+
   private static final int AVAILABLE_PROCESSORS =
       Integer.parseInt(
           System.getProperty(
               "rabbitmq.amqp.client.availableProcessors",
               String.valueOf(Runtime.getRuntime().availableProcessors())));
 
+  static {
+    boolean netty4_2 = true;
+    try {
+      Class.forName("io.netty.channel.MultiThreadIoEventLoopGroup");
+    } catch (ClassNotFoundException e) {
+      netty4_2 = false;
+    }
+    IS_NETTY_4_2 = netty4_2;
+  }
+
+  private Utils() {}
+
   static int availableProcessors() {
     return AVAILABLE_PROCESSORS;
   }
 
-  private Utils() {}
+  @SuppressWarnings("deprecation")
+  static EventLoopGroup eventLoopGroup() {
+    if (IS_NETTY_4_2) {
+      return new MultiThreadIoEventLoopGroup(NioIoHandler.newFactory());
+    } else {
+      return new io.netty.channel.nio.NioEventLoopGroup();
+    }
+  }
+
+  static ByteBufAllocator byteBufAllocator() {
+    return ByteBufAllocator.DEFAULT;
+  }
+
+  @SuppressWarnings("unchecked")
+  static <T> Consumer<T> noOpConsumer() {
+    return (Consumer<T>) NO_OP_CONSUMER;
+  }
 }
diff --git a/src/main/java/com/rabbitmq/client/impl/nio/NioContext.java b/src/main/java/com/rabbitmq/client/impl/nio/NioContext.java
index fe89375ae8..28147925d9 100644
--- a/src/main/java/com/rabbitmq/client/impl/nio/NioContext.java
+++ b/src/main/java/com/rabbitmq/client/impl/nio/NioContext.java
@@ -7,7 +7,9 @@
  *
  * @see ByteBufferFactory
  * @since 5.5.0
+ * @deprecated use {@link com.rabbitmq.client.ConnectionFactory#netty()} instead
  */
+@Deprecated
 public class NioContext {
 
     private final NioParams nioParams;
diff --git a/src/main/java/com/rabbitmq/client/impl/nio/NioParams.java b/src/main/java/com/rabbitmq/client/impl/nio/NioParams.java
index 7073b6178d..980005049f 100644
--- a/src/main/java/com/rabbitmq/client/impl/nio/NioParams.java
+++ b/src/main/java/com/rabbitmq/client/impl/nio/NioParams.java
@@ -30,8 +30,12 @@
 /**
  * Parameters used to configure the NIO mode of a {@link com.rabbitmq.client.ConnectionFactory}.
  *
+ *
+ *
  * @since 4.0.0
+ * @deprecated use {@link com.rabbitmq.client.ConnectionFactory#netty()} instead
  */
+@Deprecated
 public class NioParams {
 
     static Function<NioContext, NioQueue> DEFAULT_WRITE_QUEUE_FACTORY =
diff --git a/src/main/java/com/rabbitmq/client/impl/nio/NioQueue.java b/src/main/java/com/rabbitmq/client/impl/nio/NioQueue.java
index d15ab6ac6a..e44cf12d8e 100644
--- a/src/main/java/com/rabbitmq/client/impl/nio/NioQueue.java
+++ b/src/main/java/com/rabbitmq/client/impl/nio/NioQueue.java
@@ -9,7 +9,9 @@
  *
  * @see NioParams
  * @since 5.5.0
+ * @deprecated use {@link com.rabbitmq.client.ConnectionFactory#netty()} instead
  */
+@Deprecated
 public interface NioQueue {
 
     /**
diff --git a/src/test/java/com/rabbitmq/client/AmqpClientTestExtension.java b/src/test/java/com/rabbitmq/client/AmqpClientTestExtension.java
index dcffa744b2..78242e9d5c 100644
--- a/src/test/java/com/rabbitmq/client/AmqpClientTestExtension.java
+++ b/src/test/java/com/rabbitmq/client/AmqpClientTestExtension.java
@@ -16,6 +16,7 @@
 
 package com.rabbitmq.client;
 
+import static java.util.concurrent.TimeUnit.SECONDS;
 import static org.junit.jupiter.api.extension.ConditionEvaluationResult.disabled;
 import static org.junit.jupiter.api.extension.ConditionEvaluationResult.enabled;
 
@@ -24,8 +25,13 @@
 import com.rabbitmq.client.test.server.HaTestSuite;
 import com.rabbitmq.client.test.server.ServerTestSuite;
 import com.rabbitmq.client.test.ssl.SslTestSuite;
-import com.rabbitmq.tools.Host;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.MultiThreadIoEventLoopGroup;
+import io.netty.channel.nio.NioIoHandler;
 import java.net.Socket;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import org.junit.jupiter.api.extension.AfterAllCallback;
 import org.junit.jupiter.api.extension.AfterEachCallback;
 import org.junit.jupiter.api.extension.BeforeAllCallback;
 import org.junit.jupiter.api.extension.BeforeEachCallback;
@@ -36,42 +42,36 @@
 import org.slf4j.LoggerFactory;
 
 public class AmqpClientTestExtension
-    implements ExecutionCondition, BeforeAllCallback, BeforeEachCallback, AfterEachCallback {
+    implements ExecutionCondition,
+        BeforeAllCallback,
+        BeforeEachCallback,
+        AfterEachCallback,
+        AfterAllCallback {
 
   private static final Logger LOGGER = LoggerFactory.getLogger(AmqpClientTestExtension.class);
-
-  private static boolean isFunctionalSuite(ExtensionContext context) {
-    return isTestSuite(context, FunctionalTestSuite.class);
+  static {
+    LOGGER.debug("Available processor(s): {}", Runtime.getRuntime().availableProcessors());
   }
 
-  private static boolean isSslSuite(ExtensionContext context) {
-    return isTestSuite(context, SslTestSuite.class);
+  private static final ExtensionContext.Namespace NAMESPACE =
+      ExtensionContext.Namespace.create(AmqpClientTestExtension.class);
+
+  private static ExtensionContext.Store store(ExtensionContext extensionContext) {
+    return extensionContext.getRoot().getStore(NAMESPACE);
   }
 
-  private static boolean isServerSuite(ExtensionContext context) {
-    return isTestSuite(context, ServerTestSuite.class);
+  static EventLoopGroup eventLoopGroup(ExtensionContext context) {
+    return (EventLoopGroup) store(context).get("nettyEventLoopGroup");
   }
 
-  private static boolean isHaSuite(ExtensionContext context) {
-    return isTestSuite(context, HaTestSuite.class);
+  private static boolean isSslSuite(ExtensionContext context) {
+    return isTestSuite(context, SslTestSuite.class);
   }
 
   private static boolean isTestSuite(ExtensionContext context, Class<?> clazz) {
     return context.getUniqueId().contains(clazz.getName());
   }
 
-  public static boolean requiredProperties() {
-    /* Path to rabbitmqctl. */
-    String rabbitmqctl = Host.rabbitmqctlCommand();
-    if (rabbitmqctl == null) {
-      System.err.println(
-          "rabbitmqctl required; please set \"rabbitmqctl.bin\" system" + " property");
-      return false;
-    }
-
-    return true;
-  }
-
   public static boolean isSSLAvailable() {
     return checkServerListening("localhost", 5671);
   }
@@ -95,37 +95,30 @@ private static boolean checkServerListening(String host, int port) {
 
   @Override
   public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext context) {
-    // HA test suite must be checked first because it contains other test suites
-    if (isHaSuite(context)) {
-      return requiredProperties()
-          ? enabled("Required properties available")
-          : disabled("Required properties not available");
-    } else if (isServerSuite(context)) {
-      return requiredProperties()
-          ? enabled("Required properties available")
-          : disabled("Required properties not available");
-    } else if (isFunctionalSuite(context)) {
-      return requiredProperties()
-          ? enabled("Required properties available")
-          : disabled("Required properties not available");
-    } else if (isSslSuite(context)) {
-      return requiredProperties() && isSSLAvailable()
-          ? enabled("Required properties and TLS available")
-          : disabled("Required properties or TLS not available");
+    if (isSslSuite(context) && !isSSLAvailable()) {
+      return disabled("Required properties or TLS not available");
+    } else {
+      return enabled("ok");
     }
-    return enabled("ok");
   }
 
   @Override
-  public void beforeAll(ExtensionContext context) {}
+  public void beforeAll(ExtensionContext context) {
+    if (TestUtils.isNetty()) {
+      EventLoopGroup eventLoopGroup = new MultiThreadIoEventLoopGroup(NioIoHandler.newFactory());
+      store(context)
+          .put("nettyEventLoopGroup", eventLoopGroup);
+      TestUtils.eventLoopGroup(eventLoopGroup);
+    }
+  }
 
   @Override
   public void beforeEach(ExtensionContext context) {
     LOGGER.info(
-        "Starting test: {}.{} (nio? {})",
+        "Starting test: {}.{} (IO layer: {})",
         context.getTestClass().get().getSimpleName(),
         context.getTestMethod().get().getName(),
-        TestUtils.USE_NIO);
+        TestUtils.IO_LAYER);
   }
 
   @Override
@@ -135,4 +128,42 @@ public void afterEach(ExtensionContext context) {
         context.getTestClass().get().getSimpleName(),
         context.getTestMethod().get().getName());
   }
+
+  @Override
+  public void afterAll(ExtensionContext context) {
+    if (TestUtils.isNetty()) {
+      TestUtils.resetEventLoopGroup();
+      EventLoopGroup eventLoopGroup = eventLoopGroup(context);
+      ExecutorServiceCloseableResourceWrapper wrapper =
+          context
+              .getRoot()
+              .getStore(ExtensionContext.Namespace.GLOBAL)
+              .getOrComputeIfAbsent(ExecutorServiceCloseableResourceWrapper.class);
+      wrapper.executorService.submit(
+          () -> {
+            try {
+              eventLoopGroup.shutdownGracefully(0, 0, SECONDS).get(10, SECONDS);
+            } catch (InterruptedException e) {
+              LOGGER.debug("Error while asynchronously closing Netty event loop group", e);
+              Thread.currentThread().interrupt();
+            } catch (Exception e) {
+              LOGGER.warn("Error while asynchronously closing Netty event loop group", e);
+            }
+          });
+    }
+  }
+
+  private static class ExecutorServiceCloseableResourceWrapper implements AutoCloseable {
+
+    private final ExecutorService executorService;
+
+    private ExecutorServiceCloseableResourceWrapper() {
+      this.executorService = Executors.newCachedThreadPool();
+    }
+
+    @Override
+    public void close() {
+      this.executorService.shutdownNow();
+    }
+  }
 }
diff --git a/src/test/java/com/rabbitmq/client/impl/AMQConnectionRefreshCredentialsTest.java b/src/test/java/com/rabbitmq/client/impl/AMQConnectionRefreshCredentialsTest.java
index d99a8434d6..a853b22a41 100644
--- a/src/test/java/com/rabbitmq/client/impl/AMQConnectionRefreshCredentialsTest.java
+++ b/src/test/java/com/rabbitmq/client/impl/AMQConnectionRefreshCredentialsTest.java
@@ -97,9 +97,7 @@ public int protocolMethodId() {
             }
         };
         cf.setAutomaticRecoveryEnabled(false);
-        if (TestUtils.USE_NIO) {
-            cf.useNio();
-        }
+        TestUtils.setIoLayer(cf);
         return cf;
     }
 
@@ -174,7 +172,6 @@ public void connectionIsUnregisteredFromRefreshServiceIfUpdateSecretFails() thro
         TestUtils.sendAndConsumeMessage("", queue, queue, c);
         verify(refreshService, never()).unregister(any(CredentialsProvider.class), anyString());
 
-        verify(refreshService, never()).unregister(any(CredentialsProvider.class), anyString());
         // calling refresh, this sends garbage and should make the broker close the connection
         assertThat(refreshTokenCallable.get().call()).isFalse();
         assertThat(unregisteredLatch.await(5, TimeUnit.SECONDS)).isTrue();
diff --git a/src/test/java/com/rabbitmq/client/test/BlockedConnectionTest.java b/src/test/java/com/rabbitmq/client/test/BlockedConnectionTest.java
index 7af27fbfde..cbbdc5bf2c 100644
--- a/src/test/java/com/rabbitmq/client/test/BlockedConnectionTest.java
+++ b/src/test/java/com/rabbitmq/client/test/BlockedConnectionTest.java
@@ -32,22 +32,19 @@
 import com.rabbitmq.client.MessageProperties;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
 import org.junit.jupiter.params.provider.ValueSource;
 
 public class BlockedConnectionTest extends BrokerTestCase {
 
   @ParameterizedTest
-  @ValueSource(booleans = {true, false})
-  void errorInBlockListenerShouldCloseConnection(boolean nio) throws Exception {
+  @MethodSource("com.rabbitmq.client.test.TestUtils#ioLayers")
+  void errorInBlockListenerShouldCloseConnection(String ioLayer) throws Exception {
     ConnectionFactory cf = TestUtils.connectionFactory();
-    if (nio) {
-      cf.useNio();
-    } else {
-      cf.useBlockingIo();
-    }
+    TestUtils.setIoLayer(cf, ioLayer);
     Connection c = cf.newConnection();
     CountDownLatch shutdownLatch = new CountDownLatch(1);
-    c.addShutdownListener(cause -> shutdownLatch.countDown());
+    c.addShutdownListener(sse -> shutdownLatch.countDown());
     CountDownLatch blockedLatch = new CountDownLatch(1);
     c.addBlockedListener(
         reason -> {
diff --git a/src/test/java/com/rabbitmq/client/test/BrokerTestCase.java b/src/test/java/com/rabbitmq/client/test/BrokerTestCase.java
index cdd988930e..231f92d00b 100644
--- a/src/test/java/com/rabbitmq/client/test/BrokerTestCase.java
+++ b/src/test/java/com/rabbitmq/client/test/BrokerTestCase.java
@@ -42,7 +42,7 @@ public class BrokerTestCase {
 
     protected ConnectionFactory newConnectionFactory() {
         ConnectionFactory connectionFactory = TestUtils.connectionFactory();
-        if(TestUtils.USE_NIO) {
+        if(TestUtils.isNio()) {
             connectionFactory.setNioParams(nioParams());
         }
         connectionFactory.setAutomaticRecoveryEnabled(isAutomaticRecoveryEnabled());
diff --git a/src/test/java/com/rabbitmq/client/test/ClientTestSuite.java b/src/test/java/com/rabbitmq/client/test/ClientTestSuite.java
index 245163d3bd..8b5d097689 100644
--- a/src/test/java/com/rabbitmq/client/test/ClientTestSuite.java
+++ b/src/test/java/com/rabbitmq/client/test/ClientTestSuite.java
@@ -83,7 +83,10 @@
     RefreshCredentialsTest.class,
     AMQConnectionRefreshCredentialsTest.class,
     BlockedConnectionTest.class,
-    ValueWriterTest.class
+    ValueWriterTest.class,
+    BlockedConnectionTest.class,
+    NettyTest.class,
+    ProtocolVersionMismatch.class
 })
 public class ClientTestSuite {
 
diff --git a/src/test/java/com/rabbitmq/client/test/FrameTest.java b/src/test/java/com/rabbitmq/client/test/FrameTest.java
index fae132263b..45742dcd2f 100644
--- a/src/test/java/com/rabbitmq/client/test/FrameTest.java
+++ b/src/test/java/com/rabbitmq/client/test/FrameTest.java
@@ -72,12 +72,12 @@ private void checkWrittenChunks(int totalFrameSize, AccumulatorWritableByteChann
 
     private static class AccumulatorWritableByteChannel implements WritableByteChannel {
 
-        List<byte[]> chunks = new ArrayList<byte[]>();
+        List<byte[]> chunks = new ArrayList<>();
 
         Random random = new Random();
 
         @Override
-        public int write(ByteBuffer src) throws IOException {
+        public int write(ByteBuffer src) {
             int remaining = src.remaining();
             if(remaining > 0) {
                 int toRead = random.nextInt(remaining) + 1;
@@ -88,7 +88,6 @@ public int write(ByteBuffer src) throws IOException {
             } else {
                 return remaining;
             }
-
         }
 
         @Override
@@ -97,9 +96,7 @@ public boolean isOpen() {
         }
 
         @Override
-        public void close() throws IOException {
-
-        }
+        public void close() { }
     }
 
     public static void drain(WritableByteChannel channel, ByteBuffer buffer) throws IOException {
diff --git a/src/test/java/com/rabbitmq/client/test/NettyTest.java b/src/test/java/com/rabbitmq/client/test/NettyTest.java
new file mode 100644
index 0000000000..34651c24cf
--- /dev/null
+++ b/src/test/java/com/rabbitmq/client/test/NettyTest.java
@@ -0,0 +1,143 @@
+// Copyright (c) 2025 Broadcom. All Rights Reserved.
+// The term "Broadcom" refers to Broadcom Inc. and/or its subsidiaries.
+//
+// This software, the RabbitMQ Java client library, is triple-licensed under the
+// Mozilla Public License 2.0 ("MPL"), the GNU General Public License version 2
+// ("GPL") and the Apache License version 2 ("ASL"). For the MPL, please see
+// LICENSE-MPL-RabbitMQ. For the GPL, please see LICENSE-GPL2.  For the ASL,
+// please see LICENSE-APACHE2.
+//
+// This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND,
+// either express or implied. See the LICENSE file for specific language governing
+// rights and limitations of this software.
+//
+// If you have any questions regarding licensing, please contact us at
+// info@rabbitmq.com.
+package com.rabbitmq.client.test;
+
+import static com.rabbitmq.client.test.TestUtils.LatchConditions.completed;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.rabbitmq.client.AMQP;
+import com.rabbitmq.client.Channel;
+import com.rabbitmq.client.Connection;
+import com.rabbitmq.client.ConnectionFactory;
+import com.rabbitmq.client.DefaultConsumer;
+import com.rabbitmq.client.Envelope;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.IoHandlerFactory;
+import io.netty.channel.MultiThreadIoEventLoopGroup;
+import io.netty.channel.epoll.EpollIoHandler;
+import io.netty.channel.epoll.EpollSocketChannel;
+import io.netty.channel.kqueue.KQueueIoHandler;
+import io.netty.channel.kqueue.KQueueSocketChannel;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.EnabledIfSystemProperty;
+import org.junit.jupiter.api.condition.EnabledOnOs;
+import org.junit.jupiter.api.condition.OS;
+
+public class NettyTest {
+
+  ConnectionFactory cf;
+
+  @BeforeEach
+  void init() {
+    cf = TestUtils.connectionFactory();
+    cf.useNetty();
+  }
+
+  @Test
+  void publishConsumeDefaults() throws Exception {
+    publishConsume(cf);
+  }
+
+  @Test
+  @EnabledOnOs(OS.MAC)
+  @EnabledIfSystemProperty(named = "os.arch", matches = "aarch64")
+  void kqueue() throws Exception {
+    nativeIoTest(KQueueIoHandler.newFactory(), KQueueSocketChannel.class);
+  }
+
+  @Test
+  @EnabledOnOs(OS.LINUX)
+  @EnabledIfSystemProperty(named = "os.arch", matches = "amd64")
+  void epoll() throws Exception {
+    nativeIoTest(EpollIoHandler.newFactory(), EpollSocketChannel.class);
+  }
+
+  private static void nativeIoTest(
+      IoHandlerFactory ioHandlerFactory, Class<? extends io.netty.channel.Channel> channelClass)
+      throws IOException, TimeoutException {
+    ConnectionFactory cf = TestUtils.connectionFactory();
+    EventLoopGroup eventLoopGroup = new MultiThreadIoEventLoopGroup(ioHandlerFactory);
+    Set<io.netty.channel.Channel> channels = ConcurrentHashMap.newKeySet();
+    cf.netty()
+        .eventLoopGroup(eventLoopGroup)
+        .bootstrapCustomizer(b -> b.channel(channelClass))
+        .channelCustomizer(channels::add);
+    try {
+      publishConsume(cf);
+      assertThat(channels)
+          .isNotEmpty()
+          .allMatch(ch -> ch.getClass().isAssignableFrom(channelClass));
+    } finally {
+      eventLoopGroup.shutdownGracefully(0, 0, TimeUnit.SECONDS);
+    }
+  }
+
+  private static void publishConsume(ConnectionFactory cf) throws IOException, TimeoutException {
+    try (Connection c = cf.newConnection()) {
+      Channel ch1 = c.createChannel();
+      String q = ch1.queueDeclare().getQueue();
+
+      Channel ch2 = c.createChannel();
+      CountDownLatch consumeLatch = new CountDownLatch(1);
+      CountDownLatch cancelLatch = new CountDownLatch(1);
+      String ctag =
+          ch2.basicConsume(
+              q,
+              new DefaultConsumer(ch2) {
+                @Override
+                public void handleDelivery(
+                    String ctg, Envelope envelope, AMQP.BasicProperties properties, byte[] body)
+                    throws IOException {
+                  ch2.basicAck(envelope.getDeliveryTag(), false);
+                  consumeLatch.countDown();
+                }
+
+                @Override
+                public void handleCancelOk(String consumerTag) {
+                  cancelLatch.countDown();
+                }
+              });
+
+      Channel ch3 = c.createChannel();
+      ch3.confirmSelect();
+      CountDownLatch confirmLatch = new CountDownLatch(1);
+      ch3.addConfirmListener(
+          (deliveryTag, multiple) -> confirmLatch.countDown(), (dtag, multiple) -> {});
+      ch3.basicPublish("", q, null, "hello".getBytes(StandardCharsets.UTF_8));
+      assertThat(confirmLatch).is(completed());
+      assertThat(consumeLatch).is(completed());
+
+      TestUtils.waitAtMost(() -> ch1.queueDeclarePassive(q).getMessageCount() == 0);
+
+      ch2.basicCancel(ctag);
+      assertThat(cancelLatch).is(completed());
+
+      ch1.queueDelete(q);
+
+      ch3.close();
+      ch2.close();
+      ch1.close();
+    }
+  }
+}
diff --git a/src/test/java/com/rabbitmq/client/test/NoAutoRecoveryWhenTcpWindowIsFullTest.java b/src/test/java/com/rabbitmq/client/test/NoAutoRecoveryWhenTcpWindowIsFullTest.java
index 2b0c934cf1..ecd82d05a5 100644
--- a/src/test/java/com/rabbitmq/client/test/NoAutoRecoveryWhenTcpWindowIsFullTest.java
+++ b/src/test/java/com/rabbitmq/client/test/NoAutoRecoveryWhenTcpWindowIsFullTest.java
@@ -107,7 +107,7 @@ public void configure(Socket socket) throws IOException {
         factory.setShutdownExecutor(executorService);
         factory.setNetworkRecoveryInterval(2000);
 
-        if (TestUtils.USE_NIO) {
+        if (TestUtils.isNio()) {
             factory.setWorkPoolTimeout(10 * 1000);
             factory.setNioParams(new NioParams().setWriteQueueCapacity(10 * 1000 * 1000).setNbIoThreads(4));
         }
diff --git a/src/test/java/com/rabbitmq/client/test/ProtocolVersionMismatch.java b/src/test/java/com/rabbitmq/client/test/ProtocolVersionMismatch.java
new file mode 100644
index 0000000000..823e2293cd
--- /dev/null
+++ b/src/test/java/com/rabbitmq/client/test/ProtocolVersionMismatch.java
@@ -0,0 +1,92 @@
+// Copyright (c) 2025 Broadcom. All Rights Reserved.
+// The term "Broadcom" refers to Broadcom Inc. and/or its subsidiaries.
+//
+// This software, the RabbitMQ Java client library, is triple-licensed under the
+// Mozilla Public License 2.0 ("MPL"), the GNU General Public License version 2
+// ("GPL") and the Apache License version 2 ("ASL"). For the MPL, please see
+// LICENSE-MPL-RabbitMQ. For the GPL, please see LICENSE-GPL2.  For the ASL,
+// please see LICENSE-APACHE2.
+//
+// This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND,
+// either express or implied. See the LICENSE file for specific language governing
+// rights and limitations of this software.
+//
+// If you have any questions regarding licensing, please contact us at
+// info@rabbitmq.com.
+package com.rabbitmq.client.test;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import com.rabbitmq.client.ConnectionFactory;
+import com.rabbitmq.client.MalformedFrameException;
+import io.netty.bootstrap.ServerBootstrap;
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelFutureListener;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+import io.netty.channel.ChannelInitializer;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.MultiThreadIoEventLoopGroup;
+import io.netty.channel.nio.NioIoHandler;
+import io.netty.channel.socket.SocketChannel;
+import io.netty.channel.socket.nio.NioServerSocketChannel;
+import io.netty.util.ReferenceCountUtil;
+import java.util.concurrent.TimeUnit;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
+public class ProtocolVersionMismatch {
+
+  @ParameterizedTest
+  @MethodSource("com.rabbitmq.client.test.TestUtils#ioLayers")
+  void connectionShouldFailWithProtocolVersionMismatch(String ioLayer) throws Exception {
+    int port = TestUtils.randomNetworkPort();
+    try (ProtocolVersionMismatchServer ignored = new ProtocolVersionMismatchServer(port)) {
+      ConnectionFactory cf = TestUtils.connectionFactory();
+      TestUtils.setIoLayer(cf, ioLayer);
+      cf.setPort(port);
+      assertThatThrownBy(cf::newConnection).hasRootCauseInstanceOf(MalformedFrameException.class);
+    }
+  }
+
+  private static class ProtocolVersionMismatchServer implements AutoCloseable {
+
+    private final EventLoopGroup elp =
+        new MultiThreadIoEventLoopGroup(1, NioIoHandler.newFactory());
+
+    private static final byte[] AMQP_HEADER = new byte[] {'A', 'M', 'Q', 'P', 0, 1, 0, 0};
+
+    private ProtocolVersionMismatchServer(int port) throws InterruptedException {
+      ServerBootstrap b = new ServerBootstrap();
+      b.group(elp);
+      b.channel(NioServerSocketChannel.class);
+      b.childHandler(
+              new ChannelInitializer<SocketChannel>() {
+                @Override
+                protected void initChannel(SocketChannel ch) {
+                  ch.pipeline()
+                      .addLast(
+                          new ChannelInboundHandlerAdapter() {
+                            @Override
+                            public void channelRead(ChannelHandlerContext ctx, Object msg) {
+                              // discard the data
+                              ReferenceCountUtil.release(msg);
+                              ByteBuf b = ctx.alloc().buffer(AMQP_HEADER.length);
+                              b.writeBytes(AMQP_HEADER);
+                              ctx.channel()
+                                  .writeAndFlush(b)
+                                  .addListener(ChannelFutureListener.CLOSE);
+                            }
+                          });
+                }
+              })
+          .validate();
+      b.bind(port).sync();
+    }
+
+    @Override
+    public void close() {
+      this.elp.shutdownGracefully(0, 0, TimeUnit.SECONDS);
+    }
+  }
+}
diff --git a/src/test/java/com/rabbitmq/client/test/TestUtils.java b/src/test/java/com/rabbitmq/client/test/TestUtils.java
index 903fb82340..1050c2c15c 100644
--- a/src/test/java/com/rabbitmq/client/test/TestUtils.java
+++ b/src/test/java/com/rabbitmq/client/test/TestUtils.java
@@ -1,4 +1,5 @@
-// Copyright (c) 2007-2023 Broadcom. All Rights Reserved. The term "Broadcom" refers to Broadcom Inc. and/or its subsidiaries.
+// Copyright (c) 2007-2025 Broadcom. All Rights Reserved.
+// The term "Broadcom" refers to Broadcom Inc. and/or its subsidiaries.
 //
 // This software, the RabbitMQ Java client library, is triple-licensed under the
 // Mozilla Public License 2.0 ("MPL"), the GNU General Public License version 2
@@ -12,511 +13,594 @@
 //
 // If you have any questions regarding licensing, please contact us at
 // info@rabbitmq.com.
-
 package com.rabbitmq.client.test;
 
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 import com.rabbitmq.client.*;
 import com.rabbitmq.client.impl.NetworkConnection;
 import com.rabbitmq.client.impl.recovery.AutorecoveringConnection;
 import com.rabbitmq.tools.Host;
+import io.netty.channel.EventLoopGroup;
+import java.io.IOException;
 import java.lang.annotation.Documented;
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
-import java.util.function.Function;
-import org.assertj.core.api.Assertions;
-import org.assertj.core.api.Condition;
-import org.junit.jupiter.api.extension.ConditionEvaluationResult;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.junit.jupiter.api.extension.ExtensionContext;
-import org.junit.jupiter.api.extension.ExtensionContext.Namespace;
-import org.slf4j.LoggerFactory;
-
-import java.io.IOException;
 import java.net.ServerSocket;
 import java.time.Duration;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.List;
 import java.util.concurrent.Callable;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
-
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import java.util.function.Function;
+import org.assertj.core.api.Assertions;
+import org.assertj.core.api.Condition;
+import org.junit.jupiter.api.extension.ConditionEvaluationResult;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.api.extension.ExtensionContext.Namespace;
+import org.slf4j.LoggerFactory;
 
 public class TestUtils {
 
-    public static final boolean USE_NIO = System.getProperty("use.nio") != null;
-
-    public static ConnectionFactory connectionFactory() {
-        ConnectionFactory connectionFactory = new ConnectionFactory();
-        if (USE_NIO) {
-            connectionFactory.useNio();
-        } else {
-            connectionFactory.useBlockingIo();
+  public static final String IO_LAYER = System.getProperty("io.layer", "netty");
+  private static final String IO_SOCKET = "socket";
+  private static final String IO_NIO = "nio";
+  private static final String IO_NETTY = "netty";
+  public static final List<String> IO_LAYERS =
+      Collections.unmodifiableList(Arrays.asList(IO_SOCKET, IO_NIO, IO_NETTY));
+
+  private static final ThreadLocal<EventLoopGroup> EVENT_LOOP_GROUP = new ThreadLocal<>();
+
+  public static ConnectionFactory connectionFactory() {
+    ConnectionFactory connectionFactory = new ConnectionFactory();
+    setIoLayer(connectionFactory);
+    return connectionFactory;
+  }
+
+  public static List<String> ioLayers() {
+    return IO_LAYERS;
+  }
+
+  public static boolean isSocket() {
+    return isSocket(IO_LAYER);
+  }
+
+  public static boolean isNio() {
+    return isNio(IO_LAYER);
+  }
+
+  public static boolean isNetty() {
+    return isNetty(IO_LAYER);
+  }
+
+  private static boolean isSocket(String layer) {
+    return IO_SOCKET.equals(layer);
+  }
+
+  private static boolean isNio(String layer) {
+    return IO_NIO.equals(layer);
+  }
+
+  private static boolean isNetty(String layer) {
+    return IO_NETTY.equals(layer);
+  }
+
+  public static void setIoLayer(ConnectionFactory cf) {
+    setIoLayer(cf, IO_LAYER);
+    if (isNetty()) {
+      cf.netty().eventLoopGroup(EVENT_LOOP_GROUP.get());
+    }
+  }
+
+  public static void setIoLayer(ConnectionFactory cf, String layer) {
+    if (isNio(layer)) {
+      cf.useNio();
+    } else if (isNetty(layer)) {
+      cf.useNetty();
+    } else if (isSocket(layer)) {
+      cf.useBlockingIo();
+    } else {
+      throw new IllegalArgumentException("Unknown IO layer: " + layer);
+    }
+  }
+
+  public static void eventLoopGroup(EventLoopGroup elp) {
+    EVENT_LOOP_GROUP.set(elp);
+  }
+
+  public static void resetEventLoopGroup() {
+    EVENT_LOOP_GROUP.remove();
+  }
+
+  @FunctionalInterface
+  public interface CallableBooleanSupplier {
+
+    boolean getAsBoolean() throws Exception;
+  }
+
+  public static void waitAtMost(CallableBooleanSupplier condition) {
+    waitAtMost(Duration.ofSeconds(10), condition);
+  }
+
+  public static void waitAtMost(Duration timeout, CallableBooleanSupplier condition) {
+    try {
+      if (condition.getAsBoolean()) {
+        return;
+      }
+    } catch (Exception e) {
+      throw new RuntimeException(e);
+    }
+    int waitTime = 100;
+    int waitedTime = 0;
+    long timeoutInMs = timeout.toMillis();
+    while (waitedTime <= timeoutInMs) {
+      try {
+        Thread.sleep(waitTime);
+      } catch (InterruptedException e) {
+        Thread.currentThread().interrupt();
+        throw new RuntimeException(e);
+      }
+      try {
+        if (condition.getAsBoolean()) {
+          return;
         }
-        return connectionFactory;
-    }
-
-    @FunctionalInterface
-    public interface CallableBooleanSupplier {
-
-        boolean getAsBoolean() throws Exception;
-
-    }
-
-    public static void waitAtMost(CallableBooleanSupplier condition) {
-       waitAtMost(Duration.ofSeconds(10), condition);
-    }
+      } catch (Exception e) {
+        throw new RuntimeException(e);
+      }
+      waitedTime += waitTime;
+    }
+    Assertions.fail("Waited " + timeout.getSeconds() + " second(s), condition never got true");
+  }
+
+  public static void close(Connection connection) {
+    if (connection != null) {
+      try {
+        connection.close();
+      } catch (IOException e) {
+        throw new RuntimeException(e);
+      }
+    }
+  }
+
+  public static void abort(Connection connection) {
+    if (connection != null) {
+      connection.abort();
+    }
+  }
+
+  public static boolean atMost312(Connection connection) {
+    return atMostVersion(
+        "3.12.999", currentVersion(connection.getServerProperties().get("version").toString()));
+  }
+
+  public static boolean isVersion37orLater(Connection connection) {
+    return atLeastVersion("3.7.0", connection);
+  }
+
+  public static boolean isVersion38orLater(Connection connection) {
+    return atLeastVersion("3.8.0", connection);
+  }
+
+  public static boolean isVersion310orLater(Connection connection) {
+    return atLeastVersion("3.10.0", connection);
+  }
+
+  private static boolean atLeastVersion(String expectedVersion, Connection connection) {
+    return atLeastVersion(
+        expectedVersion,
+        currentVersion(connection.getServerProperties().get("version").toString()));
+  }
+
+  private static boolean atLeastVersion(String expectedVersion, String currentVersion) {
+    try {
+      return "0.0.0".equals(currentVersion) || versionCompare(currentVersion, expectedVersion) >= 0;
+    } catch (RuntimeException e) {
+      LoggerFactory.getLogger(TestUtils.class)
+          .warn("Unable to parse broker version {}", currentVersion, e);
+      throw e;
+    }
+  }
+
+  private static boolean atMostVersion(String expectedVersion, String currentVersion) {
+    try {
+      return versionCompare(currentVersion, expectedVersion) <= 0;
+    } catch (RuntimeException e) {
+      LoggerFactory.getLogger(TestUtils.class)
+          .warn("Unable to parse broker version {}", currentVersion, e);
+      throw e;
+    }
+  }
+
+  static String currentVersion(String currentVersion) {
+    // versions built from source: 3.7.0+rc.1.4.gedc5d96
+    if (currentVersion.contains("+")) {
+      currentVersion = currentVersion.substring(0, currentVersion.indexOf("+"));
+    }
+    // alpha (snapshot) versions: 3.7.0~alpha.449-1
+    if (currentVersion.contains("~")) {
+      currentVersion = currentVersion.substring(0, currentVersion.indexOf("~"));
+    }
+    // alpha (snapshot) versions: 3.7.1-alpha.40
+    if (currentVersion.contains("-")) {
+      currentVersion = currentVersion.substring(0, currentVersion.indexOf("-"));
+    }
+    return currentVersion;
+  }
+
+  public static boolean sendAndConsumeMessage(
+      String exchange, String routingKey, String queue, Connection c)
+      throws IOException, TimeoutException, InterruptedException {
+    Channel ch = c.createChannel();
+    try {
+      ch.confirmSelect();
+      final CountDownLatch latch = new CountDownLatch(1);
+      ch.basicConsume(
+          queue,
+          true,
+          new DefaultConsumer(ch) {
 
-    public static void waitAtMost(Duration timeout, CallableBooleanSupplier condition) {
-        try {
-            if (condition.getAsBoolean()) {
-                return;
-            }
-        } catch (Exception e) {
-            throw new RuntimeException(e);
-        }
-        int waitTime = 100;
-        int waitedTime = 0;
-        long timeoutInMs = timeout.toMillis();
-        while (waitedTime <= timeoutInMs) {
-            try {
-                Thread.sleep(waitTime);
-            } catch (InterruptedException e) {
-                Thread.currentThread().interrupt();
-                throw new RuntimeException(e);
-            }
-            try {
-                if (condition.getAsBoolean()) {
-                    return;
-                }
-            } catch (Exception e) {
-                throw new RuntimeException(e);
-            }
-            waitedTime += waitTime;
-        }
-        Assertions.fail("Waited " + timeout.getSeconds() + " second(s), condition never got true");
-    }
-
-    public static void close(Connection connection) {
-        if (connection != null) {
-            try {
-                connection.close();
-            } catch (IOException e) {
-                throw new RuntimeException(e);
+            @Override
+            public void handleDelivery(
+                String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body)
+                throws IOException {
+              latch.countDown();
             }
-        }
-    }
-
-    public static void abort(Connection connection) {
-        if (connection != null) {
-            connection.abort();
-        }
-    }
-
-    public static boolean atMost312(Connection connection) {
-        return atMostVersion("3.12.999", currentVersion(connection.getServerProperties().get("version").toString()));
-    }
-
-    public static boolean isVersion37orLater(Connection connection) {
-        return atLeastVersion("3.7.0", connection);
-    }
-
-    public static boolean isVersion38orLater(Connection connection) {
-        return atLeastVersion("3.8.0", connection);
-    }
-
-    public static boolean isVersion310orLater(Connection connection) {
-        return atLeastVersion("3.10.0", connection);
-    }
-
-    private static boolean atLeastVersion(String expectedVersion, Connection connection) {
-        return atLeastVersion(expectedVersion, currentVersion(connection.getServerProperties().get("version").toString()));
-    }
-
-    private static boolean atLeastVersion(String expectedVersion, String currentVersion) {
-        try {
-            return "0.0.0".equals(currentVersion) || versionCompare(currentVersion, expectedVersion) >= 0;
-        } catch (RuntimeException e) {
-            LoggerFactory.getLogger(TestUtils.class).warn("Unable to parse broker version {}", currentVersion, e);
-            throw e;
-        }
-    }
-
-    private static boolean atMostVersion(String expectedVersion, String currentVersion) {
-        try {
-            return versionCompare(currentVersion, expectedVersion) <= 0;
-        } catch (RuntimeException e) {
-            LoggerFactory.getLogger(TestUtils.class).warn("Unable to parse broker version {}", currentVersion, e);
+          });
+      ch.basicPublish(exchange, routingKey, null, "".getBytes());
+      ch.waitForConfirmsOrDie(5000);
+      return latch.await(5, TimeUnit.SECONDS);
+    } finally {
+      if (ch != null && ch.isOpen()) {
+        ch.close();
+      }
+    }
+  }
+
+  public static boolean resourceExists(Callable<Channel> callback) throws Exception {
+    Channel declarePassiveChannel = null;
+    try {
+      declarePassiveChannel = callback.call();
+      return true;
+    } catch (IOException e) {
+      if (e.getCause() instanceof ShutdownSignalException) {
+        ShutdownSignalException cause = (ShutdownSignalException) e.getCause();
+        if (cause.getReason() instanceof AMQP.Channel.Close) {
+          if (((AMQP.Channel.Close) cause.getReason()).getReplyCode() == 404) {
+            return false;
+          } else {
             throw e;
+          }
         }
-    }
-
-    static String currentVersion(String currentVersion) {
-        // versions built from source: 3.7.0+rc.1.4.gedc5d96
-        if (currentVersion.contains("+")) {
-            currentVersion = currentVersion.substring(0, currentVersion.indexOf("+"));
-        }
-        // alpha (snapshot) versions: 3.7.0~alpha.449-1
-        if (currentVersion.contains("~")) {
-            currentVersion = currentVersion.substring(0, currentVersion.indexOf("~"));
-        }
-        // alpha (snapshot) versions: 3.7.1-alpha.40
-        if (currentVersion.contains("-")) {
-            currentVersion = currentVersion.substring(0, currentVersion.indexOf("-"));
-        }
-        return currentVersion;
-    }
-
-    public static boolean sendAndConsumeMessage(String exchange, String routingKey, String queue, Connection c)
-            throws IOException, TimeoutException, InterruptedException {
-        Channel ch = c.createChannel();
-        try {
-            ch.confirmSelect();
-            final CountDownLatch latch = new CountDownLatch(1);
-            ch.basicConsume(queue, true, new DefaultConsumer(ch) {
-
-                @Override
-                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
-                    latch.countDown();
-                }
-            });
-            ch.basicPublish(exchange, routingKey, null, "".getBytes());
-            ch.waitForConfirmsOrDie(5000);
-            return latch.await(5, TimeUnit.SECONDS);
-        } finally {
-            if (ch != null && ch.isOpen()) {
-                ch.close();
-            }
-        }
-    }
-
-    public static boolean resourceExists(Callable<Channel> callback) throws Exception {
-        Channel declarePassiveChannel = null;
-        try {
-            declarePassiveChannel = callback.call();
-            return true;
-        } catch (IOException e) {
-            if (e.getCause() instanceof ShutdownSignalException) {
-                ShutdownSignalException cause = (ShutdownSignalException) e.getCause();
-                if (cause.getReason() instanceof AMQP.Channel.Close) {
-                    if (((AMQP.Channel.Close) cause.getReason()).getReplyCode() == 404) {
-                        return false;
-                    } else {
-                        throw e;
-                    }
-                }
-                return false;
-            } else {
-                throw e;
-            }
-        } finally {
-            if (declarePassiveChannel != null && declarePassiveChannel.isOpen()) {
-                declarePassiveChannel.close();
-            }
-        }
-    }
-
-    public static boolean queueExists(final String queue, final Connection connection) throws Exception {
-        return resourceExists(() -> {
-            Channel channel = connection.createChannel();
-            channel.queueDeclarePassive(queue);
-            return channel;
+        return false;
+      } else {
+        throw e;
+      }
+    } finally {
+      if (declarePassiveChannel != null && declarePassiveChannel.isOpen()) {
+        declarePassiveChannel.close();
+      }
+    }
+  }
+
+  public static boolean queueExists(final String queue, final Connection connection)
+      throws Exception {
+    return resourceExists(
+        () -> {
+          Channel channel = connection.createChannel();
+          channel.queueDeclarePassive(queue);
+          return channel;
         });
-    }
-
-    public static boolean exchangeExists(final String exchange, final Connection connection) throws Exception {
-        return resourceExists(() -> {
-            Channel channel = connection.createChannel();
-            channel.exchangeDeclarePassive(exchange);
-            return channel;
+  }
+
+  public static boolean exchangeExists(final String exchange, final Connection connection)
+      throws Exception {
+    return resourceExists(
+        () -> {
+          Channel channel = connection.createChannel();
+          channel.exchangeDeclarePassive(exchange);
+          return channel;
         });
-    }
-
-    public static void closeAndWaitForRecovery(RecoverableConnection connection) throws IOException, InterruptedException {
-        CountDownLatch latch = prepareForRecovery(connection);
-        Host.closeConnection((NetworkConnection) connection);
-        wait(latch);
-    }
-
-    public static void closeAllConnectionsAndWaitForRecovery(Collection<Connection> connections) throws IOException, InterruptedException {
-        CountDownLatch latch = prepareForRecovery(connections);
-        Host.closeAllConnections();
-        wait(latch);
-    }
-
-    public static void closeAllConnectionsAndWaitForRecovery(Connection connection) throws IOException, InterruptedException {
-        closeAllConnectionsAndWaitForRecovery(Collections.singletonList(connection));
-    }
-
-    public static CountDownLatch prepareForRecovery(Connection connection) {
-        return prepareForRecovery(Collections.singletonList(connection));
-    }
-
-    public static CountDownLatch prepareForRecovery(Collection<Connection> connections) {
-        final CountDownLatch latch = new CountDownLatch(connections.size());
-        for (Connection conn : connections) {
-            ((AutorecoveringConnection) conn).addRecoveryListener(new RecoveryListener() {
+  }
+
+  public static void closeAndWaitForRecovery(RecoverableConnection connection)
+      throws IOException, InterruptedException {
+    CountDownLatch latch = prepareForRecovery(connection);
+    Host.closeConnection((NetworkConnection) connection);
+    wait(latch);
+  }
+
+  public static void closeAllConnectionsAndWaitForRecovery(Collection<Connection> connections)
+      throws IOException, InterruptedException {
+    CountDownLatch latch = prepareForRecovery(connections);
+    Host.closeAllConnections();
+    wait(latch);
+  }
+
+  public static void closeAllConnectionsAndWaitForRecovery(Connection connection)
+      throws IOException, InterruptedException {
+    closeAllConnectionsAndWaitForRecovery(Collections.singletonList(connection));
+  }
+
+  public static CountDownLatch prepareForRecovery(Connection connection) {
+    return prepareForRecovery(Collections.singletonList(connection));
+  }
+
+  public static CountDownLatch prepareForRecovery(Collection<Connection> connections) {
+    final CountDownLatch latch = new CountDownLatch(connections.size());
+    for (Connection conn : connections) {
+      ((AutorecoveringConnection) conn)
+          .addRecoveryListener(
+              new RecoveryListener() {
 
                 @Override
                 public void handleRecovery(Recoverable recoverable) {
-                    latch.countDown();
+                  latch.countDown();
                 }
 
                 @Override
                 public void handleRecoveryStarted(Recoverable recoverable) {
-                    // No-op
+                  // No-op
                 }
-            });
-        }
-        return latch;
-    }
-
-    private static void wait(CountDownLatch latch) throws InterruptedException {
-        assertTrue(latch.await(90, TimeUnit.SECONDS));
-    }
-
-    /**
-     * https://stackoverflow.com/questions/6701948/efficient-way-to-compare-version-strings-in-java
-     */
-    static int versionCompare(String str1, String str2) {
-        String[] vals1 = str1.split("\\.");
-        String[] vals2 = str2.split("\\.");
-        int i = 0;
-        // set index to first non-equal ordinal or length of shortest version string
-        while (i < vals1.length && i < vals2.length && vals1[i].equals(vals2[i])) {
-            i++;
-        }
-        // compare first non-equal ordinal number
-        if (i < vals1.length && i < vals2.length) {
-            int diff = Integer.valueOf(vals1[i]).compareTo(Integer.valueOf(vals2[i]));
-            return Integer.signum(diff);
-        }
-        // the strings are equal or one string is a substring of the other
-        // e.g. "1.2.3" = "1.2.3" or "1.2.3" < "1.2.3.4"
-        return Integer.signum(vals1.length - vals2.length);
-    }
-
-    public static int randomNetworkPort() throws IOException {
-        ServerSocket socket = new ServerSocket();
-        socket.bind(null);
-        int port = socket.getLocalPort();
-        socket.close();
-        return port;
-    }
-
-    @FunctionalInterface
-    public interface CallableFunction<T, R> {
-
-        R apply(T t) throws Exception;
-
-    }
-
-    public static class LatchConditions {
-
-        static Condition<CountDownLatch> completed() {
-            return new Condition<>(
-                countDownLatch-> {
-                    try {
-                        return countDownLatch.await(10, TimeUnit.SECONDS);
-                    } catch (InterruptedException e) {
-                        throw new RuntimeException(e);
-                    }
-                },
-                "Latch did not complete in 10 seconds");
-        }
-
-    }
-
-    public static boolean basicGetBasicConsume(Connection connection, String queue, final CountDownLatch latch, int msgSize)
-        throws Exception {
-        Channel channel = connection.createChannel();
-        channel.queueDeclare(queue, false, true, false, null);
-        channel.queuePurge(queue);
-
-        channel.basicPublish("", queue, null, new byte[msgSize]);
-
-        String tag = channel.basicConsume(queue, false, new DefaultConsumer(channel) {
-
-            @Override
-            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
+              });
+    }
+    return latch;
+  }
+
+  private static void wait(CountDownLatch latch) throws InterruptedException {
+    assertTrue(latch.await(90, TimeUnit.SECONDS));
+  }
+
+  /**
+   * https://stackoverflow.com/questions/6701948/efficient-way-to-compare-version-strings-in-java
+   */
+  static int versionCompare(String str1, String str2) {
+    String[] vals1 = str1.split("\\.");
+    String[] vals2 = str2.split("\\.");
+    int i = 0;
+    // set index to first non-equal ordinal or length of shortest version string
+    while (i < vals1.length && i < vals2.length && vals1[i].equals(vals2[i])) {
+      i++;
+    }
+    // compare first non-equal ordinal number
+    if (i < vals1.length && i < vals2.length) {
+      int diff = Integer.valueOf(vals1[i]).compareTo(Integer.valueOf(vals2[i]));
+      return Integer.signum(diff);
+    }
+    // the strings are equal or one string is a substring of the other
+    // e.g. "1.2.3" = "1.2.3" or "1.2.3" < "1.2.3.4"
+    return Integer.signum(vals1.length - vals2.length);
+  }
+
+  public static int randomNetworkPort() throws IOException {
+    ServerSocket socket = new ServerSocket();
+    socket.bind(null);
+    int port = socket.getLocalPort();
+    socket.close();
+    return port;
+  }
+
+  @FunctionalInterface
+  public interface CallableFunction<T, R> {
+
+    R apply(T t) throws Exception;
+  }
+
+  public static class LatchConditions {
+
+    public static Condition<CountDownLatch> completed() {
+      return new Condition<>(
+          countDownLatch -> {
+            try {
+              return countDownLatch.await(10, TimeUnit.SECONDS);
+            } catch (InterruptedException e) {
+              throw new RuntimeException(e);
+            }
+          },
+          "Latch did not complete in 10 seconds");
+    }
+  }
+
+  public static boolean basicGetBasicConsume(
+      Connection connection, String queue, final CountDownLatch latch, int msgSize)
+      throws Exception {
+    Channel channel = connection.createChannel();
+    channel.queueDeclare(queue, false, true, false, null);
+    channel.queuePurge(queue);
+
+    channel.basicPublish("", queue, null, new byte[msgSize]);
+
+    String tag =
+        channel.basicConsume(
+            queue,
+            false,
+            new DefaultConsumer(channel) {
+
+              @Override
+              public void handleDelivery(
+                  String consumerTag,
+                  Envelope envelope,
+                  AMQP.BasicProperties properties,
+                  byte[] body)
+                  throws IOException {
                 getChannel().basicAck(envelope.getDeliveryTag(), false);
                 latch.countDown();
-            }
-        });
-
-        boolean messageReceived = latch.await(20, TimeUnit.SECONDS);
-
-        channel.basicCancel(tag);
-
-        return messageReceived;
-    }
-
-    /*
-    public static class DefaultTestSuite extends Suite {
-
-
-        public DefaultTestSuite(Class<?> klass, RunnerBuilder builder)
-            throws InitializationError {
-            super(klass, builder);
-        }
-
-        public DefaultTestSuite(RunnerBuilder builder, Class<?>[] classes)
-            throws InitializationError {
-            super(builder, classes);
-        }
-
-        protected DefaultTestSuite(Class<?> klass, Class<?>[] suiteClasses)
-            throws InitializationError {
-            super(klass, suiteClasses);
-        }
-
-        protected DefaultTestSuite(RunnerBuilder builder, Class<?> klass, Class<?>[] suiteClasses)
-            throws InitializationError {
-            super(builder, klass, suiteClasses);
-        }
-
-        @Override
-        protected void runChild(Runner runner, RunNotifier notifier) {
-            LOGGER.info("Running test {}", runner.getDescription().getDisplayName());
-            super.runChild(runner, notifier);
-        }
+              }
+            });
 
-        protected DefaultTestSuite(Class<?> klass, List<Runner> runners)
-            throws InitializationError {
-            super(klass, runners);
+    boolean messageReceived = latch.await(20, TimeUnit.SECONDS);
+
+    channel.basicCancel(tag);
+
+    return messageReceived;
+  }
+
+  /*
+  public static class DefaultTestSuite extends Suite {
+
+
+      public DefaultTestSuite(Class<?> klass, RunnerBuilder builder)
+          throws InitializationError {
+          super(klass, builder);
+      }
+
+      public DefaultTestSuite(RunnerBuilder builder, Class<?>[] classes)
+          throws InitializationError {
+          super(builder, classes);
+      }
+
+      protected DefaultTestSuite(Class<?> klass, Class<?>[] suiteClasses)
+          throws InitializationError {
+          super(klass, suiteClasses);
+      }
+
+      protected DefaultTestSuite(RunnerBuilder builder, Class<?> klass, Class<?>[] suiteClasses)
+          throws InitializationError {
+          super(builder, klass, suiteClasses);
+      }
+
+      @Override
+      protected void runChild(Runner runner, RunNotifier notifier) {
+          LOGGER.info("Running test {}", runner.getDescription().getDisplayName());
+          super.runChild(runner, notifier);
+      }
+
+      protected DefaultTestSuite(Class<?> klass, List<Runner> runners)
+          throws InitializationError {
+          super(klass, runners);
+      }
+  }
+
+   */
+
+  public static void safeDelete(Connection connection, String queue) {
+    try {
+      Channel ch = connection.createChannel();
+      ch.queueDelete(queue);
+      ch.close();
+    } catch (Exception e) {
+      // OK
+    }
+  }
+
+  private static class BaseBrokerVersionAtLeastCondition
+      implements org.junit.jupiter.api.extension.ExecutionCondition {
+
+    private final Function<ExtensionContext, String> versionProvider;
+
+    private BaseBrokerVersionAtLeastCondition(Function<ExtensionContext, String> versionProvider) {
+      this.versionProvider = versionProvider;
+    }
+
+    @Override
+    public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext context) {
+      if (!context.getTestMethod().isPresent()) {
+        return ConditionEvaluationResult.enabled("Apply only to methods");
+      }
+      String expectedVersion = versionProvider.apply(context);
+      if (expectedVersion == null) {
+        return ConditionEvaluationResult.enabled("No broker version requirement");
+      } else {
+        String brokerVersion =
+            context
+                .getRoot()
+                .getStore(Namespace.GLOBAL)
+                .getOrComputeIfAbsent(
+                    "brokerVersion",
+                    k -> {
+                      try (Connection c = TestUtils.connectionFactory().newConnection()) {
+                        return currentVersion(c.getServerProperties().get("version").toString());
+                      } catch (Exception e) {
+                        throw new RuntimeException(e);
+                      }
+                    },
+                    String.class);
+
+        if (atLeastVersion(expectedVersion, brokerVersion)) {
+          return ConditionEvaluationResult.enabled(
+              "Broker version requirement met, expected "
+                  + expectedVersion
+                  + ", actual "
+                  + brokerVersion);
+        } else {
+          return ConditionEvaluationResult.disabled(
+              "Broker version requirement not met, expected "
+                  + expectedVersion
+                  + ", actual "
+                  + brokerVersion);
         }
+      }
     }
+  }
 
-     */
+  private static class AnnotationBrokerVersionAtLeastCondition
+      extends BaseBrokerVersionAtLeastCondition {
 
-    public static void safeDelete(Connection connection, String queue) {
-        try {
-            Channel ch = connection.createChannel();
-            ch.queueDelete(queue);
-            ch.close();
-        } catch (Exception e) {
-            // OK
-        }
+    private AnnotationBrokerVersionAtLeastCondition() {
+      super(
+          context -> {
+            BrokerVersionAtLeast annotation =
+                context.getElement().get().getAnnotation(BrokerVersionAtLeast.class);
+            return annotation == null ? null : annotation.value().toString();
+          });
     }
+  }
 
-    private static class BaseBrokerVersionAtLeastCondition implements
-        org.junit.jupiter.api.extension.ExecutionCondition {
-
-        private final Function<ExtensionContext, String> versionProvider;
-
-        private BaseBrokerVersionAtLeastCondition(Function<ExtensionContext, String> versionProvider) {
-            this.versionProvider = versionProvider;
-        }
+  static class BrokerVersionAtLeast310Condition extends BaseBrokerVersionAtLeastCondition {
 
-        @Override
-        public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext context) {
-            if (!context.getTestMethod().isPresent()) {
-                return ConditionEvaluationResult.enabled("Apply only to methods");
-            }
-            String expectedVersion = versionProvider.apply(context);
-            if (expectedVersion == null) {
-                return ConditionEvaluationResult.enabled("No broker version requirement");
-            } else {
-                String brokerVersion =
-                    context
-                        .getRoot()
-                        .getStore(Namespace.GLOBAL)
-                        .getOrComputeIfAbsent(
-                            "brokerVersion",
-                            k -> {
-                                try (Connection c = TestUtils.connectionFactory().newConnection()) {
-                                    return currentVersion(
-                                        c.getServerProperties().get("version").toString()
-                                    );
-                                } catch (Exception e) {
-                                    throw new RuntimeException(e);
-                                }
-                            },
-                            String.class);
-
-                if (atLeastVersion(expectedVersion, brokerVersion)) {
-                    return ConditionEvaluationResult.enabled(
-                        "Broker version requirement met, expected "
-                            + expectedVersion
-                            + ", actual "
-                            + brokerVersion);
-                } else {
-                    return ConditionEvaluationResult.disabled(
-                        "Broker version requirement not met, expected "
-                            + expectedVersion
-                            + ", actual "
-                            + brokerVersion);
-                }
-            }
-        }
+    private BrokerVersionAtLeast310Condition() {
+      super(context -> "3.10.0");
     }
+  }
 
-    private static class AnnotationBrokerVersionAtLeastCondition
-        extends BaseBrokerVersionAtLeastCondition {
+  @Target({ElementType.TYPE, ElementType.METHOD})
+  @Retention(RetentionPolicy.RUNTIME)
+  @Documented
+  @ExtendWith(AnnotationBrokerVersionAtLeastCondition.class)
+  public @interface BrokerVersionAtLeast {
 
-        private AnnotationBrokerVersionAtLeastCondition() {
-            super(
-                context -> {
-                    BrokerVersionAtLeast annotation =
-                        context.getElement().get().getAnnotation(BrokerVersionAtLeast.class);
-                    return annotation == null ? null : annotation.value().toString();
-                });
-        }
-    }
+    BrokerVersion value();
+  }
 
-    static class BrokerVersionAtLeast310Condition extends BaseBrokerVersionAtLeastCondition {
+  public enum BrokerVersion {
+    RABBITMQ_3_8("3.8.0"),
+    RABBITMQ_3_10("3.10.0"),
+    RABBITMQ_4_0("4.0.0");
 
-        private BrokerVersionAtLeast310Condition() {
-            super(context -> "3.10.0");
-        }
-    }
-
-    @Target({ElementType.TYPE, ElementType.METHOD})
-    @Retention(RetentionPolicy.RUNTIME)
-    @Documented
-    @ExtendWith(AnnotationBrokerVersionAtLeastCondition.class)
-    public @interface BrokerVersionAtLeast {
+    final String value;
 
-        BrokerVersion value();
+    BrokerVersion(String value) {
+      this.value = value;
     }
 
-    public enum BrokerVersion {
-        RABBITMQ_3_8("3.8.0"),
-        RABBITMQ_3_10("3.10.0"),
-        RABBITMQ_4_0("4.0.0");
-
-        final String value;
-
-        BrokerVersion(String value) {
-            this.value = value;
-        }
-
-        @Override
-        public String toString() {
-            return this.value;
-        }
+    @Override
+    public String toString() {
+      return this.value;
     }
+  }
 
-    static class DisabledIfBrokerRunningOnDockerCondition implements
-        org.junit.jupiter.api.extension.ExecutionCondition {
+  static class DisabledIfBrokerRunningOnDockerCondition
+      implements org.junit.jupiter.api.extension.ExecutionCondition {
 
-        @Override
-        public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext context) {
-            if (Host.isOnDocker()) {
-                return ConditionEvaluationResult.disabled("Broker running on Docker");
-            } else {
-                return ConditionEvaluationResult.enabled("Broker not running on Docker");
-            }
-        }
+    @Override
+    public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext context) {
+      if (Host.isOnDocker()) {
+        return ConditionEvaluationResult.disabled("Broker running on Docker");
+      } else {
+        return ConditionEvaluationResult.enabled("Broker not running on Docker");
+      }
     }
+  }
 
-    @Target({ElementType.TYPE, ElementType.METHOD})
-    @Retention(RetentionPolicy.RUNTIME)
-    @Documented
-    @ExtendWith(DisabledIfBrokerRunningOnDockerCondition.class)
-    @interface DisabledIfBrokerRunningOnDocker {}
-
+  @Target({ElementType.TYPE, ElementType.METHOD})
+  @Retention(RetentionPolicy.RUNTIME)
+  @Documented
+  @ExtendWith(DisabledIfBrokerRunningOnDockerCondition.class)
+  @interface DisabledIfBrokerRunningOnDocker {}
 }
diff --git a/src/test/java/com/rabbitmq/client/test/functional/FrameMax.java b/src/test/java/com/rabbitmq/client/test/functional/FrameMax.java
index 4ca81aebc6..65b14e26e9 100644
--- a/src/test/java/com/rabbitmq/client/test/functional/FrameMax.java
+++ b/src/test/java/com/rabbitmq/client/test/functional/FrameMax.java
@@ -16,21 +16,20 @@
 
 package com.rabbitmq.client.test.functional;
 
+import static com.rabbitmq.client.test.TestUtils.LatchConditions.completed;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
 
-import java.io.ByteArrayOutputStream;
-import java.io.DataOutputStream;
 import java.io.IOException;
-import java.net.Socket;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.TimeoutException;
 
-import com.rabbitmq.client.impl.AMQBasicProperties;
 import com.rabbitmq.client.test.TestUtils;
 import org.junit.jupiter.api.Test;
 
@@ -41,22 +40,21 @@
 import com.rabbitmq.client.GetResponse;
 import com.rabbitmq.client.impl.AMQCommand;
 import com.rabbitmq.client.impl.AMQConnection;
-import com.rabbitmq.client.impl.ContentHeaderPropertyWriter;
 import com.rabbitmq.client.impl.Frame;
 import com.rabbitmq.client.impl.FrameHandler;
 import com.rabbitmq.client.impl.LongStringHelper;
-import com.rabbitmq.client.impl.SocketFrameHandler;
 import com.rabbitmq.client.test.BrokerTestCase;
 
 public class FrameMax extends BrokerTestCase {
     /* This value for FrameMax is larger than the minimum and less
      * than what Rabbit suggests. */
     final static int FRAME_MAX = 70000;
-    final static int REAL_FRAME_MAX = FRAME_MAX - 8;
 
-    public FrameMax() {
-        connectionFactory = new MyConnectionFactory();
-        connectionFactory.setRequestedFrameMax(FRAME_MAX);
+    @Override
+    protected ConnectionFactory newConnectionFactory() {
+        ConnectionFactory cf = super.newConnectionFactory();
+        cf.setRequestedFrameMax(FRAME_MAX);
+        return cf;
     }
 
     @Test public void negotiationOk() {
@@ -66,9 +64,7 @@ public FrameMax() {
     /* Publish a message of size FRAME_MAX.  The broker should split
      * this into two frames before sending back.  Frame content should
      * be less or equal to frame-max - 8. */
-    @Test public void frameSizes()
-        throws IOException, InterruptedException
-    {
+    @Test public void frameSizes() throws IOException {
         String queueName = channel.queueDeclare().getQueue();
         /* This should result in at least 3 frames. */
         int howMuch = 2*FRAME_MAX;
@@ -79,7 +75,6 @@ public FrameMax() {
                 GetResponse response = channel.basicGet(queueName, false);
                 howMuch -= response.getBody().length;
             } catch (Exception e) {
-                e.printStackTrace();
                 fail("Exception in basicGet loop: " + e);
             }
         }
@@ -87,8 +82,7 @@ public FrameMax() {
 
     /* server should reject frames larger than AMQP.FRAME_MIN_SIZE
      * during connection negotiation */
-    @Test public void rejectLargeFramesDuringConnectionNegotiation()
-            throws IOException, TimeoutException {
+    @Test public void rejectLargeFramesDuringConnectionNegotiation() throws TimeoutException {
         ConnectionFactory cf = TestUtils.connectionFactory();
         cf.getClientProperties().put("too_long", LongStringHelper.asLongString(new byte[AMQP.FRAME_MIN_SIZE]));
         try {
@@ -100,8 +94,7 @@ public FrameMax() {
 
     /* server should reject frames larger than the negotiated frame
      * size */
-    @Test public void rejectExceedingFrameMax()
-            throws IOException, TimeoutException {
+    @Test public void rejectExceedingFrameMax() throws IOException, TimeoutException {
         closeChannel();
         closeConnection();
         ConnectionFactory cf = new GenerousConnectionFactory();
@@ -114,8 +107,7 @@ public FrameMax() {
 
     /* client should throw exception if headers exceed negotiated
      * frame size */
-    @Test public void rejectHeadersExceedingFrameMax()
-            throws IOException, TimeoutException {
+    @Test public void rejectHeadersExceedingFrameMax() throws IOException {
         declareTransientTopicExchange("x");
         String queueName = channel.queueDeclare().getQueue();
         channel.queueBind(queueName, "x", "foobar");
@@ -164,17 +156,17 @@ public FrameMax() {
         cf.setRequestedFrameMax(0);
         connection = cf.newConnection();
         openChannel();
+        channel.confirmSelect();
+        CountDownLatch confirmLatch = new CountDownLatch(1);
+        channel.addConfirmListener((deliveryTag, multiple) -> confirmLatch.countDown(), (dtag, m) -> { });
 
-        Map<String, Object> headers = new HashMap<String, Object>();
-        headers.put("h1", LongStringHelper.asLongString(new byte[250]));
-        headers.put("h1", LongStringHelper.asLongString(new byte[500]));
-        headers.put("h1", LongStringHelper.asLongString(new byte[750]));
-        headers.put("h1", LongStringHelper.asLongString(new byte[5000]));
+        Map<String, Object> headers = new HashMap<>();
         headers.put("h1", LongStringHelper.asLongString(new byte[50000]));
         AMQP.BasicProperties properties = new AMQP.BasicProperties.Builder()
                                                   .headers(headers)
                                                   .build();
         basicPublishVolatile(new byte[500000], "", "", properties);
+        assertThat(confirmLatch).is(completed());
     }
 
     @Override
@@ -182,44 +174,6 @@ protected boolean isAutomaticRecoveryEnabled() {
         return false;
     }
 
-    /* ConnectionFactory that uses MyFrameHandler rather than
-     * SocketFrameHandler. */
-    private static class MyConnectionFactory extends ConnectionFactory {
-
-        public MyConnectionFactory() {
-            super();
-            if(TestUtils.USE_NIO) {
-                useNio();
-            } else {
-                useBlockingIo();
-            }
-        }
-
-        protected FrameHandler createFrameHandler(Socket sock)
-            throws IOException
-        {
-            return new MyFrameHandler(sock);
-        }
-    }
-
-    /* FrameHandler with added frame-max error checking. */
-    private static class MyFrameHandler extends SocketFrameHandler {
-        public MyFrameHandler(Socket socket)
-            throws IOException
-        {
-            super(socket);
-        }
-
-        public Frame readFrame() throws IOException {
-            Frame f = super.readFrame();
-            int size = f.getPayload().length;
-            if (size > REAL_FRAME_MAX)
-                fail("Received frame of size " + size
-                     + ", which exceeds " + REAL_FRAME_MAX + ".");
-            //System.out.printf("Received a frame of size %d.\n", f.getPayload().length);
-            return f;
-        }
-    }
 
     /*
       AMQConnection with a frame_max that is one higher than what it
@@ -245,11 +199,7 @@ private static class GenerousConnectionFactory extends ConnectionFactory {
 
         public GenerousConnectionFactory() {
             super();
-            if(TestUtils.USE_NIO) {
-                useNio();
-            } else {
-                useBlockingIo();
-            }
+            TestUtils.setIoLayer(this);
         }
 
         @Override public Connection newConnection(ExecutorService executor, List<Address> addrs)
diff --git a/src/test/java/com/rabbitmq/client/test/functional/FunctionalTestSuite.java b/src/test/java/com/rabbitmq/client/test/functional/FunctionalTestSuite.java
index 4fef629cf4..330dbb6c0a 100644
--- a/src/test/java/com/rabbitmq/client/test/functional/FunctionalTestSuite.java
+++ b/src/test/java/com/rabbitmq/client/test/functional/FunctionalTestSuite.java
@@ -23,62 +23,62 @@
 
 @Suite
 @SelectClasses({
-	ConnectionOpen.class,
-	Heartbeat.class,
-	Tables.class,
-	DoubleDeletion.class,
-	Routing.class,
-	BindingLifecycle.class,
-	Recover.class,
-	Reject.class,
-	Transactions.class,
-	RequeueOnConnectionClose.class,
-	RequeueOnChannelClose.class,
-	DurableOnTransient.class,
-    NoRequeueOnCancel.class,
-    Bug20004Test.class,
-    ExchangeDeleteIfUnused.class,
-    QosTests.class,
-    AlternateExchange.class,
-    ExchangeExchangeBindings.class,
-    ExchangeExchangeBindingsAutoDelete.class,
-    ExchangeDeclare.class,
-    FrameMax.class,
-    QueueLifecycle.class,
-    QueueLease.class,
-    QueueExclusivity.class,
-    QueueSizeLimit.class,
-    InvalidAcks.class,
-    InvalidAcksTx.class,
-    DefaultExchange.class,
-    UnbindAutoDeleteExchange.class,
-    Confirm.class,
-    ConsumerNotifications.class,
-    UnexpectedFrames.class,
-    PerQueueTTL.class,
-    PerMessageTTL.class,
-    PerQueueVsPerMessageTTL.class,
-    DeadLetterExchange.class,
-    SaslMechanisms.class,
-    UserIDHeader.class,
-    InternalExchange.class,
-    CcRoutes.class,
-    WorkPoolTests.class,
-    HeadersExchangeValidation.class,
-    ConsumerPriorities.class,
-    Policies.class,
-    ConnectionRecovery.class,
-    ExceptionHandling.class,
-    PerConsumerPrefetch.class,
-    DirectReplyTo.class,
-	ConsumerCount.class,
-	BasicGet.class,
-	Nack.class,
-	ExceptionMessages.class,
-	Metrics.class,
-	MicrometerObservationCollectorMetrics.class,
-	TopologyRecoveryFiltering.class,
-	TopologyRecoveryRetry.class
+		ConnectionOpen.class,
+		Heartbeat.class,
+		Tables.class,
+		DoubleDeletion.class,
+		Routing.class,
+		BindingLifecycle.class,
+		Recover.class,
+		Reject.class,
+		Transactions.class,
+		RequeueOnConnectionClose.class,
+		RequeueOnChannelClose.class,
+		DurableOnTransient.class,
+		NoRequeueOnCancel.class,
+		Bug20004Test.class,
+		ExchangeDeleteIfUnused.class,
+		QosTests.class,
+		AlternateExchange.class,
+		ExchangeExchangeBindings.class,
+		ExchangeExchangeBindingsAutoDelete.class,
+		ExchangeDeclare.class,
+		FrameMax.class,
+		QueueLifecycle.class,
+		QueueLease.class,
+		QueueExclusivity.class,
+		QueueSizeLimit.class,
+		InvalidAcks.class,
+		InvalidAcksTx.class,
+		DefaultExchange.class,
+		UnbindAutoDeleteExchange.class,
+		Confirm.class,
+		ConsumerNotifications.class,
+		UnexpectedFrames.class,
+		PerQueueTTL.class,
+		PerMessageTTL.class,
+		PerQueueVsPerMessageTTL.class,
+		DeadLetterExchange.class,
+		SaslMechanisms.class,
+		UserIDHeader.class,
+		InternalExchange.class,
+		CcRoutes.class,
+		WorkPoolTests.class,
+		HeadersExchangeValidation.class,
+		ConsumerPriorities.class,
+		Policies.class,
+		ConnectionRecovery.class,
+		ExceptionHandling.class,
+		PerConsumerPrefetch.class,
+		DirectReplyTo.class,
+		ConsumerCount.class,
+		BasicGet.class,
+		Nack.class,
+		ExceptionMessages.class,
+		Metrics.class,
+		MicrometerObservationCollectorMetrics.class,
+		TopologyRecoveryFiltering.class,
+		TopologyRecoveryRetry.class
 })
 public class FunctionalTestSuite {
 
diff --git a/src/test/java/com/rabbitmq/client/test/functional/Heartbeat.java b/src/test/java/com/rabbitmq/client/test/functional/Heartbeat.java
index 9a327e2ff8..bbee6e3955 100644
--- a/src/test/java/com/rabbitmq/client/test/functional/Heartbeat.java
+++ b/src/test/java/com/rabbitmq/client/test/functional/Heartbeat.java
@@ -1,4 +1,5 @@
-// Copyright (c) 2007-2023 Broadcom. All Rights Reserved. The term "Broadcom" refers to Broadcom Inc. and/or its subsidiaries.
+// Copyright (c) 2007-2025 Broadcom. All Rights Reserved. The term "Broadcom" refers to Broadcom
+// Inc. and/or its subsidiaries.
 //
 // This software, the RabbitMQ Java client library, is triple-licensed under the
 // Mozilla Public License 2.0 ("MPL"), the GNU General Public License version 2
@@ -13,37 +14,65 @@
 // If you have any questions regarding licensing, please contact us at
 // info@rabbitmq.com.
 
-
 package com.rabbitmq.client.test.functional;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.*;
+
+import com.rabbitmq.client.Connection;
 import com.rabbitmq.client.ConnectionFactory;
 import com.rabbitmq.client.impl.recovery.AutorecoveringConnection;
 import com.rabbitmq.client.test.BrokerTestCase;
+import com.rabbitmq.client.test.TestUtils;
+import io.netty.handler.traffic.ChannelTrafficShapingHandler;
+import io.netty.handler.traffic.TrafficCounter;
+import java.time.Duration;
 import org.junit.jupiter.api.Test;
 
-import java.io.IOException;
+public class Heartbeat extends BrokerTestCase {
 
-import static org.junit.jupiter.api.Assertions.*;
+  @Override
+  protected ConnectionFactory newConnectionFactory() {
+    ConnectionFactory cf = super.newConnectionFactory();
+    cf.setRequestedHeartbeat(1);
+    return cf;
+  }
 
-public class Heartbeat extends BrokerTestCase {
+  @Test
+  public void heartbeat() throws InterruptedException {
+    assertEquals(1, connection.getHeartbeat());
+    Thread.sleep(3100);
+    assertTrue(connection.isOpen());
+    ((AutorecoveringConnection) connection).getDelegate().setHeartbeat(0);
+    assertEquals(0, connection.getHeartbeat());
+    Thread.sleep(3100);
+    assertFalse(connection.isOpen());
+  }
 
-    @Override
-    protected ConnectionFactory newConnectionFactory() {
-        ConnectionFactory cf = super.newConnectionFactory();
-        cf.setRequestedHeartbeat(1);
-        return cf;
-    }
+  @Test
+  void nettyHeartbeat() throws Exception {
+    ChannelTrafficShapingHandler channelTrafficShapingHandler =
+        new ChannelTrafficShapingHandler(0, 0);
+    ConnectionFactory cf = TestUtils.connectionFactory();
+    cf.netty().channelCustomizer(ch -> ch.pipeline().addFirst(channelTrafficShapingHandler));
+    cf.setRequestedHeartbeat(2);
+    try (Connection c = cf.newConnection()) {
+      TrafficCounter trafficCounter = channelTrafficShapingHandler.trafficCounter();
+      long writtenAfterOpening = trafficCounter.cumulativeWrittenBytes();
+      long readAfterOpening = trafficCounter.currentReadBytes();
 
-    @Test
-    public void heartbeat() throws InterruptedException {
-        assertEquals(1, connection.getHeartbeat());
-        Thread.sleep(3100);
-        assertTrue(connection.isOpen());
-        ((AutorecoveringConnection) connection).getDelegate().setHeartbeat(0);
-        assertEquals(0, connection.getHeartbeat());
-        Thread.sleep(3100);
-        assertFalse(connection.isOpen());
+      int heartbeatFrameSize = 4 + 2 + 2;
+      int heartbeatFrameCount = 3;
+      int expectedAdditionalBytes = heartbeatFrameCount * heartbeatFrameSize;
 
+      TestUtils.waitAtMost(
+          Duration.ofSeconds(15),
+          () ->
+              trafficCounter.cumulativeWrittenBytes()
+                      >= writtenAfterOpening + expectedAdditionalBytes
+                  && trafficCounter.cumulativeReadBytes()
+                      >= readAfterOpening + expectedAdditionalBytes);
+      assertThat(c.isOpen()).isTrue();
     }
-
+  }
 }
diff --git a/src/test/java/com/rabbitmq/client/test/functional/UnexpectedFrames.java b/src/test/java/com/rabbitmq/client/test/functional/UnexpectedFrames.java
index 28e4c92365..0cefc4021a 100644
--- a/src/test/java/com/rabbitmq/client/test/functional/UnexpectedFrames.java
+++ b/src/test/java/com/rabbitmq/client/test/functional/UnexpectedFrames.java
@@ -71,11 +71,7 @@ private static class ConfusedConnectionFactory extends ConnectionFactory {
 
         public ConfusedConnectionFactory() {
             super();
-            if(TestUtils.USE_NIO) {
-                useNio();
-            } else {
-                useBlockingIo();
-            }
+            TestUtils.setIoLayer(this);
         }
 
         @Override protected FrameHandlerFactory createFrameHandlerFactory() {
diff --git a/src/test/java/com/rabbitmq/client/test/ssl/BadVerifiedConnection.java b/src/test/java/com/rabbitmq/client/test/ssl/BadVerifiedConnection.java
index ca71ea4c0f..c4d30f5868 100644
--- a/src/test/java/com/rabbitmq/client/test/ssl/BadVerifiedConnection.java
+++ b/src/test/java/com/rabbitmq/client/test/ssl/BadVerifiedConnection.java
@@ -38,6 +38,8 @@ public void openConnection()
         try {
             SSLContext c = TlsTestUtils.badVerifiedSslContext();
             connectionFactory.useSslProtocol(c);
+            TlsTestUtils.maybeConfigureNetty(connectionFactory, c);
+
         } catch (Exception ex) {
             throw new IOException(ex);
         }
diff --git a/src/test/java/com/rabbitmq/client/test/ssl/HostnameVerification.java b/src/test/java/com/rabbitmq/client/test/ssl/HostnameVerification.java
index efdfcb57d6..0c5dd30089 100644
--- a/src/test/java/com/rabbitmq/client/test/ssl/HostnameVerification.java
+++ b/src/test/java/com/rabbitmq/client/test/ssl/HostnameVerification.java
@@ -19,6 +19,7 @@
 import com.rabbitmq.client.Connection;
 import com.rabbitmq.client.ConnectionFactory;
 import com.rabbitmq.client.test.TestUtils;
+import io.netty.handler.ssl.SslContextBuilder;
 import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.condition.EnabledForJreRange;
@@ -38,10 +39,22 @@ public class HostnameVerification {
 
     static SSLContext sslContext;
 
-    public static Object[] data() {
-        return new Object[] {
+    @SuppressWarnings("unchecked")
+    public static Consumer<ConnectionFactory>[] data() {
+        return new Consumer[] {
             blockingIo(enableHostnameVerification()),
             nio(enableHostnameVerification()),
+            (Consumer<ConnectionFactory>) cf -> {
+                try {
+                    cf.netty().sslContext(SslContextBuilder.forClient()
+                        .trustManager(TlsTestUtils.caCertificate())
+                        // hostname verification enabled by default in Netty 4.2
+                        //.endpointIdentificationAlgorithm("HTTPS")
+                        .build());
+                } catch (Exception e) {
+                    throw new RuntimeException(e);
+                }
+            }
         };
     }
 
@@ -60,7 +73,7 @@ private static Consumer<ConnectionFactory> nio(final Consumer<ConnectionFactory>
     }
 
     private static Consumer<ConnectionFactory> enableHostnameVerification() {
-        return connectionFactory -> connectionFactory.enableHostnameVerification();
+        return ConnectionFactory::enableHostnameVerification;
     }
 
     @BeforeAll
diff --git a/src/test/java/com/rabbitmq/client/test/SslContextFactoryTest.java b/src/test/java/com/rabbitmq/client/test/ssl/SslContextFactoryTest.java
similarity index 76%
rename from src/test/java/com/rabbitmq/client/test/SslContextFactoryTest.java
rename to src/test/java/com/rabbitmq/client/test/ssl/SslContextFactoryTest.java
index c207901502..b3b959c298 100644
--- a/src/test/java/com/rabbitmq/client/test/SslContextFactoryTest.java
+++ b/src/test/java/com/rabbitmq/client/test/ssl/SslContextFactoryTest.java
@@ -13,12 +13,12 @@
 // If you have any questions regarding licensing, please contact us at
 // info@rabbitmq.com.
 
-package com.rabbitmq.client.test;
+package com.rabbitmq.client.test.ssl;
 
 import com.rabbitmq.client.Connection;
 import com.rabbitmq.client.ConnectionFactory;
 import com.rabbitmq.client.SslContextFactory;
-import com.rabbitmq.client.TrustEverythingTrustManager;
+import com.rabbitmq.client.test.TestUtils;
 import org.junit.jupiter.api.Test;
 
 import javax.net.ssl.SSLContext;
@@ -64,6 +64,20 @@ public class SslContextFactoryTest {
             connectionFactory.setAutomaticRecoveryEnabled(false);
             return connectionFactory;
         });
+        doTestSetSslContextFactory(() -> {
+            SslContextFactory sslContextFactory = sslContextFactory();
+            ConnectionFactory cf = new ConnectionFactory();
+            cf.setAutomaticRecoveryEnabled(true);
+            cf.netty().sslContextFactory(n -> TlsTestUtils.toSslContext(sslContextFactory.create(n)));
+            return cf;
+        });
+        doTestSetSslContextFactory(() -> {
+            SslContextFactory sslContextFactory = sslContextFactory();
+            ConnectionFactory cf = new ConnectionFactory();
+            cf.setAutomaticRecoveryEnabled(false);
+            cf.netty().sslContextFactory(n -> TlsTestUtils.toSslContext(sslContextFactory.create(n)));
+            return cf;
+        });
     }
 
     private void doTestSetSslContextFactory(Supplier<ConnectionFactory> supplier) throws Exception {
@@ -113,29 +127,33 @@ private void doTestSocketFactoryTakesPrecedenceOverSslContextFactoryWithBlocking
         TestUtils.close(connection);
     }
 
-    private SslContextFactory sslContextFactory() throws Exception {
-        SSLContext contextAcceptAll = SSLContext.getInstance(tlsProtocol());
-        contextAcceptAll.init(null, new TrustManager[] { new TrustEverythingTrustManager() }, null);
+    private static SslContextFactory sslContextFactory() {
+        try {
+            SSLContext contextAcceptAll = SSLContext.getInstance(tlsProtocol());
+            contextAcceptAll.init(null, new TrustManager[] { TlsTestUtils.ALWAYS_TRUST_MANAGER }, null);
+
+            SSLContext contextRejectAll = SSLContext.getInstance(tlsProtocol());
+            contextRejectAll.init(null, new TrustManager[] { new TrustNothingTrustManager() }, null);
 
-        SSLContext contextRejectAll = SSLContext.getInstance(tlsProtocol());
-        contextRejectAll.init(null, new TrustManager[] { new TrustNothingTrustManager() }, null);
+            Map<String, SSLContext> sslContexts = new HashMap<>();
+            sslContexts.put("connection01", contextAcceptAll);
+            sslContexts.put("connection02", contextRejectAll);
 
-        Map<String, SSLContext> sslContexts = new HashMap<>();
-        sslContexts.put("connection01", contextAcceptAll);
-        sslContexts.put("connection02", contextRejectAll);
+            return sslContexts::get;
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
 
-        SslContextFactory sslContextFactory = name -> sslContexts.get(name);
-        return sslContextFactory;
     }
 
-    private String tlsProtocol() throws NoSuchAlgorithmException {
+    private static String tlsProtocol() throws NoSuchAlgorithmException {
         return ConnectionFactory.computeDefaultTlsProtocol(SSLContext.getDefault().getSupportedSSLParameters().getProtocols());
     }
 
     private static class TrustNothingTrustManager implements X509TrustManager {
 
         @Override
-        public void checkClientTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
+        public void checkClientTrusted(X509Certificate[] x509Certificates, String s) {
 
         }
 
diff --git a/src/test/java/com/rabbitmq/client/test/ssl/SslTestSuite.java b/src/test/java/com/rabbitmq/client/test/ssl/SslTestSuite.java
index 868b1e26bb..f2bd0dc350 100644
--- a/src/test/java/com/rabbitmq/client/test/ssl/SslTestSuite.java
+++ b/src/test/java/com/rabbitmq/client/test/ssl/SslTestSuite.java
@@ -16,8 +16,6 @@
 
 package com.rabbitmq.client.test.ssl;
 
-import com.rabbitmq.client.test.SslContextFactoryTest;
-
 import org.junit.platform.suite.api.SelectClasses;
 import org.junit.platform.suite.api.Suite;
 
diff --git a/src/test/java/com/rabbitmq/client/test/ssl/TlsConnectionLogging.java b/src/test/java/com/rabbitmq/client/test/ssl/TlsConnectionLogging.java
index 8b388b9492..abec91737c 100644
--- a/src/test/java/com/rabbitmq/client/test/ssl/TlsConnectionLogging.java
+++ b/src/test/java/com/rabbitmq/client/test/ssl/TlsConnectionLogging.java
@@ -20,9 +20,12 @@
 import com.rabbitmq.client.impl.TlsUtils;
 import com.rabbitmq.client.impl.nio.NioParams;
 import com.rabbitmq.client.test.TestUtils;
+import io.netty.handler.ssl.SslContextBuilder;
+import io.netty.handler.ssl.SslHandler;
 import org.assertj.core.api.Assertions;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
+import wiremock.org.apache.hc.core5.ssl.SSLContextBuilder;
 
 import javax.net.ssl.*;
 import java.security.cert.X509Certificate;
@@ -35,7 +38,7 @@
 public class TlsConnectionLogging {
 
     public static Object[] certificateInfoAreProperlyExtracted() {
-        return new Object[]{blockingIo(), nio()};
+        return new Object[]{blockingIo(), nio(), netty()};
     }
 
     public static Function<ConnectionFactory, Supplier<SSLSession>> blockingIo() {
@@ -58,11 +61,30 @@ public static Function<ConnectionFactory, Supplier<SSLSession>> nio() {
         };
     }
 
+    public static Function<ConnectionFactory, Supplier<SSLSession>> netty() {
+        return connectionFactory -> {
+            AtomicReference<SSLEngine> sslEngineCaptor = new AtomicReference<>();
+            try {
+                connectionFactory.netty()
+                    .channelCustomizer(ch -> {
+                        SslHandler sslHandler = ch.pipeline().get(SslHandler.class);
+                        sslEngineCaptor.set(sslHandler.engine());
+                    })
+                    .sslContext(SslContextBuilder.forClient()
+                        .trustManager(TlsTestUtils.ALWAYS_TRUST_MANAGER)
+                        .build());
+            } catch (SSLException e) {
+                throw new RuntimeException(e);
+            }
+            return () -> sslEngineCaptor.get().getSession();
+        };
+    }
+
     @ParameterizedTest
     @MethodSource
     public void certificateInfoAreProperlyExtracted(Function<ConnectionFactory, Supplier<SSLSession>> configurer) throws Exception {
         SSLContext sslContext = TlsTestUtils.getSSLContext();
-        sslContext.init(null, new TrustManager[]{new AlwaysTrustTrustManager()}, null);
+        sslContext.init(null, new TrustManager[]{TlsTestUtils.ALWAYS_TRUST_MANAGER}, null);
         ConnectionFactory connectionFactory = TestUtils.connectionFactory();
         connectionFactory.useSslProtocol(sslContext);
         Supplier<SSLSession> sslSessionSupplier = configurer.apply(connectionFactory);
@@ -78,21 +100,4 @@ public void certificateInfoAreProperlyExtracted(Function<ConnectionFactory, Supp
         }
     }
 
-    private static class AlwaysTrustTrustManager implements X509TrustManager {
-        @Override
-        public void checkClientTrusted(X509Certificate[] chain, String authType) {
-
-        }
-
-        @Override
-        public void checkServerTrusted(X509Certificate[] chain, String authType) {
-
-        }
-
-        @Override
-        public X509Certificate[] getAcceptedIssuers() {
-            return new X509Certificate[0];
-        }
-    }
-
 }
diff --git a/src/test/java/com/rabbitmq/client/test/ssl/TlsTestUtils.java b/src/test/java/com/rabbitmq/client/test/ssl/TlsTestUtils.java
index f85829c119..bb16b08a6f 100644
--- a/src/test/java/com/rabbitmq/client/test/ssl/TlsTestUtils.java
+++ b/src/test/java/com/rabbitmq/client/test/ssl/TlsTestUtils.java
@@ -16,7 +16,14 @@
 
 package com.rabbitmq.client.test.ssl;
 
+import com.rabbitmq.client.ConnectionFactory;
+import com.rabbitmq.client.test.TestUtils;
 import com.rabbitmq.tools.Host;
+import io.netty.handler.ssl.ClientAuth;
+import io.netty.handler.ssl.IdentityCipherSuiteFilter;
+import io.netty.handler.ssl.JdkSslContext;
+import io.netty.handler.ssl.SslContext;
+import io.netty.handler.ssl.SslContextBuilder;
 import java.io.FileInputStream;
 import java.net.InetAddress;
 import java.net.UnknownHostException;
@@ -29,11 +36,14 @@
 import java.util.Collection;
 import java.util.stream.Collectors;
 import javax.net.ssl.SSLContext;
+import javax.net.ssl.TrustManager;
 import javax.net.ssl.TrustManagerFactory;
+import javax.net.ssl.X509TrustManager;
 
 class TlsTestUtils {
 
   static final String[] PROTOCOLS = new String[] {"TLSv1.3", "TLSv1.2"};
+  static TrustManager ALWAYS_TRUST_MANAGER = new AlwaysTrustManager();
 
   private TlsTestUtils() {}
 
@@ -45,6 +55,23 @@ static SSLContext verifiedSslContext() throws Exception {
     return sslContext(trustManagerFactory(caCertificate()));
   }
 
+  static void maybeConfigureNetty(ConnectionFactory cf, SSLContext sslContext) {
+    if (TestUtils.isNetty()) {
+      cf.netty().sslContext(toSslContext(sslContext));
+    }
+  }
+
+  static SslContext toSslContext(SSLContext jdkSslContext) {
+    return new JdkSslContext(jdkSslContext, true, null, IdentityCipherSuiteFilter.INSTANCE,
+        null, ClientAuth.NONE, null, false);
+  }
+
+  static void maybeConfigureNetty(ConnectionFactory cf, TrustManager trustManager) throws Exception {
+    if (TestUtils.isNetty()) {
+      cf.netty().sslContext(SslContextBuilder.forClient().trustManager(trustManager).build());
+    }
+  }
+
   static SSLContext verifiedSslContext(CallableSupplier<SSLContext> sslContextSupplier)
       throws Exception {
     return sslContext(sslContextSupplier, trustManagerFactory(caCertificate()));
@@ -144,4 +171,22 @@ interface CallableSupplier<T> {
 
     T get() throws Exception;
   }
+
+  private static class AlwaysTrustManager implements X509TrustManager {
+
+    @Override
+    public void checkClientTrusted(X509Certificate[] chain, String authType) {
+
+    }
+
+    @Override
+    public void checkServerTrusted(X509Certificate[] chain, String authType) {
+
+    }
+
+    @Override
+    public X509Certificate[] getAcceptedIssuers() {
+      return new X509Certificate[0];
+    }
+  }
 }
diff --git a/src/test/java/com/rabbitmq/client/test/ssl/UnverifiedConnection.java b/src/test/java/com/rabbitmq/client/test/ssl/UnverifiedConnection.java
index 3cf2a15b79..84519d4292 100644
--- a/src/test/java/com/rabbitmq/client/test/ssl/UnverifiedConnection.java
+++ b/src/test/java/com/rabbitmq/client/test/ssl/UnverifiedConnection.java
@@ -17,6 +17,8 @@
 
 import com.rabbitmq.client.GetResponse;
 import com.rabbitmq.client.test.BrokerTestCase;
+import com.rabbitmq.client.test.TestUtils;
+import io.netty.handler.ssl.SslContextBuilder;
 import org.junit.jupiter.api.Test;
 import org.slf4j.LoggerFactory;
 
@@ -35,6 +37,7 @@ public void openConnection()
             throws IOException, TimeoutException {
         try {
             connectionFactory.useSslProtocol();
+            TlsTestUtils.maybeConfigureNetty(connectionFactory, TlsTestUtils.ALWAYS_TRUST_MANAGER);
         } catch (Exception ex) {
             throw new IOException(ex);
         }
diff --git a/src/test/java/com/rabbitmq/client/test/ssl/VerifiedConnection.java b/src/test/java/com/rabbitmq/client/test/ssl/VerifiedConnection.java
index 179f2d18b6..4d20e26ce7 100644
--- a/src/test/java/com/rabbitmq/client/test/ssl/VerifiedConnection.java
+++ b/src/test/java/com/rabbitmq/client/test/ssl/VerifiedConnection.java
@@ -17,29 +17,27 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.junit.jupiter.api.Assertions.fail;
 
 import com.rabbitmq.client.Connection;
 import com.rabbitmq.client.impl.nio.NioParams;
-import java.io.IOException;
 import java.util.Collection;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
 
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLEngine;
 import javax.net.ssl.SSLSocket;
 
 import com.rabbitmq.client.ConnectionFactory;
 import com.rabbitmq.client.test.TestUtils;
+import io.netty.handler.ssl.SslHandler;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.condition.EnabledForJreRange;
 import org.junit.jupiter.api.condition.JRE;
-import org.slf4j.LoggerFactory;
 
 /**
  * Test for bug 19356 - SSL Support in rabbitmq
@@ -48,54 +46,39 @@
 @EnabledForJreRange(min = JRE.JAVA_11)
 public class VerifiedConnection extends UnverifiedConnection {
 
-    public void openConnection()
-            throws IOException, TimeoutException {
-        try {
-            SSLContext c = TlsTestUtils.verifiedSslContext();
-            connectionFactory = TestUtils.connectionFactory();
-            connectionFactory.useSslProtocol(c);
-        } catch (Exception ex) {
-            throw new IOException(ex);
-        }
-
-        int attempt = 0;
-        while(attempt < 3) {
-            try {
-                connection = connectionFactory.newConnection();
-                break;
-            } catch(Exception e) {
-                LoggerFactory.getLogger(getClass()).warn("Error when opening TLS connection");
-                attempt++;
-            }
-        }
-        if(connection == null) {
-            fail("Couldn't open TLS connection after 3 attempts");
-        }
-    }
-
     @Test
     public void connectionGetConsumeProtocols() throws Exception {
         Collection<String> availableProtocols = TlsTestUtils.availableTlsProtocols();
         Collection<String> protocols = Stream.of("TLSv1.2", "TLSv1.3")
-            .filter(p -> availableProtocols.contains(p))
+            .filter(availableProtocols::contains)
             .collect(Collectors.toList());
         for (String protocol : protocols) {
-            SSLContext sslContext = SSLContext.getInstance(protocol);
+            SSLContext sslContextModel = SSLContext.getInstance(protocol);
             ConnectionFactory cf = TestUtils.connectionFactory();
-            cf.useSslProtocol(TlsTestUtils.verifiedSslContext(() -> sslContext));
+            SSLContext sslContext = TlsTestUtils.verifiedSslContext(() -> sslContextModel);
+            cf.useSslProtocol(sslContext);
+            TlsTestUtils.maybeConfigureNetty(cf, sslContext);
             AtomicReference<Supplier<String[]>> protocolsSupplier = new AtomicReference<>();
-            if (TestUtils.USE_NIO) {
+            if (TestUtils.isNio()) {
                 cf.useNio();
                 NioParams nioParams = new NioParams();
                 nioParams.setSslEngineConfigurator(
                     sslEngine -> protocolsSupplier.set(() -> sslEngine.getEnabledProtocols())
                 );
                 cf.setNioParams(nioParams);
-            } else {
+            } else if (TestUtils.isSocket()) {
                 cf.setSocketConfigurator(socket -> {
                     SSLSocket s = (SSLSocket) socket;
-                    protocolsSupplier.set(() -> s.getEnabledProtocols());
+                    protocolsSupplier.set(s::getEnabledProtocols);
                 });
+            } else if (TestUtils.isNetty()) {
+                cf.netty().channelCustomizer(ch -> {
+                    SslHandler sslHandler = ch.pipeline().get(SslHandler.class);
+                    SSLEngine engine = sslHandler.engine();
+                    protocolsSupplier.set(engine::getEnabledProtocols);
+                });
+            } else {
+                throw new IllegalArgumentException();
             }
             try (Connection c = cf.newConnection()) {
                 CountDownLatch latch = new CountDownLatch(1);
diff --git a/src/test/resources/logback-test.xml b/src/test/resources/logback-test.xml
index f47371567e..f230a3f278 100644
--- a/src/test/resources/logback-test.xml
+++ b/src/test/resources/logback-test.xml
@@ -5,8 +5,7 @@
         </encoder>
     </appender>
 
-    <logger name="com.rabbitmq.client.test.TestUtils" level="info" />
-    <logger name="com.rabbitmq.client.AmqpClientTestExtension" level="info" />
+    <logger name="com.rabbitmq.client.AmqpClientTestExtension" level="debug" />
     <logger name="com.rabbitmq.client.test.server.TopicPermissions" level="debug" />
 
     <root level="warn">