Is there a way to change the JPA fetch type on a method? - jpa

Question

Is there a way to change the JPA fetch type on a single method without editing the entity object?
I have a shared ORM layer consisting of JPA entity classes. This ORM layer is accessed by two DAO layers. One DAO needs lazy fetching, as it is for my web application, the other needs eager fetching, as I need it to be threadsafe.
Here is an example method from my threadsafe DAO,
#PersistenceContext(unitName = "PersistenceUnit", type = PersistenceContextType.TRANSACTION)
private EntityManager em;
public ErrorCode findErrorCodeById(short id) {
return (ErrorCode) em.createNamedQuery("ErrorCode.findById").
setParameter("id", id).getSingleResult();
}
How would I make this method (or entire class) use eager fetching?

Answer 1

I assume that your entity associations (#OneToOne, #OneToMany, #ManyToOne) are fechted lazy (FetchType.Lazy)
Then I can think of two ways:
A. write two jpa query one which fetch the association of the lazy (thats the default way for hibernate) and a second query which explicit force eager loading of association (see "fetch" keyword in query).
Query q = HibernateUtil.getSessionFactory().getCurrentSession()
.createQuery("select c from Category as c" +
" left join fetch c.categorizedItems as ci" +
" join fetch ci.item as i");
B. use Hibernate.initialize(entity) to force eager loading of lazy relations of an entity after you have retrieved it (e.g. through finder ...)
ErrorCode lazyCode = findErrorCodeById(1);
// eager load associations
Hibernate.initialize(lazyCode);

Answer 2

In JPA the Fetch mode is specified on each persistence attribute, either through an annotation or in an xml mapping file.
So a JPA vendor agnostic way to accomplish your goal is to have separate mapping file for each DAO layer. Unfortunately this will require a separate PersistenceUnit for each mapping file, but you can at least share the same entity classes and the same JPQL query.
Code skeletons follow.
persistence.xml :
<persistence>
<persistence-unit name="dao-eager">
<mapping-file>orm-eager.xml</mapping-file>
</persistence-unit>
<persistence-unit name="dao-lazy">
<mapping-file>orm-lazy.xml</mapping-file>
</persistence-unit>
</persistence>
orm-eager.xml :
<entity-mappings>
<entity class="ErrorCode">
<attributes>
<basic name="name" fetch="EAGER"/>
</attributes>
</entity>
</entity-mappings>
orm-lazy.xml :
<entity-mappings>
<entity class="ErrorCode">
<attributes>
<basic name="name" fetch="LAZY"/>
</attributes>
</entity>
</entity-mappings>
Then it's just a matter of creating an EntityManagerFactory for the appropriate persistence-unit in your DAO layers.
Actually you don't need two mapping files, you could specify either LAZY or EAGER as an annotation in the Entity and then specify the opposite in an xml mapping file (you'll still want two persistence-units though).
Might be a little more code than the Hibernate solution above, but your application should be portable to other JPA vendors.
As an aside, OpenJPA provides similar functionality to the Hibernate solution above using FetchGroups (a concept borrowed from JDO).
One last caveat, FetchType.LAZY is a hint in JPA, the provider may load the rows eagerly if needed.
Updated per request.
Consider an entity like this :
#Entity
public class ErrorCode {
// . . .
#OneToMany(fetch=FetchType.EAGER) // default fetch is LAZY for Collections
private Collection myCollection;
// . . .
}
In that case you'd still need two persistence units, but you'll only need orm-lazy.xml. I changed the field name to reflect a more realistic scenario (only collections and blobs use FetchType.LAZY by default). So the resulting orm-lazy.xml might look like this :
<entity-mappings>
<entity class="ErrorCode">
<attributes>
<one-to-many name="myCollection" fetch="LAZY"/>
</attributes>
</entity>
</entity-mappings>
And persistence.xml will look like this :
<persistence>
<persistence-unit name="dao-eager">
<!--
. . .
-->
</persistence-unit>
<persistence-unit name="dao-lazy">
<!--
. . .
-->
<mapping-file>orm-lazy.xml</mapping-file>
</persistence-unit>
</persistence>

Answer 3

In JPA2 I use EntityGraphs, which allows you to define what related entities you want to retrieve:
https://docs.oracle.com/javaee/7/tutorial/persistence-entitygraphs002.htm
https://docs.oracle.com/javaee/7/tutorial/persistence-entitygraphs003.htm
You create a NamedQuery as you did, and you attach a Hint with key javax.persistence.loadgraph or javax.persistence.fetchgraph. It will retrieve the related entities that you defined in the graph.
You can find the details of difference between "loadgraph" and "fetchgraph" here: What is the diffenece between FETCH and LOAD for Entity graph of JPA?

Answer 4

Since no one mentioned OpenJPA, I will put an answer here.
In OpenJPA, the previously lazy configured collections and fields can be eagerly loaded as below
OpenJPAEntityManager kem = OpenJPAPersistence.cast(em);
kem.getFetchPlan().addField(Order.class, "products");
TypedQuery<Order> query = kem.createQuery(yourQuery, Order.class);
Reference:http://openjpa.apache.org/builds/1.0.3/apache-openjpa-1.0.3/docs/manual/ref_guide_fetch.html