Hibernate核心思想—ORM机制（一）

2023-07-17 18:33:58

转：http://blog.csdn.net/wanghuan203/article/details/7566518

hibernate是一个采用ORM（Object/Relation Mapping对象关系映射）机制持久层的开源框架

其主要核心思想是面向对象，而非面向过程，而这个面向对象则主要通过ORM实现。

ORM是将表与表之间的操作，映射成对象和对象之间的操作，就是通过操作实体类来达到操作表的目的。从数据库提取的数据会自动按你设置的映射要求封装成特定的对象。之后你就可以通过对对象进行操作来修改数据库中的数据。这时候你面对的不是信息的碎片，而是一个形象鲜明的对象。

最简单的情况下，hibernate把数据表的数据段映射到类的属性上，那么这个数据表的定义本身就对应于一个类的定义，而每一个数据行将映射成该类的一个对象。

所以hibernate就是通过将数据表和实体类之间的映射，使得对对象的修改对应数据行的修改，不用考虑关系型的数据库表，使得程序思考角度完全对象化，更符合面向对象思维，同时也简化了持久层的代码，使逻辑结构更清晰。

下面来全面了解Hibernate的核心---对象关系映射机制。

热身运动：

<class name="实体类名" table="实体类对应的数据库中表名">

<id name="id" column="表主键字段名" type="java.lang.Integer">

<generator class="设置主键生成策略类型"/>

</id>

<property></property>

</class>

实体类----表，采用<class>标签

实体类中的普通属性（不包括集合、自定义类和数组）-----表字段，采用<property>标签映射

注意：如果实体类的名称或实体类中属性的名称和数据库关键字重复，将会出现问题

可以考虑采用table属性和column属性对其进行重新命名

实体类的设计原则：

* 实现无参的默认的构造函数

* 提供一个标识

* 建议不要使用final修饰实体类

* 建议为实体类生成getter和setter方法

关于主要的主键生成策略，可参考《Hibernate主键生成策略总结》

基础的映射不再介绍，重点是配置实体类之间的关系，正式进入实体类关系映射

这次主要介绍实体类之间的一对一映射

（一）单向一对一主键映射

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

例如人和身份证之间意义对应。Person-IdCard

Hibernate核心思想—ORM机制（一）

在这个例子中，Person的主键参考IdCard的主键生成，其实就是IdCard的主键。所以IdCard的主键id既是主键，也是外键。

实体类的写法很简单，属性和get，set方法，空构造函数，按照上面提到的原则和UML图写就可以。

主要来介绍映射文件的写法：

Person.hbm.xml

  1. <?xml version="1.0"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC
  3. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  5. <hibernate-mapping>
  6. <class name="com.bjpowernode.hibernate.Person" table="t_person">
  7. <id name="id"><!--主键的写法-->
  8. <!-- 采用foreign生成策略，forgeign会取得关联对象的标识 -->
  9. <generator class="foreign">
  10. <!-- property只关联对象 -->
  11. <param name="property">idCard</param>
  12. </generator>
  13. </id>
  14. <property name="name"/><!--普通属性的写法-->
  15. <one-to-one name="idCard" constrained="true"/>
  16. </class>
  17. </hibernate-mapping>

通过One-to-one标签来确定了Person和IdCard的关系，

one-to-one指示hibernate如何加载其关联对象，<param>标签表明了要关联的对象，默认根据主键加载。也就是拿到关系字段值，根据对端的主键来加载关联对象

这个关系确定了Person类对象可以通过idCard的get和set方法来得到和设置其对应的IdCard对象。

constrained="true表示，当前主键(person的主键)还是一个外键参照了对端的主键（IdCard的主键），也就是会生成外键约束语句。

部分示例代码：

  1. session = HibernateUtils.getSession();
  2. session.beginTransaction();
  3. IdCard idCard = new IdCard();
  4. idCard.setCardNo("1");
  5. Person person = new Person();
  6. person.setName("张三");
  7. //建立关联
  8. person.setIdCard(idCard);
  9. session.save(person);
  10. person.getCardNo();//取得关联对象

IdCard.hbm.xml

  1. <?xml version="1.0"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC
  3. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  5. <hibernate-mapping>
  6. <class name="com.bjpowernode.hibernate.IdCard" table="t_idCard">
  7. <id name="id">
  8. <generator class="native"/>//主键生成策略采用native
  9. </id>
  10. <property name="cardNo"/>
  11. </class>
  12. </hibernate-mapping>

