diff --git a/.github/workflows/test-rabbitmq-alphas.yml b/.github/workflows/test-rabbitmq-alphas.yml
index 6fe31dfcb..700e3e32b 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 8acb19cb3..6375118d9 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 \
@@ -50,7 +50,7 @@ jobs:
             -Dnet.bytebuddy.experimental=true
       - 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 512b5f205..6a93eb453 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 a893add02..5f9cb9690 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 39c219cef..59a714c39 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-2025 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,13 +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 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;
@@ -40,944 +39,1006 @@
 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;
 
 /**
  * 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 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 int MAX_UNSIGNED_SHORT = 65535;
 
-    /**
-     * Continuation timeout on RPC calls.
-     * @since 4.1.0
-     */
-    private int channelRpcTimeout = DEFAULT_CHANNEL_RPC_TIMEOUT;
+  /** Default user name */
+  public static final String DEFAULT_USER = "guest";
 
-    /**
-     * Whether or not channels check the reply type of an RPC call.
-     * Default is false.
-     * @since 4.2.0
-     */
-    private boolean channelShouldCheckRpcResponseType = false;
+  /** Default password */
+  public static final String DEFAULT_PASS = "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 virtual host */
+  public static final String DEFAULT_VHOST = "/";
 
-    /**
-     * Timeout in ms for work pool enqueuing.
-     * @since 4.5.0
-     */
-    private int workPoolTimeout = DEFAULT_WORK_POOL_TIMEOUT;
+  /**
+   * 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;
 
-    /**
-     * Filter to include/exclude entities from topology recovery.
-     * @since 4.8.0
-     */
-    private TopologyRecoveryFilter topologyRecoveryFilter;
+  /** Default maximum frame size; zero means no limit */
+  public static final int DEFAULT_FRAME_MAX = 0;
 
-    /**
-     * Condition to trigger automatic connection recovery.
-     * @since 5.4.0
-     */
-    private Predicate<ShutdownSignalException> connectionRecoveryTriggeringCondition;
+  /** Default heart-beat interval; 60 seconds */
+  public static final int DEFAULT_HEARTBEAT = 60;
 
-    /**
-     * Retry handler for topology recovery.
-     * Default is no retry.
-     * @since 5.4.0
-     */
-    private RetryHandler topologyRecoveryRetryHandler;
-    private RecoveredQueueNameSupplier recoveredQueueNameSupplier;
+  /** The default host */
+  public static final String DEFAULT_HOST = "localhost";
 
-    /**
-     * 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;
+  /** 'Use the default port' port */
+  public static final int USE_DEFAULT_PORT = -1;
 
-    private CredentialsRefreshService credentialsRefreshService;
+  /** The default non-ssl port */
+  public static final int DEFAULT_AMQP_PORT = AMQP.PROTOCOL.PORT;
 
-    /**
-     * 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 ssl port */
+  public static final int DEFAULT_AMQP_OVER_SSL_PORT = 5671;
 
-    /** @return the default host to use for connections */
-    public String getHost() {
-        return host;
-    }
+  /** The default TCP connection timeout: 60 seconds */
+  public static final int DEFAULT_CONNECTION_TIMEOUT = 60000;
 
-    /** @param host the default host to use for connections */
-    public ConnectionFactory setHost(String host) {
-        this.host = host;
-        return this;
-    }
+  /**
+   * 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;
 
-    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;
-    }
+  /**
+   * Continuation timeout on RPC calls.
+   *
+   * @since 4.1.0
+   */
+  private int channelRpcTimeout = DEFAULT_CHANNEL_RPC_TIMEOUT;
 
-    /** @return the default port to use for connections */
-    public int getPort() {
-        return portOrDefault(port, isSSL());
-    }
+  /**
+   * Whether or not channels check the reply type of an RPC call. Default is false.
+   *
+   * @since 4.2.0
+   */
+  private boolean channelShouldCheckRpcResponseType = false;
 
-    /**
-     * Set the target port.
-     * @param port the default port to use for connections
-     */
-    public ConnectionFactory setPort(int port) {
-        this.port = port;
-        return this;
-    }
+  /**
+   * 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;
 
-    /**
-     * Retrieve the user name.
-     * @return the AMQP user name to use when connecting to the broker
-     */
-    public String getUsername() {
-        return credentialsProvider.getUsername();
-    }
+  /**
+   * Timeout in ms for work pool enqueuing.
+   *
+   * @since 4.5.0
+   */
+  private int workPoolTimeout = DEFAULT_WORK_POOL_TIMEOUT;
 
-    /**
-     * Set the user name.
-     * @param username the AMQP user name to use when connecting to the broker
-     */
-    public ConnectionFactory setUsername(String username) {
-        this.credentialsProvider = new DefaultCredentialsProvider(
-            username,
-            this.credentialsProvider.getPassword()
-        );
-        return this;
-    }
+  /**
+   * Filter to include/exclude entities from topology recovery.
+   *
+   * @since 4.8.0
+   */
+  private TopologyRecoveryFilter topologyRecoveryFilter;
 
-    /**
-     * Retrieve the password.
-     * @return the password to use when connecting to the broker
-     */
-    public String getPassword() {
-        return credentialsProvider.getPassword();
-    }
+  /**
+   * Condition to trigger automatic connection recovery.
+   *
+   * @since 5.4.0
+   */
+  private Predicate<ShutdownSignalException> connectionRecoveryTriggeringCondition;
 
-    /**
-     * Set the password.
-     * @param password the password to use when connecting to the broker
-     */
-    public ConnectionFactory setPassword(String password) {
-        this.credentialsProvider = new DefaultCredentialsProvider(
-            this.credentialsProvider.getUsername(),
-            password
-        );
-        return this;
-    }
+  /**
+   * Retry handler for topology recovery. Default is no retry.
+   *
+   * @since 5.4.0
+   */
+  private RetryHandler topologyRecoveryRetryHandler;
 
-    /**
-     * 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 ConnectionFactory setCredentialsProvider(CredentialsProvider credentialsProvider) {
-        this.credentialsProvider = credentialsProvider;
-        return this;
-    }
-    
-    /**
-     * Retrieve the virtual host.
-     * @return the virtual host to use when connecting to the broker
-     */
-    public String getVirtualHost() {
-        return this.virtualHost;
-    }
+  private RecoveredQueueNameSupplier recoveredQueueNameSupplier;
 
