One of the greatest new features coming to 1.1 release of Demoiselle Framework [1] is the ability of using JPA [2] (Java Persistence API) in a straightforward manner. JPA specification [3] is a trend in Java development and is often recommended to be used in new applications.
In this article we'll explore the technical steps involved on developing the simplest DAO [4] (Data Access Object) implementation classes with the new JPA support components.
So, what's new in Demoiselle concerning JPA? First of all, there is a new injection aspect towards IDAO [5] interfaces. Basic classes implementing IDAO interface should now simply have an attribute of type EntityManager [6] annotated by @Injection and then with the aid of AspectJ engine and some proxy classes the magic happens!
For instance, consider the following IDepartmentDAO interface in order to manage a Department entity:
public interface IDepartmentDAO extends IDAO<Department> {
public Department findById(Short id);
}
The respective implementation class DepartmentDAO should have the structure below:
public class DepartmentDAO implements IDepartmentDAO {
@Injection
private EntityManager em;
public Department findById(Short id) {
return em.find(Department.class, id);
}
public boolean exists(Department pojo) {
return em.contains(pojo);
}
public Object insert(Department pojo) {
em.persist(pojo);
return pojo;
}
public void update(Department pojo) {
em.merge(pojo);
}
public void remove(Department pojo) {
em.remove(pojo);
}
}
Simple, isn't it?
EntityManager is the interface used to interact with the persistence context in JPA. A persistence context is a set of entity instances in which for any persistent entity identity there is a unique entity instance. Within the persistence context, the entity instances and their lifecycle are managed. This interface defines the methods that are used to interact with the persistence context. The EntityManager API is used to create and remove persistent entity instances, to find entities by their primary key, and to query over entities.
Within a given unit of work, such as an HTTP request in web applications, a single instance of EntityManager is created and automatically injected on every DAO class that is referenced on that thread. That EntityManager is then closed as the transaction is finished.
Moreover, even outside a complete and robust Java EE application, i.e. without an EJB [3] container, the developer could make easy use of JPA in Demoiselle!
In order to turn it even simpler for the developer, the DAO implementation could still make use of the new JPAGenericDAO [7] support class. Thus, DepartmentDAO could have the following code:
public class DepartmentDAO extends JPAGenericDAO<Department>
implements IDepartmentDAO {
public Department findById(Short id) {
return super.findById(id);
}
}
In other words, there is no need anymore of storing an EntityManager field and to implement all IDAO methods. That is, there will be almost nothing left to do but customized business rules methods!
If you want to know more about the framework technical details, there will be another article explaining the whole architecture behind the scenes. :D
References:
[1] Demoiselle Framework
[2] The Java Persistence API
[3] EJB 3.0 JPA Specification
[4] Data Access Object
[5] IDAO interface
[6] EntityManager interface
[7] JPAGenericDAO class
