public JmsTransactionManager() 
{
		setTransactionSynchronization(SYNCHRONIZATION_NEVER);
}

Create a new JmsTransactionManager for bean-style usage.

Note: The ConnectionFactory has to be set before using the instance. This constructor can be used to prepare a JmsTemplate via a BeanFactory, typically setting the ConnectionFactory via setConnectionFactory.

Turns off transaction synchronization by default, as this manager might be used alongside a datastore-based Spring transaction manager like DataSourceTransactionManager, which has stronger needs for synchronization. Only one manager is allowed to drive synchronization at any point of time.

Also see:

setConnectionFactory
setTransactionSynchronization

 public JmsTransactionManager(ConnectionFactory connectionFactory) 
{
		this();
		setConnectionFactory(connectionFactory);
		afterPropertiesSet();
}

Create a new JmsTransactionManager, given a ConnectionFactory.

Parameters:

connectionFactory - the ConnectionFactory to obtain connections from

 public  void afterPropertiesSet() 
{
		if (getConnectionFactory() == null) {
			throw new IllegalArgumentException("Property 'connectionFactory' is required");
		}
}

Make sure the ConnectionFactory has been set.

 protected Connection createConnection() throws JMSException 
{
		return getConnectionFactory().createConnection();
}

Create a JMS Connection via this template's ConnectionFactory.

This implementation uses JMS 1.1 API.

 protected Session createSession(Connection con) throws JMSException 
{
		return con.createSession(true, Session.AUTO_ACKNOWLEDGE);
}

Create a JMS Session for the given Connection.

This implementation uses JMS 1.1 API.

 protected  void doBegin(Object transaction,
    TransactionDefinition definition) 
{
		if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
			throw new InvalidIsolationLevelException("JMS does not support an isolation level concept");
		}
		JmsTransactionObject txObject = (JmsTransactionObject) transaction;
		Connection con = null;
		Session session = null;
		try {
			con = createConnection();
			session = createSession(con);
			if (logger.isDebugEnabled()) {
				logger.debug("Created JMS transaction on Session [" + session + "] from Connection [" + con + "]");
			}
			txObject.setResourceHolder(new JmsResourceHolder(getConnectionFactory(), con, session));
			txObject.getResourceHolder().setSynchronizedWithTransaction(true);
			int timeout = determineTimeout(definition);
			if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
				txObject.getResourceHolder().setTimeoutInSeconds(timeout);
			}
			TransactionSynchronizationManager.bindResource(
					getConnectionFactory(), txObject.getResourceHolder());
		}
		catch (JMSException ex) {
			if (session != null) {
				try {
					session.close();
				}
				catch (Throwable ex2) {
					// ignore
				}
			}
			if (con != null) {
				try {
					con.close();
				}
				catch (Throwable ex2) {
					// ignore
				}
			}
			throw new CannotCreateTransactionException("Could not create JMS transaction", ex);
		}
}

 protected  void doCleanupAfterCompletion(Object transaction) 
{
		JmsTransactionObject txObject = (JmsTransactionObject) transaction;
		TransactionSynchronizationManager.unbindResource(getConnectionFactory());
		txObject.getResourceHolder().closeAll();
		txObject.getResourceHolder().clear();
}

 protected  void doCommit(DefaultTransactionStatus status) 
{
		JmsTransactionObject txObject = (JmsTransactionObject) status.getTransaction();
		Session session = txObject.getResourceHolder().getSession();
		try {
			if (status.isDebug()) {
				logger.debug("Committing JMS transaction on Session [" + session + "]");
			}
			session.commit();
		}
		catch (TransactionRolledBackException ex) {
			throw new UnexpectedRollbackException("JMS transaction rolled back", ex);
		}
		catch (JMSException ex) {
			throw new TransactionSystemException("Could not commit JMS transaction", ex);
		}
}

 protected Object doGetTransaction() 
{
		JmsTransactionObject txObject = new JmsTransactionObject();
		txObject.setResourceHolder(
				(JmsResourceHolder) TransactionSynchronizationManager.getResource(getConnectionFactory()));
		return txObject;
}

 protected  void doResume(Object transaction,
    Object suspendedResources) 
{
		JmsResourceHolder conHolder = (JmsResourceHolder) suspendedResources;
		TransactionSynchronizationManager.bindResource(getConnectionFactory(), conHolder);
}

 protected  void doRollback(DefaultTransactionStatus status) 
{
		JmsTransactionObject txObject = (JmsTransactionObject) status.getTransaction();
		Session session = txObject.getResourceHolder().getSession();
		try {
			if (status.isDebug()) {
				logger.debug("Rolling back JMS transaction on Session [" + session + "]");
			}
			session.rollback();
		}
		catch (JMSException ex) {
			throw new TransactionSystemException("Could not roll back JMS transaction", ex);
		}
}

 protected  void doSetRollbackOnly(DefaultTransactionStatus status) 
{
		JmsTransactionObject txObject = (JmsTransactionObject) status.getTransaction();
		txObject.getResourceHolder().setRollbackOnly();
}

 protected Object doSuspend(Object transaction) 
{
		JmsTransactionObject txObject = (JmsTransactionObject) transaction;
		txObject.setResourceHolder(null);
		return TransactionSynchronizationManager.unbindResource(getConnectionFactory());
}

 public ConnectionFactory getConnectionFactory() 
{
		return this.connectionFactory;
}

Return the JMS ConnectionFactory that this instance should manage transactions for.

 public Object getResourceFactory() 
{
		return getConnectionFactory();
}

 protected boolean isExistingTransaction(Object transaction) 
{
		JmsTransactionObject txObject = (JmsTransactionObject) transaction;
		return (txObject.getResourceHolder() != null);
}

 public  void setConnectionFactory(ConnectionFactory cf) 
{
		if (cf instanceof TransactionAwareConnectionFactoryProxy) {
			// If we got a TransactionAwareConnectionFactoryProxy, we need to perform transactions
			// for its underlying target ConnectionFactory, else JMS access code won't see
			// properly exposed transactions (i.e. transactions for the target ConnectionFactory).
			this.connectionFactory = ((TransactionAwareConnectionFactoryProxy) cf).getTargetConnectionFactory();
		}
		else {
			this.connectionFactory = cf;
		}
}

Set the JMS ConnectionFactory that this instance should manage transactions for.