Question

I’ve been beating my head against a wall for awhile now trying to get this to work. I have created the following data access object:

public interface GenericDAO<T, ID extends Serializable> {
  T findById(ID id);
  List<T> findAll();
  T save(T entity);
  void update(T entity);
  void delete(T entity);
}

public class GenericHibernateDAO<T, ID extends Serializable> implements GenericDAO<T, ID> {

  private final Class<T> persistentClass;
  private final SessionFactory sessionFactory;

  public GenericHibernateDAO(final SessionFactory sessionFactory) {
    this.persistentClass = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
    this.sessionFactory = sessionFactory;
  }

  protected Session getSession() {
    return sessionFactory.getCurrentSession();
  }

  public Class<T> getPersistentClass() {
    return persistentClass;
  }

  @Override
  public T findById(final ID id) {
    return (T) getSession().load(getPersistentClass(), id);
  }

  @Override @SuppressWarnings("unchecked")
  public List<T> findAll() {
    return findByCriteria();
  }

  protected List<T> findByCriteria(final Criterion... criterion) {
    final Criteria crit = getSession().createCriteria(getPersistentClass());
    for (final Criterion c : criterion) {
      crit.add(c);
    }
    return crit.list();
  }

  @Override
  public T save(final T entity) {
    getSession().saveOrUpdate(entity);
    return entity;
  }

  @Override
  public void delete(final T entity) {
    getSession().delete(entity);
  }

  @Override
  public void update(final T entity) {
    getSession().saveOrUpdate(entity);
  }
}

@Repository
public class StockHibernateDAO extends GenericHibernateDAO<Stock, String> implements StockDAO {

  @Inject
  public StockHibernateDAO(final SessionFactory sessionFactory) {
    super(sessionFactory);
  }
}

I’m attempting to set this up with Java Configuration, so here is my configuration to setup my service layer:

@Configuration @Profile("hibernate")
@EnableCaching @EnableTransactionManagement
@ComponentScan("reference.dao.hibernate")
public class HibernateServiceConfig implements TransactionManagementConfigurer {

  @Inject private StockDAO stockDao; //No extra methods, just the base stuff for now

  @Bean(destroyMethod = "shutdown")
  public DataSource dataSource() {
    return new EmbeddedDatabaseBuilder().setType(EmbeddedDatabaseType.HSQL).addScript("classpath:schema.sql").build();
  }

  @Bean
  public SessionFactory sessionFactory() {
    return new LocalSessionFactoryBuilder(dataSource()).addAnnotatedClasses(Stock.class)
    .setProperty("hibernate.show_sql", "true")
    .setProperty("hibernate.cache.region.factory_class", "org.hibernate.cache.ehcache.EhCacheRegionFactory")
    .setProperty("hibernate.cache.use_query_cache", "true")
    .setProperty("hibernate.cache.use_second_level_cache", "true")
    .setProperty("hibernate.dialect", "org.hibernate.dialect.HSQLDialect").buildSessionFactory();
  }

  @Override @Bean
  public PlatformTransactionManager annotationDrivenTransactionManager() {
    return new HibernateTransactionManager(sessionFactory());
  }

}

Here is the TradingService:

@Service
public class TradingServiceImpl implements TradingService {    
  @Inject private StockDAO stockDAO;

  @Override @Transactional
  @CachePut(value = "stockCache", key = "#stock.name")
  public Stock addNewStock(final Stock stock) {
    stockDAO.save(stock);
    return stock;
  }

  @Override @Cacheable(value = "stockCache")
  public Stock getStock(final String stockName) {
    return stockDAO.findById(stockName);
  }

  @Override @CacheEvict(value = "stockCache", key = "#stock.name")
  public void removeStock(final Stock stock) {
    stockDAO.delete(stock);
  }

  @Override @CacheEvict(value = "stockCache", key = "#stock.name")
  public void updateStock(final Stock stock) {
    stockDAO.update(stock);
  }

  @Override
  public List<Stock> getAll() {
    return stockDAO.findAll();
  }
}

The saving of a stock only seems to be completed if I add a session.flush() to the save method. The way I understand things, having the TransactionManager and the @Transactional around the service layer method should in fact cause that call to be made for me. What is this configuration missing?

Answer 1

Because you are injecting a Session

  @Bean
  public Session session() {
    return sessionFactory().openSession();
  }

Spring cannot add it’s transactional behavior around it. Let Spring open the session and do it’s business.

Instead of injecting a Session, inject a SessionFactory. In your DAO, keep a attribute for SessionFactory and use sessionFactory.getCurrentSession() to acquire a session.

When Spring sees the @Transactional, it will get the SessionFactory, call openSession(), begin a transaction on it, then call your method. When your method returns successfully, it will close that transaction.

You should also probably @Autowired the dao in your service class.