Question

I’m starting a new project, trying to do things right this time(so more than one question), I might need some help, I’m not sure what I’m doing wrong :

1. Spring context
2. Controller
3. Service Interface
4. Service Implementation
5. DAO interface
6. DAO implementation

I want to utilize spring MVC as much as possible, how do I make session opening/closing handled by @Transactional?

How do I catch the exceptions(i.e. non existing record or database failed) if any. i.e My database doesn’t accept duplicate entries like this one :

com.mysql.jdbc.exceptions.jdbc4.MySQLIntegrityConstraintViolationException: Duplicate entry

How can I catch this?

And for every next request I make I get this exception :

org.hibernate.AssertionFailure: null id in com.test.spring.ws.service.impl.TestObject entry (don't flush the Session after an exception occurs)

What I’m doing wrong? Can anyone suggest some improvements in my project?

Answer 1

Component Scan

First things first: you’re using @Controller, @Service, @Repository, and an @Autowired, but you don’t do anything with them. I recommend using classpath scanning. Remove the “testServiceDAO” and “testService” beans from your spring context file, and instead use:

<context:component-scan base-package="com.test.spring.ws"/>

That will find and create those beans by their annotations instead of requiring you to declare them in the XML. Add @Autowired to the testServiceDAO field in your service and to the sessionFactory field in your DAO. Remove the setters for these fields. They’re no longer needed. The component-scan tag will also do the autowiring for you. To use the context namespace, you need to add it to your root element. For example:

<beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:context="http://www.springframework.org/schema/context"
     xsi:schemaLocation="
         http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context-3.0.xsd">

Transaction Management

To use @Transactional, as Sean said, you need to add an element to your spring context file:

<tx:annotation-driven/>

Since your transaction manager bean is named “transactionManager”, it will find it automatically. You also need to add the “tx” namespace to your root element, so it should look something like:

<beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:context="http://www.springframework.org/schema/context"
     xmlns:tx="http://www.springframework.org/schema/tx"
     xsi:schemaLocation="
         http://www.springframework.org/schema/beans 
         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
         http://www.springframework.org/schema/tx 
         http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context-3.0.xsd">

For this to have any chance of working, you need to remove both session.beginTransaction() and session.close() from your DAO method. Opening your own transaction in that way is mixing programmatic and declarative transaction demarcation, and the declarative way is usually better. Also, you should never ever close a session in a DAO in a real project. That will get you into all kinds of trouble.

Exception Handling

Your MySQLIntegrityConstraintViolationException, being a database-specific exception, would be caught by Hibernate and wrapped in a ConstraintViolationException, which is what would come out of your DAO; however, since your DAO is a @Repository now, you can benefit from Spring’s exception translation. With this, the Hibernate exception will be caught by Spring and translated to a DataIntegrityViolationException. Database exception handling is always fun!

Session Management

Are you using an OpenSessionInViewFilter or OpenSessionInViewInterceptor? If so, a Hibernate session is opened when a request is first received and closed after the response is written. If not, then the session doesn’t start until a transaction begins (at an @Transactional method), and it’s closed when that transaction finishes. With the filter/interceptor, you can do things in the “view” tier that require calling back to the database–specifically when you have lazy relationships or lazy-loaded objects that you need for rendering the view. If the session isn’t available–as it isn’t if it only exists for the length of the transactional service method–you can’t do those things in the view and you’ll get the infamous LazyInitializationException.

As for the “don’t flush the Session after an exception occurs” error you’re getting, I don’t see anything immediately that would make me think that should happen. Perhaps something in your web-tier spring context is misconfigured, or maybe there’s some weird interplay in how you’re handling the transaction and session directly in the DAO.