DAO, Spring and Hibernate

Question

Correct me if anything is wrong.

Now when we use Spring DAO for ORM templates, when we use @Transactional attribute, we do not have control over the transaction and/or session when the method is called externally, not within the method.

Lazy loading saves resources - less queries to the db, less memory to keep all the collections fetched in the app memory.

So, if lazy=false, then everything is fetched, all associated collections, that is not effectively, if there are 10,000 records in a linked set.

Now, I have a method in a DAO class that is supposed to return me a User object. It has collections that represent linked tables of the database. I need to get a object by id and then query its collections.

Hibernate "failed to lazily initialize a collection" exception occurs when I try to access the linked collection that this DAO method returns.

Explain please, what is a workaround here?

Update: All right, let me ask you this. DAO is an abstract layer, so a method "getUserById(Integer id)" is supposed to return an Object.

What if in some cases I need these linked collections of the User object and in other situation I need those collections.

Are there only two ways: 1) lazy loading = false 2) create different methods: getUserByIdWithTheseCollections(), getUserByIdWithOtherCollections() and inside those methods use your approach?

I mean are there only 2 ways and nothing better?

Update 2: Explain please, what would give me the explicit use of SESSIONFACTORY? How does it look in practice? We create an instance of DAO object, then inject it with session factory and this would mean that two consequent method calls to DAO will run within the same transaction? It seems to me that anyway, DAO is detached from the classes that make use of it!

The logic and transactions are encapsulated within DAO, right?

Answer 1

You can get the linked collection in transaction to load it while you're still within the transaction:

User user = sessionFactory.getCurrentSession().get(User.class, userId);
user.getLinkedCollection().size();
return user;

As BalusC has pointed out, you can use Hibernate.initialize() instead of size(). That's a lot cleaner.

Then when you return such an entity, the lazy field is already initialized.

Replying to your PS - is using transactions on service level (rather than DAO) level feasible? It seems to be, as doing each DAO call in separate transaction seems to be a waste (and may be incorrect).

Answer 2

I find that it's best to put @Transactional at the service layer, rather than the DAO layer. Otherwise, all your DAO calls are in separate hibernate sessions - all that object equality stuff won't work.

Answer 3

In my opinion best way to solve this problem will be to design application in a session-per-request model. Then, if you even have an object taken from DAO, until your OSIV pattern works you can use the object safely anywhere in application, even in views without bothering this stuff. This is probably better solution that those proposed because:

1. Hibernate.initialize() or size is a very artificial workaround - what if you want to have User with different collection initialized, would you write another method for getting user?
2. Service layer transactional model is OK, but the same problem comes when you want to get object extracted from the service layer to use it in controller or view

Answer 4

You could do something like following:

public User getByUserId(Long id, String ... fetch) {
    Criteria criteria = createCriteria();

    if (fetch != null) {
        for (String fieldName : fetch) {
             criteria.setFetchMode(fieldName, FetchMode.JOIN); // fetch these fields eagerly
        }
    }
    return criteria.add(Restrictions.eq("id", id)).list();
}