Hi community,
I found the statement in hibernate documentation chapter 7.2.3 that states:


http://docs.jboss.org/hibernate/stable/ ... tions.html
and it recommend that to use the 'unidirectional one-to-many association on a join table'

Look like mapping the one-to-many relationship by using the foreign key is about the same as using the join table, what are the other impact or pro and con in using one-to-many mapping by foreign key?

I 'm newbie to hibernate so hope anyone of you can point me out. thanks

Unidirectional(!) one-to-many association without join table is in my opinion not recommended,
because it breaks UML-specification:



as the association is unidirectional, 'b' should not know anything about 'a',
only 'a' should know about associated 'b' entities.
Therefore it is not correct to save the association information physically into b (as foreign key).
Also consider optimistic locking with corresponding versioning:
if you associate 'a' with 'b' then you would expect a version increment on 'a' only.
Without join table you have indeed a physically change and therefore a version increment on 'b' too.

Hi pb00067,
thanks for your quick reply.

So using the foreign key in one-to-many association will not only pollute the class B with unnecessary foreign key, but it also affect the locking version?

The join table also come in with the trade off of the extra table in db and more complex in the configuration. Is the performance will be affected by using the join table way of association?

the foreign key is not unnecessary In this scenario, as it is the only field to hold the relation information.



Yes, see here
Example association a with b :




As you can see the association with foreign key also increments implicitly the version of b from 0 to 1.



Yes, the schema on database gets a little bit more complicate.



It depends on the database you are using and if the join-table has the proper indexes working
(primary key (A_id, B_id) and unique (B_id) in our case)
Modern database should no have performance problems for executing simple join-queries,
so generally you should take a decision based on your needs for locking and concurrency.