Example:


UserRole u = getById(UserRole.class, userId, roleId);
....
User user = u.getUser();(*)
hibernate will return user assigned to this UserRole class and this is OK,

but

UserRole u = new UserRole(userId, roleId, dateEntered);
this.insert(u);
User user = u.getUser();(**)
this will return NULL for user.

How to make that (**) return user object as (*)?

in UserRole.hbm file I have something like:
...
<many-to-one name="user" class="User" fetch="select" >
<column name="userId" not-null="true" />
</many-to-one>
..

Need to see the code for this UserRole constructor:

This is just example, same will happen with this constructor:

dateEntered is here just to see that there can be more fields.

Pass actual User and Role objects to a constructor instead of passing just the foreign keys, and then construct it using those objects.



The this.user = user and user.getUserRoles.add(this) will associate the User object to the UserRole and vice versa, and the this.role = role and role.getUserRoles.add(this) will associate the Role to the UserRole and vice versa. If Hibernate is configured properly, then it will handle the associations and insertions. There are a couple ways this code can be improved (getUserRoles() in the User and Role classes needs to be null safed wrt the collections, probably better to add the bidirectional pairings in the setUser() and setRole() methods of the UserRole class and then call those in the constructor).

Do yourself a favor and pass around references to the POJOs instead of the primary keys (the only place I ever use the primary keys are in load methods to load a single POJO). Break out of those JDBC/SQL shackles and be free! :D

Ok, I know that, but I'm want to avoid extra coding. With this solution I need to read user and role object by my self. In first example:

hibernate do all reading, and in this example you posted, I have to read it and add it, and I want to avoid that.
Is there a way that hibernate do that for me as in (*) example?

It is weird that after:


and after this:


or


user object returned from (*) is realy User object, and
user object returned from (**) and (***) is null?

Note than in (*) and (***) I have same code for reading userRole and user object!!

After the insert, Hibernate will use it's first level cache to resolve the UserRole after insertion. By using the foreign keys to insert data, it will not resolve the joined classes until the UserRole object is evicted. If you have to do it this way, after your insert, evict the UserRole object and then reread it from Hibernate. For example,



An alternative to evicting and rereading is to resolve the associations inside the aforementioned constructor, but that introduces a strong dependecy on Hibernate in your domain layer, not a good thing to say the least.

and this make sense, but it is not the case...

So, after insert, I need to evict inserted data, and hibernate will than read same data as evicted data from database and than associate foreign keys to joinned classes.
There is one unnecessary reading from database!
Is this a bug in hibernate logic?

Nope, it's just a consequence of loading your domain object using the foreign keys instead of the foreign domain objects. Really, we are only talking a couple lines of code here:

In UserRole.java:


Service layer method:


This maintains your flexibility to create objects using their foreign keys, but will still associate the User and Role objects properly while maintaining proper separation of concerns.