Transaction ManageMent in Spring with Hibernate

[s vai]

Hi Following are some of relavent code snippets from my project...What i want ot ask is that whether one must use HibernateTransactionManager if he is using Hibernate in DAO classes to fire queries. Because we are accidentally using DatasourceTransactionManager with Hibernate Query Language in DAO implementation classes. Please calrify my doubts .According to me it shouldn't matter which transaction management strategy we are using...wat say??

My applicationcontext.xml

   <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
							http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">

	<!--  Tomcats Data Source -->
	<!--
		bean id="neebalDataSource"
		class="org.springframework.jndi.JndiObjectFactoryBean"> <property
		name="jndiName"> <value>java:comp/env/jdbc/neebalDataSource</value>
		</property> </bean
	-->
	<!-- DataSource used for Oracle database... -->
	<bean id="neebalDataSource"
		class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName">
			<value>oracle.jdbc.OracleDriver</value>
		</property>
		<property name="url">
			<value>jdbc:oracle:thin:neebal/neebal@//10.1.1.1:1521/ORCL
			</value>
		</property>
		<property name="username">
			<value>neebal</value>
		</property>
		<property name="password">
			<value>neebal</value>
		</property>
	</bean>

	<bean id="mailSession" class="org.springframework.jndi.JndiObjectFactoryBean">
		<property name="jndiName">
			<value>java:comp/env/mail/Session</value>
		</property>
	</bean>

	<!--
		DataSource used for MySQL database... <bean id="neebalMySqLDataSource"
		class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName"> <value>com.mysql.jdbc.Driver</value>
		</property> <property name="url">
		<value>jdbc:mysql://localhost:3306/neebal?autoReconnect=true </value>
		</property> <property name="username"> <value>root</value> </property>
		<property name="password"> <value>root</value> </property> </bean>
	-->


	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
		<property name="dataSource">
			<ref local="neebalDataSource" />
		</property>
		<property name="mappingResources">
			<list>	
                                                                <value>com/neebal/domain/spring/User.hbm.xml							</value>
				<value>com/neebal/domain/spring/Friends.hbm.xml
				</value>
			</list>
		</property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">org.hibernate.dialect.OracleDialect
				</prop>
				<prop key="hibernate.current_session_context_class">thread</prop>
				<prop key="hibernate.hbm2ddl.auto">false</prop>
				<prop key="hibernate.jdbc.batch_size">20</prop>
				<prop key="hibernate.default_batch_fetch_size">20</prop>
				<prop key="hibernate.show_sql">false</prop>
				<prop key="hibernate.cache.use_second_level_cache">false</prop>
				<prop key="hibernate.cache.provider_class">org.hibernate.cache.NoCacheProvider
				</prop>
				<prop key="hibernate.jdbc.use_streams_for_binary">true</prop>
			</props>
		</property>
	</bean>

	<!--
		Transaction manager for a single Hibernate SessionFactory (alternative
		to JTA)
	-->
	<bean id="transactionManager"
		class="org.springframework.orm.hibernate3.HibernateTransactionManager">
		<property name="sessionFactory">
			<ref local="sessionFactory" />
		</property>
	</bean>




	<!-- Transaction manager for a single JDBC Template -->
	<bean id="txManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
		lazy-init="default" autowire="default" dependency-check="default">
		<property name="dataSource" ref="neebalDataSource" />
	</bean>


	<!-- Session Service Bean -->
	<bean id="sessionService" class="com.neebal.framework.service.session.SessionService"
		scope="session">
		<aop:scoped-proxy />
	</bean>

	<bean id="abstractservice" class="com.neebal.framework.service.BaseService"
		abstract="true">
		<property name="sessionService">
			<ref bean="sessionService" />
		</property>
	</bean>

</beans> 

