Hi,
is there any set of best practices how to use hibernate in distributed enviroments (WS,RMI etc.)?

For exmaple:
class Parent
Set childrens;

User gets a long list of Parents but he clicks maybe 3 or 4 of them during his work with application.
So it's a waste of memory to load all childrens(lazy="false" or Hibernate.initialize(childrens) for instance)...
But when the application is distributed over the Internet then user have to wait after clicking the parent to get childrens
(it's even the same story with parents - load whole objects to get the procedure 'View detail' faster
or load only the names for viewing in list of parents - but make user wait after calling 'View detail' to load data)?

Thank you

My take is this: never ever use Lazy=”true” for distributed environment.
The situation with list of objects:
well, there should not be “objects”, the list should contain briefs about real objects, the real ones should be instantiated when user makes choice – click on one.

Unfortunately Hibernate does not support auto conversion of a result set into a list of maps, and does not support using naming conventions to call setters on objects, although Max wants to add it at some point. Therefore there are options:
create separate mapping for lightweight objects (or maps);
use native query support and map result sets to list of arrays;
supplement Hibernate with direct JDBC;
supplement Hibernate with iBatis;

Note: if you use master-details relationships then Hibernate uses own implementation of collection interfaces, therefore in case of RMI client should have hibernate.jar in its classpath.
Or Hibernate collections has to be replaced with Java standard ones like this:
parent.setChildren( new ArrayList( parent.getChildren()));

So the working solution can be to create lightweight object ParentSmall (name,surname,age)
to make it faster when user clicks it in the list to view the brief information(ParentSmall is loaded locally - but what if I have 50 thousand of them in database?)
and real Parent object (ParentSmall+address,childrens) which is full-value object (user clicks 'full info' for instance)
which will be loaded on demand?

And lazy="false" everywhere?


What's the preffered approach? Is it only about the time to download client (with/out hibernate.jar) or is there any other complication?
now I have to have hibernate.jar in client classpath...

Thank you

Time to download hibernate.jar on client is the only concern.
ParentSmall and ParentFull might be entity names in the mappings and employ the same class, or they can be separate classes
For the list use "from ParentSmall where ...."
When client will need ParentFull then the retrieval of the object will happens in a separate H session where you can employ method like session.get( ParentFull.class, id); so no problems are expected
and then you need to make sure that object is fully initialized before sending it over the wire.
http://www.hibernate.org/hib_docs/v3/re ... e-fetching