Java tutorial
/* * Copyright 2002-2018 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * https://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.springframework.jms.connection; import javax.jms.Connection; import javax.jms.ConnectionFactory; import javax.jms.JMSContext; import javax.jms.JMSException; import javax.jms.QueueConnection; import javax.jms.QueueConnectionFactory; import javax.jms.TopicConnection; import javax.jms.TopicConnectionFactory; import org.springframework.beans.factory.InitializingBean; import org.springframework.core.NamedThreadLocal; import org.springframework.lang.Nullable; import org.springframework.util.Assert; import org.springframework.util.StringUtils; /** * An adapter for a target JMS {@link javax.jms.ConnectionFactory}, applying the * given user credentials to every standard {@code createConnection()} call, * that is, implicitly invoking {@code createConnection(username, password)} * on the target. All other methods simply delegate to the corresponding methods * of the target ConnectionFactory. * * <p>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 {@code createConnection()} call. * * <p>In the following example, client code can simply transparently work * with the preconfigured "myConnectionFactory", implicitly accessing * "myTargetConnectionFactory" with the specified user credentials. * * <pre class="code"> * <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></pre> * * <p>If the "username" is empty, this proxy will simply delegate to the standard * {@code createConnection()} method of the target ConnectionFactory. * This can be used to keep a UserCredentialsConnectionFactoryAdapter bean * definition just for the <i>option</i> of implicitly passing in user credentials * if the particular target ConnectionFactory requires it. * * <p>As of Spring Framework 5, this class delegates JMS 2.0 {@code 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. * * @author Juergen Hoeller * @since 1.2 * @see #createConnection * @see #createQueueConnection * @see #createTopicConnection */ public class UserCredentialsConnectionFactoryAdapter implements ConnectionFactory, QueueConnectionFactory, TopicConnectionFactory, InitializingBean { @Nullable private ConnectionFactory targetConnectionFactory; @Nullable private String username; @Nullable private String password; private final ThreadLocal<JmsUserCredentials> threadBoundCredentials = new NamedThreadLocal<>( "Current JMS user credentials"); /** * Set the target ConnectionFactory that this ConnectionFactory should delegate to. */ public void setTargetConnectionFactory(ConnectionFactory targetConnectionFactory) { Assert.notNull(targetConnectionFactory, "'targetConnectionFactory' must not be null"); this.targetConnectionFactory = targetConnectionFactory; } /** * Set the username that this adapter should use for retrieving Connections. * Default is no specific user. */ public void setUsername(String username) { this.username = username; } /** * Set the password that this adapter should use for retrieving Connections. * Default is no specific password. */ public void setPassword(String password) { this.password = password; } @Override public void afterPropertiesSet() { if (this.targetConnectionFactory == null) { throw new IllegalArgumentException("Property 'targetConnectionFactory' is required"); } } /** * Set user credententials for this proxy and the current thread. * The given username and password will be applied to all subsequent * {@code createConnection()} calls on this ConnectionFactory proxy. * <p>This will override any statically specified user credentials, * that is, values of the "username" and "password" bean properties. * @param username the username to apply * @param password the password to apply * @see #removeCredentialsFromCurrentThread */ public void setCredentialsForCurrentThread(String username, String password) { this.threadBoundCredentials.set(new JmsUserCredentials(username, password)); } /** * Remove any user credentials for this proxy from the current thread. * Statically specified user credentials apply again afterwards. * @see #setCredentialsForCurrentThread */ public void removeCredentialsFromCurrentThread() { this.threadBoundCredentials.remove(); } /** * 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. * @see #doCreateConnection */ @Override public final Connection createConnection() throws JMSException { JmsUserCredentials threadCredentials = this.threadBoundCredentials.get(); if (threadCredentials != null) { return doCreateConnection(threadCredentials.username, threadCredentials.password); } else { return doCreateConnection(this.username, this.password); } } /** * Delegate the call straight to the target ConnectionFactory. */ @Override public Connection createConnection(String username, String password) throws JMSException { return doCreateConnection(username, password); } /** * This implementation delegates to the {@code 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 * {@code createConnection()} method of the target ConnectionFactory. * @param username the username to use * @param password the password to use * @return the Connection * @see javax.jms.ConnectionFactory#createConnection(String, String) * @see javax.jms.ConnectionFactory#createConnection() */ protected Connection doCreateConnection(@Nullable String username, @Nullable String password) throws JMSException { ConnectionFactory target = obtainTargetConnectionFactory(); if (StringUtils.hasLength(username)) { return target.createConnection(username, password); } else { return target.createConnection(); } } /** * 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. * @see #doCreateQueueConnection */ @Override public final QueueConnection createQueueConnection() throws JMSException { JmsUserCredentials threadCredentials = this.threadBoundCredentials.get(); if (threadCredentials != null) { return doCreateQueueConnection(threadCredentials.username, threadCredentials.password); } else { return doCreateQueueConnection(this.username, this.password); } } /** * Delegate the call straight to the target QueueConnectionFactory. */ @Override public QueueConnection createQueueConnection(String username, String password) throws JMSException { return doCreateQueueConnection(username, password); } /** * This implementation delegates to the {@code 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 * {@code createQueueConnection()} method of the target ConnectionFactory. * @param username the username to use * @param password the password to use * @return the Connection * @see javax.jms.QueueConnectionFactory#createQueueConnection(String, String) * @see javax.jms.QueueConnectionFactory#createQueueConnection() */ protected QueueConnection doCreateQueueConnection(@Nullable String username, @Nullable String password) throws JMSException { ConnectionFactory target = obtainTargetConnectionFactory(); if (!(target instanceof QueueConnectionFactory)) { throw new javax.jms.IllegalStateException("'targetConnectionFactory' is not a QueueConnectionFactory"); } QueueConnectionFactory queueFactory = (QueueConnectionFactory) target; if (StringUtils.hasLength(username)) { return queueFactory.createQueueConnection(username, password); } else { return queueFactory.createQueueConnection(); } } /** * 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. * @see #doCreateTopicConnection */ @Override public final TopicConnection createTopicConnection() throws JMSException { JmsUserCredentials threadCredentials = this.threadBoundCredentials.get(); if (threadCredentials != null) { return doCreateTopicConnection(threadCredentials.username, threadCredentials.password); } else { return doCreateTopicConnection(this.username, this.password); } } /** * Delegate the call straight to the target TopicConnectionFactory. */ @Override public TopicConnection createTopicConnection(String username, String password) throws JMSException { return doCreateTopicConnection(username, password); } /** * This implementation delegates to the {@code 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 * {@code createTopicConnection()} method of the target ConnectionFactory. * @param username the username to use * @param password the password to use * @return the Connection * @see javax.jms.TopicConnectionFactory#createTopicConnection(String, String) * @see javax.jms.TopicConnectionFactory#createTopicConnection() */ protected TopicConnection doCreateTopicConnection(@Nullable String username, @Nullable String password) throws JMSException { ConnectionFactory target = obtainTargetConnectionFactory(); if (!(target instanceof TopicConnectionFactory)) { throw new javax.jms.IllegalStateException("'targetConnectionFactory' is not a TopicConnectionFactory"); } TopicConnectionFactory queueFactory = (TopicConnectionFactory) target; if (StringUtils.hasLength(username)) { return queueFactory.createTopicConnection(username, password); } else { return queueFactory.createTopicConnection(); } } @Override public JMSContext createContext() { return obtainTargetConnectionFactory().createContext(); } @Override public JMSContext createContext(String userName, String password) { return obtainTargetConnectionFactory().createContext(userName, password); } @Override public JMSContext createContext(String userName, String password, int sessionMode) { return obtainTargetConnectionFactory().createContext(userName, password, sessionMode); } @Override public JMSContext createContext(int sessionMode) { return obtainTargetConnectionFactory().createContext(sessionMode); } private ConnectionFactory obtainTargetConnectionFactory() { Assert.state(this.targetConnectionFactory != null, "'targetConnectionFactory' is required"); return this.targetConnectionFactory; } /** * Inner class used as ThreadLocal value. */ private static final class JmsUserCredentials { public final String username; public final String password; public JmsUserCredentials(String username, String password) { this.username = username; this.password = password; } @Override public String toString() { return "JmsUserCredentials[username='" + this.username + "',password='" + this.password + "']"; } } }