框架的诞生必然是为了解决某一问题,要对Hibernate的身世有所了解,知道它的优点、作用,能够干什么,不能够干什么,这然才算是掌握了Hibernate.

典型的B/S三层架构,这个都不陌生:

为什么要把Dao单独作为一个层?这样设计肯定是有原因的.底层数据库的实现不同,Dao的实现也不尽相同,可能一个Dao接口下有很多个实现,比如MysqlDaoImpl或者OracleDaoImpl等,这样写很不方便,很麻烦,而且就算用dbUtils这样的框架简化开发,也有一些问题解决不了,比如要把一个域对象映射到一张表里面去,如果这个对象的属性名或者表的字段名发生了更改,就全部都要改,很不方便,而Hibernate就能解决这样的问题,它不用管底层数据库的实现是什么,只需要告诉它所说的方言并通过域对象生成SQL语句,通过配置文件映射到表,为业务逻辑层提供了面向对象的API,对数据访问进一步的封装.所以Hibernate的特点如下:

在实际应用中,对象的映射文件后缀名是.hbm.xml,Hibernate的主配置文件名为hibernate.cfg.xml.

映射文件描述对象与表之间的关系,映射文件并没有创建实质性的东西,只有当hibernate的Configuration类将配置文件读到流中,创建SessionFactory,SessionFactory才会检查表的结构,然后根据主配置文件里的hbm2ddl.auto的取值,作相应的反应.配置映射文件的时候,需要思考,需要什么信息,且只需要配置hibernate猜不到的信息,比如配置了对象的属性ID为主键,如果表中的主键列的列名为ID,则可以不用配置,不同的集合需要配置不同的属性:

    Set
        <set>    属性名、集合表、集合外键、存放元素的列
    List
        <list>    属性名、集合表、集合外键、存放元素的列、表示索引的列
    Bag
        <bag>    属性名、集合表、集合外键、存放元素的列
    Map
        <map>    属性名、集合表、集合外键、存放元素的列、表示key的列
    数组
        <array>    属性名、集合表、集合外键、存放元素的列、表示索引的列

集合有懒加载，是配置集合的元素中的lazy属性，可取的值有:true,false,extra.默认值为true,为懒加载,就是当你用的时候才加载.extra就是增强的"超级懒加载",此时大多数操作都不会初始化集合类,只有当程序第一次访问集合属性的iterator()方法时,才会导致集合类的初始化,或者是有时候只想看集合的长度或者是不是空的,不关心集合中存放着什么数据,如果这个时候把集合的全部数据都读取出来,就很没有必要,于是就有第二个作用:当程序第一次访问集合属性的 size(), contains() 和 isEmpty() 方法时, Hibernate 不会初始化集合类的实例, 仅通过特定的 select 语句查询必要的信息.需要注意的是只有集合的lazy属性才有extra的取值.普通的值映射如下:

主键值的生成策略虽然有很多,但是只有当<generator>元素的class属性的值为assigned策略时才需要自己指定主键值,其他的都由Hibernate指定,自己不需要指定,指定了也没用还需要注意一点的就是increment,它是由Hibernate来维护的自增长,有并发问题,除了这种自增长,还有几种方式,native会根据数据库的能力选择 identity、sequence 或者hilo 中的一个,如果是mysql就会选择identity,由数据库维护,不会有并发问题.如果生成策略是hilo(高/低算法),需要额外配置几个参数.主键的类型分为两种:自然主键和代理主键.自然主键是在数据库表中把具有业务逻辑含义的字段作为主键,比如有客户的姓名,把客户的姓名当作主键,就是自然主键;代理主键就是采用一个与当前表中逻辑信息无关的字段作为其主键,比如在一张表中插入一列与业务数据毫无关系的数据.

主配置文件可以包含三类信息的配置:数据库连接信息、其他配置和声明映射文件.例如:

读取主配置文件的方法有多种,都是Configuration类的configure()方法重载的版本,最简单的就是将主配置文件命名为hibernate.cfg.xml,原因如下:

这是源码.然后我们在主配置文件中利用<mapping>标签声明了映射文件,这个标签会找到指定的类,然后把相应的映射文件加载进来,我们还有另外一种方法加载映射文件:

只是比之前的代码多了一行,addClass()方法的返回值仍是Configuration对象,意味着如果你还有映射文件没有加载进来,仍可能继续接着写,那么它是如何找到映射文件的呢?其实很简单,我们一样可以写出来:

这是它的源码,先得到类的全限定名,再把点替换把/,就得到了路径,再连接后缀,就行了,方法本身很简单,我们也要掌握它的思想,也就是方法调用链.

