Question

In my Web Application I load many Entities, to display them in a table. I can click on each tablerow to get the ‘detailed information’ regarding the specific entity.

To me it was obvious to not load the ‘detailed information’ for the tableview, but only when someone wants to see it (clicks a row).

Just setting (fetch = FetchType.LAZY) for these fields didn’t work because the entities get detached after fetching and in my WebApp there will be nulls.

Okay, so the next thing I did was to prevent the detaching by putting my fetch-operations into a StatefulSessionBean with an extended PersistenceContext.

@PersistenceContext(unitName="unitname", type=PersistenceContextType.EXTENDED)
private EntityManager em;

This works but produces strange sideeffects too (most notably ConcurrentAccessExceptions on some page reloads, which I could fix by setting some openjpa-property)
Servlets need their own fetching-ejbs since they don’t team up with SFSBs. Atm most things seem to work okay but I’m expecting the s**t to hit the fan soon.

My question is if I’m on the wrong track. This all seems a little awkward to me. Using a stateful bean when there is no real conversation and a user can leave at any time without triggering some @Remove-Method. Having to close resources on Timeout when the user is long gone, resulting in many open-unused SFSBs.

LazyLoading in general is a quite simple thing but in the Java EE Environment I don’t get how to do it. What is the best practice?

Thank you.

UPDATE

this is how I manually fetch the fields now

@SuppressWarnings("unchecked")
public <T extends BasicEntity> T loadLazyField(T entity, String field) throws NoSuchFieldException {
    if (!typeHasField(entity.getClass(), field)) {
        throw new NoSuchFieldException(entity.getClass().getSimpleName() + " has no field called " + field);
    }

    String queryString = String.format("SELECT x FROM %s x WHERE x = :entity LEFT JOIN FETCH x.%s", entity.getClass()
            .getSimpleName(), entity, field);
    Query q = em.createQuery(queryString);
    q.setParameter("entity", entity);
    return (T) q.getSingleResult();
}

@SuppressWarnings("unchecked")
public <T extends BasicEntity> T loadLazyFields(T entity, String[] fields) throws NoSuchFieldException {
    String queryString = String.format("SELECT x FROM %s x WHERE x = :entity", entity.getClass().getSimpleName());

    for (String field : fields) {
        if (!typeHasField(entity.getClass(), field)) {
            throw new NoSuchFieldException(entity.getClass().getSimpleName() + " has no field called " + field);
        }
        queryString += String.format(" LEFT JOIN FETCH x.%s", field);
    }
    Query q = em.createQuery(queryString);
    q.setParameter("entity", entity);
    return (T) q.getSingleResult();

}

private boolean typeHasField(Class<?> type, String field) {
    try {
        type.getDeclaredField(field);
        return true;
    } catch (NoSuchFieldException e) {
        return false;
    }
}

Answer 1

You need a design pattern called “Open Session in View” keeping the persistence session open in the page rendering phase. This feature is provided by Integration Frameworks like Seam.

I’m not sure if this is supported by JSF2, since many features from Seam2 moved to JavaEE6. Anyhow, you should take a look for Seam (although it’s hard to get something running with Seam3).