Hibernate深入理解----关联关系(一对一,多对多)

参考代码下载github:https://github.com/changwensir/java-ee/tree/master/hibernate4

一、一对一

[java]  view plain  copy
  1. public class Manager{  
  2.     private Integer mgrId;  
  3.     private String mgrName;  
  4.     private Department dept;  
  5. //省去get,set方法  
  6. }  
[java]  view plain  copy
  1. public class Department {  
  2.     private Integer deptId;  
  3.     private String deptName;  
  4.     private Manager mgr; //这个是外键,对应表的manager_id  
  5.   
  6. //省去get,set方法  
  7. }  

1-1.基于外键映射的 1-1

[html]  view plain  copy
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  4. <hibernate-mapping package="com.changwen.hibernate4.mapped.oneToOne.pojo">  
  5.   
  6.     <class name="Department" table="DEPARTMENTS">  
  7.   
  8.         <id name="deptId" type="java.lang.Integer">  
  9.             <column name="DEPT_ID" />  
  10.             <generator class="native" />  
  11.         </id>  
  12.           
  13.         <property name="deptName" type="java.lang.String">  
  14.             <column name="DEPT_NAME" />  
  15.         </property>  
  16.           
  17.         <!-- 使用 many-to-one 的方式来映射 1-1 关联关系, 会在这个表里生成一个外键-->  
  18.         <many-to-one name="mgr" class="Manager"  
  19.                      column="MGR_ID" unique="true"/>  
  20.     </class>  
  21. </hibernate-mapping>  
[html]  view plain  copy
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  4.   
  5. <hibernate-mapping package="com.changwen.hibernate4.mapped.oneToOne.pojo">  
  6.     <class name="Manager" table="MANAGERS">  
  7.           
  8.         <id name="mgrId" type="java.lang.Integer">  
  9.             <column name="MGR_ID" />  
  10.             <generator class="native" />  
  11.         </id>  
  12.           
  13.         <property name="mgrName" type="java.lang.String">  
  14.             <column name="MGR_NAME" />  
  15.         </property>  
  16.           
  17.         <!-- 映射 1-1 的关联关系: 在对应的数据表中已经有外键了, 当前持久化类使用 one-to-one 进行映射 -->  
  18.         <!--  
  19.             没有外键的一端需要使用one-to-one元素,该元素使用 property-ref 属性指定使用被关联实体主键以外的字段作为关联字段 
  20.          -->  
  21.         <one-to-one name="dept" class="Department" property-ref="mgr"/>  
  22.     </class>  
  23. </hibernate-mapping>  
两个hbm.xml文件要配置到cfg.xml里

测试方法

[java]  view plain  copy
  1. @Test  
  2. public void testSave(){  
  3.     Department department = new Department();  
  4.     department.setDeptName("DEPT-BB");  
  5.   
  6.     Manager manager = new Manager();  
  7.     manager.setMgrName("MGR-BB");  
  8.   
  9.     //设定关联关系  
  10.     department.setMgr(manager);  
  11.     manager.setDept(department);  
  12.   
  13.     //保存操作  
  14.     //建议先保存没有外键列的那个对象. 这样会减少 UPDATE 语句  
  15.     session.save(manager);  
  16.     session.save(department);  
  17. }  
[java]  view plain  copy
  1.     @Test  
  2.     public void testGet(){  
  3.         //1. 默认情况下对关联属性使用懒加载(因为没有把关联的Manager查找出来)  
  4.         Department dept = (Department) session.get(Department.class13);  
  5.         System.out.println(dept.getDeptName());  
  6.   
  7.         //2. 所以会出现懒加载异常的问题.  
  8. //      sessionPojo.close(); //还有把destory()方法里的session 和transaction注解掉  
  9. //      Manager mgr = dept.getMgr();  
  10. //      System.out.println(mgr.getClass());  
  11. //      System.out.println(mgr.getMgrName());  
  12.   
  13.         //3. 查询 Manager 对象的连接条件应该是 dept.manager_id(外键字段) = mgr.manager_id  
  14.         //   而不应该是 dept.dept_id = mgr.manager_id。  
  15.         //这里需要在Manager.hbm.xml里设置property-ref!!!  
  16.         Manager mgr = dept.getMgr();  
  17.         System.out.println(mgr.getMgrName());  
  18.     }  