对象的状态

hibernate的设计者为了更好的维护对象,以便生成恰当的SQL语句,引入了对象的状态这个概念.hibernate文档里面描述hibernate的状态分为三种:

其实我也觉得如果按照Hibernate的关于对象的状态定义,状态应该分为四种才对:

多了一个删除状态,因为游离状态本身也是有对象引用,只是没有被session管理起来,不会被gc回收.四种对象状态的完整定义:

对象状态虽然不多,但是在使用中要格外小心,只有持久状态的对象才能同步到数据库中.管理对象状态的常用方法:

上面这些方法中需要特意说下的是load()方法.load()方法是基于类的懒加载,也就是class标签的lazy属性,默认值为true.在为true的情况下调用load()方法会返回一个代理类,且是一个没有初始化的代理类,只有当使用这个类的某个方法时才会去真正的加载记录;如果没有在数据库中找到对应的记录,则抛出异常.如果类的修饰符是fianl,由于hibernate是使用的继承创建的代理类,所以在这种情况下就不能创建代理类,将立即加载.

Hibernate中有二级缓存的概念,既然有二级缓存,那也自然就有"一级缓存"了,实际上,一级缓存就是session的缓存,Session 接口是Hibernate向应用程序提供的操纵对数据库的最主要的接口,它提供了基本的保存,更新,删除和加载Java对象的方法.Session接口的实现中包含了一系列的集合,这些集合构成了Session缓存,只要Session实例的生命周期没有结束,存放在它缓存里的对象也不会结束生命周期,因为还有这些集合在引用这些对象.所以如果有对象已经不需要了,就要即时的清除.把对象变为游离状态或者删除状态.

Session提供了一系列对缓存进行操作的方法:

事务管理

Hibernate的事务(Transaction)使用的很简单,和Spring整合后也就用不着了,简单的记下几个方法.

• 
  
  READ UNCOMMITED     1
  READ COMMITED         2
  REPEATABLE READ      4
  SERIALIZEABLE           8

可以在主配置文件中增加<property>标签的hibernate.connection.isolation属性来修改隔离级别.隔离级别标准有4种，但具体应看数据库支持几种,Oracle 只支持2种事务隔离级别：READ COMMITED, SERIALIZABLE.Oracle 默认的事务隔离级别为 READ COMMITED;Mysql 支持4中事务隔离级别,Mysql 默认的事务隔离级别为: REPEATABLE READ,可以修改,Mysql中对事务进行操作:

查看当前连接隔离级别：SELECT @@tx_isolation;

查看全局隔离级别：SELECT @@global.tx_isolation;

设置当前连接连接的隔离级别：set transaction isolation level read committed;

设置全局连接的隔离级别:set global transaction isolation level read committed;

设置是否自动提交(0为false):set autocommit=0;

查看当前的自动提交状态:select @@autocommit;

关联关系映射

关系总体分为三种:一对多,多对多,一对一.在配置映射文件时, 需要选择与保存对象相应的集合标签.

在一对多的关系中,往往只需要一方维护两者的关系,因为在关系型数据库中,只需要有一方存储关系就行了,称为外键,外键列保存在多的一方即可,对于对象来说,双方都设置关联才比较好,这样双方才都知道与对方关联,但是对于数据库来说,只需要一方设置有关联就可以了,不管哪一方，只进行设置,默认就会生成一条update语句来更新外键的值,以保存关联关系（维护关联关系）,如果关联一个没有保存的对象（有效的关联）,会抛出一个TransientObjectException异常.不管在哪一方都能找到另一方,称为双向关联,单项关联就是指仅仅从某一方才能找到另一方,而另一方不能找到某一方,因为在另一方的数据库中没有维护关系,自然就找不到.关联关系中重要的属性:

• inverse:是否只由对方维护关联关系,默认值为false.对于一对多,维护关联关系是指更新外键列的值,对于多对多,维护关联关系是指在中间表中插入或删除记录,这个属性只在表示关联关系的集合映射中用（一对多、多对多）
• cascade:级联操作,即对从对象也做相应的操作,级联风格有：save-update, delete, none, all, delete-orphan, all-delete-orphan, ...，默认值为none.只要是关联关系，都可以配这个属性（一对多、多对一、多对多、一对一）
• order-by:指定排序子句（order by子句，是指定的sql语句，所以要写列名,这个属性可以在所有的无序集合映射中使用(<set>中可以用，<list>中不可以用),模拟一的一方:
  
  

  <!--

  不用指定表名,因为根据类,可以自动找到映射文件,映射文件里有描述表的结构

  cascade="all":将一个关联关系（无论是对值对象的关联，或者对一个集合的关联）

  标记为父/子关系的关联。

  这样对父对象进行 save/update/delete 操作就会导致子对象也进行 save/update/delete 操作     lazy:默认值为true,开启懒加载.属性interests是set集合的引用,这个集合里面的对象存在数据库中,是person对象的子对象,     如果开启懒加载,且没有在session关闭之前访问interests的成员,则关闭session之后就获取不到了,访问将抛LazyInitializationException异常.

  -->

  <set name="interests" cascade="all">

  <key column="personID"></key>

  <one-to-many class="..domain.Interest"/>

  </set>