My BasetransactionAction which get a Particular transactionManager Instance and starts the transaction

 public abstract class BaseTransactionAction extends BaseAction {

	/** Standard Logger. */
	private static final Logger log = Logger.getLogger(BaseTransactionAction.class);

	public ActionForward handleExecute(ActionMapping mapping, ActionForm form, HttpServletRequest request,
			HttpServletResponse response) throws Exception {

		TransactionCallback callback = new ActionTransactionCallback(mapping, form, request, response);
		Object forward = null;
		while (true) {
			try {
				forward = getHibernateTransactionTemplate().execute(callback);
			} catch (Exception exo) {
				log.debug("\n\nSQL exception arrived for timeout it seems --");
				String str = StackTraceUtil.getStackTrace((Throwable) exo);
				log.debug(str);
				if (str.indexOf("underlying cause: null") > 1) {
					log.debug("Yes it was SQL connection issue ...\n\n");
					continue;
				}
			}
			break;
		}

		if (forward instanceof BusinessException)
			throw (BusinessException) forward;
		else if (forward instanceof NeebalTransactionException)
			throw (NeebalTransactionException) forward;
		else if (forward instanceof Exception)
			throw (Exception) forward;

		return (ActionForward) forward;
	}

	protected abstract ActionForward handleExecute(ActionMapping mapping, ActionForm form, HttpServletRequest request,
			HttpServletResponse response, TransactionStatus transactionStatus) throws Exception;

	private class ActionTransactionCallback implements TransactionCallback {
		/** Action mapping. */
		private ActionMapping mMapping;

		/** Action form. */
		private ActionForm mForm;

		/** HTTP request. */
		private HttpServletRequest mRequest;

		/** HTTP response. */
		private HttpServletResponse mResponse;

		/**
		 * Constructor that initializes all the fields.
		 * 
		 * @param mapping
		 *            action mapping
		 * @param form
		 *            action form
		 * @param request
		 *            HTTP request
		 * @param response
		 *            HTTP response
		 */
		public ActionTransactionCallback(ActionMapping mapping, ActionForm form, HttpServletRequest request,
				HttpServletResponse response) {
			mMapping = mapping;
			mForm = form;
			mRequest = request;
			mResponse = response;
		}

		/**
		 * @inheritDoc
		 */
		public Object doInTransaction(TransactionStatus transactionStatus) {
			ActionForward forward = null;

			try {
				forward = handleExecute(mMapping, mForm, mRequest, mResponse, transactionStatus);				
				return forward;
			} catch (Exception e) {
				transactionStatus.setRollbackOnly();				
				return e;
			}
		}
	}
}   

My BaseAction class which provides various methods to get differenct types of transaction templates and hence different types of transaction managers:

  public abstract class BaseAction extends ActionSupport {
	// -- Logger
	NeebalLogger logger = new NeebalLogger(BaseAction.class.getName());

	/** Transaction template bean name in spring context. */
	private static final String BEAN_TRANSACTION_TEMPLATE = "txManager";

	/** Transaction template bean name in spring context. */
	private static final String BEAN_HIBERNATE_TRANSACTION_TEMPLATE = "transactionManager";

	// -- Common error page in case user hits the roadBlock
	final static String input = "errorPage";

	/**
	 * Default Constructor.
	 * 
	 * @see Related links
	 * @since
	 */
	public BaseAction() {
		super();
	}

	/**
	 * Abstract method. Handle execute must be implemented by child/extending
	 * classes to process the request.
	 * 
	 * @param ActionMapping
	 *            ActionMapping
	 * @param ActionForm
	 *            ActionForm
	 * @param HttpServletRequest
	 *            HttpServletRequest
	 * @param HttpServletResponse
	 *            HttpServletResponse
	 * @return ActionForward returned ActionForward from the child class.
	 * @throws Exception
	 *             Exceptions written in throws clause.
	 * @see Related links.
	 * @since 1.0
	 */
	protected abstract ActionForward handleExecute(ActionMapping arg0,
			ActionForm arg1, HttpServletRequest arg2, HttpServletResponse arg3)
			throws Exception;

	// -- Store the action errors messages list, if any which would be shown on
	// user screen ..
	private void extractCheckedMessages(BaseException exception,
			HttpServletRequest req) {
		ActionMessages messages = new ActionMessages();
		// -- Add all the errors present in the Exception
		List errorList = (List) exception.getBusinessItems();
		if (errorList != null && errorList.size() > 0) {
			ListIterator errorListIterator = errorList.listIterator();
			while (errorListIterator.hasNext()) {
				messages.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(
						(String) errorListIterator.next()));
			}
		}
		this.saveErrors(req, messages);
	}

	/*
	 * Struts framework calls the method for processing of action commands
	 * 
	 * @seeorg.apache.struts.action.Action#execute(org.apache.struts.action.
	 * ActionMapping, org.apache.struts.action.ActionForm,
	 * javax.servlet.http.HttpServletRequest,
	 * javax.servlet.http.HttpServletResponse)
	 */
	@Override
	public ActionForward execute(ActionMapping mapping, ActionForm form,
			HttpServletRequest req, HttpServletResponse res) throws Exception {
		try {
			ActionForward forward = this.handleExecute(mapping, form, req, res);
			return forward;
		} catch (NeebalRuntimeException runtimeException) {
			// -- Handled by the Declarative Handling Strategy
			throw runtimeException;
		} catch (com.neebal.framework.exception.BusinessException businessException) {
			// -- Extract Messages
			extractCheckedMessages(businessException, req);
			// -- Forward the control, check if input is present. No handling is
			// required for business exceptions in any action classes if you are
			// showing the errors on same page i.e. previous submitted page.
			String lclInput = mapping.getInput();
			// -- if input is null then forward the control to common errorPage
			if (lclInput == null
					|| StringUtils.isEmpty(StringUtils.trim(lclInput)))
				throw businessException;

			// -- Show the mapping.getInput page with errors
			return mapping.findForward(lclInput);
		} catch (BaseException baseException) {
			// -- Handled by the Declarative Handling Strategy
			throw baseException;
		}
		// -- All other exception of type runtime exception, error,
		// -- throwable would be handled by UnhandledThrowableHandler
	}

	/**
	 * Returns transaction template configured in the application context.
	 * 
	 * @return transaction template
	 */
	protected TransactionTemplate getTransactionTemplate() {
		DataSourceTransactionManager transManager = (DataSourceTransactionManager) getWebApplicationContext()
				.getBean(BEAN_TRANSACTION_TEMPLATE);
		return new TransactionTemplate(transManager);
	}

	/**
	 * Returns hibernate transaction template configured in the application
	 * context.
	 * 
	 * @return transaction template
	 */
	protected TransactionTemplate getHibernateTransactionTemplate() {
		HibernateTransactionManager transManager = (HibernateTransactionManager) getWebApplicationContext()
				.getBean(BEAN_HIBERNATE_TRANSACTION_TEMPLATE);
		return new TransactionTemplate(transManager);
	}

	// -- Helper methods to return the services
	protected SessionServiceIF getSessionService() {
		return (SessionServiceIF) getWebApplicationContext().getBean(
				"sessionService");
	}

	
	protected UserServiceIF getUserService() {
		return (UserServiceIF) getWebApplicationContext()
				.getBean("userService");
	}

	}  

