Hibernate（8）- O/R 映射

以你之姓@ 2024-04-17 23:39 11阅读 0赞

## 一.O/R 映射 ##

目前为止我们已经通过应用 Hibernate 见识过十分基础的 O/R 映射了，但是还有三个更加重要的有关映射的话题需要我们更详细的探讨。这三个话题是集合的映射，实体类之间的关联映射以及组件映射。

### 二.集合映射 ###

如果一个实例或者类中有特定变量的值的集合，那么我们可以应用 Java 中的任何的可用的接口来映射这些值。Hibernate 可以保存 **java.util.Map, java.util.Set, java.util.SortedMap, java.util.SortedSet, java.util.List** 和其它持续的实例或者值的任何**数组**的实例。

<table> 
 <thead> 
  <tr> 
   <th><strong>集合类型</strong></th> 
   <th><strong>映射和描述</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>java.util.Set</strong></td> 
   <td>它和 \&lt;set&gt; 元素匹配并且用 java.util.HashSet 初始化。</td> 
  </tr> 
  <tr> 
   <td><strong>java.util.SortedSet</strong></td> 
   <td>它和 \&lt;set&gt; 元素匹配并且用 java.util.TreeSet 初始化。<strong>sort</strong>&nbsp;属性可以设置成比较器或者自然排序。</td> 
  </tr> 
  <tr> 
   <td><strong>java.util.List</strong></td> 
   <td>它和 \&lt;list&gt; 元素匹配并且用 java.util.ArrayList 初始化。</td> 
  </tr> 
  <tr> 
   <td><strong>java.util.Collection</strong></td> 
   <td>它和 \&lt;bag&gt; 或者 \&lt;ibag&gt; 元素匹配以及用 java.util.ArrayList 初始化。</td> 
  </tr> 
  <tr> 
   <td><strong>java.util.Map</strong></td> 
   <td>它和 \&lt;map&gt; 元素匹配并且用 java.util.HashMap 初始化。</td> 
  </tr> 
  <tr> 
   <td><strong>java.util.SortedMap</strong>")</td> 
   <td>它和 \&lt;map&gt; 元素匹配并且用 java.util.TreeMap 初始化。<strong>sort</strong>&nbsp;属性可以设置成比较器或者 自然排序。</td> 
  </tr> 
 </tbody> 
</table>

对于 Java 的原始数值 Hibernate 采用`<primitive-array>`支持数组，对于 Java 的其它数值 Hibernate 采用`<array>`支持数组。然而它们很少被应用，因此我也就不在本指导中讨论它们。

如果你想要映射一个用户定义的集合接口而这个接口不是 Hibernate 直接支持的话，那么你需要告诉 Hibernate 你定义的这个集合的语法，这个很难操作而且不推荐使用。

# #

## 三.关联映射 ##

实体类之间的关联映射以及表之间的关系是 ORM 的灵魂之处。对象间的关系的子集可以用下列四种方式解释。关联映射可以是单向的也可以是双向的。

<table> 
 <thead> 
  <tr> 
   <th><strong>映射类型</strong></th> 
   <th><strong>描述</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td> <p><strong>Many-to-One</strong></p> </td> 
   <td>使用 Hibernate 映射多对一关系，如用户和组，学生和班级</td> 
  </tr> 
  <tr> 
   <td><strong>One-to-One</strong></td> 
   <td>使用 Hibernate 映射一对一关系，如用户和身份证</td> 
  </tr> 
  <tr> 
   <td><strong>One-to-Many</strong></td> 
   <td>使用 Hibernate 映射一对多关系，如用户和电子邮件</td> 
  </tr> 
  <tr> 
   <td><strong>Many-to-Many</strong></td> 
   <td>使用 Hibernate 映射多对多关系，如学生选课</td> 
  </tr> 
 </tbody> 
</table>

# #

## 四.组件映射 ##

作为变量的一员实体类很可能和其它类具有相关关系。如果引用的类没有自己的生命周期并且完全依靠于拥有它的那个实体类的生命周期的话，那么这个引用类因此就可以叫做组件类。

组件集合的映射很可能和正常集合的映射相似，只会有很少的设置上的不同。我们可以在例子中看看这两种映射。

<table> 
 <thead> 
  <tr> 
   <th><strong>映射类型</strong></th> 
   <th><strong>描述</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>Component Mappings</strong></td> 
   <td>类的映射对于作为变量的一员的另外的类具有参考作用。</td> 
  </tr> 
 </tbody> 
</table>

### 五.关联映射练习  ###