[java]  view plain  copy
  1. /** 
  2.  * 基于外键映射的 1-1 
  3.  * 对于基于外键的1-1关联,其外键可以存放在任意一边,在需要存放外键一端,增加many-to-one元素。 
  4.  *    为many-to-one元素增加unique=“true” 属性来表示为1-1关联 
  5.  * 另一端需要使用one-to-one元素,该元素使用 property-ref 属性指定使用被关联实体主键以外的字段作为关联字段 
  6.  */  
  7. @Test  
  8. public void testGet2(){  
  9.     //在查询没有外键的实体对象时, 使用的左外连接查询, 一并查询出其关联的对象  
  10.     //并已经进行初始化.  
  11.     Manager mgr = (Manager) session.get(Manager.class13);  
  12.     System.out.println(mgr.getMgrName());  
  13.     System.out.println(mgr.getDept().getDeptName());  
  14. }  

1-2.基于主键映射的 1-1

    基于主键的映射策略:指一端的主键生成器使用 foreign 策略,表明根据”对方”的主键来生成自己的主键,自己并不能独立生成主键. <param> 子元素指定使用当前持久化类的哪个属性作为 “对方

    采用foreign主键生成器策略的一端增加 one-to-one 元素映射关联属性,其one-to-one属性还应增加 constrained=“true” 属性;另一端增加one-to-one元素映射关联属性。
    constrained(约束):指定为当前持久化类对应的数据库表的主键添加一个外键约束,引用被关联的对象(“对方”)所对应的数据库表主键

[html]  view plain  copy
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  4. <hibernate-mapping package="com.changwen.hibernate4.mapped.oneToOne.pojo">  
  5.   
  6.     <class name="Department" table="DEPARTMENTS">  
  7.   
  8.         <id name="deptId" type="java.lang.Integer">  
  9.             <column name="DEPT_ID" />  
  10.             <!-- 使用外键的方式来生成当前的主键!!!! -->  
  11.             <generator class="foreign">  
  12.                 <!-- property 属性指定使用当前持久化类的哪一个属性的主键作为外键 -->  
  13.                 <param name="property">mgr</param>  
  14.             </generator>  
  15.         </id>  
  16.           
  17.         <property name="deptName" type="java.lang.String">  
  18.             <column name="DEPT_NAME" />  
  19.         </property>  
  20.   
  21.         <!--基于外键改为基于主键:这里将many-to-one修改为one-to-one-->  
  22.         <one-to-one name="mgr" class="Manager" constrained="true"/>  
  23.     </class>  
  24. </hibernate-mapping>  
[html]  view plain  copy
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  4.   
  5. <hibernate-mapping package="com.changwen.hibernate4.mapped.oneToOne.pojo">  
  6.   
  7.     <class name="Manager" table="MANAGERS">  
  8.           
  9.         <id name="mgrId" type="java.lang.Integer">  
  10.             <column name="MGR_ID" />  
  11.             <generator class="native" />  
  12.         </id>  
  13.           
  14.         <property name="mgrName" type="java.lang.String">  
  15.             <column name="MGR_NAME" />  
  16.         </property>  
  17.   
  18.         <!-- 映射 1-1 的关联关系: 在对应的数据表中已经有外键了, 当前持久化类使用 one-to-one 进行映射 -->  
  19.         <one-to-one name="dept" class="Department"/>  
  20.     </class>  
  21. </hibernate-mapping>  
save方法,先插入哪个都不会有多余的update语句
[java]  view plain  copy
  1. @Test  
  2. public void testGet2(){  
  3.     //在查询没有外键的实体对象时, 使用的左外连接查询, 一并查询出其关联的对象  
  4.     //并已经进行初始化.  
  5.     Manager mgr = (Manager) session.get(Manager.class1);  
  6.     System.out.println(mgr.getMgrName());  
  7.     System.out.println(mgr.getDept().getDeptName());  
  8. }  
  9.   
  10. @Test  
  11. public void testGet(){  
  12.     //1. 默认情况下对关联属性使用懒加载  
  13.     Department dept = (Department) session.get(Department.class1);  
  14.     System.out.println(dept.getDeptName());  
  15.   
  16.     //2. 所以会出现懒加载异常的问题.  
  17.     Manager mgr = dept.getMgr();  
  18.     System.out.println(mgr.getMgrName());  
  19. }  

二、多对多


2-1.单向/双向n-n

    n-n 的关联必须使用连接表
    与 1-n 映射类似,必须为 set 集合元素添加 key 子元素,指定 CATEGORIES_ITEMS 表中参照 CATEGORIES 表的外键为 CATEGORIY_ID. 与 1-n 关联映射不同的是,建立 n-n 关联时, 集合中的元素使用 many-to-many. many-to-many 子元素的 class 属性指定 items 集合中存放的是 Item 对象, column 属性指定  CATEGORIES_ITEMS 表中参照 ITEMS 表的外键为 ITEM_ID

  - 双向 n-n 关联需要两端都使用集合属性
 -  双向n-n关联必须使用连接表
  -  集合属性应增加 key 子元素用以映射外键列, 集合元素里还应增加many-to-many子元素关联实体类
  - 在双向 n-n 关联的两边都需指定连接表的表名及外键列的列名. 两个集合元素 set 的 table 元素的值必须指定而且必须相同。set元素的两个子元素:key 和 many-to-many 都必须指定 column 属性,其中,key 和 many-to-many 分别指定本持久化类和关联类在连接表中的外键列名,因此两边的 key 与 many-to-many 的column属性交叉相同。也就是说,一边的set元素的key的 cloumn值为a,many-to-many 的 column 为b;则另一边的 set 元素的 key 的 column 值 b,many-to-many的 column 值为 a.  