one of my action classes which gives call to UserServiceserviceImpl class

  public class AddFriendAction extends BaseTransactionAction {

	/*
	 * (non-Javadoc) allows user to login into the system
	 * 
	 * @see
	 * com.neebal.framework.struts.BaseTransactionAction#handleExecute(org.apache
	 * .struts.action.ActionMapping, org.apache.struts.action.ActionForm,
	 * javax.servlet.http.HttpServletRequest,
	 * javax.servlet.http.HttpServletResponse,
	 * org.springframework.transaction.TransactionStatus)
	 */
	protected ActionForward handleExecute(ActionMapping mapping,
			ActionForm form, HttpServletRequest request,
			HttpServletResponse response, TransactionStatus transactionStatus)
			throws Exception {

		String message = "";
		try {
			Long userId = new Long(request.getParameter("userid"));
			UserBO loggedInUser = (UserBO) getSessionService().getObject(
					KeyConstants.USER_INFO);
			getUserService().addFriend(loggedInUser.getId(), userId);
			message = "Your friend request has been sent to the current profile.";

		} catch (Exception ex) {
			//in case there was an exception the message is set appropriately. 
			message = "cannot send a friend request. Please try again.";
		}

		//the message is finally written to the response.
		response.setContentType("text/html");
		ServletOutputStream out = response.getOutputStream();
		out.write(message.getBytes());
		out.flush();
		out.close();
		return null;
	}

}  

My UserServiceImpl class whioch ultimately gives call to UserDAOImpl

 public class UserServiceImpl extends BaseService implements UserServiceIF {

	private UserDaoIF userDaoIF;

	public UserDaoIF getUserDaoIF() {
		return userDaoIF;
	}

	public void setUserDaoIF(UserDaoIF userDaoIF) {
		this.userDaoIF = userDaoIF;
	}

	public Long addFriend(Long userId, Long friendId) throws BusinessException,
			Exception {

		try {

			UserBO userBO = getUserDaoIF().getUser(userId);
			UserBO friendUser = getUserDaoIF().getUser(friendId);

			FriendBO friend = new FriendBO();
			friend.setApprovalStatus("N");
			friend.setFriendUser(friendUser);
			friend.setUserBO(userBO);

			getUserDaoIF().[code]addFriend

(friend);

} catch (Exception e) {
throw new BusinessException(e);
}

return null;
}
}
[/code]
Finally My UserDAO implementation for the above service method

  
       public class UserDaoImpl extends AbstractHibernateDAO implements UserDaoIF {
                      ...
                   /**
	 * @param: FriendBO friendBO - this object has a userId and and a frindId
	 *         that is to be set as friend of the userId
	 * @return: Long - Id of the object hat was passed in as an argument.
	 */
	public Long addFriend(FriendBO friendBO) throws PersistenceException,
			Exception {

		try {

			friendBO = (FriendBO) getHibernateTemplate().merge(friendBO);

		} catch (Exception e) {
			e.printStackTrace();
			throw new PersistenceException(e);
		}
		return friendBO.getId();
	}
}



  

