What is the interaction between Hibernate classes and Java serialization?

We would like to write (for instance) session beans with interfaces such as:

public List getClients();

which would return a List of Client objects fetched on the server with

session.find("from Client");

Eventually, each Client object will have a lazy list of Campaign objects (a standard lazy parent-child mapping where Client is the parent and Campaign is the child).

What might happen if we try to return a List of such Client objects from a session bean, and the session bean is remote? Could we get RemoteExceptions because the Hibernate lazy collection is not serializable?

Additionally, what if we want to pass Clients around in JMS MapMessages? Might we also have similar serialization problems?

What are the best practices with respect to passing Hibernated data objects around between (possibly remote, possibly message-driven) beans? Should we have "flattener" methods which handle our own fetching, to ensure we never pass lazy collections or proxies over the wire? (This is certainly doable, we just want to understand whether we are right to be thinking about this issue or whether there is some other approach altogether....)

Thanks very much.
Cheers,
Rob

Passing lazy collections around is no problem, they are all serializeable. Note however that you can't access them on the client side (no more session available to initialize)

OK. So if I want to make sure that the client side will not hit any exceptions, then I should make sure that the whole collection has been fetched?

I just wanted to verify that I don't have to do something like:

class MyStatelessSessionBean {
public Client getFirstClient () {
// open Session...
Client client = (Client)(session.find("from Client client where client.id='foo'").get(0));
HashSet nonLazyCampaignSet = new HashSet();
nonLazyCampaignSet.addAll(client.getCampaigns());
session.close();
client.setCampaigns(nonLazyCampaignSet);
return client;
// handle exceptions...
}

In other words, I wanted to make sure that it's sufficient to be sure the lazy collection is fully fetched, rather than *also* having to make sure that the collection is serializable. Sounds like it will all be OK :-)

Also I've found the many other threads discussing issues of multi-tier laziness, object graph fetching (CarrierWave), etc., etc. Love this forum!

Thanks,
cheers!
Rob

It is sufficient to do this:


If you really have detatched objects (e.g. sending the objects to a swing application) you have to ensure the client side code does not hit any uninitialized collections, otherwise you get an Exception. If you are still in the server environment (e.g. Servlets, JSP) you should take a look at the Open Session in View pattern in the Wiki Community area.

Groovy. Thank you! I love Hibernate :-)
Cheers ---
Rob