转载：从整体上了解hibernate

该文出自博客http://blog.csdn.net/jiuqiyuliang/article/details/39078749/，转载仅供自己学习。

什么是Hibernate？

      Hibernate，翻译过来是冬眠的意思，正好现在已经进入秋季，世间万物开始准备冬眠了。其实对于对象来说就是持久化。

扫盲--------------------------------------------------------------------------------------------------------

      持久化（Persistence），即把数据（如内存中的对象）保存到可永久保存的存储设备中（如磁盘）。持久化的主要应用是将内存中的对象存储在关系型的数据库中，当然也可以存储在磁盘文件中、XML数据文件中等等。

持久化是将程序数据在持久状态和瞬时状态间转换的机制。
 

JDBC就是一种持久化机制。文件IO也是一种持久化机制。
 

日常持久化的方法：
1、将鲜肉冷藏，吃的时候再解冻的方法也是。
2、将水果做成罐头的方法也是。

结束----------------------------------------------------------------------------------------------------------

  

我们从三个角度理解一下Hibernate：

一、Hibernate是对JDBC进一步封装

       原来没有使用Hiberante做持久层开发时，存在很多冗余，如：各种JDBC语句，connection的管理，所以出现了Hibernate把JDBC封装了一下，我们不用操作数据，直接操作它就行了。
 

二、我们再从分层的角度来看

       我们知道非常典型的三层架构：表示层，业务层，还有持久层。Hiberante也是持久层的框架，而且持久层的框架还有很多，比如：IBatis，Nhibernate，JDO，OJB，EJB等等。

三、Hibernate是开源的一个ORM（对象关系映射）框架。

      ORM，即Object-Relational Mapping，它的作用就是在关系型数据库和对象之间做了一个映射。从对象（Object）映射到关系（Relation），再从关系映射到对象。这 样，我们在操作数据库的时候，不需要再去和复杂SQL打交道，只要像操作对象一样操作它就可以了（把关系数据库的字段在内存中映射成对象的属性）。

Hibernate的核心：

                 

     从上图中，我们可以看出Hibernate六大核心接口，两个主要配置文件，以及他们直接的关系。Hibernate的所有内容都在这了。那我们从上到下简单的认识一下，每个接口进行一句话总结。

1、Configuration接口:负责配置并启动Hibernate

2、SessionFactory接口:负责初始化Hibernate

3、Session接口:负责持久化对象的CRUD操作

4、Transaction接口:负责事务

5、Query接口和Criteria接口:负责执行各种数据库查询

注意：Configuration实例是一个启动期间的对象，一旦SessionFactory创建完成它就被丢弃了。

Hibernate的优/缺点：

优点：

1、更加对象化

      以对象化的思维操作数据库，我们只需要操作对象就可以了，开发更加对象化。

2、移植性
      因为Hibernate做了持久层的封装，你就不知道数据库，你写的所有的代码都具有可复用性。

3、Hibernate是一个没有侵入性的框架，没有侵入性的框架我们称为轻量级框架。

      对比Struts的Action和ActionForm，都需要继承，离不开Struts。Hibernate不需要继承任何类，不需要实现任何接口。这样的对象叫POJO对象。

4、Hibernate代码测试方便。

5、提高效率，提高生产力。

缺点：

1、使用数据库特性的语句，将很难调优

2、对大批量数据更新存在问题

3、系统中存在大量的攻击查询功能

ORM映射

       ORM（Object Relational Mapping），即对象关系数据库之间的映射。它的作用就是在关系型数据库和对象之间做了一个映射。从对象（Object）映射到关系（Relation），再从关系映射到对象。

    

         这张图特别简单：原来，没有Hibernate时，我们需要通过JDBC+手动写SQL语句来操作数据库，现在，有了Hibernate，它将JDBC+SQL进行了高度封装，我们不需要再去和复杂SQL打交道，只要像操作对象一样操作数据库就可以了。

       ORM的实现思想就是将数据库中表的数据映射成对象，Hibernate可以使我们采用对象化的思维操作关系型数据库。

