Hibernate关联关系映射-----双向一对多/多对一映射配置

来源:互联网 发布:软件行业就业方向 编辑:程序博客网 时间:2024/05/01 04:05
  1. 转自:http://blog.csdn.net/yifei12315/article/details/6985194
  2. ///  
  3. Hibernate:  
  4.     ///  
  5.     双向关联就是有“一对多”和“多对一”两个关联组合而成德,在双向关联的两端都知道对方是谁。  
  6.   
  7.     下面就开始演示这种关联。  
  8.   
  9.     首先定义我们需要使用的POJO对象。  
  10.   
  11.     public class Member  
  12.     {  
  13.         private String id;   
  14.         private String name;   
  15.         private Integer age;   
  16.         private Set<Order> orders = new HashSet<Order>();//我知道Order对象  
  17.         ……  
  18.     }  
  19.   
  20.     public class Order  
  21.     {  
  22.         private Integer id;   
  23.         private String name;   
  24.         private String num;   
  25.         private Member member;//我知道Member对象  
  26.         ……  
  27.     }  
  28.   
  29.     两个POJO对应的映射文件分别为Member.hbm.xml和Order.hbm.xml。  
  30.   
  31.     Member.hbm.xml  
  32.   
  33.     <hibernate-mapping package="org.louis.domain">   
  34.         <class name="Member" table="TEST_MEMBER" dynamic-insert="true">  
  35.             <id name="id" column="ID">   
  36.                 <generator class="uuid.hex"></generator>   
  37.             </id>   
  38.             <property name="age" column="AGE"></property>   
  39.             <property name="name" column="NAME"></property>   
  40.             <set name="orders" cascade="all" inverse="true">  
  41.                 <!--设置inverse=”true”表示Member不在作为主控方,就是说不再由Member来维持关联关系,  
  42.                 而有Order方来维持关联关系,这样Order在持久化的时候会主动去获取Member的主键值来作为自己  
  43.                 的外键值。 在one-to-manay关联关系中,一般将manay端设置为主控方(inverse=”false”),  
  44.                 这样将有助于改善性能。默认情况下inverse=”false” -->   
  45.                 <key column="MEMBER_ID"></key>   
  46.                 <one-to-many class="Order"/>   
  47.             </set>  
  48.         </class>   
  49.     </hibernate-mapping>  
  50.   
  51.     Order.hbm.xml  
  52.   
  53.     <hibernate-mapping package="org.louis.domain">   
  54.         <class name="Order" table="TEST_ORDER">   
  55.             <id name="id" column="ID">   
  56.                 <generator class="native"></generator>   
  57.             </id>   
  58.             <property name="name" column="NAME"></property>   
  59.             <property name="num" column="NUM"></property>   
  60.             <many-to-one name="member" class="Member" column="MEMBER_ID"></many-to-one>  
  61.     </hibernate-mapping>  
  62.   
  63.     下面我们来进行测试。  
  64.   
  65.     a、插入数据  
  66.   
  67.     public void insert()  
  68.     {   
  69.         Session session = HibernateSessionFactory.getSessionFactory().getCurrentSession();   
  70.         session.beginTransaction();   
  71.         Member m = new Member();   
  72.         m.setAge(24);   
  73.         m.setName("Louis");  
  74.   
  75.         Order order = new Order();  
  76.         order.setName("order 1");  
  77.         order.setNum("order num 1");  
  78.         order.setMember(m);  
  79.         m.getOrders().add(order);  
  80.   
  81.         session.save(m);   
  82.         session.getTransaction().commit();   
  83.     }  
  84.   
  85.     查看Hibernate在后台使用的SQL语句如下:  
  86.   
  87.     Hibernate:   
  88.         insert   
  89.         into   
  90.             TEST_MEMBER   
  91.             (AGE, NAME, ID)   
  92.         values   
  93.             (?, ?, ?)   
  94.     Hibernate:   
  95.         insert   
  96.         into   
  97.             TEST_ORDER   
  98.             (NAME, NUM, MEMBER_ID)   
  99.         values   
  100.             (?, ?, ?)  
  101.   
  102.     仅仅就两条语句,明显比单向关联的时候少了一条更新语句(把Order的外键进行更新为Menber的主键值)。  
  103.   
  104.     b、加载数据  
  105.       
  106.     和单向关联的区别在于,如果加载的是Order对象,那么它也知道和它关联的对象。  
  107.   
  108.     c、删除数据  
  109.       
  110.     删除数据和单向关联时的删除数据的区别在于,对Member及它的关联对象Order加载后,不需要在更新Order的外键为NULL,而是紧跟着逐条删除Order,最后删除Member。  
  111.       
原创粉丝点击