因为Person和idCard的关系由Person来维护，即有Person断可以持有IdCard对象，而idCard并不知道Person的存在，所以IdCard的映射文件就是其本身映射，没有其他标签。

（二）双向一对一主键映射

因为Person和IdCard是一对一关系，如果IdCard也想得到与之对应的Person对象，那就可以将他们之间的关系设置成双向的。

此时IdCard的实体类需要加入person属性，用来装载其对应的Person对象。

Hibernate核心思想—ORM机制（一）

Person类的映射文件不变，IdCard映射文件需要加入<one-to-one>标签，指示hibernate将关联对象Person根据主键加载上来。

IdCard.hbm.xml

  1. <?xml version="1.0"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC
  3. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  5. <hibernate-mapping>
  6. <class name="com.bjpowernode.hibernate.IdCard" table="t_idCard">
  7. <id name="id">
  8. <generator class="native"/>
  9. </id>
  10. <property name="cardNo"/>
  11. <one-to-one name="person"/>
  12. </class>
  13. </hibernate-mapping>

因为<one-to-one>不影响存储，只影响加载，所以单向关联和双向关联所生成的数据库的表机构不变。

此时对象双方都可以互相加载对方，都持有对方的引用。

（三）单向一对一唯一外键映射

因为采用主键关联的扩展性不好，主键直接生成，修改之后对双方都有很大影响，基本没有办法进行修改。所以比较好的是采用唯一外键关联。

一对一唯一外键关联映射其实是多对一的特例。多对一的关联将在下篇文章中介绍。

实体类与单向一对一主键映射中一样。

Hibernate核心思想—ORM机制（一）

主要改变的是Person类的映射。

Person.hbm.xml

  1. <?xml version="1.0"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC
  3. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  5. <hibernate-mapping>
  6. <class name="com.bjpowernode.hibernate.Person" table="t_person">
  7. <id name="id">
  8. <generator class="native"/>
  9. </id>
  10. <property name="name"/>
  11. <many-to-one name="idCard" unique="true"/>
  12. </class>
  13. </hibernate-mapping>

IdCard.hbm.xml,不持有关系，如下

  1. <?xml version="1.0"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC
  3. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  5. <hibernate-mapping>
  6. <class name="com.bjpowernode.hibernate.IdCard" table="t_idCard">
  7. <id name="id">
  8. <generator class="native"/>
  9. </id>
  10. <property name="cardNo"/>
  11. </class>
  12. </hibernate-mapping>

采用<many-to-one>标签来映射，指定多的一端unique为true，这样就限制了多的一端的多重性。

唯一，就是这样来映射的。

通过<many-to-one>的映射，会在数据库表中生成一个idCard字段，通过idCard字段关联IdCard表类维持Person与IdCard的关系

生成的表如下：

Hibernate核心思想—ORM机制（一）

（四）双向一对一唯一外键映射

如果想在IdCard里同时持有与之对应的Person对象，则需要要实体类idCard里加入person字段，实体类与双向一对一主键映射相同。

Hibernate核心思想—ORM机制（一）

映射文件的写法Person.hbm.xml与单向一对一唯一外键映射相同，

不同的是IdCard.hbm.xml,如下：

  1. <?xml version="1.0"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC
  3. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  5. <hibernate-mapping>
  6. <class name="com.bjpowernode.hibernate.IdCard" table="t_idCard">
  7. <id name="id">
  8. <generator class="native"/>
  9. </id>
  10. <property name="cardNo"/>
  11. <one-to-one name="person" property-ref="idCard"/>
  12. </class>
  13. </hibernate-mapping>

一对一唯一外键关联双向采用<one-to-one>标签映射，必须指定<one-to-one>

标签中的property-ref属性为关系字段的名称，因为不是idCard不是主键，所以在此必须指定。

此关系生成的数据库表与单向一对一唯一外键相同，因为双向用到的是,<one-to-one>标签，此标签只影响加载，不影响数据库表结构。

关于这四个关系映射，对比记忆理解之后特别简单清楚，主要是两个标签<one-to-one>,和<many-to-one>。Hibernate的思想就是在配置文件中通过标签的位置，便可以直接生成数据库表，而且对象之间的关系也明确了，可以根据配置进行相应对象的加载，不再需要面向关系数据库，不用写级联查询语句，而是直接操作对象就可以。绝对的面向对象编程。

下篇文章继续介绍多对多映射关系。

上一篇：Redis的正确使用姿势


下一篇：Sql server 2008镜像配置步骤