映射文件

 Hibernate在实现ORM功能的时候主要用到的文件有：
    1、 映射类（*.java）：它是描述数据库表的结构，表中的字段在类中被描述成属性，将来就可以实现把表中的记录映射成为该类的对象了。
 
    2、映射文件（*.hbm.xml）：它是指定数据库表和映射类之间的关系，包括映射类和数据库表的对应关系、表字段和类属性类型的对应关系以及表字段和类属性名称的对应关系等。
 
    3、 hibernate核心配置文件（*.properties/*.cfg.xml）：它指定hibernate的一些核心配置，包含与数据库连接时需要的 连接信息，比如连接哪种数据库、登录数据库的用户名、登录密码以及连接字符串等。映射文件的地址信息也放在这里。

分类

           

      上面的内容看上去挺多，其实特别少，基本映射很简单，我们主要学习关联关系映射，其他几种映射一般不会用，只需要了解即可，用的时候看一下相关资料会做就好。

 基本映射

          上篇博文我们已经实现了一个基本映射，是使用XML方式配置映射，如下所示：

<span style="font-size:12px;"><?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>
    <class name="com.liang.hibernate.User" >
        <id name="id">
            <!-- 算法的核心思想是结合机器的网卡、当地时间、一个随机数来生成GUID -->
            <generator class="uuid"></generator>
        </id>
        <property name="name"></property>
        <property name="password"></property>
        <property name="createTime" type="date"></property>
        <property name="expireTime" type="date"></property>
    </class>
</hibernate-mapping></span>

除了XML方式配置映射外，还可以通过给类文件添加注解的方式配置映射，在上篇博文的基础之上，我们稍加修改。

1、加入hibernate annotion支持包

      *hibernate-annotations.jar
      *hibernate-commons-annotations.jar
      *ejb3-persistence.jar

 如图所示：

          

2、建立实体类User，采用注解完成映射

package com.liang.hibernate;

import java.util.Date;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

@Entity //不写Table默认为user，@Table(name="t_user")
public class User {

    @Id //主键
    @GeneratedValue(strategy=GenerationType.AUTO)//采用数据库自增方式生成主键
    //JPA提供的四种标准用法为TABLE,SEQUENCE,IDENTITY,AUTO.
    //TABLE：使用一个特定的数据库表格来保存主键。
    //SEQUENCE：根据底层数据库的序列来生成主键，条件是数据库支持序列。
    //IDENTITY：主键由数据库自动生成（主要是自动增长型）
    //AUTO：主键由程序控制。
    private int id;

    private String name;
    private String password;

    @Temporal(TemporalType.DATE)//生成yyyy-MM-dd类型的日期
    private Date createTime;
    @Temporal(TemporalType.DATE)//生成yyyy-MM-dd类型的日期
    private Date expireTime;



    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    @Column(name="name",unique=true,nullable=false) //字段为name，不允许为空，用户名唯一
    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;
    }

}

注：由于主键改成了自增长，所以数据类型修改成了int类型

3、提供hibernate.cfg.xml文件，将实体类User加入到hibernate.cfg.xml配置文件中，完成基本配置

<span style="font-size:12px;"><!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
    <session-factory>
        <!-- 驱动 -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <!-- 数据库URL -->
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_first</property>
        <!-- 数据库用户名 -->
        <property name="hibernate.connection.username">root</property>
        <!-- 数据库密码 -->
        <property name="hibernate.connection.password">123456</property>
        <!-- mysql的方言 -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

        <!-- 映射文件 -->
        <!--  <mapping resource="com/liang/hibernate/User.hbm.xml"/>  -->

        <!-- 由原来的映射文件，改成实体类 -->
        <mapping class="com.liang.hibernate.User"/>

    </session-factory>
</hibernate-configuration></span>

4、编写工具类ExportDB.java，注解生成ddl,必须采用AnnotationConfiguration类

<span style="font-size:12px;">package com.liang.hibernate;

import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.cfg.Configuration;
import org.hibernate.tool.hbm2ddl.SchemaExport;

/**
 * 将hbm生成ddl
 * @author liang
 *
 */
public class ExportDB{
    public static void main(String[]args){
        //默认读取hibernate.cfg.xml文件
        Configuration cfg = new AnnotationConfiguration().configure();
        SchemaExport export = new SchemaExport(cfg);
        export.create(true, true);
    }
}</span>

数据库生成表如图所示：

     

5、建立客户端类Client，添加用户数据到mysql

package com.liang.hibernate;

import java.util.Date;

import org.hibernate.Session;
import org.hibernate.SessionFactory;

import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.cfg.Configuration;

