Hibernate总结3

实例状态:

PO的三个状态：瞬态，持久化，脱管(离线)

 

1、（瞬态）未被持久化的VO

此时就是一个内存对象VO，由JVM管理生命周期

 

2、(持久化)已被持久化的PO，并且在Session生命周期内

此时映射数据库数据，由数据库管理生命周期

 

3、（脱管）曾被持久化过，但现在和Session已经detached了，以VO的身份在运行

这种和Session已经detached的PO还能够进入另一个Session，继续进行PO状态管理，此时它就成为PO的第二种状态了。这种PO实际上是跨了Session进行了状态维护的。

 

在传统的JDO1.x中，PO只有前面两种状态，一个PO一旦脱离PM，就丧失了状态了，不再和数据库数据关联，成为一个纯粹的内存VO，它即使进入一个新的PM，也不能恢复它的状态了。

 

 

Hibernate缓存介绍:

缓存在Hibernate中主要有三个方面：一级缓存、二级缓存和查询缓存。

一级缓存

      Hibernate的一级缓存是由Session提供的，因此它只存在于Session的生命周期中，也就是当Session关闭的时候该Session所管理的一级缓存也会立即被清除，所以也可以理解为一级缓存是session缓存。

       Hibernate的一级缓存是Session所内置的，不能被卸载，也不能进行任何配置。

       一级缓存采用的是key-value的Map方式来实现的，在缓存实体对象时，对象的主关键字ID是Map的key，实体对象就是对应的值。所以说，一级缓存是以实体对象为单位进行存储的，在访问的时候使用的是主关键字ID。

       虽然，Hibernate对一级缓存使用的是自动维护的功能，没有提供任何配置功能，但是可以通过Session中所提供的方法来对一级缓存的管理进行手工干预。Session中所提供的干预方法包括以下两种。

●   evict() ：用于将某个对象从Session的一级缓存中清除。

●   clear() ：用于将一级缓存中的对象全部清除。

       在进行大批量数据一次性更新的时候，会占用非常多的内存来缓存被更新的对象。这时就应该阶段性地调用clear()方法来清空一级缓存中的对象，控制一级缓存的大小，以避免产生内存溢出的情况。具体的实现方法如清单14.8所示。

       清单14.8    大批量更新时缓存的处理方法

Session session = sessionFactory.openSession();

Transaction tx = session.beginTransaction();

for ( int i=0; i<100000; i++ ) {

    Customer customer = new Customer(……);

    session.save(customer);

    if ( i % 20 == 0 ) {

        //将本批插入的对象立即写入数据库并释放内存

        session.flush();

        session.clear();

    }

}

tx.commit();

session.close();

 

 

Hibernate查询方法与缓存的关系

       在前面介绍了Hibernate的缓存技术以及基本的用法，在这里就具体的Hibernate所提供的查询方法与Hibernate缓存之间的关系做一个简单的总结。

       在开发中，通常是通过两种方式来执行对数据库的查询操作的。一种方式是通过ID来获得单独的Java对象，另一种方式是通过HQL语句来执行对数据库的查询操作。下面就分别结合这两种查询方式来说明一下缓存的作用。

       通过ID来获得Java对象可以直接使用Session对象的load()或者get()方法，这两种方式的区别就在于对缓存的使用上。

●   load()方法

       在使用了二级缓存的情况下，使用load()方法会在二级缓存中查找指定的对象是否存在。

在执行load()方法时，Hibernate首先从当前Session的一级缓存中获取ID对应的值，在获取不到的情况下，将根据该对象是否配置了二级缓存来做相应的处理。

       如配置了二级缓存，则从二级缓存中获取ID对应的值，如仍然获取不到则还需要根据是否配置了延迟加载来决定如何执行，如未配置延迟加载则从数据库中直接获取。在从数据库获取到数据的情况下，Hibernate会相应地填充一级缓存和二级缓存，如配置了延迟加载则直接返回一个代理类，只有在触发代理类的调用时才进行数据库的查询操作。

       在Session一直打开的情况下，并在该对象具有单向关联维护的时候，需要使用类似Session.clear()，Session.evict()的方法来强制刷新一级缓存。

●   get()方法

       get()方法与load()方法的区别就在于不会查找二级缓存。在当前Session的一级缓存中获取不到指定的对象时，会直接执行查询语句从数据库中获得所需要的数据。

       在Hibernate中，可以通过HQL来执行对数据库的查询操作。具体的查询是由Query对象的list()和iterator()方法来执行的。这两个方法在执行查询时的处理方法存在着一定的差别，在开发中应该依据具体的情况来选择合适的方法。