-    /**
-     * Set the virtual host.
-     * @param virtualHost the virtual host to use when connecting to the broker
-     */
-    public ConnectionFactory setVirtualHost(String virtualHost) {
-        this.virtualHost = virtualHost;
-        return this;
-    }
+  /**
+   * 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;
 
+  private CredentialsRefreshService credentialsRefreshService;
 
-    /**
-     * 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 ConnectionFactory 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());
-        }
+  /**
+   * 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;
 
-        String host = uri.getHost();
-        if (host != null) {
-            setHost(host);
-        }
+  /**
+   * @return the default host to use for connections
+   */
+  public String getHost() {
+    return host;
+  }
 
-        int port = uri.getPort();
-        if (port != -1) {
-            setPort(port);
-        }
+  /**
+   * @param host the default host to use for connections
+   */
+  public ConnectionFactory setHost(String host) {
+    this.host = host;
+    return this;
+  }
 
-        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);
-            }
+  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;
+  }
 
-            setUsername(uriDecode(userPass[0]));
-            if (userPass.length == 2) {
-                setPassword(uriDecode(userPass[1]));
-            }
-        }
+  /**
+   * @return the default port to use for connections
+   */
+  public int getPort() {
+    return portOrDefault(port, isSSL());
+  }
 
-        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);
-            }
+  /**
+   * Set the target port.
+   *
+   * @param port the default port to use for connections
+   */
+  public ConnectionFactory setPort(int port) {
+    this.port = port;
+    return this;
+  }
 
-            setVirtualHost(uriDecode(uri.getPath().substring(1)));
-        }
-        
-        String rawQuery = uri.getRawQuery();
-        if (rawQuery != null && rawQuery.length() > 0) {
-            setQuery(rawQuery);
-        }
-        return this;
-    }
+  /**
+   * Retrieve the user name.
+   *
+   * @return the AMQP user name to use when connecting to the broker
+   */
+  public String getUsername() {
+    return credentialsProvider.getUsername();
+  }
 
-    /**
-     * 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 ConnectionFactory setUri(String uriString)
-        throws URISyntaxException, NoSuchAlgorithmException, KeyManagementException
-    {
-        setUri(new URI(uriString));
-        return this;
-    }
+  /**
+   * Set the user name.
+   *
+   * @param username the AMQP user name to use when connecting to the broker
+   */
+  public ConnectionFactory setUsername(String username) {
+    this.credentialsProvider =
+        new DefaultCredentialsProvider(username, this.credentialsProvider.getPassword());
+    return this;
+  }
 
-    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);
-        }
-    }
+  /**
+   * Retrieve the password.
+   *
+   * @return the password to use when connecting to the broker
+   */
+  public String getPassword() {
+    return 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");
-                }
-            });
-        }
-      };
+  /**
+   * Set the password.
+   *
+   * @param password the password to use when connecting to the broker
+   */
+  public ConnectionFactory setPassword(String password) {
+    this.credentialsProvider =
+        new DefaultCredentialsProvider(this.credentialsProvider.getUsername(), password);
+    return this;
+  }
 
-    /**
-     * 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 ConnectionFactory 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 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 ConnectionFactory setCredentialsProvider(CredentialsProvider credentialsProvider) {
+    this.credentialsProvider = credentialsProvider;
+    return this;
+  }
 
-        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());
-            }
-        }
-        return this;
-    }
+  /**
+   * Retrieve the virtual host.
+   *
+   * @return the virtual host to use when connecting to the broker
+   */
+  public String getVirtualHost() {
+    return this.virtualHost;
+  }
 
-    /**
-     * 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 virtual host.
+   *
+   * @param virtualHost the virtual host to use when connecting to the broker
+   */
+  public ConnectionFactory setVirtualHost(String virtualHost) {
+    this.virtualHost = virtualHost;
+    return this;
+  }
 
+  /**
+   * 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 ConnectionFactory 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());
     }
 
-    /**
-     * Retrieve the requested maximum channel number
-     * @return the initially requested maximum channel number; zero for unlimited
-     */
-    public int getRequestedChannelMax() {
-        return this.requestedChannelMax;
+    String host = uri.getHost();
+    if (host != null) {
+      setHost(host);
     }
 
-    /**
-     * 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 ConnectionFactory setRequestedChannelMax(int requestedChannelMax) {
-        if (requestedChannelMax < 0 || requestedChannelMax > MAX_UNSIGNED_SHORT) {
-            throw new IllegalArgumentException("Requested channel max must be between 0 and " + MAX_UNSIGNED_SHORT);
-        }
-        this.requestedChannelMax = requestedChannelMax;
-        return this;
+    int port = uri.getPort();
+    if (port != -1) {
+      setPort(port);
     }
 
-    /**
-     * Retrieve the requested maximum frame size
-     * @return the initially requested maximum frame size, in octets; zero for unlimited
-     */
-    public int getRequestedFrameMax() {
-        return this.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);
+      }
 
-    /**
-     * Set the requested maximum frame size
-     * @param requestedFrameMax initially requested maximum frame size, in octets; zero for unlimited
-     */
-    public ConnectionFactory setRequestedFrameMax(int requestedFrameMax) {
-        this.requestedFrameMax = requestedFrameMax;
-        return this;
+      setUsername(uriDecode(userPass[0]));
+      if (userPass.length == 2) {
+        setPassword(uriDecode(userPass[1]));
+      }
     }
 
-    /**
-     * Retrieve the requested heartbeat interval.
-     * @return the initially requested heartbeat interval, in seconds; zero for none
-     */
-    public int getRequestedHeartbeat() {
-        return this.requestedHeartbeat;
-    }
+    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);
+      }
 
-    /**
-     * Set the TCP connection timeout.
-     * @param timeout connection TCP establishment timeout in milliseconds; zero for infinite
-     */
-    public ConnectionFactory setConnectionTimeout(int timeout) {
-        if(timeout < 0) {
-            throw new IllegalArgumentException("TCP connection timeout cannot be negative");
-        }
-        this.connectionTimeout = timeout;
-        return this;
+      setVirtualHost(uriDecode(uri.getPath().substring(1)));
     }
 