1.  **One-to-One**
    
    1.  基于主键映射的1-1关联关系  
        基于主键的映射策略：指一端的主键生成器使用foreign策略，表明根据对方的主键来生成自己的主键，自己并不独立生成主键。  
        代码示例:
        
        1.  Manager.class
            
                package com.zit.hibernate.one2one.primary;
                 
                public class Manager {
                    
                    private Integer mgrId;
                    private String mgrName;
                    
                    private Department dept;
                    
                    public Integer getMgrId() {
                        return mgrId;
                    }
                 
                    public void setMgrId(Integer mgrId) {
                        this.mgrId = mgrId;
                    }
                 
                    public String getMgrName() {
                        return mgrName;
                    }
                 
                    public void setMgrName(String mgrName) {
                        this.mgrName = mgrName;
                    }
                 
                    public Department getDept() {
                        return dept;
                    }
                 
                    public void setDept(Department dept) {
                        this.dept = dept;
                    }
                    
                }
        2.  Department.class
            
                package com.zit.hibernate.one2one.primary;
                 
                public class Department {
                    
                    private Integer deptId;
                    private String deptName;
                    
                    private Manager mgr;
                 
                    public Integer getDeptId() {
                        return deptId;
                    }
                 
                    public void setDeptId(Integer deptId) {
                        this.deptId = deptId;
                    }
                 
                    public String getDeptName() {
                        return deptName;
                    }
                 
                    public void setDeptName(String deptName) {
                        this.deptName = deptName;
                    }
                 
                    public Manager getMgr() {
                        return mgr;
                    }
                 
                    public void setMgr(Manager mgr) {
                        this.mgr = mgr;
                    }
                    
                }
        3.  Manager.hbm.xml
            
                <?xml version="1.0"?>
                <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
                "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
                
                <hibernate-mapping package="com.zit.hibernate.one2one.primary">
                    <class name="Manager" table="MANAGERS_2">
                        <id name="mgrId" type="java.lang.Integer">
                            <column name="MGR_ID" />
                            <generator class="native" />
                        </id>
                        <property name="mgrName" type="java.lang.String">
                            <column name="MGR_NAME" />
                        </property>
                        
                        
                        <one-to-one name="dept" class="Department"></one-to-one>
                        
                    </class>
                </hibernate-mapping>
        4.  Department.hbm.xml
            
                <?xml version="1.0"?>
                <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
                "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
                
                <hibernate-mapping package="com.zit.hibernate.one2one.primary">
                    <class name="Department" table="DEPARTMENTS_2">
                        <id name="deptId" type="java.lang.Integer">
                            <column name="DEPT_ID" />
                            <generator class="foreign">
                                <param name="property">mgr</param>
                            </generator>
                        </id>
                        <property name="deptName" type="java.lang.String">
                            <column name="DEPT_NAME" />
                        </property>
                        
                        <one-to-one name="mgr" class="Manager" constrained="true"></one-to-one>
                        
                    </class>
                </hibernate-mapping>
        5.  注意：在指定了foreign为主键生成策略的映射文件中，one-to-one属性一定要增加 constrained="true"属性，不然两张表之间不会有外键关联。  
            增加 constrained="true"，以使当前主键上添加外键约束  
            而主键生成器的配置中，<param name="property">mgr</param>   这里mgr为当前持久化类关联的另一个持久化类的属性名。指定当前持久化类的哪一个属性的主键作为外键。
        6.  使用注意：
            
            1.  保存数据时，无论先save(manager),还是先save(department)，hibernate都会先插入manager，再插入department,因为 department表是以manager表的主键为自己的主键，若manager表中没有对应记录的主键，则department自己也无法插入数据,都不会有多余的UPDATE语句。
            2.  查询时，若先查询manager，会用左外连接一并查出关联的department；但是在查询条件中：on manager0\_.MGR\_ID=department1\_.DEPT\_ID   这里这个条件就是正确的，因为两个表中相关联的两个记录主键永远相同。若先查询department，会用懒加载。
    2.  基于外键映射的1-1关联关系  
        [http://www.cnblogs.com/zitt/p/5074326.html][http_www.cnblogs.com_zitt_p_5074326.html]
2.  **One-to-Many**
    
    1.  单向一对多映射  
        [http://blog.csdn.net/csh624366188/article/details/7585129][http_blog.csdn.net_csh624366188_article_details_7585129]
    2.  双向一对多关联
3.  **Many-to-One**
    
    1.  单向多对一映射  
        [http://blog.csdn.net/csh624366188/article/details/7585129][http_blog.csdn.net_csh624366188_article_details_7585129]
4.  **Many-to-Many**
    
    1.  ****单向多对多关联关系  
        [http://how2j.cn/k/hibernate/hibernate-many-to-many/42.html\#nowhere][http_how2j.cn_k_hibernate_hibernate-many-to-many_42.html_nowhere]
    2.  多向多对多关联关系

[http_www.cnblogs.com_zitt_p_5074326.html]: http://www.cnblogs.com/zitt/p/5074326.html
[http_blog.csdn.net_csh624366188_article_details_7585129]: http://blog.csdn.net/csh624366188/article/details/7585129
[http_how2j.cn_k_hibernate_hibernate-many-to-many_42.html_nowhere]: http://how2j.cn/k/hibernate/hibernate-many-to-many/42.html#nowhere