多的一方:

假设我有一个员工表,和一个部门表,我有15个员工和5个部门,它们的关系在数据库中表示为员工表的外键列,在session开启之后获取到部门的持久对象,也将获取和它关联的员工,在session关闭之前所做的任何修改都将直接同步到数据库中.如果要解除两者的关联关系:

删除部门时,如果有和它关联的员工,则可能会有约束异常,必须先把与员工的关系解除或者连员工一起删除,需要设置cascade属性,然后才能进行:

多对多的关联关系比多对一的关联关系更好理解一些,通常在数据库中有张中间表来描述:

在Hibernate中默认双方都能维护关联关系,但双方都设置关联关系会有异常:java.sql.BatchUpdateException.因为中间表通常以两个外键作为联合主键,在程序中,由于是多对多的关系,双方维护的对象都是一样的,比如:

从任何一方都能关联,任何一方都清楚的展示了对方的属性,任何一方的对象里面都维护着另一方的对象(双向关联),这样一来,在持久化对象的时候,就会在中间表中出现重复记录,当然是不允许的.所以一般做法为:只关联一方或者在某一方设置inverse=”true”即可.多对多是关联关系里面用的最多的:

一对一.一对一虽然不难,理解起来比多对多稍微麻烦一点,假设一个部门只能有一个员工,一个员工也只能有一个部门.一对一有两种映射方式:

基于主键(推荐)

这是一种万能方式,因为employee表中的主键是id,属于代理主键,如果开发部被删除了,zhang将不会被删除,因为department_id可能设置允许为null.

有外键的表的映射文件(employee):

无外键表的映射文件(department):

基于外键

在这种方式下,employee表中的id既当主键又当外键,如果开发部被删除了,zhang也要被删除,因为主键不能为null,与其他对象有多个一对一关系时,如果外键设计在当前表中,则最多只能有一个基于主键的一对一映射.有外键方的对象需要独立存在而不与对方的某一条数据关联时,不能使用基于主键的一对一映射.除非保证employee表中的id始终有值对应.除了这些以外,还需要在两者之间寻找主从关系,比如人是必须存在的,身份证需要依赖人,人就是主,身份证就是从.
主:

从:

不管关联关系是什么,不是谁都能维护关联关系,关于谁才能维护关联关系:

一对多：
            默认双方都能维护
            在一方可以通过设置inverse="true"来放弃维护关联关
            在多方（有外键方）始终能维护关联关系，因为外键在自己表中
多对多：
            默认双方都能维护
            在任何一方都可以通过设置inverse="true"来放弃维护关联关系。注意只需设置一边就可以
一对一：
            不管是采基于外键的还是基于主键的一对一映射，都是只有有外键方可以维护关联关系，没有外键方不可以维护。而且不可以配置
            当采用基于主键的一对一映射时，双方都不能解除关联关系，因为主键值为能为null

单向关联与上述的一致,能维护关系的一方才可以做单向关联到对方.

继承映射

映射继承结构的时候,一般是整个继承结构使用一个映射文件,名称前缀为超类的名,继承映射有三种方式,全部以论坛的帖子为例:

方式一:

一个继承结构只有一张表,同时只有一个映射文件,那它的子类怎么办?用<subclass>标签配置它的子类.另外分析下,因为是一张表,表中要有所有的字段,但是主题的帖子肯定不需要floor(楼层),只有回复表才需要标注自己是几楼,同理,主题的extra(如精华、置顶...)也是主题表特有的.那么如何判断帖子是什么类型呢?判断帖子有extra,则是主题,有floor,则是回复等,所有可能情况如下:

前两条记录还好说,第三条怎么算呢?可能是一个没有extra的主贴,也有可能是一个没有标注楼层的回复,总之,从设计表的结构上就要把这种可能性排除,所以采用中表中加入一个type来指定具体的类型.那么,如果把类型在添加记录的时候就加入进来呢?不同类型的对象添加的时候自然就是不一样的值,比如主题就是type=topic,回复就是type=reply.如下:

方式二:

每个类一张表,抽象类也有表(<joined-subclass>),子类表与父类表是一对一的关系,在映射时,每个类都只映射自己特有的属性,公共的属性值存放在父类表中,父类表的主键和子类表的主键相关联,不相关的子类表,不添加记录:

关于Hibernate的查询,有多种方式：

1. 根据OID查询（get()与load()）
2. 导航对象图检索方式:  根据已经加载的对象导航到其他对象
3. HQL（Hibernate Query Language）
4. QBC（Query By Criteria）

HQL

命名查询

Query query = session.getNamedQuery("queryAllEmployees");

List list = query.setParameter(0, 5).list(); 

对应的配置文件:

<!-- 定义命句查询语句 -->

<query name="queryAllEmployees">

    <!--[CDATA[FROM Employee WHERE id>?]]-->

</query> 

如果执行一条查询,查询出了多个结果，则会抛NonUniqueResultException异常.

Criteria(面向对象的查询)

// 1，简单查询（查询所有的Employee）

// Criteria criteria = session.createCriteria(Employee.class);

// criteria.add(Restrictions.gt("id", 5)); // id大于5

// criteria.add(Restrictions.le("id", 10)); // id小于等于10

// criteria.addOrder(Order.desc("id")); // 按id降序排列

Criteria criteria = session.createCriteria(Employee.class)//

        .add(Restrictions.gt("id", 5)) // id大于5

        .add(Restrictions.le("id", 10)) // id小于等于10

        .addOrder(Order.asc("name")) // 第1顺序，按name升序排列

        .addOrder(Order.desc("id")); // 第2顺序按id降序排列

// 执行查询，得到结果集合

List list = criteria.list();

// 显示结果

for (Object obj : list) {

    if (obj.getClass().isArray()) { // 如果是数组

        String result = Arrays.toString((Object[]) obj);

        System.out.println(result);

    } else { // 如果不是数组，则使用toString()的结果

        System.out.println(obj);

    }

}

// 执行查询，得到唯一的结果。如果查询出了多个结果，则会抛异常。

// Object result = criteria.uniqueResult();

配置数据库连接池(c3p0)

使用Hibernate包中自带的c3p0.只需在主配置文件中配置几个关键属性即可:

<!-- 使用c3p0连接池  配置连接池提供的供应商-->

<property name="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>

<!--在连接池中可用的数据库连接的最少数目 -->

<property name="c3p0.min_size">5</property>

<!--在连接池中所有数据库连接的最大数目  -->

<property name="c3p0.max_size">20</property>

<!--设定数据库连接的过期时间,以秒为单位,

如果连接池中的某个数据库连接处于空闲状态的时间超过了timeout时间,就会从连接池中清除 -->

<property name="c3p0.timeout">120</property>

<!--每3000秒检查所有连接池中的空闲连接 以秒为单位-->

<property name="c3p0.idle_test_period">3000</property> 

二级缓存

Hibernate中提供了两个级别的缓存:

一级缓存是session的缓存,它属于session的生命周期,session关闭后缓存也将清除.这就说明用session来提升性能的能力有限,而二级缓存是sessionFactory级别的,可以做更多的事情,但是默认是不开启的,我们想要使用,就必须先开启.在主配置文件中添加以下代码来开启二级缓存:

<property name="cache.use_second_level_cache">true</property> 

光开启还不够,还要提供二级缓存的实现,需要给定缓存的提供商,有多种提供商可供选择,EhCacheProvider是一个专业的缓存提供商,在这里就使用它为hibernate的二级缓存服务.给出配置文件的相关配置:

<ehcache>

    <!-- 在内存中存不下的时候,存放的临时目录 -->

    <diskStore path="c:/ehcache"/>

    <!-- 

        maxElementsInMemory:可存10000个对象,超出后存入临时目录

        eternal:设置对象是否为永久的,true表示永不过期,此时将忽略timeToIdleSeconds 和 timeToLiveSeconds属性; 默认值是false 

        timeToIdleSeconds:设置对象空闲最长时间,以秒为单位, 超过这个时间,对象过期。当对象过期时,EHCache会把它从缓存中清除。

                    如果此值为0,表示对象可以无限期地处于空闲状态。 

        timeToLiveSeconds:设置对象生存最长时间,超过这个时间,对象过期。

                    如果此值为0,表示对象可以无限期地存在于缓存中. 该属性值必须大于或等于 timeToIdleSeconds 属性值 

        overflowToDisk:设置基于内在的缓存中的对象数目达到上限后,是否把溢出的对象写到基于硬盘的缓存中

    -->

    <defaultCache

        maxElementsInMemory="10000"

        eternal="false"

        timeToIdleSeconds="120"

        timeToLiveSeconds="120"

        overflowToDisk="true"

        />

</ehcache> 

到此才算是完全开启,但是,光开启还不够!需要指定哪些类需要缓存,不需要的就不指定.如果有哪个类更新频率很快,比如新闻、首页之类的,就不需要缓存.把类缓存起来称为类缓存.

<class-cache usage="read-write" class="..senondcache.Department"/>

<class-cache usage="read-write" class="..senondcache.Employee"/> 

@Test

public void testSecondCache() {

    // ==========================================================

    // 第一个Session

    Session session = sessionFactory.openSession();

    Transaction tx = session.beginTransaction();

    // --------------------------------------------------------------

    Department department = (Department) session.get(Department.class, 1);

    System.out.println(department);

    System.out.println(department.getEmployees());

    // --------------------------------------------------------------

    tx.commit();

    session.close();

    System.out.println("/n----------/n");

    // ==========================================================

    // 第二个Session

    session = sessionFactory.openSession();

    tx = session.beginTransaction();

    // --------------------------------------------------------------

    Department department2 = (Department) session.get(Department.class, 1);

    System.out.println(department2);

    System.out.println(department2.getEmployees());

    // --------------------------------------------------------------

    tx.commit();

    session.close();

} 

如果想使用查询缓存,还要在主配置文件中打开"开关":

<property name="cache.use_query_cache">true</property> 

但是这样还不够,没有缓存哪条语句,在程序中指定:

@Test

    public void testQueryCache() {

        // ==========================================================

        // 第一个Session

        Session session = sessionFactory.openSession();

        Transaction tx = session.beginTransaction();

        // --------------------------------------------------------------

        Department department = (Department) session.createQuery(//

                "FROM Department d WHERE d.id=?")//

                .setParameter(0, 1)//

                .setCacheable(true)// 把查询语句缓存起来,以后使用就是使用缓存了

                .uniqueResult();

        System.out.println(department);

        // --------------------------------------------------------------

        tx.commit();

        session.close();

        System.out.println("/n----------/n");

        // ==========================================================

        // 第二个Session

        session = sessionFactory.openSession();

        tx = session.beginTransaction();

        // --------------------------------------------------------------

        Department department2 = (Department) session.createQuery(//

                "FROM Department d WHERE d.id=?")//

                .setParameter(0, 1)//

                .setCacheable(true)// 使用查询缓存

                .uniqueResult();

        System.out.println(department2);

        // --------------------------------------------------------------

        tx.commit();

        session.close();

    } 

如果类中有集合,则集合不会缓存进来,除非设置集合缓存:

<collection-cache usage="read-write" collection="..senondcache.Department.employees"/> 

还有另外一种缓存,叫时间戳缓存.

时间戳缓存就是指定Hibernate的二级缓存会自动的检测，如果使用了Update或Delete语句，则把一些数据清出缓存,但是它只会清出二级缓存,如果要更新一级缓存,必须使用refresh()方法.

最后还有一个和缓存相关的,使用Query对象.

Query.list()不会使用缓存，除非调用了.setCacheable(true)才可以，但是HQL一变或参数变了，就不会再用缓存的结果了.

但是Query.iterate()会使用类缓存，原理是：

• 先执行一个查询，查询所有的符合条件的id
• 再使用每一个对象时，先根据id找缓存，如果找不着，就会生成一个select .. where id=? 的查询
• 就是说会有n+1次查询的问题（n是指定符合条件的数据量，1是指定查询id的SQL语句）

@Test

public void testQueryIterate() {

    // ==========================================================

    // 第一个Session

    Session session = sessionFactory.openSession();

    Transaction tx = session.beginTransaction();

    // --------------------------------------------------------------

    List list = session.createQuery("FROM Department d WHERE d.id<=2").list();

    for(Object obj : list){

        System.out.println(obj);

    }

    // --------------------------------------------------------------

    tx.commit();

    session.close();

    System.out.println("/n----------/n");

    // ==========================================================

    // 第二个Session

    session = sessionFactory.openSession();

    tx = session.beginTransaction();

    // --------------------------------------------------------------

    Iterator iter = session.createQuery("FROM Department d WHERE d.id<=3").iterate();

    while(iter.hasNext()){

        System.out.println(iter.next());

    }

    // --------------------------------------------------------------

    tx.commit();

    session.close();

}

如果本文有什么问题,不严谨的地方,请及时指出来.不胜感激.