-    /**
-     * Retrieve the TCP connection timeout.
-     * @return the TCP connection timeout, in milliseconds; zero for infinite
-     */
-    public int getConnectionTimeout() {
-        return this.connectionTimeout;
+    String rawQuery = uri.getRawQuery();
+    if (rawQuery != null && rawQuery.length() > 0) {
+      setQuery(rawQuery);
     }
+    return this;
+  }
 
-    /**
-     * Retrieve the AMQP 0-9-1 protocol handshake timeout.
-     * @return the AMQP0-9-1 protocol handshake timeout, in milliseconds
-     */
-    public int getHandshakeTimeout() {
-        return handshakeTimeout;
-    }
+  /**
+   * 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 ConnectionFactory setUri(String uriString)
+      throws URISyntaxException, NoSuchAlgorithmException, KeyManagementException {
+    setUri(new URI(uriString));
+    return this;
+  }
+
+  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");
+                    }
+                  });
+            }
+          };
 
-    /**
-     * Set the AMQP0-9-1 protocol handshake timeout.
-     * @param timeout the AMQP0-9-1 protocol handshake timeout, in milliseconds
-     */
-    public ConnectionFactory setHandshakeTimeout(int timeout) {
-        if(timeout < 0) {
-            throw new IllegalArgumentException("handshake timeout cannot be negative");
+  /**
+   * 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 ConnectionFactory 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;
-        return this;
+        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 ConnectionFactory setShutdownTimeout(int shutdownTimeout) {
-        this.shutdownTimeout = shutdownTimeout;
-        return this;
+    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());
+      }
     }
+    return this;
+  }
 
-    /**
-     * 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 ConnectionFactory setRequestedHeartbeat(int requestedHeartbeat) {
-        if (requestedHeartbeat < 0 || requestedHeartbeat > MAX_UNSIGNED_SHORT) {
-            throw new IllegalArgumentException("Requested heartbeat must be between 0 and " + MAX_UNSIGNED_SHORT);
-        }
-        this.requestedHeartbeat = requestedHeartbeat;
-        return this;
-    }
+  /**
+   * 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 ConnectionFactory setRequestedChannelMax(int requestedChannelMax) {
+    if (requestedChannelMax < 0 || requestedChannelMax > MAX_UNSIGNED_SHORT) {
+      throw new IllegalArgumentException(
+          "Requested channel max must be between 0 and " + MAX_UNSIGNED_SHORT);
     }
+    this.requestedChannelMax = requestedChannelMax;
+    return this;
+  }
 
-    /**
-     * 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 ConnectionFactory setClientProperties(Map<String, Object> clientProperties) {
-        this._clientProperties = clientProperties;
-        return this;
-    }
+  /**
+   * 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 ConnectionFactory setRequestedFrameMax(int requestedFrameMax) {
+    this.requestedFrameMax = requestedFrameMax;
+    return this;
+  }
 
-    /**
-     * Sets the sasl config to use when authenticating
-     * @param saslConfig
-     * @see com.rabbitmq.client.SaslConfig
-     */
-    public ConnectionFactory setSaslConfig(SaslConfig saslConfig) {
-        this.saslConfig = saslConfig;
-        return this;
-    }
+  /**
+   * 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 ConnectionFactory setConnectionTimeout(int timeout) {
+    if (timeout < 0) {
+      throw new IllegalArgumentException("TCP connection timeout cannot be negative");
     }
+    this.connectionTimeout = timeout;
+    return this;
+  }
 
-    /**
-     * 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 ConnectionFactory setSocketFactory(SocketFactory factory) {
-        this.socketFactory = factory;
-        return this;
-    }
+  /**
+   * 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 ConnectionFactory setSocketConfigurator(SocketConfigurator socketConfigurator) {
-        this.socketConf = socketConfigurator;
-        return this;
+  /**
+   * Set the AMQP0-9-1 protocol handshake timeout.
+   *
+   * @param timeout the AMQP0-9-1 protocol handshake timeout, in milliseconds
+   */
+  public ConnectionFactory setHandshakeTimeout(int timeout) {
+    if (timeout < 0) {
+      throw new IllegalArgumentException("handshake timeout cannot be negative");
     }
+    this.handshakeTimeout = timeout;
+    return this;
+  }
 
-    /**
-     * 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 ConnectionFactory setSharedExecutor(ExecutorService executor) {
-        this.sharedExecutor = executor;
-        return this;
-    }
+  /**
+   * 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 ConnectionFactory setShutdownTimeout(int shutdownTimeout) {
+    this.shutdownTimeout = shutdownTimeout;
+    return this;
+  }
 
-    /**
-     * 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 ConnectionFactory setShutdownExecutor(ExecutorService executor) {
-        this.shutdownExecutor = executor;
-        return this;
-    }
+  /**
+   * 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 ConnectionFactory setHeartbeatExecutor(ScheduledExecutorService executor) {
-        this.heartbeatExecutor = executor;
-        return this;
-    }
-    
-    /**
-     * 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 ConnectionFactory setRequestedHeartbeat(int requestedHeartbeat) {
+    if (requestedHeartbeat < 0 || requestedHeartbeat > MAX_UNSIGNED_SHORT) {
+      throw new IllegalArgumentException(
+          "Requested heartbeat must be between 0 and " + MAX_UNSIGNED_SHORT);
     }
+    this.requestedHeartbeat = requestedHeartbeat;
+    return this;
+  }
 
-    /**
-     * Set the thread factory used to instantiate new threads.
-     * @see ThreadFactory
-     */
-    public ConnectionFactory setThreadFactory(ThreadFactory threadFactory) {
-        this.threadFactory = threadFactory;
-        return this;
-    }
+  /**
+   * 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 ConnectionFactory setClientProperties(Map<String, Object> clientProperties) {
+    this._clientProperties = clientProperties;
+    return this;
+  }
 
-    /**
-     * Set the exception handler to use for newly created connections.
-     * @see com.rabbitmq.client.ExceptionHandler
-     */
-    public ConnectionFactory setExceptionHandler(ExceptionHandler exceptionHandler) {
-        if (exceptionHandler == null) {
-          throw new IllegalArgumentException("exception handler cannot be null!");
-        }
-        this.exceptionHandler = exceptionHandler;
-        return this;
-    }
+  /**
+   * 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 ConnectionFactory setSaslConfig(SaslConfig saslConfig) {
+    this.saslConfig = saslConfig;
+    return this;
+  }
 
-    /**
-     * 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 ConnectionFactory useSslProtocol()
-        throws NoSuchAlgorithmException, KeyManagementException
-    {
-        return 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 ConnectionFactory useSslProtocol(String protocol)
-        throws NoSuchAlgorithmException, KeyManagementException
-    {
-        return 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 ConnectionFactory setSocketFactory(SocketFactory factory) {
+    this.socketFactory = factory;
+    return this;
+  }
 
-    /**
-     * 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 ConnectionFactory useSslProtocol(String protocol, TrustManager trustManager)
-        throws NoSuchAlgorithmException, KeyManagementException
-    {
-        SSLContext c = SSLContext.getInstance(protocol);
-        c.init(null, new TrustManager[] { trustManager }, null);
-        return 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 ConnectionFactory useSslProtocol(SSLContext context) {
-        this.sslContextFactory = name -> context;
-        setSocketFactory(context.getSocketFactory());
-        return this;
-    }
+  /**
+   * 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 ConnectionFactory setSocketConfigurator(SocketConfigurator socketConfigurator) {
+    this.socketConf = socketConfigurator;
+    return this;
+  }
 
-    /**
-     * 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 ConnectionFactory enableHostnameVerification() {
-        enableHostnameVerificationForNio();
-        enableHostnameVerificationForBlockingIo();
-        return this;
-    }
+  /**
+   * 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 ConnectionFactory setSharedExecutor(ExecutorService executor) {
+    this.sharedExecutor = executor;
+    return this;
+  }
 
-    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 ConnectionFactory setShutdownExecutor(ExecutorService executor) {
+    this.shutdownExecutor = executor;
+    return this;
+  }
 
-    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 ConnectionFactory setHeartbeatExecutor(ScheduledExecutorService executor) {
+    this.heartbeatExecutor = executor;
+    return this;
+  }
+
+  /**
+   * 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 ConnectionFactory setThreadFactory(ThreadFactory threadFactory) {
+    this.threadFactory = threadFactory;
+    return this;
+  }
+
+  /**
+   * 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 ConnectionFactory setExceptionHandler(ExceptionHandler exceptionHandler) {
+    if (exceptionHandler == null) {
+      throw new IllegalArgumentException("exception handler cannot be null!");
     }
+    this.exceptionHandler = exceptionHandler;
+    return this;
+  }
 
-    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 ConnectionFactory useSslProtocol()
+      throws NoSuchAlgorithmException, KeyManagementException {
+    return 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.
+   *
+   * @see #setSslContextFactory(SslContextFactory)
+   *     <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 ConnectionFactory useSslProtocol(String protocol)
+      throws NoSuchAlgorithmException, KeyManagementException {
+    return 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 ConnectionFactory useSslProtocol(String protocol, TrustManager trustManager)
+      throws NoSuchAlgorithmException, KeyManagementException {
+    SSLContext c = SSLContext.getInstance(protocol);
+    c.init(null, new TrustManager[] {trustManager}, null);
+    return 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 ConnectionFactory useSslProtocol(SSLContext context) {
+    this.sslContextFactory = name -> context;
+    setSocketFactory(context.getSocketFactory());
+    return this;
+  }
+
+  /**
+   * 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 ConnectionFactory enableHostnameVerification() {
+    enableHostnameVerificationForNio();
+    enableHostnameVerificationForBlockingIo();
+    return this;
+  }
+
+  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 ConnectionFactory setAutomaticRecoveryEnabled(boolean automaticRecovery) {
-        this.automaticRecovery = automaticRecovery;
-        return this;
-    }
+  /**
+   * 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 ConnectionFactory setAutomaticRecoveryEnabled(boolean automaticRecovery) {
+    this.automaticRecovery = automaticRecovery;
+    return this;
+  }
 
-    /**
-     * 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 ConnectionFactory setTopologyRecoveryEnabled(boolean topologyRecovery) {
-        this.topologyRecovery = topologyRecovery;
-        return this;
-    }
-    
-    /**
-     * 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 ConnectionFactory setTopologyRecoveryExecutor(final ExecutorService topologyRecoveryExecutor) {
-        this.topologyRecoveryExecutor = topologyRecoveryExecutor;
-        return this;
-    }
+  /**
+   * 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 ConnectionFactory setTopologyRecoveryEnabled(boolean topologyRecovery) {
+    this.topologyRecovery = topologyRecovery;
+    return this;
+  }
 
-    public ConnectionFactory setMetricsCollector(MetricsCollector metricsCollector) {
-        this.metricsCollector = metricsCollector;
-        return this;
-    }
+  /**
+   * 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 ConnectionFactory setTopologyRecoveryExecutor(
+      final ExecutorService topologyRecoveryExecutor) {
+    this.topologyRecoveryExecutor = topologyRecoveryExecutor;
+    return this;
+  }
+
+  public ConnectionFactory setMetricsCollector(MetricsCollector metricsCollector) {
+    this.metricsCollector = metricsCollector;
+    return this;
+  }
+
+  public MetricsCollector getMetricsCollector() {
+    return metricsCollector;
+  }
 
   /**
    * Set observation collector.
@@ -988,778 +1049,957 @@ public MetricsCollector getMetricsCollector() {
    * @see com.rabbitmq.client.observation.micrometer.MicrometerObservationCollectorBuilder
    */
   public void setObservationCollector(ObservationCollector observationCollector) {
-        this.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 ConnectionFactory setCredentialsRefreshService(CredentialsRefreshService credentialsRefreshService) {
-        this.credentialsRefreshService = credentialsRefreshService;
-        return this;
-    }
-
-    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 ConnectionFactory setCredentialsRefreshService(
+      CredentialsRefreshService credentialsRefreshService) {
+    this.credentialsRefreshService = credentialsRefreshService;
+    return this;
+  }
+
+  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.
+   *
+   * <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");
+    }
+  }
+
+  public ConnectionParams params(ExecutorService consumerWorkServiceExecutor) {
+    ConnectionParams result = new ConnectionParams();
+
+    result.setCredentialsProvider(credentialsProvider);
+    result.setConsumerWorkServiceExecutor(consumerWorkServiceExecutor);
+    result.setVirtualHost(virtualHost);
+    result.setClientProperties(getClientProperties());
+    result.setRequestedFrameMax(requestedFrameMax);
+    result.setRequestedChannelMax(requestedChannelMax);
+    result.setShutdownTimeout(shutdownTimeout);
+    result.setSaslConfig(saslConfig);
+    result.setNetworkRecoveryInterval(networkRecoveryInterval);
+    result.setRecoveryDelayHandler(recoveryDelayHandler);
+    result.setTopologyRecovery(topologyRecovery);
+    result.setTopologyRecoveryExecutor(topologyRecoveryExecutor);
+    result.setExceptionHandler(exceptionHandler);
+    result.setThreadFactory(threadFactory);
+    result.setHandshakeTimeout(handshakeTimeout);
+    result.setRequestedHeartbeat(requestedHeartbeat);
+    result.setShutdownExecutor(shutdownExecutor);
+    result.setHeartbeatExecutor(heartbeatExecutor);
+    result.setChannelRpcTimeout(channelRpcTimeout);
+    result.setChannelShouldCheckRpcResponseType(channelShouldCheckRpcResponseType);
+    result.setWorkPoolTimeout(workPoolTimeout);
+    result.setErrorOnWriteListener(errorOnWriteListener);
+    result.setTopologyRecoveryFilter(topologyRecoveryFilter);
+    result.setConnectionRecoveryTriggeringCondition(connectionRecoveryTriggeringCondition);
+    result.setTopologyRecoveryRetryHandler(topologyRecoveryRetryHandler);
+    result.setRecoveredQueueNameSupplier(recoveredQueueNameSupplier);
+    result.setTrafficListener(trafficListener);
+    result.setCredentialsRefreshService(credentialsRefreshService);
+    result.setMaxInboundMessageBodySize(maxInboundMessageBodySize);
+    return result;
+  }
+
+  protected AMQConnection createConnection(
+      ConnectionParams params, FrameHandler frameHandler, MetricsCollector metricsCollector) {
+    return new AMQConnection(params, frameHandler, metricsCollector, observationCollector);
+  }
+
+  /**
+   * Create a new broker connection.
+   *
+   * <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())));
+  }
 
-    /**
-     * 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.
+   *
+   * <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.
+   * @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);
+  }
 
-    /**
-     * 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);
-    }
+  /**
+   * Create a new broker connection.
+   *
+   * <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
+   * @throws IOException if it encounters a problem
+   */
+  public Connection newConnection(ExecutorService executor) throws IOException, TimeoutException {
+    return newConnection(executor, Collections.singletonList(new Address(getHost(), getPort())));
+  }
 
-    /**
-     * 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);
-    }
+  /**
+   * Create a new broker connection.
+   *
+   * <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.
+   * @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);
+  }
+
+  protected AddressResolver createAddressResolver(List<Address> addresses) {
+    if (addresses == null || addresses.isEmpty()) {
+      throw new IllegalArgumentException("Please provide at least one address to connect to");
+    } else if (addresses.size() > 1) {
+      return new ListAddressResolver(addresses);
+    } else {
+      return new DnsRecordIpAddressResolver(addresses.get(0), isSSL());
+    }
+  }
+
+  @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;
+  }
 
-    /**
-     * 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);
-    }
+  /**
+   * 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;
+  }
 
-    /**
-     * 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);
-    }
+  /**
+   * 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;
+  }
 
-    /**
-     * 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);
-    }
+  /**
+   * 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;
+  }
 
-    /**
-     * 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 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);
-    }
+  /**
+   * 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;
+  }
 
-    /**
-     * Create a new broker connection with a client-provided name, 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
-     * @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);
-        }
+  /**
+   * 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;
+  }
 
-        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");
-        }
-    }
+  /**
+   * 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;
+  }
 
-    public ConnectionParams params(ExecutorService consumerWorkServiceExecutor) {
-        ConnectionParams result = new ConnectionParams();
-
-        result.setCredentialsProvider(credentialsProvider);
-        result.setConsumerWorkServiceExecutor(consumerWorkServiceExecutor);
-        result.setVirtualHost(virtualHost);
-        result.setClientProperties(getClientProperties());
-        result.setRequestedFrameMax(requestedFrameMax);
-        result.setRequestedChannelMax(requestedChannelMax);
-        result.setShutdownTimeout(shutdownTimeout);
-        result.setSaslConfig(saslConfig);
-        result.setNetworkRecoveryInterval(networkRecoveryInterval);
-        result.setRecoveryDelayHandler(recoveryDelayHandler);
-        result.setTopologyRecovery(topologyRecovery);
-        result.setTopologyRecoveryExecutor(topologyRecoveryExecutor);
-        result.setExceptionHandler(exceptionHandler);
-        result.setThreadFactory(threadFactory);
-        result.setHandshakeTimeout(handshakeTimeout);
-        result.setRequestedHeartbeat(requestedHeartbeat);
-        result.setShutdownExecutor(shutdownExecutor);
-        result.setHeartbeatExecutor(heartbeatExecutor);
-        result.setChannelRpcTimeout(channelRpcTimeout);
-        result.setChannelShouldCheckRpcResponseType(channelShouldCheckRpcResponseType);
-        result.setWorkPoolTimeout(workPoolTimeout);
-        result.setErrorOnWriteListener(errorOnWriteListener);
-        result.setTopologyRecoveryFilter(topologyRecoveryFilter);
-        result.setConnectionRecoveryTriggeringCondition(connectionRecoveryTriggeringCondition);
-        result.setTopologyRecoveryRetryHandler(topologyRecoveryRetryHandler);
-        result.setRecoveredQueueNameSupplier(recoveredQueueNameSupplier);
-        result.setTrafficListener(trafficListener);
-        result.setCredentialsRefreshService(credentialsRefreshService);
-        result.setMaxInboundMessageBodySize(maxInboundMessageBodySize);
-        return result;
-    }
+  /**
+   * 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 ConnectionFactory setNetworkRecoveryInterval(int networkRecoveryInterval) {
+    this.networkRecoveryInterval = networkRecoveryInterval;
+    return this;
+  }
 
-    protected AMQConnection createConnection(ConnectionParams params, FrameHandler frameHandler, MetricsCollector metricsCollector) {
-        return new AMQConnection(params, frameHandler, metricsCollector, observationCollector);
-    }
+  /**
+   * 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 ConnectionFactory setNetworkRecoveryInterval(long networkRecoveryInterval) {
+    this.networkRecoveryInterval = networkRecoveryInterval;
+    return this;
+  }
 
-    /**
-     * 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}.
-     *
-     * @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())));
-    }
+  /**
+   * 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;
+  }
 
-    /**
-     * 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}.
-     *
-     * @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);
-    }
+  /**
+   * Sets the automatic connection recovery delay handler.
+   *
+   * @param recoveryDelayHandler the recovery delay handler
+   * @since 4.3.0
+   */
+  public ConnectionFactory setRecoveryDelayHandler(
+      final RecoveryDelayHandler recoveryDelayHandler) {
+    this.recoveryDelayHandler = recoveryDelayHandler;
+    return this;
+  }
 
-    /**
-     * 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}.
-     *
-     * @param executor thread execution service for consumers on the connection
-     * @return an interface to the connection
-     * @throws IOException if it encounters a problem
-     */
-    public Connection newConnection(ExecutorService executor) throws IOException, TimeoutException {
-        return newConnection(executor, Collections.singletonList(new Address(getHost(), getPort())));
-    }
+  /**
+   * 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.
-     *
-     * 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.
-     * @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);
-    }
+  /**
+   * Retrieve the parameters for NIO mode.
+   *
+   * @return
+   * @deprecated Use {@link #netty()}
+   */
+  @Deprecated
+  public NioParams getNioParams() {
+    return nioParams;
+  }
 
-    protected AddressResolver createAddressResolver(List<Address> addresses) {
-        if (addresses == null || addresses.isEmpty()) {
-            throw new IllegalArgumentException("Please provide at least one address to connect to");
-        } else if (addresses.size() > 1) {
-            return new ListAddressResolver(addresses);
-        } else {
-            return new DnsRecordIpAddressResolver(addresses.get(0), isSSL());
-        }
-    }
+  /**
+   * 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;
+  }
 
-    @Override public ConnectionFactory clone(){
-        try {
-            ConnectionFactory clone = (ConnectionFactory)super.clone();
-            return clone;
-        } catch (CloneNotSupportedException e) {
-            throw new RuntimeException(e);
-        }
-    }
+  /**
+   * 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;
+  }
 
-    /**
-     * 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;
+  /**
+   * Set the continuation timeout for RPC calls in channels. Default is 10 minutes. 0 means no
+   * timeout.
+   *
+   * @param channelRpcTimeout
+   */
+  public ConnectionFactory setChannelRpcTimeout(int channelRpcTimeout) {
+    if (channelRpcTimeout < 0) {
+      throw new IllegalArgumentException("Timeout cannot be less than 0");
     }
+    this.channelRpcTimeout = channelRpcTimeout;
+    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;
-    }
+  /**
+   * Get the timeout for RPC calls in channels.
+   *
+   * @return
+   */
+  public int getChannelRpcTimeout() {
+    return channelRpcTimeout;
+  }
 
-    /**
-     * 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;
+  /**
+   * 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;
+  }
 
-    /**
-     * 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;
-    }
+  /**
+   * 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 ConnectionFactory setSslContextFactory(SslContextFactory sslContextFactory) {
+    this.sslContextFactory = sslContextFactory;
+    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;
-    }
+  /**
+   * 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 ConnectionFactory setChannelShouldCheckRpcResponseType(
+      boolean channelShouldCheckRpcResponseType) {
+    this.channelShouldCheckRpcResponseType = channelShouldCheckRpcResponseType;
+    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;
-    }
+  public boolean isChannelShouldCheckRpcResponseType() {
+    return channelShouldCheckRpcResponseType;
+  }
 
-    /**
-     * 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;
-    }
+  /**
+   * 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 ConnectionFactory setWorkPoolTimeout(int workPoolTimeout) {
+    this.workPoolTimeout = workPoolTimeout;
+    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 ConnectionFactory setNetworkRecoveryInterval(int networkRecoveryInterval) {
-        this.networkRecoveryInterval = networkRecoveryInterval;
-        return this;
-    }
+  public int getWorkPoolTimeout() {
+    return workPoolTimeout;
+  }
 
-    /**
-     * 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 ConnectionFactory setNetworkRecoveryInterval(long networkRecoveryInterval) {
-        this.networkRecoveryInterval = networkRecoveryInterval;
-        return this;
-    }
-    
-    /**
-     * 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 ConnectionFactory setRecoveryDelayHandler(final RecoveryDelayHandler recoveryDelayHandler) {
-        this.recoveryDelayHandler = recoveryDelayHandler;
-        return this;
-    }
+  /**
+   * 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 ConnectionFactory setErrorOnWriteListener(ErrorOnWriteListener errorOnWriteListener) {
+    this.errorOnWriteListener = errorOnWriteListener;
+    return this;
+  }
 
-    /**
-     * Sets the parameters when using NIO.
-     *
-     *
-     * @param nioParams
-     * @see NioParams
-     */
-    public ConnectionFactory setNioParams(NioParams nioParams) {
-        this.nioParams = nioParams;
-        return this;
-    }
+  /**
+   * Set filter to include/exclude entities from topology recovery.
+   *
+   * @since 4.8.0
+   */
+  public ConnectionFactory setTopologyRecoveryFilter(
+      TopologyRecoveryFilter topologyRecoveryFilter) {
+    this.topologyRecoveryFilter = topologyRecoveryFilter;
+    return this;
+  }
 
-    /**
-     * Retrieve the parameters for NIO mode.
-     * @return
-     */
-    public NioParams getNioParams() {
-        return nioParams;
-    }
+  /**
+   * Allows to decide on automatic connection recovery is triggered. Default is for shutdown not
+   * initiated by application or missed heartbeat errors.
+   *
+   * @param connectionRecoveryTriggeringCondition
+   */
+  public ConnectionFactory setConnectionRecoveryTriggeringCondition(
+      Predicate<ShutdownSignalException> connectionRecoveryTriggeringCondition) {
+    this.connectionRecoveryTriggeringCondition = connectionRecoveryTriggeringCondition;
+    return this;
+  }
 
-    /**
-     * 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 ConnectionFactory useNio() {
-        this.nio = true;
-        return this;
-    }
+  /**
+   * Set retry handler for topology recovery. Default is no retry.
+   *
+   * @param topologyRecoveryRetryHandler
+   * @since 5.4.0
+   */
+  public ConnectionFactory setTopologyRecoveryRetryHandler(
+      RetryHandler topologyRecoveryRetryHandler) {
+    this.topologyRecoveryRetryHandler = topologyRecoveryRetryHandler;
+    return this;
+  }
 
-    /**
-     * 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;
-        return this;
-    }
+  /**
+   * Set the recovered queue name supplier. Default is use the same queue name when recovering
+   * queues.
+   *
+   * @param recoveredQueueNameSupplier queue name supplier
+   */
+  public ConnectionFactory setRecoveredQueueNameSupplier(
+      RecoveredQueueNameSupplier recoveredQueueNameSupplier) {
+    this.recoveredQueueNameSupplier = recoveredQueueNameSupplier;
+    return this;
+  }
 
-    /**
-     * Set the continuation timeout for RPC calls in channels.
-     * Default is 10 minutes. 0 means no timeout.
-     * @param channelRpcTimeout
-     */
-    public ConnectionFactory setChannelRpcTimeout(int channelRpcTimeout) {
-        if(channelRpcTimeout < 0) {
-            throw new IllegalArgumentException("Timeout cannot be less than 0");
-        }
-        this.channelRpcTimeout = channelRpcTimeout;
-        return this;
-    }
+  /**
+   * 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 ConnectionFactory setTrafficListener(TrafficListener trafficListener) {
+    this.trafficListener = trafficListener;
+    return this;
+  }
 
-    /**
-     * Get the timeout for RPC calls in channels.
-     * @return
-     */
-    public int getChannelRpcTimeout() {
-        return channelRpcTimeout;
-    }
+  /**
+   * Use Netty with the default configuration.
+   *
+   * @return the connection factory
+   * @see #netty()
+   */
+  public ConnectionFactory useNetty() {
+    this.netty = true;
+    this.nio = false;
+    return this;
+  }
 
-    /**
-     * 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;
-    }
+  /**
+   * Activate and configure Netty for the IO layer.
+   *
+   * @return Netty configuration
+   * @since 5.27.0
+   */
+  public NettyConfiguration netty() {
+    useNetty();
+    return this.nettyConf;
+  }
 
-    /**
-     * 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 ConnectionFactory setSslContextFactory(SslContextFactory sslContextFactory) {
-        this.sslContextFactory = sslContextFactory;
-        return this;
-    }
+  /**
+   * Helper class to configure Netty.
+   *
+   * @since 5.27.0
+   */
+  public static final class NettyConfiguration {
 
-    /**
-     * 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 ConnectionFactory setChannelShouldCheckRpcResponseType(boolean channelShouldCheckRpcResponseType) {
-        this.channelShouldCheckRpcResponseType = channelShouldCheckRpcResponseType;
-        return this;
-    }
+    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;
 
-    public boolean isChannelShouldCheckRpcResponseType() {
-        return channelShouldCheckRpcResponseType;
+    private NettyConfiguration(ConnectionFactory cf) {
+      this.cf = cf;
     }
 
     /**
-     * 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.
+     * Set the {@link io.netty.channel.EventLoopGroup} shared by all the connections created with
+     * this connection factory.
+     *
+     * <p>A connection uses a one-thread NIO event loop group if none is provided. It disposes it
+     * when it closes itself.
+     *
+     * <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.
      *
-     * @param workPoolTimeout timeout in ms
-     * @since 4.5.0
+     * <p>It is the developer's responsibility to close the event loop group they provide.
+     *
+     * @param eventLoopGroup the event loop group to use
+     * @return this configuration instance
      */
-    public ConnectionFactory setWorkPoolTimeout(int workPoolTimeout) {
-        this.workPoolTimeout = workPoolTimeout;
-        return this;
-    }
-
-    public int getWorkPoolTimeout() {
-        return workPoolTimeout;
+    public NettyConfiguration eventLoopGroup(EventLoopGroup eventLoopGroup) {
+      this.eventLoopGroup = eventLoopGroup;
+      return this;
     }
 
     /**
-     * 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.
+     * An extension point to customize Netty's {@link io.netty.channel.Channel}s used for
+     * connections.
      *
-     * @param errorOnWriteListener the listener
-     * @since 4.5.0
+     * @param channelCustomizer the customization callback
+     * @return this configuration instance
      */
-    public ConnectionFactory setErrorOnWriteListener(ErrorOnWriteListener errorOnWriteListener) {
-        this.errorOnWriteListener = errorOnWriteListener;
-        return this;
+    public NettyConfiguration channelCustomizer(
+        Consumer<io.netty.channel.Channel> channelCustomizer) {
+      this.channelCustomizer = channelCustomizer;
+      return this;
     }
 
     /**
-     * Set filter to include/exclude entities from topology recovery.
+     * An extension point to customize Netty's {@link Bootstrap}s used to configure connections.
      *
-     * @since 4.8.0
+     * @param bootstrapCustomizer the bootstrap customization callback
+     * @return this configuration instance
      */
-    public ConnectionFactory setTopologyRecoveryFilter(TopologyRecoveryFilter topologyRecoveryFilter) {
-        this.topologyRecoveryFilter = topologyRecoveryFilter;
-        return this;
+    public NettyConfiguration bootstrapCustomizer(Consumer<Bootstrap> bootstrapCustomizer) {
+      this.bootstrapCustomizer = bootstrapCustomizer;
+      return this;
     }
 
     /**
-     * Allows to decide on automatic connection recovery is triggered.
-     * Default is for shutdown not initiated by application or missed heartbeat errors.
+     * Netty {@link SslContext} for TLS connections.
+     *
+     * <p>Use {@link SslContextBuilder#forClient()} to configure and create an instance.
      *
-     * @param connectionRecoveryTriggeringCondition
+     * @param sslContext the SSL context
+     * @return this configuration instance
      */
-    public ConnectionFactory setConnectionRecoveryTriggeringCondition(Predicate<ShutdownSignalException> connectionRecoveryTriggeringCondition) {
-        this.connectionRecoveryTriggeringCondition = connectionRecoveryTriggeringCondition;
-        return this;
+    public NettyConfiguration sslContext(SslContext sslContext) {
+      this.sslContextFactory = name -> sslContext;
+      return this;
     }
 
     /**
-     * Set retry handler for topology recovery.
-     * Default is no retry.
+     * A factory to create {@link io.netty.handler.ssl.SslContext} depending on the connection name.
      *
-     * @param topologyRecoveryRetryHandler
-     * @since 5.4.0
+     * @param sslContextFactory the factory
+     * @return this configuration instance
      */
-    public ConnectionFactory setTopologyRecoveryRetryHandler(RetryHandler topologyRecoveryRetryHandler) {
-        this.topologyRecoveryRetryHandler = topologyRecoveryRetryHandler;
-        return this;
+    public NettyConfiguration sslContextFactory(Function<String, SslContext> sslContextFactory) {
+      this.sslContextFactory = sslContextFactory;
+      return this;
     }
 
     /**
-     * Set the recovered queue name supplier. Default is use the same queue name when recovering queues.
-     * 
-     * @param recoveredQueueNameSupplier queue name supplier
+     * Go back to the connection factory.
+     *
+     * @return the connection factory
      */
-    public ConnectionFactory setRecoveredQueueNameSupplier(RecoveredQueueNameSupplier recoveredQueueNameSupplier) {
-        this.recoveredQueueNameSupplier = recoveredQueueNameSupplier;
-        return this;
+    public ConnectionFactory connectionFactory() {
+      return this.cf;
     }
 
-    /**
-     * 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 ConnectionFactory setTrafficListener(TrafficListener trafficListener) {
-        this.trafficListener = trafficListener;
-        return this;
+    private boolean isTls() {
+      return this.sslContextFactory != null;
     }
+  }
 }
diff --git a/src/main/java/com/rabbitmq/client/SocketChannelConfigurator.java b/src/main/java/com/rabbitmq/client/SocketChannelConfigurator.java
index 69dc2ef0b..60182de79 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 95d96c4fa..a4b35b92f 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 78b2b2eae..e98087fe5 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 929fd507d..33032f8ff 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 1a91a3cd8..53c106168 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,7 +408,11 @@ public void start()
             throw te;
         } catch (ShutdownSignalException sse) {
             _frameHandler.close();
-            throw AMQChannel.wrap(sse);
+            if (sse.getCause() instanceof SSLHandshakeException) {
+                throw (SSLHandshakeException) sse.getCause();
+            } else {
+                throw AMQChannel.wrap(sse);
+            }
         }
 
         try {
@@ -484,6 +493,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 000000000..8bfee96eb
--- /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 858400b5f..5024bf167 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;
@@ -89,7 +90,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
         }
 
@@ -201,6 +201,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 c445bd34f..6c72521c8 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 e0d373738..f83647d52 100644
--- a/src/main/java/com/rabbitmq/client/impl/HeartbeatSender.java
+++ b/src/main/java/com/rabbitmq/client/impl/HeartbeatSender.java
@@ -1,147 +1,22 @@
-// 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 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 000000000..1e60b5013
--- /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 6d1fb8ec3..d6b86480c 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) 2007-2025 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 fe89375ae..28147925d 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 1d049189d..8ecaf5e97 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 d15ab6ac6..e44cf12d8 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 dcffa744b..78242e9d5 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 d99a8434d..a853b22a4 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 7af27fbfd..cbbdc5bf2 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 c686409c1..5b9fba317 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 6ee9091c0..6fd29f7aa 100644
--- a/src/test/java/com/rabbitmq/client/test/ClientTestSuite.java
+++ b/src/test/java/com/rabbitmq/client/test/ClientTestSuite.java
@@ -74,7 +74,9 @@
     RefreshCredentialsTest.class,
     AMQConnectionRefreshCredentialsTest.class,
     ValueWriterTest.class,
-    BlockedConnectionTest.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 fae132263..45742dcd2 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 000000000..34651c24c
--- /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 2b0c934cf..ecd82d05a 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 000000000..823e2293c
--- /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 3f2061bff..1050c2c15 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-2025 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 1bc007d75..326ccc8f8 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 7f7767fbd..19db721c6 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 7cdb1e873..bbee6e395 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-2025 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 4c9a51dec..042d217f0 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 4c0646fe9..62bfa2b95 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 dce1565ae..6cc602494 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 74%
rename from src/test/java/com/rabbitmq/client/test/SslContextFactoryTest.java
rename to src/test/java/com/rabbitmq/client/test/ssl/SslContextFactoryTest.java
index f9e798832..276d9d857 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;
@@ -56,6 +56,18 @@ public class SslContextFactoryTest {
                 .useNio()
                 .setAutomaticRecoveryEnabled(false)
         );
+        doTestSetSslContextFactory(() -> {
+            SslContextFactory sslContextFactory = sslContextFactory();
+            return new ConnectionFactory()
+                .setAutomaticRecoveryEnabled(true)
+                .netty().sslContextFactory(n -> TlsTestUtils.toSslContext(sslContextFactory.create(n))).connectionFactory();
+        });
+        doTestSetSslContextFactory(() -> {
+            SslContextFactory sslContextFactory = sslContextFactory();
+            return new ConnectionFactory()
+                .setAutomaticRecoveryEnabled(false)
+                .netty().sslContextFactory(n -> TlsTestUtils.toSslContext(sslContextFactory.create(n))).connectionFactory();
+        });
     }
 
     private void doTestSetSslContextFactory(Supplier<ConnectionFactory> supplier) throws Exception {
@@ -101,29 +113,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 f4aba114e..9e02b883c 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 0369927d4..bb096c828 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() {
@@ -57,11 +60,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);
@@ -77,21 +99,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 f85829c11..bb16b08a6 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 68cb7b1f3..35d952171 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 39d5094f3..7dd37a4bf 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,28 @@
 
 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.SslContextBuilder;
+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,53 +47,38 @@
 @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();
                 cf.setNioParams(new NioParams()
                     .setSslEngineConfigurator(sslEngine -> {
                         protocolsSupplier.set(() -> sslEngine.getEnabledProtocols());
                     }));
-            } 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 3e3340923..aeab3742f 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" />
     <logger name="com.rabbitmq.client.impl.AbstractMetricsCollector" level="debug" />