对于双向 n-n 关联, 必须把其中一端的 inverse 设置为 true, 否则两端都维护关联关系可能会造成主键冲突.

多个category对应多个item

[java]  view plain  copy
  1. public class Category {  
  2.     private Integer id;  
  3.     private String name;  
  4.     private Set<Item> items = new HashSet<Item>();  
  5.   
  6. //省去get,set方法  
  7. }  

[html]  view plain  copy
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  4.   
  5. <hibernate-mapping package="com.changwen.hibernate4.mapped.manyToMany">  
  6.   
  7.     <class name="Category" table="CATEGORIES">  
  8.       
  9.         <id name="id" type="java.lang.Integer">  
  10.             <column name="ID" />  
  11.             <generator class="native" />  
  12.         </id>  
  13.       
  14.         <property name="name" type="java.lang.String">  
  15.             <column name="NAME" />  
  16.         </property>  
  17.   
  18.   
  19.         <!-- table: 指定中间表 ,还可以增加cascade="save-update"-->  
  20.         <set name="items" table="CATEGORIES_ITEMS">  
  21.             <key>  
  22.                 <column name="C_ID" />  
  23.             </key>  
  24.             <!-- 使用 many-to-many 指定多对多的关联关系. column 执行 Set 集合中的持久化类在中间表的外键列的名称  -->  
  25.             <many-to-many class="Item" column="I_ID"/>  
  26.         </set>  
  27.           
  28.     </class>  
  29. </hibernate-mapping>  
Item类
[java]  view plain  copy
  1. public class Item {  
  2.     private Integer id;  
  3.     private String name;  
  4.     private Set<Category> categories = new HashSet<Category>();  
  5.   
  6. //省去get,set方法  
  7. }  
如果是单向n-n,则把下面那个双向的配置去除就行
[html]  view plain  copy
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  4.   
  5. <hibernate-mapping package="com.changwen.hibernate4.mapped.manyToMany">  
  6.   
  7.     <class name="Item" table="ITEMS">  
  8.           
  9.         <id name="id" type="java.lang.Integer">  
  10.             <column name="ID" />  
  11.             <generator class="native" />  
  12.         </id>  
  13.           
  14.         <property name="name" type="java.lang.String">  
  15.             <column name="NAME" />  
  16.         </property>  
  17.   
  18.         <!-- 双向n-n,则要加上这个:  
  19.                 table: 指定中间表 -->  
  20.         <set name="categories" table="CATEGORIES_ITEMS" inverse="true">  
  21.             <key column="I_ID"/>  
  22.             <many-to-many class="Category" column="C_ID"/>  
  23.         </set>  
  24.           
  25.     </class>  
  26. </hibernate-mapping>  
测试类
[java]  view plain  copy
  1. @Test  
  2. public void testSave(){  
  3.     Category category1 = new Category();  
  4.     category1.setName("C-AA");  
  5.     Category category2 = new Category();  
  6.     category2.setName("C-BB");  
  7.   
  8.     Item item1 = new Item();  
  9.     item1.setName("I-AA");  
  10.     Item item2 = new Item();  
  11.     item2.setName("I-BB");  
  12.   
  13.     //设定关联关系  
  14.     category1.getItems().add(item1);  
  15.     category1.getItems().add(item2);  
  16.   
  17.     category2.getItems().add(item1);  
  18.     category2.getItems().add(item2);  
  19.   
  20.     item1.getCategories().add(category1);  
  21.     item1.getCategories().add(category2);  
  22.   
  23.     item2.getCategories().add(category1);  
  24.     item2.getCategories().add(category2);  
  25.   
  26.     //执行保存操作  
  27.     session.save(category1);  
  28.     session.save(category2);  
  29.   
  30.     session.save(item1);  
  31.     session.save(item2);  
  32. }  
[java]  view plain  copy
  1. @Test  
  2. public void testGet(){  
  3.     Category category = (Category) session.get(Category.class1);  
  4.     System.out.println(category.getName());  
  5.   
  6.     //需要连接中间表  
  7.     Set<Item> items = category.getItems();  
  8.     System.out.println(items.size());  
  9. }  
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值