Reduce Boilerplate Code for DAO's -- Hades Introduction

Most web applications will have DAO's for accessing the database layer. A DAO provides an interface for some type of database or persistence mechanism, providing CRUD and finders operations without exposing any database details. So, in your application you will have different DAO's for different entities. Most of the time, code that you have written in one DAO will get duplicated in other DAO's because much of the functionality in DAO's is same (like CRUD and finder methods).

One of way of avoiding this problem is to have generic DAO and have your domain classes inherit this generic DAO implementation. You can also add finders using Spring AOP; this approach is explained Per Mellqvist in this article. There is a problem with the approach: this boiler plate code becomes part of your application source code and you will have to maintain it. The more code you write, there are more chances of new bugs getting introduced in your application. So, to avoid writing this code in an application, we can use an open source framework called Hades.

Hades is a utility library to work with Data Access Objects implemented with Spring and JPA. The main goal is to ease the development and operation of a data access layer in applications.  In this article, I will show you how easy it is write DAO's using Hades without writing any boiler plate code.

In order to introduce you to Hades, I will show you how we can manage an entity like Book. Before we write any code we need to add the following dependencies to pom.xml.

<dependency>
			<groupId>org.synyx.hades</groupId>
			<artifactId>org.synyx.hades</artifactId>
			<version>2.0.0.RC3</version>
		</dependency>
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-entitymanager</artifactId>
			<version>3.5.5-Final</version>
		</dependency>

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Book {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    @Column(unique = true)
    private String title;

    private String author;
    private String isbn;
    private double price;

    // setters and getters

}

import org.synyx.hades.dao.GenericDao;

public interface BookDao extends GenericDao<Book, Long> {

}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jdbc="http://www.springframework.org/schema/jdbc"
	xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
	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
	http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-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/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd">

	<bean id="bookDao" class="org.synyx.hades.dao.orm.GenericDaoFactoryBean">
		<property name="daoInterface" value="com.shekhar.hades.BookDao"></property>
	</bean>

	<bean id="entityManagerFactory"
		class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
		<property name="dataSource" ref="dataSource" />
	</bean>

	<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
		<property name="entityManagerFactory" ref="entityManagerFactory" />
	</bean>

	<jdbc:embedded-database id="dataSource" type="HSQL" />
</beans>

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.0" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
	<persistence-unit name="persistenceUnit" transaction-type="RESOURCE_LOCAL">
        <provider>org.hibernate.ejb.HibernatePersistence</provider>
        <properties>
            <property name="hibernate.dialect" value="org.hibernate.dialect.HSQLDialect"/>
            <!--value='create' to build a new database on each run; value='update' to modify an existing database; value='create-drop' means the same as 'create' but also drops tables when Hibernate closes; value='validate' makes no changes to the database-->
            <property name="hibernate.hbm2ddl.auto" value="create"/>
            <property name="hibernate.ejb.naming_strategy" value="org.hibernate.cfg.ImprovedNamingStrategy"/>
        </properties>
    </persistence-unit>

</persistence>

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
@Transactional
public class BookDaoTest {

    @Autowired
    private BookDao bookDao;
    private Book book;

    @Before
    public void setUp() throws Exception {
        book = new Book();
        book.setAuthor("shekhar");
        book.setTitle("Effective Java");
        book.setPrice(500);
        book.setIsbn("1234567890123");
    }

    @Test
    public void shouldCreateABook() throws Exception {
        Book persistedBook = bookDao.save(book);
        assertBook(persistedBook);
    }

    @Test
    public void shouldReadAPersistedBook() throws Exception {
        Book persistedBook = bookDao.save(book);
        Book bookReadByPrimaryKey = bookDao.readByPrimaryKey(persistedBook.getId());
        assertBook(bookReadByPrimaryKey);
    }

    @Test
    public void shouldDeleteBook() throws Exception {
        Book persistedBook = bookDao.save(book);
        bookDao.delete(persistedBook);
        Book bookReadByPrimaryKey = bookDao.readByPrimaryKey(persistedBook.getId());
        assertNull(bookReadByPrimaryKey);
    }

    private void assertBook(Book persistedBook) {
        assertThat(persistedBook, is(notNullValue()));
        assertThat(persistedBook.getId(), is(not(equalTo(null))));
        assertThat(persistedBook.getAuthor(), equalTo(book.getAuthor()));
    }
}

Auto Configuration Using Spring Namespaces

The way that we have configured the DAO can become quite cumbersome if the number of DAO's increases. To overcome this we can make use of namespaces to configure daos.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jdbc="http://www.springframework.org/schema/jdbc"
	xmlns:hades="http://schemas.synyx.org/hades"
	xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
	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
	http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-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/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd
	http://schemas.synyx.org/hades http://schemas.synyx.org/hades/hades.xsd">

	<hades:dao-config base-package="com.shekhar.hades"
		entity-manager-factory-ref="entityManagerFactory"></hades:dao-config>

	<!-- All other things remain same -->
</beans>

This configuration will trigger the auto detection mechanism of DAOs that extend GenericDAO or Extended-GenericDAO. It will create DAO instances for all the DAO interfaces found in this package. You can use <include-filter> or <exclude-filter> for including or excluding interfaces from getting their beans created.

Adding Finders and Query Methods

So far we have used the inbuilt operations provided by GenericDao but most of the time we need to add our own finders methods like findByAuthorAndTitle, findWithPriceLessThan . Hades makes it very easy for you to add such methods in your domain dao interface like BookDao. Hades provides 3 strategies for creating JPA query at runtime. These are :-

1. CREATE : This will create a JPA query from method name. This strategy ties you with the method name so you have to think twice before changing the method name.

   public interface BookDao extends GenericDao<Book, Long> {
   
       public Book findByAuthorAndTitle(String author, String title);
   }
   
   // test code
    @Test
       public void shouldFindByAuthorAndTitle() throws Exception {
           Book persistedBook = bookDao.save(book);
           Book bookByAuthorAndTitle = bookDao.findByAuthorAndTitle("shekhar", "Effective Java");
           assertBook(bookByAuthorAndTitle);
       }

2. USE DECLARED QUERY : This lets you define query using JPA @NamedQuery  or Hades @Query annotation. If no query is found exception will be thrown.

    @Query("FROM Book b WHERE b.author = ?1")
       public Book findBookByAuthorName(String author);
   
   // test code
       public void shouldFindBookByAuthorName() {
           Book persistedBook = bookDao.save(book);
           Book bookByAuthor = bookDao.findBookByAuthorName("shekhar");
           assertBook(bookByAuthor);
       }

3. CREATE IF NOT FOUND : It is the combination of both the strategies mentioned above. It will first lookup for the declared query and if it is not found will lookup for method name. This is by default option and you can change it by changing query-lookup-strategy attribute in hades:dao-config element. 

Hades queries also has the support for pagination and sorting. You can pass the instance of Pageable and Sort to the finder methods create above.

public Page<Book> findByAuthor(String author, Pageable pageable);
public List<Book> findByAuthor(String author, Sort sort);

Hades is not limited to just limited to CRUD and adding custom finder methods. There are some other features like auditing ,Specifications,etc that I will discuss in second part of this article.