org.springframework.jms.connection

## Class UserCredentialsConnectionFactoryAdapter

- java.lang.Object
- - org.springframework.jms.connection.UserCredentialsConnectionFactoryAdapter

All Implemented Interfaces:
  ConnectionFactory, QueueConnectionFactory, TopicConnectionFactory, org.springframework.beans.factory.InitializingBean

    public class UserCredentialsConnectionFactoryAdapter
    extends Object
    implements ConnectionFactory, QueueConnectionFactory, TopicConnectionFactory, org.springframework.beans.factory.InitializingBean

An adapter for a target JMS `ConnectionFactory`, applying the given user credentials to every standard `createConnection()` call, that is, implicitly invoking `createConnection(username, password)` on the target. All other methods simply delegate to the corresponding methods of the target ConnectionFactory.

Can be used to proxy a target JNDI ConnectionFactory that does not have user credentials configured. Client code can work with the ConnectionFactory without passing in username and password on every `createConnection()` call.

In the following example, client code can simply transparently work with the preconfigured "myConnectionFactory", implicitly accessing "myTargetConnectionFactory" with the specified user credentials.

     <bean id="myTargetConnectionFactory" class="org.springframework.jndi.JndiObjectFactoryBean">
       <property name="jndiName" value="java:comp/env/jms/mycf"/>
     </bean>

     <bean id="myConnectionFactory" class="org.springframework.jms.connection.UserCredentialsConnectionFactoryAdapter">
       <property name="targetConnectionFactory" ref="myTargetConnectionFactory"/>
       <property name="username" value="myusername"/>
       <property name="password" value="mypassword"/>
     </bean>

If the "username" is empty, this proxy will simply delegate to the standard `createConnection()` method of the target ConnectionFactory. This can be used to keep a UserCredentialsConnectionFactoryAdapter bean definition just for the option of implicitly passing in user credentials if the particular target ConnectionFactory requires it.

As of Spring Framework 5, this class delegates JMS 2.0 `JMSContext` calls and therefore requires the JMS 2.0 API to be present at runtime. It may nevertheless run against a JMS 1.1 driver (bound to the JMS 2.0 API) as long as no actual JMS 2.0 calls are triggered by the application's setup.

Since:
  1.2
Author:
  Juergen Hoeller
See Also:
  `createConnection()`, `createQueueConnection()`, `createTopicConnection()`

### Constructor Summary

Constructors
Constructor and Description
`UserCredentialsConnectionFactoryAdapter()`

### Method Summary