[Christian Gossart]

If I understand correctly your design, we have the following flow:

1. User login submit

2.

 AddFriendAction.execute(ActionMapping mapping, ActionForm form, HttpServletRequest req, HttpServletResponse res) 

is called, which is in fact

 BaseAction.execute(ActionMapping mapping, ActionForm form, HttpServletRequest req, HttpServletResponse res) 

because it's not overriden neither in AddFriendAction nor in BaseTransactionAction

3. Call is delegated to

 this.handleExecute(mapping, form, req, res)  

which invoke the BaseTransactionAction version of this method (not overriden in AddFriendAction and abstract in BaseAction)

4. In this method you create an ActionTransactionCallback instance:

 TransactionCallback callback = new ActionTransactionCallback(mapping, form, request, response); 

5. This callback is then used with the code:

 getHibernateTransactionTemplate().execute(callback); 

Here, the doInTransaction method of the callback will be invoked, within a transaction exposed by the transaction manager referenced by the given transaction template.
getHibernateTransactionTemplate() returns the Spring bean with id BEAN_HIBERNATE_TRANSACTION_TEMPLATE="transactionManager" which is defined of class org.springframework.orm.hibernate3.HibernateTransactionManager in your Spring application context. This transaction manager manages transactions for its session factory, build on your datasource "neebalDataSource".

Back to the doInTransaction method, the call to

 handleExecute(mMapping, mForm, mRequest, mResponse, transactionStatus) 

triggers the one from AddFriendAction, calling your UserServiceImpl and the underlying UserDaoImpl.

=> In this scenario, transactions are in fact managed by the HibernateTransactionManager. Well, I might have miss something , but I can't see here where you

are accidentally using DatasourceTransactionManager with Hibernate Query Language in DAO implementation classes

.

Your Spring application context also declares also a bean named "txManager", of class org.springframework.jdbc.datasource.DataSourceTransactionManager. This one will manage transactions around the JDBC connections opened from your datasource "neebalDataSource". This will be the case if you use Spring JdbcTemplate for example, but not for HibernateTemplate which is automatically managed by the HibernateTransactionManager if present.

To sum up, I would use the following:

Hibernate-only transaction => HibernateTransactionManager
JDBC-only transaction => DataSourceTransactionManager
Mixed Hibernate-JDBC transaction (same datasource) => HibernateTransactionManager
Mixed transactional datasources => JtaTransactionManager

By the way, try to keep data access in your Dao layer, business in your service layer (with transaction management), and presentation in your presentation layer: a Struts action should not know anything about Hibernate or JDBC or whatever; a service can be transactional, but it should be transparent for the caller (your Struts action)... The more a functionality is confined, the easier it is to debug/enhance/implement differently without breaking the whole application.

Hope this helps

[s vai]

hey Chris

thanks a lot for your input...

actually i made a mistake while posting the post... sorry for that ...but when i replace "getHibernateTransactionTemplate()" with "getTransactionTemplate()" which actually uses datasourcetransactionManager the code and flow works just fine....why??? if i use HibernateTemplate in DAO layer you say i "must" (correct me if i am wrong) use HibernateTransactionTemplate...if yes then i am violating this by using DatasourceTransactionManager.......and still all is well...

where exactly my code would break if i use DatasourceTrnsactionManager instead of HibernateTransactinManager

Please disillusion me from this confusion

[Christian Gossart]

Well transactions are a tricky topic

org.springframework.orm.hibernate3.LocalSessionFactoryBean exposes by default a "transaction-aware" SessionFactory.

Here I assume you extends org.springframework.orm.hibernate3.support.HibernateDaoSupport with your AbstractHibernateDAO, to get access to Spring HibernateTemplate. In that case, when your UserDaoImpl invoke

 getHibernateTemplate() 

, the current Hibernate Session will participate to any Spring-managed transaction, no matter this transaction management strategy or synchronization mechanism (cf. the LocalSessionFactoryBean javadoc). In your case, even if the transaction comes from a DataSourceTransactionManager, the Hibernate Session used by your DAO is aware of it: transaction is opened, JDBC statement created by the HibernateTemplate in the Session is flushed to the database, connection is closed, Session is closed, and the transaction completes.

That's my own understanding, and I'd be glad to see someone confirm or infirm this

[s vai]

hey Chris,

thanks a lot...at least i got someone to support what i was thinking abt....lets hope somebody puts more light on it.....