This document introduces YAGDAO, a lightweight Java ORM framework that uses JPA and Hibernate. It provides annotation-based CRUD and custom data access methods without static code generation. YAGDAO supports Spring dependency injection and includes features like generic DAOs, query builders, pagination, and object fetching. The framework aims to reduce boilerplate code and dependency while enabling custom data access layers.

1. Yet Another DAO
JPA Guide
YAGDAO 0.3.1

2. yagdao
 http://www.altuure.com/projects/yagdao
 Mert Can Akkan
 mcakkan@yahoo.com
 http://www.altuure.com

3. overview
 Popular Java ORM layer
 JPA 2.0
 Hibernate
 Spring 3.0+ Support (optional)
 Lightweight
 No Implementation Framework
 No Static Code Generation
 Annotation Based
 GenericDAO/CRUD operations
 Custom operations

4. dependency-heaven
Lightweight framework with minimal dependency
GroupId ArtifactId Version Optional
cglib cglib 2.2 No
commons-logging commons-logging 1.0.2 No
org.antlr antlr-runtime 3.2 No
org.slf4j slf4j-log4j12 1.5.8 No
org.apache.geronimo.specs geronimo-jpa_2.0_spec 1.1 JPA
org.hibernate hibernate-core 3.5.1-Final hibernate
org.hibernate hibernate-entitymanager 3.5.1-Final hibernate
org.springframework spring-beans 3.0.4.RELEASE spring support
org.springframework spring-jdbc 3.0.4.RELEASE spring support
org.springframework spring-orm 3.0.4.RELEASE Spring support

5. maven dependecy
<dependencies>
<dependency>
<groupId>com.altuure</groupId>
<artifactId>com.altuure.yagdao</artifactId>
<version>0.3.1</version>
</dependency>
<dependencies>
<!-- repo.altuure.com-->
<repositories>
<repository>
<id>repo.altuure.com</id>
<name>repo.altuure.com</name>
<url>http://repo.altuure.com</url>
<layout>default</layout>
</repository>
</repositories>

6. my first yagdao
 easy implementation
public interface UserDAO extends
GenericDAO<User,Long>{
}

7. quickstart
 GenericHibernateDAOFactory
userDAO = (UserDAO)
GenericHibernateDAOFactory.createInstance(UserDAO.class,
sessionAccessor);
The GenericHibernateDAOFactory will create instance
of given DAO at the runtime

8. springframework support
 package scan feature
<yagdao:jpa id="DAOFactory1"
base-package="com.altuure.yagdao.blog.dao"
entity-manager-factory="entityManagerFactory"/>
 one by one definition
<yagdao:jpa
base-class="com.altuure.yagdao.blog.dao.UserDAO"
session-factory="mySessionFactory"/>

9. GenericDAO
 save(Object entity)
 update(Object entity)
 load(T id)
 loadLazy(T id)
 delete(Object object)
 delete(T id)
 vs….

10. custom methods
create & update
 Get rid of all setter and getter operations
public interface UserDAO extends GenericDAO<User,Long>{
@YMethod(type = YMethodType.SAVE)
User create(
@YParameter("username")String username,
@YParameter("password")String password,
@YParameter("email")String email);
@YMethod(type = YMethodType.UPDATE)
User updateRoles(long id,
@YParameter("roles")Set roles);
}

11. custom methods
query
 Embeded Query Support
@YMethod(
type = YMethodType.QUERY,
query="select u.username from User u where u.email=:email“
)
String findUsernameByEmailQuery(
@YParameter(value = "email")String email);
 Named Query Support
@YMethod(type = YMethodType.QUERY,queryName="findByEmail")
String findUsernameByEmailNamed(
@YParameter(value = "email")String email);

12. custom methods
execute
@YMethod(type = YMethodType.EXECUTE,
query="update User set password=:password")
int updateAllPasswords(String newPassword);
Tip:
All execute methods must return an integer

13. custom methods
append
 APPEND Method handler is a simple query builder
in which you can append query strings with not null
parameters
@YMethod(type = YMethodType.APPEND,
select = "pbyte,count(id)",
groupBy = "pbyte",
having = "count(id)>10")
List<SimpleBean> appendQuery(
@YParameter("pint>=?") int i);

14. custom methods
criteria &count(experimental)
 Criteria method handler is like append method
handler tries to build a query with not null values by
parsing query parameters.

15. custom methods
criteria
•Custom Paging and order is supported
•Selected field and fetch are supported
@YMethod(type = YMethodType.CRITERIA)
SearchResultList<SimpleBean>
criteria1(@YParameter(value = "pint>=") Integer
arg1);

16. custom methods
count
@YMethod(type = YMethodType.COUNT)
long count2(@YParameter("pint") Integer arg1,
@YParameter("pdate<=")Date endDate);
Returns only count query result of criteria method
To execute both see SearchResultList

17. smart parameters & return types
 YPage: enables order and paging
 criteria methods
 YLimit: enables only paging
 append method
 criteria methods
 SearchResultList: fetch total size of result list
public SearchResultList(List<T> result,
long totalCount, YPage paging) {
super(result);
this.totalCount = totalCount;
this.paging = paging;
}

18. paging
To add paging to any querying method is easy just
add YPage,YLimit as a method parameter
@YMethod(type = YMethodType.APPEND,orderBy = "id desc")
SearchResultList appendPage1(@YParameter("pbyte>=?")
byte arg1,YLimit limit);
PS: YLimit is valid in all while YPage is valid on only
Criteria Methods

19. prefetch result size
Defining ‘SearchResultList’ as a return type enables a
count queires for all methods
@YMethod(type = YMethodType.CRITERIA)
SearchResultList<SimpleBean> criteria1(@YParameter(value = "pint>=") Integer
arg1);

20. and more
 Object based and method based fetch support
@YMethod(type = YMethodType.CRITERIA)
@YFetch({ "product", "order", "order.customer" })
List<OrderItem> findByCustomerCityAndMaxPrice2(…);
 projection support at append methods

21. thanks 
For more please see sample application:
http://code.google.com/p/yagdao/downloads/list?q=label:Type-Sample
maven jetty:run
http://localhost:8080/blog