Hibernate进行了分类整合发现其实Hibernate分为三大部分：核心对象、映射、HQL，这三大部分开发过程中最常使用，前几篇讨论了核心对象及对象之间的转换方法，接下来讨论Hibernate的映射使用方法。
Hibernate一个重要的功能就是映射，它能够在对象模型和关系模型之间转换，是面向对象编程思想提倡使用的，使用映射程序开发人员只需要关心对象模型中代码的编写。对象和关系数据库之间的映射通常是由XML文档来定义的。这个映射文档被设计为易读的，并且可以手动修改。这种映射关系我总结为下图：
映射是通过XML来定义的，使用Hibernate创建的session来管理，最后由session使用JTA把更改提交到数据库中。session可以理解为持久化管理器，管理持久层中的对象，它是由sessionFactory创建的。使用Hibernate编程时首先要连接数据库，所以首先要去查看xml中有关数据库连接的配置，根据文档的配置创建sessionFactory（可以理解为数据库镜像），再由sessionFactory创建一个session，最后由session统一将更改提交到数据库，这才完成了一部所有的操作。
使用过程
1.创建映射文件，映射文件以.hbm.xml为后缀名，标明它是Hibernate的映射文件；
2.在映射文件中注册实体类，并将实体类的属性添加到映射类中，在添加属性时要指定两种值分别是id和property，id指明它是一个实体的唯一标示，property指明它是表的字段列；
3.提交修改，同步数据。
Note：开发过xml数据转到数据库的开发人员很快就能理解这种映射其实是一种批量更新、批量创建的过程，映射也不例外，Hibernate规定了一套映射标准，按照标准就能够实现转换，它的内部实现还是死的，所以它只是相对的灵活易用。
一个简单的实体类映射过程：
1. 实体类User1的属性代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
package com.hibernate; import java.util.Date; public class User1 { private String id; private String name; private String password; private Date createTime; private Date expireTime; public String getId() { return id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } public Date getCreateTime() { return createTime; } public void setCreateTime(Date createTime) { this.createTime = createTime; } public Date getExpireTime() { return expireTime; } public void setExpireTime(Date expireTime) { this.expireTime = expireTime; } } |
2. User1.java的映射文件User1.hbm.xml的内部代码实现：
基础数据库中能够设置的在Hibernate中同样提供了设置的方法，可以使用标签属性来设置具体的映射关系。
类-->表使用class标签，常用属性：
（1）name：映射实体类，它的值需要设置为需要转化成表的实体类的名称，在同步时会根据该属性查找相应的实体类。
（2）table：映射数据库表的名称，如果要映射的表的名称和实体类名称不相同，使用该属性来指定映射的表，如果不存在的话会根据该属性值创建一个表。
查看上图中配置生成的表结构，如下图：
其中的表名更改为了t_user1；id字段更名为user_id，字段长度为32位；createTime属性，映射为数据库字段create_time，并修改为date类型。
属性-->字段使用id或property标签，常用属性：
（1）name：功能类似于class标签的name，值定实体类的映射属性名；
（2）column：类似于实体类class标签的table，指定映射表的列名称，如果不存在将会创建；
（3）type：指定映射到数据库中字段的数据类型，根据需要查看文档即可；
（4）generator，它是可选的，用来为一个持久类生成唯一的标识。
|
1
2
3
4
5
6
|
<id name="id" type="long" column="cat_id"> <generator class="org.hibernate.id.TableHiLoGenerator"> <param name="table">uid_table</param> <param name="column">next_hi_value_column</param> </generator> </id> |
所有的生成器都实现org.hibernate.id.IdentifierGenerator接口。 这是一个非常简单的接口；某些应用程序可以选择提供他们自己特定的实现。当然， Hibernate提供了很多内置的实现。下面介绍常用的几种：
（1）identity：返回的标识符是long, short 或者int类型的。类似于数据库的自增字段。
（2）sequence：在DB2,PostgreSQL, Oracle, SAP DB, McKoi中使用序列（sequence)， 而在Interbase中使用生成器(generator)。返回的标识符是long, short或者 int类型的。在整个数据库中自增，而不是单个的表中自增，需要指定单个的表中自增需要添加属性。
（3）uuid：用一个128-bit的UUID算法生成字符串类型的标识符， 这在一个网络中是唯一的（使用了IP地址）。UUID被编码为一个32位16进制数字的字符串。类似于.NET生成的序列号。
（4）native：根据底层数据库的能力选择identity, sequence 或者hilo中的一个。灵活的方式，会根据使用的数据库来确定使用的标识类型，MySQL会选择identity，Oracle选择sequence。
（5）assigned：手动为实体类制定一个标识id。这是 <generator>元素没有指定时的默认生成策略。
（6）foreign：使用另外一个相关联的对象的标识符。通常和<one-to-one>联合起来使用。
开发人员往往习惯了手动配置的方法根据文档的说明来编写配置属性，这样做很原始，初学者建议采用手动配置的方法，有助于思考。另外还有很多第三方工具，通过可视化的方法来配置然后生成xml配置文档，提高了开发效率，类似的工具如：XDoclet、Middlegen和AndorMDA。
关联映射之多对一
上面讨论了Hibernate的基本映射，一个实体类对应着一张表，在相应的Hibernate Mapping文件中使用<class>标签映射。并且实体类中的普通属性对应着表字段，使用<property>标签映射。另外在构造实体类时应注意：在实体类中应实现无参的默认的构造函数，提供一个标示，建议不要使用final修饰实体类，为实体类生成getter和setter方法，最后介绍了几种主要的主键生成策略，接下来讨论多对一映射。
这种多对一关联映射反应到对象模型中它是一种聚合关系，User是group的一部分，group中存在User，它们两个的生命周期是不相同的，可反应为下图：
那么这种多对一关系映射在Hibernate中是如何设置的呢？下面将会介绍两种方法，使用<many-to-one>标签直接映射，或者使用<many-to-one>的cascade级联修改表。
1、Many-to-one直接映射
从字面意思上就能够理解，它是指多对一的关系，many指的是多的一端，one指的是少的一端，在使用时往往在多的一端的hbm中使用该标签，并将<many-to-one>的name属性设置为该映射文件对应的类中的one一端的属性，如：<many-to-one name="group" column="groupid"></many-to-one>，该标签添加在了User.hbm.xml中，它对应many；标签中的name值为group对映射one，并且在User.java中会有一个名为group的属性。接下来看下具体实现实现的代码类。
（1）User.java类代码，其中有一个名为group的属性，它将会作为<many-to-one>的one一端的name值。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public class User { private String name; public String GetName(){ return name; } public void SetName(String name){ this.name=name; } private Group group; public Group GetGroup(){ return group; } public void SetGroup(Group group){ this.group=group; } } |
（2）User.hbm.xml中的<many-to-one>，name的值为User.java中one端的属性值，它会在数据库中生成一个新列，可以将该新列理解为User表的外键。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
<?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <!-- Generated 2014-5-14 23:39:25 by Hibernate Tools 3.4.0.CR1 --><hibernate-mapping> <class name="com.hibernate.User" table="USER"> <id name="id" type="java.lang.Long"> <column name="ID" /> <generator class="assigned" /> </id> <!-- name的值group为User.java中的一个对应的one中的一个属性，它会自动在表中生成一列，所以使用column对列进行了重命名 --> <many-to-one name="group" column="groupid"></many-to-one> </class> </hibernate-mapping> |
（3）测试上面的映射关系，向表中写入两个User对象分别为user1和user2，命名为张三和李四，使用session保存对象，向数据库中写入数据，代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
public void testSave1(){ Session session=null; try{ session=GetSession.getSession(); session.beginTransaction(); Group group=new Group(); group.SetName("动力节点"); User user1=new User(); user1.SetName("张三"); user1.SetGroup(group); User user2=new User(); user2.SetName("李四"); user2.SetGroup(group); session.save(user1); session.save(user2); //会报TransientObjectException错误 //在清理缓存时发生错误TransientObjectException //因为Group为Transient状态，没有被Session，在数据库中没有匹配的数据 //而User为Persistent状态，在清理缓存时Hibernate在缓存中无法找到Group对象 //揭露：Persistent状态的对象不能引用Transient状态的对象 //该问题在testSave2方法中更改 session.getTransaction().commit(); }catch(Exception e){ e.printStackTrace(); session.getTransaction().rollback(); }finally{ GetSession.CloseSession(session); } } |
但是使用上面的代码在执行写入时会报错TransientObjectException，这是因为在保存User对象时它会按照<many-to-one>中添加的group去内存中查找group对象，但是上面的代码中group对象一直都是在Transient状态中，并没有被session管理，也就是说查找不到session对象，而User对象进入了Persistent状态，于是会报此错误。正确的代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
public void testSave2(){ Session session=null; try{ session=GetSession.getSession(); session.beginTransaction(); Group group=new Group(); group.SetName("动力节点"); session.save(group); //此处将group对象设置为Persistent对象 User user1=new User(); user1.SetName("张三"); user1.SetGroup(group); User user2=new User(); user2.SetName("李四"); user2.SetGroup(group); session.save(user1); session.save(user2); //可以正确的保存数据 //因为Group和User都是Persistent状态的对象 //所以在Hibernate清理缓存时在session中可以找到关联对象 session.getTransaction().commit(); }catch(Exception e){ e.printStackTrace(); session.getTransaction().rollback(); }finally{ GetSession.CloseSession(session); } } |
2、级联映射
除了上面所说的将group对象和user对象都转化到Persistent对象外，还可以使用cascade级联映射属性，在<many-to-one>属性中添加cascade属性，并复制为save-update，在group对象并非为Persistent状态时即可写入数据库。这样只需要将两个user对象的Group属性设置为同一个group对象即可实现多对一的映射关系，此时User.hbm.xml中对应的内容为如下代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
<?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <!-- Generated 2014-5-14 23:39:25 by Hibernate Tools 3.4.0.CR1 --><hibernate-mapping> <class name="com.hibernate.User" table="USER"> <id name="id" type="java.lang.Long"> <column name="ID" /> <generator class="assigned" /> </id> <!-- 级联修改表 --> <many-to-one name="group" column="groupid" cascade="save-update"></many-to-one> </class> </hibernate-mapping> |
Note：cascade设置为save-update后即可实现向数据库中级联修改、添加和删除，但是具体的级联查询操作却不可以。
对应的测试配置文件的方法为如下代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
//级联cascade public void testSave3(){ Session session=null; try{ session=GetSession.getSession(); session.beginTransaction(); Group group=new Group(); group.SetName("动力节点"); User user1=new User(); user1.SetName("张三"); user1.SetGroup(group); User user2=new User(); user2.SetName("李四"); user2.SetGroup(group); session.save(user1); session.save(user2); //没有抛出TransientObjectException异常 //因为使用了级联 //Hibernate会首先保存User的关联对象Group //Group和User就都是Persistent状态的对象了 session.getTransaction().commit(); }catch(Exception e){ e.printStackTrace(); session.getTransaction().rollback(); }finally{ GetSession.CloseSession(session); } } |
3、对比升华
两种方法同样实现了多对一的映射方法，结果上是相同的，但在实现上很不相同。无论是第一种还是第二种采用的都是<many-to-one>在many一端的映射文件中添加该标签，并将标签的name属性赋值为该映射文件注册的类中的one一端的属性值，这样就完成了多对一的基本映射，这是相同点。不同点是直接映射关系没有采用Hibernate字段的属性，这样在实现上较灵活，不但支持增删改，而且可以查询；第二种的cascade级联修改则采用了Hibernate提供的方法，此种方法只支持增删改，并不支持查询。
