Lazy Initialization

Let's say for simplicity that I have the following

Class A
Collection bs

Class B
Collection cs

Class C
Collection ds

Class D

A) So I basically have a chain of one-to-many relationships, all of which are using lazy initialization. At what point should each Collection actually get loaded? It appears, from my testing, that as soon as I reference the Collection of bs, all subsequent collections also get loaded. I would have guessed that each related Collection would not be loaded until it was explicitly referenced. So, I am not sure if this is the way it is supposed to work, or I am doing something wrong here.


B) In some cases, referencing these collections may throw a LazyInitializationException. Because it is a RuntimeException, there is no real graceful/pretty way to recover from this. Is there a write-up somewhere that explains why this is this way, or why the DAO's do not throw an exception? I have seen many posts on this subject, but none that really explained things well.



net.sf.hibernate.UserType

I have created a few of these, but I have not seen any documentation on how it is referenced internally. Is it safe to use member variables in these classes? Would/should there be a case that any of the functions ( ie nullSafeSet, nullSafeGet ) are synchronized?


Thanks in advance for any information, the help is much appreciated.

Hello

A: Are really all the one-to-manies set to lazy?

B:I suppose you tried to access a lazy collection after having closed the session. And the Daos are always accessed from within a session.

Salut, Thomas

A: Yes they are all set to lazy. Is this not supposed to happen?

B:No, I did not try to access them outside the session. This will happen without changing code. If the relationship expects there to be rows there, but they are not, then this exception is thrown.

It will also throw this exception if it looses connectivity with the database. Try unplugging your network cable while a look up is being done. The message is very concise. but it is still a RunTimeException.

A. Subsequent lazy one-to-many are not loaded unless they are explicitly requested.

B.
What d you mean


Interesting. You're saying that unplugging the network while accessing a lazy collection in an opened session throws a LazyInitializationException. We could have a subclass of LazyInitializationException to be more precise, but it 'll stay a RT. The collection API does not declare checked exceptions.

A: I will have to look into this more to see if I can see a reason for this happening. While stepping through the code and hibernate logging set to debug, I can see many selects on the first reference to a collection ( those including subsequent collections ) and nothing after I actually reference the subsequent collections.

B: Using the above example

In A I have a foreign key defined as not null; meaning it is a true one-to-many relationship.

In B I have a foreign key defined as nullable; meaning it is actually a zero-to-many relationship.

What would you expect to happen if in either case either the foreign key was null, or its value did not actually exist in the foreign table?

I understand that the first scenario is actually an error, but it can happen. I am just trying to get a good understanding of how things work and what to expect.


Yes, unplugging the network will throw a LazyInitializationException, it looks aas though it wraps a JDBCException. What was the reasoning behind the collection API not declaring any checked exceptions? It would seem like the natural thing to do, but I am sure you all had good reasoning behind it.


Thanks again for the replies.

Hibernate will get lost. I can't remember the exact error message. Just try it, you should get an HibernateException.



Hehe, this is core java api (java.util.Collection). Ask sun to add an HibernateException ;-)