public class Client {
    public static void main(String[]args){
        //读取hibernate.cfg.xml文件
        Configuration cfg = new AnnotationConfiguration().configure();
        //建立SessionFactory
        SessionFactory factory =cfg.buildSessionFactory();

        //取得session
        Session session = null;

        try{
            //开启session
            session = factory.openSession();
            //开启事务
            session.beginTransaction();

            User user = new User();
            user.setName("jiuqiyuliang");
            user.setPassword("123456");
            user.setCreateTime(new Date());
            user.setExpireTime(new Date());
            //保存User对象
            session.save(user);

            //提交事务
            session.getTransaction().commit();

        }catch(Exception e){
            e.printStackTrace();
            //回滚事务
            session.getTransaction().rollback();
        }finally{
            if(session != null){
                if(session.isOpen()){
                    //关闭session
                    session.close();
                }
            }
        }
    }
}

 运行之后，数据库表生成的数据，如下图所示：

      

一对一的关联映射

      两个实体对象之间是一对一的关联映射，即一个对象只能与另外唯一的一个对象相对应。例如：一个人(Person)只有一张身份证(IdCard)。我们看一下这个例子的对象模型，如下图所示：

对象模型

       

        从上图中可以看出：

        1、一个人只有一张身份证，唯一的一个身份证号，对象之间是一对一的关系；

        2、人(Person)持有身份证(IdCard)的引用，所以，两个对象关系维护由person端决定。

        从对象模型映射成关系模型，有两种方式：主键关联和唯一外键关联，我们继续看下面的内容。

分类： 

 主键关联：

        1、两个实体对象的主键一样，以表明它们之间的一一对应关系；

        2、不需要多余的外键字段来维护关系，仅通过主键来关联，即Person的主键要依赖IdCard的主键，他们共用一个主键值。

        以上两点恰与唯一外键关联相反。

 主键关联的关系模型

 Person.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.liang.hibernate">
    <class name="Person" table="t_person">
        <id name="id">
        <!-- 采用foreign生成策略，forgeign会取得另外一个关联对象的标识 -->
            <generator class="foreign" >
                <param name="property">idCard</param>
            </generator>
        </id>
        <property name="name"></property>
        <!--
            one-to-one指示hibernate如何加载其关联对象，默认根据主键加载
            也就是拿到关系字段值，根据对端的主键来加载关联对象

            constrained="true"表示约束，当前主键（person的主键）还是一个外键
            参照了对端的主键（IdCard的主键），也就是会生成外键约束语句
         -->
         <!-- idCard属性，表达的是本对象与IdCard的一对一关系。 -->
        <one-to-one name="idCard" class="IdCard"  constrained="true"></one-to-one>
    </class>
</hibernate-mapping>

生成的表结构以及测试数据：

唯一外键关联：

       1、两个实体对象用一个外键来关联，以表表明对象之间的关系。

       2、其实它是多对一关联映射的特例，多的一端加上唯一的限制之后，用来表示一对一的关联关系。

       所以它采用多对一的标签来映射，如下所示：

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

唯一外键的关系模型

Person.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.liang.hibernate">
    <class name="Person" table="t_person">
        <id name="id">
            <generator class="native" ></generator>
        </id>
        <property name="name"></property>
        <!-- 由于它是一对一的唯一外键关联，它是多对一关联的特例，注释可以直接写成多对一关联-->
        <!-- idCard属性，表达的是本对象与IdCard的多对一关系。 -->
        <many-to-one name="idCard" class="IdCard" column="idCardId" unique="true"></many-to-one>
    </class>
</hibernate-mapping>

生成的表结构以及测试数据：

 

其他相同代码如下：

Person

public class Person {
    private int id;
    private String name;
    private IdCard idCard;

    public IdCard getIdCard() {
        return idCard;
    }
    public void setIdCard(IdCard idCard) {
        this.idCard = idCard;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

IdCard

public class IdCard {
    private int id;
    private String cardNo;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getCardNo() {
        return cardNo;
    }
    public void setCardNo(String cardNo) {
        this.cardNo = cardNo;
    }
}

IdCard.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.liang.hibernate">
    <class name="IdCard" table="t_idCard">
        <id name="id">
            <generator class="native"></generator>
        </id>
        <property name="cardNo"></property>
    </class>
</hibernate-mapping>

建议

由于一对一主键关联映射具有以下两个缺点：

      1、灵活性差，没有办法改成多对一关联映射，不能应变多变的需求；

      2、必须先保存关联对象IdCard，之后才能保持Person；

所以，在映射一对一单向关联映射时，我们采用唯一外键关联映射。

     下篇博文，我们介绍一对一双向关联映射，谢谢关注。