Class ConnectionFactory

  • All Implemented Interfaces:
    Cloneable

    public class ConnectionFactory
    extends Object
    implements Cloneable
    Convenience factory class to facilitate opening a 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.
    • Field Detail

      • DEFAULT_CHANNEL_MAX

        public static final int DEFAULT_CHANNEL_MAX
        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
        See Also:
        Constant Field Values
      • DEFAULT_FRAME_MAX

        public static final int DEFAULT_FRAME_MAX
        Default maximum frame size; zero means no limit
        See Also:
        Constant Field Values
      • DEFAULT_HEARTBEAT

        public static final int DEFAULT_HEARTBEAT
        Default heart-beat interval; 60 seconds
        See Also:
        Constant Field Values
      • USE_DEFAULT_PORT

        public static final int USE_DEFAULT_PORT
        'Use the default port' port
        See Also:
        Constant Field Values
      • DEFAULT_AMQP_PORT

        public static final int DEFAULT_AMQP_PORT
        The default non-ssl port
        See Also:
        Constant Field Values
      • DEFAULT_AMQP_OVER_SSL_PORT

        public static final int DEFAULT_AMQP_OVER_SSL_PORT
        The default ssl port
        See Also:
        Constant Field Values
      • DEFAULT_CONNECTION_TIMEOUT

        public static final int DEFAULT_CONNECTION_TIMEOUT
        The default TCP connection timeout: 60 seconds
        See Also:
        Constant Field Values
      • DEFAULT_HANDSHAKE_TIMEOUT

        public static final int DEFAULT_HANDSHAKE_TIMEOUT
        The default AMQP 0-9-1 connection handshake timeout. See DEFAULT_CONNECTION_TIMEOUT for TCP (socket) connection timeout.
        See Also:
        Constant Field Values
      • DEFAULT_SHUTDOWN_TIMEOUT

        public static final int DEFAULT_SHUTDOWN_TIMEOUT
        The default shutdown timeout; zero means wait indefinitely
        See Also:
        Constant Field Values
      • DEFAULT_CHANNEL_RPC_TIMEOUT

        public static final int DEFAULT_CHANNEL_RPC_TIMEOUT
        The default continuation timeout for RPC calls in channels: 10 minutes
      • DEFAULT_NETWORK_RECOVERY_INTERVAL

        public static final long DEFAULT_NETWORK_RECOVERY_INTERVAL
        The default network recovery interval: 5000 millis
        See Also:
        Constant Field Values
      • DEFAULT_WORK_POOL_TIMEOUT

        public static final int DEFAULT_WORK_POOL_TIMEOUT
        The default timeout for work pool enqueueing: no timeout
        See Also:
        Constant Field Values
    • Constructor Detail

      • ConnectionFactory

        public ConnectionFactory()
    • Method Detail

      • getHost

        public String getHost()
        Returns:
        the default host to use for connections
      • setHost

        public void setHost​(String host)
        Parameters:
        host - the default host to use for connections
      • portOrDefault

        public static int portOrDefault​(int port,
                                        boolean ssl)
      • getPort

        public int getPort()
        Returns:
        the default port to use for connections
      • setPort

        public void setPort​(int port)
        Set the target port.
        Parameters:
        port - the default port to use for connections
      • getUsername

        public String getUsername()
        Retrieve the user name.
        Returns:
        the AMQP user name to use when connecting to the broker
      • setUsername

        public void setUsername​(String username)
        Set the user name.
        Parameters:
        username - the AMQP user name to use when connecting to the broker
      • getPassword

        public String getPassword()
        Retrieve the password.
        Returns:
        the password to use when connecting to the broker
      • setPassword

        public void setPassword​(String password)
        Set the password.
        Parameters:
        password - the password to use when connecting to the broker
      • setCredentialsProvider

        public void setCredentialsProvider​(CredentialsProvider credentialsProvider)
        Set a custom credentials provider. Default implementation uses static username and password.
        Parameters:
        credentialsProvider - The custom implementation of CredentialsProvider to use when connecting to the broker.
        Since:
        4.5.0
        See Also:
        DefaultCredentialsProvider
      • getVirtualHost

        public String getVirtualHost()
        Retrieve the virtual host.
        Returns:
        the virtual host to use when connecting to the broker
      • setVirtualHost

        public void setVirtualHost​(String virtualHost)
        Set the virtual host.
        Parameters:
        virtualHost - the virtual host to use when connecting to the broker
      • getRequestedChannelMax

        public int getRequestedChannelMax()
        Retrieve the requested maximum channel number
        Returns:
        the initially requested maximum channel number; zero for unlimited
      • setRequestedChannelMax

        public void setRequestedChannelMax​(int requestedChannelMax)
        Set the requested maximum channel number
        Parameters:
        requestedChannelMax - initially requested maximum channel number; zero for unlimited
      • getRequestedFrameMax

        public int getRequestedFrameMax()
        Retrieve the requested maximum frame size
        Returns:
        the initially requested maximum frame size, in octets; zero for unlimited
      • setRequestedFrameMax

        public void setRequestedFrameMax​(int requestedFrameMax)
        Set the requested maximum frame size
        Parameters:
        requestedFrameMax - initially requested maximum frame size, in octets; zero for unlimited
      • getRequestedHeartbeat

        public int getRequestedHeartbeat()
        Retrieve the requested heartbeat interval.
        Returns:
        the initially requested heartbeat interval, in seconds; zero for none
      • setConnectionTimeout

        public void setConnectionTimeout​(int timeout)
        Set the TCP connection timeout.
        Parameters:
        timeout - connection TCP establishment timeout in milliseconds; zero for infinite
      • getConnectionTimeout

        public int getConnectionTimeout()
        Retrieve the TCP connection timeout.
        Returns:
        the TCP connection timeout, in milliseconds; zero for infinite
      • getHandshakeTimeout

        public int getHandshakeTimeout()
        Retrieve the AMQP 0-9-1 protocol handshake timeout.
        Returns:
        the AMQP0-9-1 protocol handshake timeout, in milliseconds
      • setHandshakeTimeout

        public void setHandshakeTimeout​(int timeout)
        Set the AMQP0-9-1 protocol handshake timeout.
        Parameters:
        timeout - the AMQP0-9-1 protocol handshake timeout, in milliseconds
      • setShutdownTimeout

        public void setShutdownTimeout​(int shutdownTimeout)
        Set the shutdown timeout. This is the amount of time that Consumer implementations have to continue working through deliveries (and other Consumer callbacks) after 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, including the Consumer's handleShutdownSignal() invocation) will be lost.
        Parameters:
        shutdownTimeout - shutdown timeout in milliseconds; zero for infinite; default 10000
      • getShutdownTimeout

        public int getShutdownTimeout()
        Retrieve the shutdown timeout.
        Returns:
        the shutdown timeout, in milliseconds; zero for infinite
      • setRequestedHeartbeat

        public void setRequestedHeartbeat​(int requestedHeartbeat)
        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.
        Parameters:
        requestedHeartbeat - the initially requested heartbeat timeout, in seconds; zero for none
        See Also:
        RabbitMQ Heartbeats Guide
      • getClientProperties

        public Map<String,​Object> getClientProperties()
        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.
        Returns:
        the map of client properties
        See Also:
        setClientProperties(java.util.Map<java.lang.String, java.lang.Object>)
      • setClientProperties

        public void setClientProperties​(Map<String,​Object> clientProperties)
        Replace the table of client properties that will be sent to the server during subsequent connection startups.
        Parameters:
        clientProperties - the map of extra client properties
        See Also:
        getClientProperties()
      • getSaslConfig

        public SaslConfig getSaslConfig()
        Gets the sasl config to use when authenticating
        Returns:
        the sasl config
        See Also:
        SaslConfig
      • setSaslConfig

        public void setSaslConfig​(SaslConfig saslConfig)
        Sets the sasl config to use when authenticating
        Parameters:
        saslConfig -
        See Also:
        SaslConfig
      • getSocketFactory

        public SocketFactory getSocketFactory()
        Retrieve the socket factory used to make connections with.
      • setSocketFactory

        public void setSocketFactory​(SocketFactory factory)
        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 Also:
        useSslProtocol()
      • setSocketConfigurator

        public void setSocketConfigurator​(SocketConfigurator socketConfigurator)
        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.
        Parameters:
        socketConfigurator - the configurator to use
      • setSharedExecutor

        public void setSharedExecutor​(ExecutorService executor)
        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.
        Parameters:
        executor - executor service to be used for consumer operation
      • setShutdownExecutor

        public void setShutdownExecutor​(ExecutorService executor)
        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.
        Parameters:
        executor - executor service to be used for connection shutdown
      • setHeartbeatExecutor

        public void setHeartbeatExecutor​(ScheduledExecutorService executor)
        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.
        Parameters:
        executor - executor service to be used to send heartbeat
      • getThreadFactory

        public ThreadFactory getThreadFactory()
        Retrieve the thread factory used to instantiate new threads.
        See Also:
        ThreadFactory
      • setThreadFactory

        public void setThreadFactory​(ThreadFactory threadFactory)
        Set the thread factory used to instantiate new threads.
        See Also:
        ThreadFactory
      • setExceptionHandler

        public void setExceptionHandler​(ExceptionHandler exceptionHandler)
        Set the exception handler to use for newly created connections.
        See Also:
        ExceptionHandler
      • isSSL

        public boolean isSSL()
      • enableHostnameVerificationForNio

        protected void enableHostnameVerificationForNio()
      • enableHostnameVerificationForBlockingIo

        protected void enableHostnameVerificationForBlockingIo()
      • computeDefaultTlsProcotol

        public static String computeDefaultTlsProcotol​(String[] supportedProtocols)
      • isAutomaticRecoveryEnabled

        public boolean isAutomaticRecoveryEnabled()
        Returns true if automatic connection recovery is enabled, false otherwise
        Returns:
        true if automatic connection recovery is enabled, false otherwise
        See Also:
        Automatic Recovery
      • setAutomaticRecoveryEnabled

        public void setAutomaticRecoveryEnabled​(boolean automaticRecovery)
        Enables or disables automatic connection recovery.
        Parameters:
        automaticRecovery - if true, enables connection recovery
        See Also:
        Automatic Recovery
      • isTopologyRecoveryEnabled

        public boolean isTopologyRecoveryEnabled()
        Returns true if topology recovery is enabled, false otherwise
        Returns:
        true if topology recovery is enabled, false otherwise
        See Also:
        Automatic Recovery
      • setTopologyRecoveryEnabled

        public void setTopologyRecoveryEnabled​(boolean topologyRecovery)
        Enables or disables topology recovery
        Parameters:
        topologyRecovery - if true, enables topology recovery
        See Also:
        Automatic Recovery
      • getTopologyRecoveryExecutor

        public ExecutorService getTopologyRecoveryExecutor()
        Get the executor to use for parallel topology recovery. If null (the default), recovery is done single threaded on the main connection thread.
        Returns:
        thread pool executor
        Since:
        4.7.0
      • setTopologyRecoveryExecutor

        public void setTopologyRecoveryExecutor​(ExecutorService 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 ExceptionHandler.handleTopologyRecoveryException(Connection, Channel, TopologyRecoveryException) method should be thread-safe.
        Parameters:
        topologyRecoveryExecutor - thread pool executor
        Since:
        4.7.0
      • setMetricsCollector

        public void setMetricsCollector​(MetricsCollector metricsCollector)
      • newConnection

        public Connection newConnection​(Address[] addrs)
                                 throws IOException,
                                        TimeoutException
        Create a new broker connection, picking the first available address from the list. If automatic connection recovery is enabled, the connection returned by this method will be Recoverable. Future reconnection attempts will pick a random accessible address from the provided list.
        Parameters:
        addrs - an array of known broker addresses (hostname/port pairs) to try in order
        Returns:
        an interface to the connection
        Throws:
        IOException - if it encounters a problem
        TimeoutException
      • newConnection

        public Connection newConnection​(Address[] addrs,
                                        String clientProvidedName)
                                 throws IOException,
                                        TimeoutException
        Create a new broker connection with a client-provided name, picking the first available address from the list. If automatic connection recovery is enabled, the connection returned by this method will be Recoverable. Future reconnection attempts will pick a random accessible address from the provided list.
        Parameters:
        addrs - an array of known broker addresses (hostname/port pairs) to try in order
        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.
        Returns:
        an interface to the connection
        Throws:
        IOException - if it encounters a problem
        TimeoutException
      • newConnection

        public Connection newConnection​(List<Address> addrs)
                                 throws IOException,
                                        TimeoutException
        Create a new broker connection, picking the first available address from the list. If automatic connection recovery is enabled, the connection returned by this method will be Recoverable. Future reconnection attempts will pick a random accessible address from the provided list.
        Parameters:
        addrs - a List of known broker addresses (hostname/port pairs) to try in order
        Returns:
        an interface to the connection
        Throws:
        IOException - if it encounters a problem
        TimeoutException
      • newConnection

        public Connection newConnection​(List<Address> addrs,
                                        String clientProvidedName)
                                 throws IOException,
                                        TimeoutException
        Create a new broker connection with a client-provided name, picking the first available address from the list. If automatic connection recovery is enabled, the connection returned by this method will be Recoverable. Future reconnection attempts will pick a random accessible address from the provided list.
        Parameters:
        addrs - a List of known broker addresses (hostname/port pairs) to try in order
        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.
        Returns:
        an interface to the connection
        Throws:
        IOException - if it encounters a problem
        TimeoutException
      • newConnection

        public Connection newConnection​(ExecutorService executor,
                                        Address[] addrs,
                                        String clientProvidedName)
                                 throws IOException,
                                        TimeoutException
        Create a new broker connection with a client-provided name, picking the first available address from the list. If automatic connection recovery is enabled, the connection returned by this method will be Recoverable. Future reconnection attempts will pick a random accessible address from the provided list.
        Parameters:
        executor - thread execution service for consumers on the connection
        addrs - an array of known broker addresses (hostname/port pairs) to try in order
        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.
        Returns:
        an interface to the connection
        Throws:
        IOException - if it encounters a problem
        TimeoutException
        See Also:
        Automatic Recovery
      • newConnection

        public Connection newConnection​(ExecutorService executor,
                                        List<Address> addrs,
                                        String clientProvidedName)
                                 throws IOException,
                                        TimeoutException
        Create a new broker connection with a client-provided name, picking the first available address from the list. If automatic connection recovery is enabled, the connection returned by this method will be Recoverable. Future reconnection attempts will pick a random accessible address from the provided list.
        Parameters:
        executor - thread execution service for consumers on the connection
        addrs - a List of known broker addrs (hostname/port pairs) to try in order
        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.
        Returns:
        an interface to the connection
        Throws:
        IOException - if it encounters a problem
        TimeoutException
        See Also:
        Automatic Recovery
      • newConnection

        public Connection newConnection​(ExecutorService executor,
                                        AddressResolver addressResolver,
                                        String clientProvidedName)
                                 throws IOException,
                                        TimeoutException
        Create a new broker connection with a client-provided name, picking the first available address from the list provided by the AddressResolver. If automatic connection recovery is enabled, the connection returned by this method will be Recoverable. Future reconnection attempts will pick a random accessible address provided by the AddressResolver.
        Parameters:
        executor - thread execution service for consumers on the connection
        addressResolver - discovery service to list potential addresses (hostname/port pairs) to connect to
        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.
        Returns:
        an interface to the connection
        Throws:
        IOException - if it encounters a problem
        TimeoutException
        See Also:
        Automatic Recovery
      • getNetworkRecoveryInterval

        public long getNetworkRecoveryInterval()
        Returns automatic connection recovery interval in milliseconds.
        Returns:
        how long will automatic recovery wait before attempting to reconnect, in ms; default is 5000
      • getRecoveryDelayHandler

        public RecoveryDelayHandler getRecoveryDelayHandler()
        Returns automatic connection recovery delay handler.
        Returns:
        recovery delay handler. May be null if not set.
        Since:
        4.3.0
      • setRecoveryDelayHandler

        public void setRecoveryDelayHandler​(RecoveryDelayHandler recoveryDelayHandler)
        Sets the automatic connection recovery delay handler.
        Parameters:
        recoveryDelayHandler - the recovery delay handler
        Since:
        4.3.0
      • setNioParams

        public void setNioParams​(NioParams nioParams)
        Sets the parameters when using NIO.
        Parameters:
        nioParams -
        See Also:
        NioParams
      • getNioParams

        public NioParams getNioParams()
        Retrieve the parameters for NIO mode.
        Returns:
      • useBlockingIo

        public void useBlockingIo()
        Use blocking IO for communication with the server. With blocking IO, each connection creates its own thread to read data from the server.
      • setChannelRpcTimeout

        public void setChannelRpcTimeout​(int channelRpcTimeout)
        Set the continuation timeout for RPC calls in channels. Default is 10 minutes. 0 means no timeout.
        Parameters:
        channelRpcTimeout -
      • getChannelRpcTimeout

        public int getChannelRpcTimeout()
        Get the timeout for RPC calls in channels.
        Returns:
      • setSslContextFactory

        public void setSslContextFactory​(SslContextFactory sslContextFactory)
        The factory to create SSL contexts. This provides more flexibility to create SSLContexts for different connections than sharing the SSLContext with all the connections produced by the connection factory (which is the case with the useSslProtocol() methods). This way, different connections with a different certificate for each of them is a possible scenario.
        Parameters:
        sslContextFactory -
        Since:
        5.0.0
        See Also:
        useSslProtocol(SSLContext)
      • setChannelShouldCheckRpcResponseType

        public void setChannelShouldCheckRpcResponseType​(boolean channelShouldCheckRpcResponseType)
        When set to true, channels will check the response type (e.g. queue.declare expects a queue.declare-ok response) of RPC calls and ignore those that do not match. Default is false.
        Parameters:
        channelShouldCheckRpcResponseType -
      • isChannelShouldCheckRpcResponseType

        public boolean isChannelShouldCheckRpcResponseType()
      • setWorkPoolTimeout

        public void setWorkPoolTimeout​(int workPoolTimeout)
        Timeout (in ms) for work pool enqueueing. The 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.
        Parameters:
        workPoolTimeout - timeout in ms
        Since:
        4.5.0
      • getWorkPoolTimeout

        public int getWorkPoolTimeout()
      • setErrorOnWriteListener

        public void setErrorOnWriteListener​(ErrorOnWriteListener errorOnWriteListener)
        Set a listener to be called when connection gets an IO error trying to write on the socket. Default listener triggers connection recovery asynchronously and propagates the exception. Override the default listener to disable or customise automatic connection triggering on write operations.
        Parameters:
        errorOnWriteListener - the listener
        Since:
        4.5.0
      • setTopologyRecoveryFilter

        public void setTopologyRecoveryFilter​(TopologyRecoveryFilter topologyRecoveryFilter)
        Set filter to include/exclude entities from topology recovery.
        Since:
        4.8.0
      • setConnectionRecoveryTriggeringCondition

        public void setConnectionRecoveryTriggeringCondition​(Predicate<ShutdownSignalException> connectionRecoveryTriggeringCondition)
        Allows to decide on automatic connection recovery is triggered. Default is for shutdown not initiated by application or missed heartbeat errors.
        Parameters:
        connectionRecoveryTriggeringCondition -
      • setTopologyRecoveryRetryHandler

        public void setTopologyRecoveryRetryHandler​(RetryHandler topologyRecoveryRetryHandler)
        Set retry handler for topology recovery. Default is no retry.
        Parameters:
        topologyRecoveryRetryHandler -
        Since:
        5.4.0
      • setTrafficListener

        public void setTrafficListener​(TrafficListener trafficListener)
        Traffic listener notified of inbound and outbound Commands.

        Useful for debugging purposes, e.g. logging all sent and received messages. Default is no-op.

        Parameters:
        trafficListener -
        Since:
        5.5.0
        See Also:
        TrafficListener, LogTrafficListener