hibernate一对多关联关系配置经验

假使有一个order表和一个customer表，那么它们两者的关系是一个customer可以有多个order，一个order只能属于一个customer，在hibernate中，他们的配置如下：

<?xmlversion="1.0"?>
<!DOCTYPEhibernate-mapping
PUBLIC"-//Hibernate/HibernateMappingDTD3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>

<classname="mypack.Customer"table="CUSTOMERS">
<idname="id"type="long"column="ID">
<generatorclass="increment"/>
</id>

<propertyname="name"type="string">
<columnname="NAME"length="15"/>
</property>
<!--

<set
name="orders"
cascade="all-delete-orphan"
inverse="true"
>

<keycolumn="CUSTOMER_ID"/>
<one-to-manyclass="mypack.Order"/>
</set>
-->
<set
name="orders"
inverse="true"
cascade="save-update"
>

<keycolumn="CUSTOMER_ID"/>
<one-to-manyclass="mypack.Order"/>
</set>

</class>
</hibernate-mapping>

<?xmlversion="1.0"?>
<!DOCTYPEhibernate-mapping
PUBLIC"-//Hibernate/HibernateMappingDTD3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>

<classname="mypack.Order"table="ORDERS">

<idname="id"type="long"column="ID">
<generatorclass="increment"/>
</id>

<propertyname="orderNumber"type="string">
<columnname="ORDER_NUMBER"length="15"/>
</property>

<many-to-one
name="customer"
column="CUSTOMER_ID"
class="mypack.Customer"
cascade="save-update"
/>

</class>

</hibernate-mapping>

他们的业务类中则有以下方法：

packagemypack;

importorg.hibernate.*;
importorg.hibernate.cfg.Configuration;
importjava.util.*;

publicclassBusinessService{
publicstaticSessionFactorysessionFactory;
privateLongidOfTom;
privateLongidOfTomOrder;
privateLongidOfJack;
privateLongidOfJackOrder;

static{
try{
Configurationconfig=newConfiguration();
config.configure();
sessionFactory=config.buildSessionFactory();
}catch(RuntimeExceptione){e.printStackTrace();throwe;}
}

publicvoidprintOrdersOfCustomer(LongcustomerId){
Sessionsession=sessionFactory.openSession();
Transactiontx=null;
try{
tx=session.beginTransaction();
Customercustomer=(Customer)session.get(Customer.class,customerId);
printOrders(customer.getOrders());
tx.commit();
}catch(RuntimeExceptione){
if(tx!=null){
tx.rollback();
}
throwe;
}finally{
session.close();
}
}

publicvoidsaveCustomerAndOrderWithCascade(){
Sessionsession=sessionFactory.openSession();
Transactiontx=null;
try{
tx=session.beginTransaction();

Customercustomer=newCustomer("Tom",newHashSet());
Orderorder=newOrder();
order.setOrderNumber("Tom_Order001");

order.setCustomer(customer);
customer.getOrders().add(order);

session.save(customer);
tx.commit();
idOfTom=customer.getId();
idOfTomOrder=order.getId();

}catch(RuntimeExceptione){
if(tx!=null){
tx.rollback();
}
e.printStackTrace();
}finally{
session.close();
}
}

publicvoidassociateCustomerAndOrder(){
Sessionsession=sessionFactory.openSession();
Transactiontx=null;
try{
tx=session.beginTransaction();
Customercustomer=(Customer)session.load(Customer.class,idOfJack);
Orderorder=(Order)session.load(Order.class,idOfJackOrder);
order.setCustomer(customer);
customer.getOrders().add(order);
tx.commit();
}catch(RuntimeExceptione){
if(tx!=null){
tx.rollback();
}
e.printStackTrace();
}finally{
session.close();
}
}

publicvoidsaveCustomerAndOrderSeparately(){
Sessionsession=sessionFactory.openSession();
Transactiontx=null;
try{
tx=session.beginTransaction();

Customercustomer=newCustomer();
customer.setName("Jack");

Orderorder=newOrder();
order.setOrderNumber("Jack_Order001");

session.save(customer);
session.save(order);

tx.commit();
idOfJack=customer.getId();
idOfJackOrder=order.getId();
}catch(RuntimeExceptione){
if(tx!=null){
tx.rollback();
}
e.printStackTrace();
}finally{
session.close();
}
}

publicvoiddeleteCustomer(LongcustomerId){
Sessionsession=sessionFactory.openSession();
Transactiontx=null;
try{
tx=session.beginTransaction();
Customercustomer=(Customer)session.load(Customer.class,customerId);
session.delete(customer);
tx.commit();

}catch(RuntimeExceptione){
if(tx!=null){
tx.rollback();
}
e.printStackTrace();
}finally{
session.close();
}
}

publicvoidremoveOrderFromCustomer(LongcustomerId){
Sessionsession=sessionFactory.openSession();
Transactiontx=null;
try{
tx=session.beginTransaction();
Customercustomer=(Customer)session.load(Customer.class,customerId);
Orderorder=(Order)customer.getOrders().iterator().next();

//½â³ýCustomerºÍOrderµÄ¹ØÁª¹Øϵ
customer.getOrders().remove(order);
order.setCustomer(null);
tx.commit();

}catch(RuntimeExceptione){
if(tx!=null){
tx.rollback();
}
e.printStackTrace();
}finally{
session.close();
}
}

publicvoidprintOrders(Setorders){
for(Iteratorit=orders.iterator();it.hasNext();){
Orderorder=(Order)it.next();
System.out.println("OrderNumberof"+order.getCustomer().getName()+":"+order.getOrderNumber());
}
}

publicvoidsaveCustomerAndOrderWithInverse(){
saveCustomerAndOrderSeparately();
associateCustomerAndOrder();
}
publicvoidtest(){

saveCustomerAndOrderWithCascade();
saveCustomerAndOrderWithInverse();
printOrdersOfCustomer(idOfTom);
deleteCustomer(idOfJack);
removeOrderFromCustomer(idOfTom);
}

publicstaticvoidmain(Stringargs[]){
newBusinessService().test();
sessionFactory.close();
}
}

由以上代码执行时的效率和打印的sql语句，我们可以得出以下经验：1.应把one的一方的<set>元素的inverse属性，设置为true，因此hibernate不会因为customer对象的属性变化来同步更新数据库，以提高性能。 2.在建立关联关系之后，在进行更新操作的时候，最好操作关联两端的对象的相关属性。如：

order.setCustomer(customer);
customer.getOrders().add(order);

这样会是程序更加健壮，提高业务逻辑的独立性，使代码不收hibernate实现的影像。同理，当解除双向关联关系时，也该操作关联双发的对应属性，如：

customer.getOrders().remove(order);
order.setCustomer(null);