public boolean areCallbacksLocalToHibernateTransactions() 
{
		return false;
}

{@inheritDoc}

 public  void configure(Properties props) throws HibernateException 
{
	                                    	 
		this.initialContext = resolveInitialContext( props );
		this.userTransactionName = resolveUserTransactionName( props );
		log.trace( "Configured JTATransactionFactory to use [{}] for UserTransaction JDNI namespace", userTransactionName );
}

Configure this transaction factory. Specifically here we are attempting to resolve both an InitialContext as well as the JNDI namespace for the UserTransaction .

 public Transaction createTransaction(JDBCContext jdbcContext,
    Context transactionContext) throws HibernateException 
{
		UserTransaction ut = getUserTransaction();
		return new JTATransaction( ut, jdbcContext, transactionContext );
}

{@inheritDoc}

 public ConnectionReleaseMode getDefaultReleaseMode() 
{
		return ConnectionReleaseMode.AFTER_STATEMENT;
}

{@inheritDoc}

 protected InitialContext getInitialContext() 
{
		return initialContext;
}

Getter for property 'initialContext'.

 protected UserTransaction getUserTransaction() 
{
		log.trace( "Attempting to locate UserTransaction via JNDI [{}]", getUserTransactionName() );
		try {
			UserTransaction ut = ( UserTransaction ) getInitialContext().lookup( getUserTransactionName() );
			if ( ut == null ) {
				throw new TransactionException( "Naming service lookup for UserTransaction returned null [" + getUserTransactionName() +"]" );
			}
			log.trace( "Obtained UserTransaction" );
			return ut;
		}
		catch ( NamingException ne ) {
			throw new TransactionException( "Could not find UserTransaction in JNDI [" + getUserTransaction() + "]", ne );
		}
}

Get the UserTransaction reference.

 protected String getUserTransactionName() 
{
		return userTransactionName;
}

Getter for property 'userTransactionName'. The algorithm here is

 public boolean isTransactionInProgress(JDBCContext jdbcContext,
    Context transactionContext,
    Transaction transaction) 
{
		try {
			// Essentially:
			// 1) If we have a local (Hibernate) transaction in progress
			//      and it already has the UserTransaction cached, use that
			//      UserTransaction to determine the status.
			// 2) If a transaction manager has been located, use
			//      that transaction manager to determine the status.
			// 3) Finally, as the last resort, try to lookup the
			//      UserTransaction via JNDI and use that to determine the
			//      status.
			if ( transaction != null ) {
				UserTransaction ut = ( ( JTATransaction ) transaction ).getUserTransaction();
				if ( ut != null ) {
					return JTAHelper.isInProgress( ut.getStatus() );
				}
			}
			if ( jdbcContext.getFactory().getTransactionManager() != null ) {
				return JTAHelper.isInProgress( jdbcContext.getFactory().getTransactionManager().getStatus() );
			}
			else {
				UserTransaction ut = getUserTransaction();
				return ut != null && JTAHelper.isInProgress( ut.getStatus() );
			}
		}
		catch ( SystemException se ) {
			throw new TransactionException( "Unable to check transaction status", se );
		}
}

{@inheritDoc}

 public boolean isTransactionManagerRequired() 
{
		return false;
}

{@inheritDoc}

 protected final InitialContext resolveInitialContext(Properties properties) 
{
		try {
			return NamingHelper.getInitialContext( properties );
		}
		catch ( NamingException ne ) {
			throw new HibernateException( "Could not obtain initial context", ne );
		}
}

Given the lot of Hibernate configuration properties, resolve appropriate reference to JNDI InitialContext .

In general, the properties in which we are interested here all begin with hibernate.jndi. Especially important depending on your environment are hibernate.jndi.url and hibernate.jndi.class

 protected final String resolveUserTransactionName(Properties properties) 
{
		String utName = properties.getProperty( Environment.USER_TRANSACTION );
		if ( utName == null ) {
			TransactionManagerLookup lookup = TransactionManagerLookupFactory.getTransactionManagerLookup( properties );
			if ( lookup != null ) {
				utName = lookup.getUserTransactionName();
			}
		}
		return utName == null ? DEFAULT_USER_TRANSACTION_NAME : utName;
}

Given the lot of Hibernate configuration properties, resolve appropriate JNDI namespace to use for UserTransaction resolution.

We determine the namespace to use by

1. Any specified jta.UserTransaction config property
2. If a TransactionManagerLookup was indicated, use its TransactionManagerLookup#getUserTransactionName
3. finally, as a last resort, we use #DEFAULT_USER_TRANSACTION_NAME