Hibernate - Mapping a parent/children relationship

The first thing many developer try to do when they begin using Hibernate is a mapping of a parent/children relationship. this is usually the first time you encounter collections. it's also the first time you have to think about the differences between entities and value tyhpes, or get lost in the complexity of ORM.

Managing the associations between classes and the relationships between tables is at the heart of ORM. Most of the difficult problems involved in implementing an ORM solution relate to association management.

POJO-oriented persistence engines such as Hibernate don't implement managed associations, and POJO stands such as EJB3.0 and Java Persistence don't require managed assocations. contrary to EJB2.0 CMR, Hibernate and JPA associations are all inherently unidirectional.

Use Bid and Item ( for auction) as the example,
As far as Hibernate is concerned, the association from Bid to Item is a different association than the association from Item to Bid! The association from Bid to Item is a many-to-one assocation. Recalling that associations are directional, you classify the inverse association from item to bid as a one-to-many association.

The association from Bid to Item(and vice versa) is an example of the simplest possible kind of entity association. You have two properties in two classes. One is a collection of references, and the other a single reference.


public class Bid {
...
private Item item;
public void setItem(Item item) {
this.item = item;
}
public Item getItem() {
return item;
}
...
}
Next, this is the Hibernate mapping for this association:
<class
name="Bid"
table="BID">
...
<many-to-one
name="item"
column="ITEM_ID"
class="Item"
not-null="true"/>
</class>

OR in JPA:


public class Bid {
...
@ManyToOne( targetEntity = auction.model.Item.class )
@JoinColumn(name = "ITEM_ID", nullable = false)
private Item item;
...
}




There are two optional elements in this mapping. First, you don't have to include the targetEntity of the association; it's implicit from the type of the field.
The second optoinal element is the @JoinColumn. If you don't declare the name of the foreign key column, Hibernate automatically uses a combination of the target entity name and the database identifier proprety name of the target entity. In other words, if you don't add a @JoinColumn annotation, the default name for the foreign key colum is item plus id, separated with an underscore. However, because you want to make the foreign key column not null, you need to annotation anyway to set nullable=false.




public class Item {
...
private Set bids = new HashSet();
public void setBids(Set bids) {
this.bids = bids;
}
public Set getBids() {
return bids;
}
public void addBid(Bid bid) {
bid.setItem(this);
bids.add(bid);
}
...
}


<class
name="Item"
table="ITEM">
...
<set name="bids">
<key column="ITEM_ID"/>

<one-to-many class="Bid"/>
</set>
</class>

OR in JPA: