学步园

  首先我们了解一个名词ORM，全称是（Object Relational Mapping），即对象关系映射。ORM的实现思想就是将关系数据库中表的数据映射成对象，以对象的形式展现，这样开发人员就可以把对数据库的操作转化为对这些对象的操作。Hibernate正是实现了这种思想，达到了方便开发人员以面向对象的思想来实现对数据库的操作。 
     

        Hibernate在实现ORM功能的时候主要用到的文件有：映射类（*.java）、映射文件（*.hbm.xml）和数据库配置文件（*.properties/*.cfg.xml），它们各自的作用如下。

        映射类（*.java）：它是描述数据库表的结构，表中的字段在类中被描述成属性，将来就可以实现把表中的记录映射成为该类的对象了。

        映射文件（*.hbm.xml）：它是指定数据库表和映射类之间的关系，包括映射类和数据库表的对应关系、表字段和类属性类型的对应关系以及表字段和类属性名称的对应关系等。

        数据库配置文件（*.properties/*.cfg.xml）：它是指定与数据库连接时需要的连接信息，比如连接哪种数据库、登录数据库的用户名、登录密码以及连接字符串等。当然还可以把映射类的地址映射信息放在这里。

        接下来让我们就一起走进Hibernate的七种映射关系：

        1、        单向一对一关联映射（one-to-one）：

        两个对象之间一对的关系，例如：Person（人）-IdCard（身份证）

        有两种策略可以实现一对一的关联映射：

               *主键关联：即让两个对象具有相同的主键值，以表明它们之间的一一对应的关系；数据库表不会有额外的字段来维护它们之间的关系，仅通过表的主键来关联。如下图：

            例子：单向一对一主键关联例子连接

               *唯一外键关联：外键关联，本来是用于多对一的配置，但是加上唯一的限制之后（采用<many-to-one>标签来映射，指定多的一端unique为true，这样就限制了多的一端的多重性为一），也可以用来表示一对一关联关系，其实它就是多对一的特殊情况。如下图：

        例子：单向一对一唯一外键关联例子连接

        注意：因为一对一的主键关联映射扩展性不好，当我们的需要发生改变想要将其变为一对多的时候变无法操作了，所以我们遇到一对一关联的时候经常会采用唯一外键关联来解决问题，而很少使用一对一主键关联。

        2、        单向多对一关联映射（many-to-one）：

       多对一关联映射原理：在多的一端加入一个外键，指向一的一端，如下图：

       关键映射代码——在多的一端加入如下标签映射：      

       3、         单向一对多关联映射（one-to-many）：

       一对多关联映射和多对一关联映射原理是一致的，都是在多的一端加入一个外键，指向一的一端。如下图（学生和班级）：

       注意：它与多对一的区别是维护的关系不同

               *多对一维护的关系是：多指向一的关系，有了此关系，加载多的时候可以将一加载上来

               *一对多维护的关系是：一指向多的关系，有了此关系，在加载一的时候可以将多加载上来

       关键映射代码——在一的一端加入如下标签映射：

       缺陷：因为多的一端Student不知道Classes的存在（也就是Student没有维护与Classes的关系）所以在保存Student的时候关系字段classesid是为null的，如果将该关系字段设置为非空，则将无法保存数据，常用解决办法是改用双向关联映射，参见6。

       4、         单向多对多映射（many-to-many）：

      多对多关联映射新增加一张表才完成基本映射，如下图：

      关键映射代码——可以在User的一端加入如下标签映射：

        5、         双向一对一关联映射：

        对比单向一对一映射，需要在IdCard加入<one-to-one>标签，它不影响，只影响加载。如下图：

   

       双向一对一主键映射关键映射代码——在IdCard端新加入如下标签映射：       

       双向一对一唯一外键映射关键映射代码——在IdCard端新加入如下标签映射：

       注意：一对一唯一外键关联双向采用<one-to-one>标签映射，必须指定<one-to-one>标签中的property-ref属性为关系字段的名称

       6、         双向一对多关联映射（非常重要）：

       采用一对多双向关联映射的目的主要是为了主要是为了解决一对多单向关联的缺陷而不是需求驱动的。

       一对多双向关联的映射方式：

              * 在一的一端的集合上采用<key>标签，在多的一端加入一个外键

              * 在多的一端采用<many-to-one>标签

       注意：<key>标签和<many-to-one>标签加入的字段保持一直，否则会产生数据混乱

      关键映射代码：

      在Classes的一端加入如下标签映射：     

      在Student的一端加入如下标签映射：

      注释：inverse属性

               * inverse属性可以用在一对多和多对多双向关联上，inverse属性默认为false，为false表示本端可以维护关系，如果inverse为true，则本端不能维护关系，会交给另一端维护关系，本端失效。所以一对多关联映射我们通常在多的一端维护关系，让一的一端失效。

              * inverse是控制方向上的反转，只影响存储

      7、         双向多对多关联映射：

      双向的目的就是为了两端都能将对方加载上来，和单向多对多的区别就是双向需要在两端都加入标签映射，需要注意的是：

              * 生成的中间表名称必须一样

              * 生成的中间表中的字段必须一样

        Role（角色）端关键映射代码： 

       User（用户）端关键映射代码：         

       总结：对于上面这七种关联映射中，最重要的就是一对多的映射，因为它更贴近我们的现实生活，比如：教室和学生就可以是典型的一对多的关系，而我们开发软件的目的之一就是为了解决一些生活中重复性问题，把那些重复的问题交给计算机帮助我们完成，从而来提高我们的工作效率。一句话：生活离开不开编程，编程更离不开生活。

原址传送门：http://blog.csdn.net/smszhuang168/article/details/7761310

下面添加一些继承映射的部分

继承映射：是将对象模型中的继承关系映射的数据模型，有3中映射方式，1，对象模型映射成一个表 2，每个类映射成一张表3，每个实体类映射成一张表

1、       对象模型映射成一个表：

             将对象模型中的所有类映射在一张表中

             *  对象模型

     

       *  数据模型（t_animal）

          

<class name="lee.com.animal" table="t_animal">
             <id name="id">
               <generator class="native"/>
             </id> 
             <discriminator  column="type" type="string"></discriminator>
               <property name="name"/>
               <property name="sex"/>
             <subclass name ="com.lee.Pig" discriminator-value="P">
                    <property name="weight"></property>
             </subclass>
             <subclass name ="com.lee.Bird" discriminator-value="B">
                    <property name="hight"></property>
             </subclass>          
   </class>

建一个表符合数据库设计的粗粒度行，也是常使用的一种映射方式

2、     每个类映射成一张表：

映射文件：

 <class name="lee.com.animal" table="t_animal">
             <id name="id">
               <generator class="native"/>
             </id>
               <property name="name"/>
               <property name="sex"/>
             <joined-subclass name="com.lee.hibernate.Pig" table="t_pig">
                <key column="id"/>
                <property name="weight"/>
             </joined-subclass>
             <joined-subclass name="com.lee.hibernate.Bird" table="t_bird">
                <key column="id"/>
                <property name="higjt"/>
             </joined-subclass>
        </class>

 3、      每个实体类映射成一张表：

<class name="lee.com.animal" table="t_animal" abstract="true">
             <id name="id">
               <generator class="assigned"/>
             </id>
               <property name="name"/>
               <property name="sex"/>
             <union-subclass name="com.lee.hibernate.Pig">
               <property name="weight"></property>
             </union-subclass>
             <union-subclass name="com.lee.hibernate.Bird"> 
                <property name="hight"/>
             </union-subclass>
        </class>

class中有个abstract属性设置为true，那个父类就不生成表了,注意主键生成策略只能手动分配，不能采用UUID等自增策略，否则实体类ID会重复

复合主键映射：复合主键映射分为2种情况：

   1、基于实体类属性的复合主键（主键字段和普通字段都在一个实体类中，注意复合主键实体类必须是序列化对象，即实现Serializable接口，实现hashCode(),equals()方法）

        

   
在person类中fistName和lastName属性作为符合主键。

  
看下映射文件：

<class name="com.lee.Person" table="t_person">
           <composite-id>
             <key-property name="firtName" type="string"/>
             <key-property name="lastName" type="string"/>
           </composite-id>
           <property name="email"/>
        </class>

   2、基于主键类的复合主键(单独将主键字段提取出来放到一个实体类中,主键所在的实体类，要实现Serializable接口，要覆盖hashCode()和equals()方法)

 <class name="com.lee.Person" table="t_person">
           <composite-id name="PersonPK">
             <key-property name="firtName" type="string"/>
             <key-property name="lastName" type="string"/>
           </composite-id>
           <property name="email"/>
        </class>

 

集合映射：(Set,List,Array,Map)

Set:

<class name="com.lee.Collection" table="t_collection">
            <id>
              <generator class="uuid"></generator>
            </id>
            <set name=setMapping table="t_set_mapping">
               <key column="id"/>
               <element type="string" column="set_values"/>
            </set>
        </class>

 List:

<class name="com.lee.Collection" table="t_collection">
            <id>
              <generator class="uuid"></generator>
            </id>
            <list name="listMapping" table="t_list_mapping">
               <key column="id"/>
               <list-index column="list_index"/>
               <element column="list_values" type="string"/>
            </list>
        </class>

Array:

<class name="com.lee.Collection" table="t_collection">
            <id>
              <generator class="uuid"></generator>
            </id>
            <array name="arrayMapping" table="t_array_mapping">
                <key column="id"/>
                <list-index column="arrayIndex"/>
                <element column="arrayValues" type="string"/>
            </array>
        </class>

Mapping:

 <class name="com.lee.Collection" table="t_collection">
            <id>
              <generator class="uuid"></generator>
            </id>
            <map name="mapMapping" table="t_map_mapping">
                  <key column="id"/>
                  <map-key type="string" column="mapKey"/>
                  <element type="string" column="mapValues"/> 
            </map>
        </class>