All Methods Instance Methods Concrete Methods
`void` `afterPropertiesSet()`
`Connection` `createConnection()` Determine whether there are currently thread-bound credentials, using them if available, falling back to the statically specified username and password (i.e.
`Connection` `createConnection(String username, String password)` Delegate the call straight to the target ConnectionFactory.
`JMSContext` `createContext()`
`JMSContext` `createContext(int sessionMode)`
`JMSContext` `createContext(String userName, String password)`
`JMSContext` `createContext(String userName, String password, int sessionMode)`
`QueueConnection` `createQueueConnection()` Determine whether there are currently thread-bound credentials, using them if available, falling back to the statically specified username and password (i.e.
`QueueConnection` `createQueueConnection(String username, String password)` Delegate the call straight to the target QueueConnectionFactory.
`TopicConnection` `createTopicConnection()` Determine whether there are currently thread-bound credentials, using them if available, falling back to the statically specified username and password (i.e.
`TopicConnection` `createTopicConnection(String username, String password)` Delegate the call straight to the target TopicConnectionFactory.
`protected Connection` `doCreateConnection(String username, String password)` This implementation delegates to the `createConnection(username, password)` method of the target ConnectionFactory, passing in the specified user credentials.
`protected QueueConnection` `doCreateQueueConnection(String username, String password)` This implementation delegates to the `createQueueConnection(username, password)` method of the target QueueConnectionFactory, passing in the specified user credentials.
`protected TopicConnection` `doCreateTopicConnection(String username, String password)` This implementation delegates to the `createTopicConnection(username, password)` method of the target TopicConnectionFactory, passing in the specified user credentials.
`void` `removeCredentialsFromCurrentThread()` Remove any user credentials for this proxy from the current thread.
`void` `setCredentialsForCurrentThread(String username, String password)` Set user credententials for this proxy and the current thread.
`void` `setPassword(String password)` Set the password that this adapter should use for retrieving Connections.
`void` `setTargetConnectionFactory(ConnectionFactory targetConnectionFactory)` Set the target ConnectionFactory that this ConnectionFactory should delegate to.
`void` `setUsername(String username)` Set the username that this adapter should use for retrieving Connections.

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Constructor Detail

#### UserCredentialsConnectionFactoryAdapter

    public UserCredentialsConnectionFactoryAdapter()

### Method Detail

#### setTargetConnectionFactory

    public void setTargetConnectionFactory(ConnectionFactory targetConnectionFactory)

Set the target ConnectionFactory that this ConnectionFactory should delegate to.

#### setUsername

    public void setUsername(String username)

Set the username that this adapter should use for retrieving Connections. Default is no specific user.

#### setPassword

    public void setPassword(String password)

Set the password that this adapter should use for retrieving Connections. Default is no specific password.

#### afterPropertiesSet

    public void afterPropertiesSet()

Specified by:
  `afterPropertiesSet` in interface `org.springframework.beans.factory.InitializingBean`

#### setCredentialsForCurrentThread

    public void setCredentialsForCurrentThread(String username,
                                               String password)

Set user credententials for this proxy and the current thread. The given username and password will be applied to all subsequent `createConnection()` calls on this ConnectionFactory proxy.

This will override any statically specified user credentials, that is, values of the "username" and "password" bean properties.

Parameters:
  `username` - the username to apply
  `password` - the password to apply
See Also:
  `removeCredentialsFromCurrentThread()`

#### removeCredentialsFromCurrentThread

    public void removeCredentialsFromCurrentThread()

Remove any user credentials for this proxy from the current thread. Statically specified user credentials apply again afterwards.

See Also:
  `setCredentialsForCurrentThread(java.lang.String, java.lang.String)`

#### createConnection

    public final Connection createConnection()
                                      throws JMSException

Determine whether there are currently thread-bound credentials, using them if available, falling back to the statically specified username and password (i.e. values of the bean properties) otherwise.

Specified by:
  `createConnection` in interface `ConnectionFactory`
Throws:
  `JMSException`
See Also:
  `doCreateConnection(java.lang.String, java.lang.String)`

#### createConnection

    public Connection createConnection(String username,
                                       String password)
                                throws JMSException

Delegate the call straight to the target ConnectionFactory.

Specified by:
  `createConnection` in interface `ConnectionFactory`
Throws:
  `JMSException`

#### doCreateConnection

    protected Connection doCreateConnection(@Nullable
                                            String username,
                                            @Nullable
                                            String password)
                                     throws JMSException

This implementation delegates to the `createConnection(username, password)` method of the target ConnectionFactory, passing in the specified user credentials. If the specified username is empty, it will simply delegate to the standard `createConnection()` method of the target ConnectionFactory.

Parameters:
  `username` - the username to use
  `password` - the password to use
Returns:
  the Connection
Throws:
  `JMSException`
See Also:
  `ConnectionFactory.createConnection(String, String)`, `ConnectionFactory.createConnection()`

#### createQueueConnection

    public final QueueConnection createQueueConnection()
                                                throws JMSException

Determine whether there are currently thread-bound credentials, using them if available, falling back to the statically specified username and password (i.e. values of the bean properties) else.

Specified by:
  `createQueueConnection` in interface `QueueConnectionFactory`
Throws:
  `JMSException`
See Also:
  `doCreateQueueConnection(java.lang.String, java.lang.String)`

#### createQueueConnection

    public QueueConnection createQueueConnection(String username,
                                                 String password)
                                          throws JMSException

Delegate the call straight to the target QueueConnectionFactory.

Specified by:
  `createQueueConnection` in interface `QueueConnectionFactory`
Throws:
  `JMSException`

#### doCreateQueueConnection

    protected QueueConnection doCreateQueueConnection(@Nullable
                                                      String username,
                                                      @Nullable
                                                      String password)
                                               throws JMSException

This implementation delegates to the `createQueueConnection(username, password)` method of the target QueueConnectionFactory, passing in the specified user credentials. If the specified username is empty, it will simply delegate to the standard `createQueueConnection()` method of the target ConnectionFactory.

Parameters:
  `username` - the username to use
  `password` - the password to use
Returns:
  the Connection
Throws:
  `JMSException`
See Also:
  `QueueConnectionFactory.createQueueConnection(String, String)`, `QueueConnectionFactory.createQueueConnection()`

#### createTopicConnection

    public final TopicConnection createTopicConnection()
                                                throws JMSException

Determine whether there are currently thread-bound credentials, using them if available, falling back to the statically specified username and password (i.e. values of the bean properties) else.

Specified by:
  `createTopicConnection` in interface `TopicConnectionFactory`
Throws:
  `JMSException`
See Also:
  `doCreateTopicConnection(java.lang.String, java.lang.String)`

#### createTopicConnection

    public TopicConnection createTopicConnection(String username,
                                                 String password)
                                          throws JMSException

Delegate the call straight to the target TopicConnectionFactory.

Specified by:
  `createTopicConnection` in interface `TopicConnectionFactory`
Throws:
  `JMSException`

#### doCreateTopicConnection

    protected TopicConnection doCreateTopicConnection(@Nullable
                                                      String username,
                                                      @Nullable
                                                      String password)
                                               throws JMSException

This implementation delegates to the `createTopicConnection(username, password)` method of the target TopicConnectionFactory, passing in the specified user credentials. If the specified username is empty, it will simply delegate to the standard `createTopicConnection()` method of the target ConnectionFactory.

Parameters:
  `username` - the username to use
  `password` - the password to use
Returns:
  the Connection
Throws:
  `JMSException`
See Also:
  `TopicConnectionFactory.createTopicConnection(String, String)`, `TopicConnectionFactory.createTopicConnection()`

#### createContext

    public JMSContext createContext()

Specified by:
  `createContext` in interface `ConnectionFactory`

#### createContext

    public JMSContext createContext(String userName,
                                    String password)

Specified by:
  `createContext` in interface `ConnectionFactory`

#### createContext

    public JMSContext createContext(String userName,
                                    String password,
                                    int sessionMode)

Specified by:
  `createContext` in interface `ConnectionFactory`

#### createContext

    public JMSContext createContext(int sessionMode)

Specified by:
  `createContext` in interface `ConnectionFactory`