Hi gurus,

According to the API doc, the load method throws an exception if the persistent instance doesn't exist.
The get method returns null instead. Is this the only difference ?

Why I'm asking this silly question is that the behavior of the persistent instance retrieved by load(...)
and get(...) methods after closing session is different.
Accessing the instance retrieved by load(...) after closing session would throw an exception (InitializationException).
But not for the instance retrieved by get(...) method. It doesn't throw the exception and its properties are accessible.

I assumed that's because the instance retrieved by load(...) is actually a proxy object so accessing the instance
after closing session is detected by the proxy object and would throw an exception. However, the instance retrieved
by get(...) is NOT a proxy object so that accessing the instance cannot be detected. Therefore, accessing the instance
retrieved by get(...) doesn't throw any exceptions and its properties are of course accessible.

Is my assumption correct ?
( I don't think so though... if it is correct, it means I cannot do lazy-fetch on a persistent instance
retrieved by get(...) method since there's no proxy object in it. )

So my questions are :
1. What's difference between Session#load(...) and Session#get(...) other than throwing an exception or not ?
2. Why does accessing a persistent object retrieved by load(...) throw an exception after closing session while one retrieved by get(...) doesn't ?
(If possible, could someone briefly explain me the underlining implementation of those two methods ?)


Cheers,

-Wolfgang

You should have a look here : http://www.hibernate.org/hib_docs/v3/re ... te-loading

You'll understand all you're asking for.

Briefly, you get the main facts :
* load() returns a lazyloaded dynamic-proxy.
* get() returns a "real" instance, though directly accessing the data in database.

That said, the answer to your second question is quite obvious : accessing the reference that has been loaded by load() triggers the database query, right ? So you see why you're receiving a LazyInitializationException with load, if you close the session before accessing the data.

With load, you HAVE to access a property of the object to be able to access it after closing the session. If not, you'll get LazyInitException. But if you do it, the proxy will have been loaded and you won't get this exception anymore, even if you access it once more after closing the session.

Example 1 :

This code throws the LazyInitException.

Example 2 :

This code does NOT throw the LazyInitException.

To sum up, depending on what you want to do, you decide if you want to load() or get() your data, for example, you could use load() if you don't want data to be always loaded. Personnally, most of the time, I use get, because of the inherent risk caused by the lazy-loading. So I always load completely my data when I need it.

OK ?

Wow, u r da bomb !

I now fully understand the fact behind the scene.

Thanks a trillion !

-wolfgang
ps)
How can I give u two more credits ? :)

This way ? :-)