Solving LazyInitializationException via ignorance

Question

There are countless questions here, how to solve the "could not initialize proxy" problem via eager fetching, keeping the transaction open, opening another one, OpenEntityManagerInViewFilter, and whatever.

But is it possible to simply tell Hibernate to ignore the problem and pretend the collection is empty? In my case, not fetching it before simply means that I don't care.

This is actually an XY problem with the following Y:

I'm having classes like

class Detail {
    @ManyToOne(optional=false) Master master;
    ...
}

class Master {
    @OneToMany(mappedBy="master") List<Detail> details;
    ...
}

and want to serve two kinds of requests: One returning a single master with all its details and another one returning a list of masters without details. The result gets converted to JSON by Gson.

I've tried session.clear and session.evict(master), but they don't touch the proxy used in place of details. What worked was

 master.setDetails(nullOrSomeCollection)

which feels rather hacky. I'd prefer the "ignorance" as it'd be applicable generally without knowing what parts of what are proxied.

Writing a Gson TypeAdapter ignoring instances of AbstractPersistentCollection with initialized=false could be a way, but this would depend on org.hibernate.collection.internal, which is surely no good thing. Catching the exception in the TypeAdapter doesn't sound much better.

Update after some answers

My goal is not to "get the data loaded instead of the exception", but "how to get null instead of the exception" I

Dragan raises a valid point that forgetting to fetch and returning a wrong data would be much worse than an exception. But there's an easy way around it:

• do this for collections only
• never use null for them
• return null rather than an empty collection as an indication of unfetched data

This way, the result can never be wrongly interpreted. Should I ever forget to fetch something, the response will contain null which is invalid.

Answer 1

You could utilize Hibernate.isInitialized, which is part of the Hibernate public API.

So, in the TypeAdapter you can add something like this:

if ((value instanceof Collection) && !Hibernate.isInitialized(value)) {
   result = new ArrayList();
}

However, in my modest opinion your approach in general is not the way to go.

"In my case, not fetching it before simply means that I don't care."

Or it means you forgot to fetch it and now you are returning wrong data (worse than getting the exception; the consumer of the service thinks the collection is empty, but it is not).

I would not like to propose "better" solutions (it is not topic of the question and each approach has its own advantages), but the way that I solve issues like these in most use cases (and it is one of the ways commonly adopted) is using DTOs: Simply define a DTO that represents the response of the service, fill it in the transactional context (no LazyInitializationExceptions there) and give it to the framework that will transform it to the service response (json, xml, etc).

Answer 2

What you can try is a solution like the following.

Creating an interface named LazyLoader

@FunctionalInterface // Java 8
public interface LazyLoader<T> {
    void load(T t);
}

And in your Service

public class Service {
    List<Master> getWithDetails(LazyLoader<Master> loader) {
        // Code to get masterList from session
        for(Master master:masterList) {
            loader.load(master);
        }        
    }
}

And call this service like below

Service.getWithDetails(new LazyLoader<Master>() {
    public void load(Master master) {
        for(Detail detail:master.getDetails()) {
            detail.getId(); // This will load detail
        }
    }
});

And in Java 8 you can use Lambda as it is a Single Abstract Method (SAM).

Service.getWithDetails((master) -> {
    for(Detail detail:master.getDetails()) {
        detail.getId(); // This will load detail
    }
});

You can use the solution above with session.clear and session.evict(master)

Answer 3

I have raised a similar question in the past (why dependent collection isn't evicted when parent entity is), and it has resulted an answer which you could try for your case.

Answer 4

The solution for this is to use queries instead of associations (one-to-many or many-to-many). Even one of the original authors of Hibernate said that Collections are a feature and not an end-goal.

In your case you can get better flexibility of removing the collections mapping and simply fetch the associated relations when you need them in your data access layer.

Answer 5

You could create a Java proxy for every entity, so that every method is surrounded by a try/catch block that returns null when a LazyInitializationException is catched.

For this to work, all your entities would need to implement an interface and you'd need to reference this interface (instead of the entity class) all throughout your program.

If you can't (or just don't want) to use interfaces, then you could try to build a dynamic proxy with javassist or cglib, or even manually, as explained in this article.

If you go by common Java proxies, here's a sketch:

public static <T> T ignoringLazyInitialization(
    final Object entity, 
    final Class<T> entityInterface) {

    return (T) Proxy.newProxyInstance(
        entityInterface.getClassLoader(),
        new Class[] { entityInterface },
        new InvocationHandler() {

            @Override
            public Object invoke(
                Object proxy, 
                Method method, 
                Object[] args) 
                throws Throwable {

                try {
                    return method.invoke(entity, args);
                } catch (InvocationTargetException e) {
                    Throwable cause = e.getTargetException();
                    if (cause instanceof LazyInitializationException) {
                        return null;
                    }
                    throw cause;
                }
            }
        });
}

So, if you have an entity A as follows:

public interface A {

    // getters & setters and other methods DEFINITIONS

}

with its implementation:

public class AImpl implements A {

    // getters & setters and other methods IMPLEMENTATIONS

}

Then, assuming you have a reference to the entity class (as returned by Hibernate), you could create a proxy as follows:

AImpl entityAImpl = ...; // some query, load, etc

A entityA = ignoringLazyInitialization(entityAImpl, A.class);

NOTE 1: You'd need to proxy collections returned by Hibernate as well (left as an excersice to the reader) ;)

NOTE 2: Ideally, you should do all this proxying stuff in a DAO or in some type of facade, so that everything is transparent to the user of the entities

NOTE 3: This is by no means optimal, since it creates a stacktrace for every access to an non-initialized field

NOTE 4: This works, but adds complexity; consider if it's really necessary.