●   list()方法

       在执行Query的list()方法时，Hibernate的做法是首先检查是否配置了查询缓存，如配置了则从查询缓存中寻找是否已经对该查询进行了缓存，如获取不到则从数据库中进行获取。从数据库中获取到后，Hibernate将会相应地填充一级、二级和查询缓存。如获取到的为直接的结果集，则直接返回，如获取到的为一些ID的值，则再根据ID获取相应的值（Session.load()），最后形成结果集返回。可以看到，在这样的情况下，list()方法也是有可能造成N次查询的。

       查询缓存在数据发生任何变化的情况下都会被自动清空。

●   iterator()方法

       Query的iterator()方法处理查询的方式与list()方法是不同的，它首先会使用查询语句得到ID值的列表，然后再使用Session的load()方法得到所需要的对象的值。

       在获取数据的时候，应该依据这4种获取数据方式的特点来选择合适的方法。在开发中可以通过设置show_sql选项来输出Hibernate所执行的SQL语句，以此来了解Hibernate是如何操作数据库的。

 

 

Hibernate锁:乐观锁，悲观锁。

悲观锁：是基于数据库锁的机制实现的，只支持单个事务的操作，有一个事务在操作时别的事务操作就不能进行。

session.load(Person.class, "ID", LockMode.UPGRADE);

乐观锁：支持多个事务操作。是采用数据库版本机制实现的

<class name="包名.类名" table="表名" optimistic-lock="version">

           <id name="id">   

               <generator class="uuid.hex" />

           </id>

           <version name="version"/>

           <property name="属性名" />

    </class>

注：version在数据进行更改时会自动加一

 

使用hibernate 操作oracle:

Hibernate连接Oracle数据库的步骤
在hibernate.cfg.xml需要改动两处地方

1.       数据库连接驱动:：oracle.jdbc.driver.OracleDriver

2.       方言：org.hibernate.dialect.OracleDialect

 

Hibernate 原始sql的另一种查询方法命名查询
<sql-query name="persons">
    <return alias="person" class="erson"/>
    SELECT
          person.person_id  AS {person.id},
          person.NAME AS {person.name},
           person.AGE AS {person.age}
        
    FROM PERSON person
</sql-query>
Hibernate调用Oracle函数
  <sql-query name="名字" callable="true">
      <return alias="person" class="erson">
    <return-property name="id" column="person_id"/>
    <return-property name="name" column="name"/>
    <return-property name="age" column="age"/>
    </return>
          {?=call oracle函数名()}
  </sql-query>

Hibernate的事务：

Hibernate 是JDBC 的轻量级封装，本身并不具备事务管理能力。在事务管理层，
Hibernate将其委托给底层的JDBC或者JTA，以实现事务管理和调度功能。
Hibernate的默认事务处理机制基于JDBC Transaction。

 

 

 

抓取策略:连接.查询.子查询.批量

1.连接抓取（Join fetching） - Hibernate通过 在SELECT语句使用OUTER JOIN（外连接）来获得对象的关联实例或者关联集合。一个对象一条SQl语句．

  <set name="students" inverse="true" cascade="all" fetch="join">

            <key column="classid" />

            <one-to-many class="com.Student" />

  </set>

 

  Classes cla = (Classes)session.load(Classes.class,1);

  System.out.println(cla.getName());

  for(Iterator iter = cla.getStudents().iterator();iter.hasNext();){

       Student student = (Student)iter.next();

       System.out.println(student.getName());

   }

   Fetch=”join” ,上面程序只发了一条sql语句.

 

2.查询抓取（Select fetching） - 另外发送一条 SELECT 语句抓取当前对象的关联实体或集合。除非你显式的指定lazy="false"禁止延迟抓取（lazy fetching），否则只有当你真正访问关联关系的时候，才会执行第二条select语句。在上面的程序中会发出当前对象关联的集合的大小+1条sql语句.

 

3.子查询抓取（Subselect fetching） - 另外发送一条SELECT 语句抓取在前面查询到（或者抓取到）的所有实体对象的关联集合。除非你显式的指定lazy="false" 禁止延迟抓取（lazy fetching），否则只有当你真正访问关联关系的时候，才会执行第二条

  select语句。所有最多只会发出两条SQL语句． 如果只有一个对对象则Join与Subselect没有区别．如果是多个则Join查询次数为对象的个数而Subselect则只有一条sql语句．

 

4.批量抓取（Batch fetching） - 对查询抓取的优化方案， 通过指定一个主键或外键列表，Hibernate使用单条SELECT语句获取一批对象实例或集合。

  <set name="students" inverse="true" cascade="save-update" batch-size=”3”>

  List students = session.createQuery(“select s from Student s where s.id in(1,2,3,4,5,6,7,8).list();

  for(Iterator iter=students.iterator();iter.hasNext();){

       Student student = (Sutdent)iter.next();

       System.out.println(student.getName());

       System.out.println(student.getClassess().getName());

   }  

  当第二个for循环时，每次加载 之前设置的 数量 实体对象,  如：现在设置3，那么当

  Iterator iter=students.iterator();

  iter.hasNext();时候，他会查询出3个student对象