Hibernate会尽量将与数据库的操作延迟，直到必须要与数据库进行交互，例如save方法一般会在提交时才真正执行，最终在提交时会以批处理的方式与数据库进行交互，以提高效率。

而将操作延迟，就是利用缓存，将最后要处理的操作放到缓存中。

flush方法的主要作用就是清理缓存，强制数据库与Hibernate缓存同步，以保证数据的一致性。它的主要动作就是向数据库发送一系列的sql语句，并执行这些sql语句，但是不会向数据库提交。而commit方法则会首先调用flush方法，然后提交事务。
     
      在下面的情况下，Hibernate会调用Session.flush()以清理缓存：
     1)事务提交时，如果flush模式不为FlushMode.NEVER,commit()将调用flush().
     2)在某些查询语句之前（此查询语句之前的语句已经改变了数据库状态，所以需要调用flush（）以同步数据库是查出来的数据是经过更改的）。
    
     除非明确地指定了flush（）命令，否则关于Session何时会执行这些JDBC调用完全是无法保证的，只能保证他们执行的前后顺序。

 
  通过设置session.setFlushMode(),可以精确控制Hibernate的FlushMode.
  (1)  FlushMode.AUTO:Hibernate判断对象属性有没有改变，如果被更改成为脏数据，则在一个查询语句前将更新此改动以保证数据库的同步。这也是Hibernate的默认清理模式。
  (2) FlushMode.COMMIT:在事务结束之前清理session的缓存。这样有可能导致查出脏数据
  (3) FlushMode.NEVER：除非强制调用Session.flush(),否则永远不清理Session。相当于将数据库设置为一个只读的数据库。
       【如果此时进行数据的写入操作，会发生错误】
  (4) FlushMode.ALWAYS：在每一个查询数据之前都调用Session.flush()。很显然这种效率很低。
 
 在调用Session.flush()时，涉及的SQL语句会按照下面的顺序执行。
（1）         所有的实体进行插入的语句，其顺序按照对象执行Session.save()的时间顺序。
（2）         所有对实体进行更新的语句
（3）         所有对集合元素进行删除，更新或者插入的语句
（4）         所有对实体经行删除的语句，其顺序按照对象执行Session.delete()的时间顺序。
（5）         有一个例外是，如果对象使用native方式生成的ID（持久化标识），则他们一执行save就会被插入。
                 【因为native方式若想得到主键，必须与数据库交互，而hilo方式则不用】）

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/MageShuai/archive/2009/09/11/4544202.aspx

二）dynamic statements generated at runtime
      1)<property>元素 dynamic-insert属性:设置为true,表示insert对象的时候,生成动态的insert语句,如果这个字段的值是null就不会加入到insert语句当中.默认false
      2)<property>元素 dynamic-update属性,设置为true,表示update对象的时候,生成动态的update语句,如果这个字段的值是null就不会被加入到update语句中,默认false
      3)<class>元素 dynamic-insert属性:设置为true,表示把所有的<property>元素的dynamic-insert属性设置为true,默认false
      4)<class>元素 dynamic-update属性:设置为true,表示把所有的<property>元素的dynamic-update属性设置为true,默认false

总结：如果表中包含N多字段,建议把dynamic-update属性和insert属性设置为true,这样在插入和修改数据的时候,语句中只包括要插入或者修改的字段.可以节省SQL语句的执行时间,提高程序的运行效率.(In some situations, such as a legacy table with hundreds of columns where the SQL statements will be large for even the simplest operations (say, only one column needs updating), you have to turn off this startup SQL generation and switch to dynamic statements generated at runtime.)

其他属性设置对SQL Statement影响

      1)<property>元素 insert属性:设置为false,在insert语句中不包含这个字段,表示永远不会被插入,默认true
      2)<property>元素 update属性:设置为false,在update语句中不包含这个字段,表示永远不会被修改,默认true
      3)<class>元素 mutable属性:设置为false就是把所有的<property>元素的update属性设置为了false,说明这个对象不会被更新,默认true

==============

Hibernate Criteria 关联查询

前面讲了Criteria看起来比HQL顺眼多了，接着继续。

如果每个美女都有自己的客户资源（不要想歪了！），那么需要查询拥有客户Gates的美女怎么办？

使用Criteria可以有两种方法：

1：
DetachedCriteria beautyCriteria = DetachedCriteria.forClass(Beauty.class).createCriteria("customers");
beautyCriteria.add(Restrictions.eq("name", "Gates")):

2：
DetachedCriteria beautyCriteria = DetachedCriteria.forClass(Beauty.class).createAlias("customers", "c");
beautyCriteria.add(Restrictions.eq("c.name", "Gates")):

接着有了新的要求，年纪太大的美女不要，还是查找拥有客户Gates的，条件如下：
DetachedCriteria beautyCriteria = DetachedCriteria.forClass(Beauty.class, "b").;
DetachedCriteria customerCriteria = beautyCriteria.createAlias("customers", c");
beautyCriteria.add(Restrictions.le("b.age", new Long(20))):
customerCriteria.add(Restrictions.eq("c.name", "Gates")):

关于Criteria更详细的资料，Hibernate的源代码和测试是最好的文档。

Criteria的缺点？DBA很生气，后果很严重。

  Transient instances may be made persistent by calling save(),persist() or saveOrUpdate(). Persistent instances may be made transient by calling delete(). Any instance returned by a get() or load() method is persistent. Detached instances may be made persistent by calling update(), saveOrUpdate(), lock() or replicate(). The state of a transient or detached instance may also be made persistent as a new  persistent instance by calling merge().save() and persist() result in an SQL INSERT, delete() in an SQL DELETE and update() or merge() in an SQL UPDATE. Changes to persistent instances are detected at flush time and also result in an SQL UPDATE. saveOrUpdate() and replicate() result in either an INSERT or an UPDATE.

persist():
    Make a transient instance persistent. This operation cascades to associated instances if the association is mapped with cascade="persist". The semantics of this method are defined by JSR-220.
    当级联风格为persist时，这个操作会级联操作关联的对象。这个方法的语义是JSR-220定义的。

persist() is well defined. It makes a transient instance persistent. However,
it doesn't guarantee that the identifier value will be assigned to the persistent
instance immediately, the assignment might happen at flush time. The spec doesn't say
that, which is the problem I have with persist().

persist() also guarantees that it will not execute an INSERT statement if it is
called outside of transaction boundaries. This is useful in long-running conversations
with an extended Session/persistence context.A method like persist() is required.

save() does not guarantee the same, it returns an identifier, and if an INSERT
has to be executed to get the identifier (e.g. "identity" generator, not "sequence"),
this INSERT happens immediately, no matter if you are inside or outside of a transaction. This is not good in a long-running conversation with an extended Session/persistence context."

save():
    Persist the given transient instance, first assigning a generated identifier. (Or using the current value of the identifier property if the assigned generator is used.)  This operation cascades to associated instances if the association is mapped with cascade="save-update".
    首先会赋予一个标志符，然后持久化给定的对象。但是如果使用assigned 标志符产生方法，则会使用当前的标志符值。如果级联风格为save－pdate，则会持久化相应的关联对象.

merge():
    Copy the state of the given object onto the persistent object with the same identifier. If there is no persistent instance currently associated with the session, it will be loaded. Return the persistent instance. If the given instance is unsaved, save a copy of and return it as a newly persistent instance. The given instance does not become associated with the session. This operation cascades to associated instances if the association is mapped with cascade="merge". The semantics of this method are defined by JSR-220.
    拷贝当前的对象的状态到相同标志符的持久化对象的状态。如果当前关联的session中没有持久化对象，Hibernate会加载该对象，并返回这个持久化对象。如果给定的对象没有保存，则Hibernate保存该副本，返回这个新持久化的对象，但给定的对象并没有和session关联。如果指定级联风格为merge，则会级联关联对象。该方法的语义是JSR－200定义的。

saveOrUpdate():
     Either {@link #save(String, Object)} or {@link #update(String, Object)} the given instance, depending upon resolution of the unsaved-value checks (see the manual for discussion of unsaved-value checking). This operation cascades to associated instances if the association is mapped with cascade="save-update".
    保存或更新给定对象，取决于给定对象的持久化状态。默认情况下是保存，在指定标志符元素属性为unsaved-value时则会调整。如果级联风格为"save-update",则会级联相关联的对象

delete():
     Remove a persistent instance from the datastore. The object argument may be an instance associated with the receiving Session or a transient instance with an identifier associated with existing persistent state. This operation cascades to associated instances if the association is mapped with cascade="delete".
    删除对象。

lock():
    Obtain the specified lock level upon the given object. This may be used to perform a version check (LockMode.READ), to upgrade to a pessimistic lock (LockMode.UPGRADE), or to simply reassociate a transient instance with a session (LockMode.NONE). This operation cascades to associated instances if the association is mapped with cascade="lock".
    用于对指定对象设置参数中给定的锁。如果锁为LockMode.READ，可以用来执行版本检查；如果锁为LockMode.UPGRADE则用来执行悲观锁。如果定为LockMode.NONE，则仅仅时持久化一个未持久化的对象。如果级联风格为lock，会级联相关联的对象。

refresh():
    Re-read the state of the given instance from the underlying database. It is inadvisable to use this to implement long-running sessions that span many business tasks. This method is, however, useful in certain special circumstances.For example where a database trigger alters the object state upon insert or update after executing direct SQL (eg. a mass update) in the same session after inserting a Blob or Clob.
    从当前数据库中重新读取给定对象的状态。这在执行跨越多个业务任务的长时间session中优势不显著，在少数特定环境下还是有用的，例如： 插入或更新后数据库触发器更改了对象的状态。当前session中执行完原生SQL后（如批量更新）。 插入Blob或Clob对象后。
 
evict():
    Remove this instance from the session cache. Changes to the instance will not be synchronized with the database. This operation cascades to associated instances if the association is mapped with cascade="evict".
    从session的缓存中去除当前实例。执行后对象的改变将不再和数据库保持同步。当指定级联风格为'evict’时，会级联操作关联对象。我用的时候主要是用于批量操作的时候，清空缓存，防止内存紧张。

replicate():
    Persist the state of the given detached instance, reusing the current identifier value. This operation cascades to associated instances if the association is mapped with cascade="replicate"
    重用当前的标志符，持久化当前已经脱离session的对象的状态。具体的操作和要看参数ReplicationMode。如果是ReplicationMode.EXCEPTION,则在复制时如果有重复的行数据，则抛出异常。ReplicationMode.IGNORE则忽略异常。ReplicationMode.OVERWRITE则会覆盖掉已有行数据。ReplicationMode.LATEST_VERSION则是在有重复时使用最新的版本进行控制。

    Hibernate的用户曾要求一个既可自动分配新持久化标识(identifier)保存瞬时(transient)对象，又可更新/重新关联脱管(detached)实例的通用方法。 saveOrUpdate()方法实现了这个功能。 saveOrUpdate()用途和语义可能会使新用户感到迷惑。 首先，只要你没有尝试在某个session中使用来自另一session的实例，你就应该不需要使用update()， saveOrUpdate()，或merge()。有些程序从来不用些方法。

通常下面的场景会使用update()或saveOrUpdate()：
程序在第一个session中加载对象
该对象被传递到表现层
对象发生了一些改动
该对象被返回到业务逻辑层
程序调用第二个session的update()方法持久这些改动

saveOrUpdate()做下面的事:
如果对象已经在本session中持久化了，不做任何事
如果另一个与本session关联的对象拥有相同的持久化标识(identifier)，抛出一个异常
如果对象没有持久化标识(identifier)属性，对其调用save()
如果对象的持久标识(identifier)表明其是一个新实例化的对象，对其调用save()
如果对象是附带版本信息的（通过<version>或<timestamp>） 并且版本属性的值表明其是一个新实例化的对象，save()它。
否则update() 这个对象

merge()可非常不同:
如果session中存在相同持久化标识(identifier)的实例，用用户给出的对象的状态覆盖旧有的持久实例
如果session没有相应的持久实例，则尝试从数据库中加载，或创建新的持久化实例 ,最后返回该持久实例
用户给出的这个对象没有被关联到session上，它依旧是脱管的.

Session刷出(flush)
每间隔一段时间，Session会执行一些必需的SQL语句来把内存中的对象的状态同步到JDBC连接中。这个过程被称为刷出(flush)，默认会在下面的时间点执行：
a.在某些查询执行之前
b.在调用org.hibernate.Transaction.commit()的时候
c.在调用Session.flush()的时候

涉及的SQL语句会按照下面的顺序发出执行：
所有对实体进行插入的语句，其顺序按照对象执行Session.save()的时间顺序
所有对实体进行更新的语句
所有进行集合删除的语句
所有对集合元素进行删除，更新或者插入的语句
所有进行集合插入的语句
所有对实体进行删除的语句，其顺序按照对象执行Session.delete()的时间顺序

（有一个例外是，如果对象使用native方式来生成ID（持久化标识）的话，它们一执行save就会被插入。）
除非你明确地发出了flush()指令，关于Session何时会执行这些JDBC调用是完全无法保证的，只能保证它们执行的前后顺序。 当然，Hibernate保证，Query.list(..)绝对不会返回已经失效的数据，也不会返回错误数据。

也可以改变默认的设置，来让刷出(flush)操作发生的不那么频繁。 FlushMode类定义了三种不同的方式。 仅在提交时刷出(仅当Hibernate的Transaction API被使用时有效)， 按照刚才说的方式刷出， 以及除非明确使用flush()否则从不刷出。 最后一种模式对于那些需要长时间保持Session为打开或者断线状态的长时间运行的工作单元很有用。

父子关系的级联(cascading)操作准确语义如下：
如果父对象被persist()，那么所有子对象也会被persist()
如果父对象被merge()，那么所有子对象也会被merge()
如果父对象被save()，update()或 saveOrUpdate()，那么所有子对象则会被saveOrUpdate()
如果某个持久的父对象引用了瞬时(transient)或者脱管(detached)的子对象，那么子对象将会被saveOrUpdate()
如果父对象被删除，那么所有子对象也会被delete()

除非被标记为cascade="delete-orphan"（删除“孤儿”模式，此时不被任何一个父对象引用的子对象会被删除）， 否则子对象失掉父对象对其的引用时，什么事也不会发生。 如果有特殊需要，应用程序可通过显式调用delete()删除子对象。

　　大体上，对于HIBERNATE性能调优的主要考虑点如下:

　　Ø 数据库设计调整

　　Ø HQL优化

　　Ø API的正确使用(如根据不同的业务类型选用不同的集合及查询API)

　　Ø 主配置参数(日志，查询缓存，fetch_size, batch_size等)

　　Ø 映射文件优化(ID生成策略，二级缓存，延迟加载，关联优化)

　　Ø 一级缓存的管理

　　Ø 针对二级缓存，还有许多特有的策略

　　Ø 事务控制策略。

　　1、 数据库设计

　　a) 降低关联的复杂性

　　b) 尽量不使用联合主键

　　c) ID的生成机制，不同的数据库所提供的机制并不完全一样

　　d) 适当的冗余数据，不过分追求高范式

　　2、 HQL优化

　　HQL如果抛开它同HIBERNATE本身一些缓存机制的关联，HQL的优化技巧同普通的SQL优化技巧一样，可以很容易在网上找到一些经验之谈。

　　3、 主配置

　　a) 查询缓存，同下面讲的缓存不太一样，它是针对HQL语句的缓存，即完全一样的语句再次执行时可以利用缓存数据。但是，查询缓存在一个交易系统(数据变更频繁，查询条件相同的机率并不大)中可能会起反作用:它会白白耗费大量的系统资源但却难以派上用场。

　　b) fetch_size，同JDBC的相关参数作用类似，参数并不是越大越好，而应根据业务特征去设置

　　c) batch_size同上。

　　d) 生产系统中，切记要关掉SQL语句打印。

　　4、 缓存

　　a) 数据库级缓存:这级缓存是最高效和安全的，但不同的数据库可管理的层次并不一样，比如，在ORACLE中，可以在建表时指定将整个表置于缓存当中。

　　b) SESSION缓存:在一个HIBERNATE SESSION有效，这级缓存的可干预性不强，大多于HIBERNATE自动管理，但它提供清除缓存的方法，这在大批量增加/更新操作是有效的。比如，同时增加十万条记录，按常规方式进行，很可能会发现OutofMemeroy的异常，这时可能需要手动清除这一级缓存:Session.evict以及 Session.clear

　　c) 应用缓存:在一个SESSIONFACTORY中有效，因此也是优化的重中之重，因此，各类策略也考虑的较多，在将数据放入这一级缓存之前，需要考虑一些前提条件:

　　i. 数据不会被第三方修改(比如，是否有另一个应用也在修改这些数据?)

　　ii. 数据不会太大

　　iii. 数据不会频繁更新(否则使用CACHE可能适得其反)

　　iv. 数据会被频繁查询

　　v. 数据不是关键数据(如涉及钱，安全等方面的问题)。

　　缓存有几种形式，可以在映射文件中配置:read-only(只读，适用于很少变更的静态数据/历史数据)，nonstrict-read- write，read-write(比较普遍的形式，效率一般)，transactional(JTA中，且支持的缓存产品较少)

　　d) 分布式缓存:同c)的配置一样，只是缓存产品的选用不同，在目前的HIBERNATE中可供选择的不多，oscache, jboss cache，目前的大多数项目，对它们的用于集群的使用(特别是关键交易系统)都持保守态度。在集群环境中，只利用数据库级的缓存是最安全的。

　　5、 延迟加载

　　a) 实体延迟加载:通过使用动态代理实现

　　b) 集合延迟加载:通过实现自有的SET/LIST，HIBERNATE提供了这方面的支持

　　c) 属性延迟加载:

　　6、 方法选用

　　a) 完成同样一件事，HIBERNATE提供了可供选择的一些方式，但具体使用什么方式，可能用性能/代码都会有影响。显示，一次返回十万条记录 (List/Set/Bag/Map等)进行处理，很可能导致内存不够的问题，而如果用基于游标(ScrollableResults)或 Iterator的结果集，则不存在这样的问题。

　　b) Session的load/get方法，前者会使用二级缓存，而后者则不使用。

　　c) Query和list/iterator，如果去仔细研究一下它们，你可能会发现很多有意思的情况，二者主要区别(如果使用了Spring，在HibernateTemplate中对应find,iterator方法):

　　i. list只能利用查询缓存(但在交易系统中查询缓存作用不大)，无法利用二级缓存中的单个实体，但list查出的对象会写入二级缓存，但它一般只生成较少的执行SQL语句，很多情况就是一条(无关联)。

　　ii. iterator则可以利用二级缓存，对于一条查询语句，它会先从数据库中找出所有符合条件的记录的ID，再通过ID去缓存找，对于缓存中没有的记录，再构造语句从数据库中查出，因此很容易知道，如果缓存中没有任何符合条件的记录，使用iterator会产生N+1条SQL语句(N为符合条件的记录数)

　　iii. 通过iterator，配合缓存管理API，在海量数据查询中可以很好的解决内存问题，如:

　　while(it.hasNext()){

　　YouObject object = (YouObject)it.next();

　　session.evict(youObject);

　　sessionFactory.evice(YouObject.class, youObject.getId());

　　}

　　如果用list方法，很可能就出OutofMemory错误了。

　　iv. 通过上面的说明，我想你应该知道如何去使用这两个方法了。

　　7、 集合的选用

　　在HIBERNATE 3.1文档的“19.5. Understanding Collection performance”中有详细的说明。

　　8、 事务控制

　　事务方面对性能有影响的主要包括:事务方式的选用，事务隔离级别以及锁的选用

　　a) 事务方式选用:如果不涉及多个事务管理器事务的话，不需要使用JTA，只有JDBC的事务控制就可以。

　　b) 事务隔离级别:参见标准的SQL事务隔离级别

　　c) 锁的选用:悲观锁(一般由具体的事务管理器实现)，对于长事务效率低，但安全。乐观锁(一般在应用级别实现)，如在HIBERNATE中可以定义 VERSION字段，显然，如果有多个应用操作数据，且这些应用不是用同一种乐观锁机制，则乐观锁会失效。因此，针对不同的数据应有不同的策略，同前面许多情况一样，很多时候我们是在效率与安全/准确性上找一个平衡点，无论如何，优化都不是一个纯技术的问题，你应该对你的应用和业务特征有足够的了解。

　　9、 批量操作

　　即使是使用JDBC，在进行大批数据更新时，BATCH与不使用BATCH有效率上也有很大的差别。我们可以通过设置batch_size来让其支持批量操作。

　　举个例子，要批量删除某表中的对象，如“delete Account”，打出来的语句，会发现HIBERNATE找出了所有ACCOUNT的ID，再进行删除，这主要是为了维护二级缓存，这样效率肯定高不了，在后续的版本中增加了bulk delete/update，但这也无法解决缓存的维护问题。也就是说，由于有了二级缓存的维护问题，HIBERNATE的批量操作效率并不尽如人意!

　　从前面许多要点可以看出，很多时候我们是在效率与安全/准确性上找一个平衡点，无论如何，优化都不是一个纯技术的问题，你应该对你的应用和业务特征有足够的了解，一般的，优化方案应在架构设计期就基本确定，否则可能导致没必要的返工，致使项目延期，而作为架构师和项目经理，还要面对开发人员可能的抱怨，必竟，我们对用户需求更改的控制力不大，但技术/架构风险是应该在初期意识到并制定好相关的对策。

　　还有一点要注意，应用层的缓存只是锦上添花，永远不要把它当救命稻草，应用的根基(数据库设计，算法，高效的操作语句，恰当API的选择等)才是最重要的。

    二级缓存是SessionFactory级别的全局缓存，它底下可以使用不同的缓存类库，比如ehcache、oscache等，需要使用缓存实现方案。

    详细请看: hibernate二级缓存攻略

 3.1 基本设置

1. 如果需要特别设置ehcache的属性，把一个ehcache.xml 定义文件拷贝到class-path.

2. jdbc.properties加上

hibernate.cache.use_query_cache=true
hibernate.cache.provider_class=org.hibernate.cache.EhCacheProvider

3. applicationContext.xml的 <property name="hibernateProperties">下加上

<prop key="hibernate.cache.use_query_cache">$ {hibernate.cache.use_query_cache}</prop>
<prop key="hibernate.cache.provider_class">$ {hibernate.cache.provider_class}</prop>

3.2 Entity级二级缓存

   Entity二级缓存是把PO放进cache，缓存的key就是ID，value是POJO，不同于查询的缓存。

   Entity二级缓存在BookDao.get(3)，和book.getCategory()的情况下都能用到，把category这样的小表完全cache到内存挺不错的。

在hbm文件中: 

<class name="Product" table="PRODUCT" dynamic-insert="true" dynamic-update="true">
<cache usage="nonstrict-read-write"/>
<id name="id" column="ID">
<generator class="native"/>
</id>

   如果你使用的二级缓存实现是ehcache的话，需要配置ehcache.xml ，否则就会使用ehcache默认的配置

<cache name="com.xxx.pojo.Foo" maxElementsInMemory="500" eternal="false" timeToLiveSeconds="7200" timeToIdleSeconds="3600" overflowToDisk="true" />

3.3 查询缓存

   上面的二级缓存是针对单个对象的，如果要对查询结果，则是用下面的语句

query.setCacheable(true);//激活查询缓存
query.setCacheRegion("myCacheRegion");//指定要使用的cacheRegion，可选

   cacheRegion是可选的，可以对使用的缓存进行特殊设置， 在ehcahe.xml里要补上下面的一段。

<cache name="myCacheRegion" maxElementsInMemory="10" eternal="false" timeToIdleSeconds="3600" timeToLiveSeconds="7200" overflowToDisk="true" />

2． 依赖容器的参数化事务管理
通过容器提供的集约式参数化事务机制，实现事务的外部管理，如EJB 中的事务管理模式。
 容器管理的参数化事务为程序开发提供了相当的灵活性，同时因为将事务委托给容器进行管理，
应用逻辑中无需再编写事务代码，大大节省了代码量（特别是针对需要同时操作多个事务资源的应用），从而提高了生产率。

    它有两种配置方式OpenSessionInViewInterceptor和OpenSessionInViewFilter(具体参看SpringSide)，功能相同，只是一个在web.xml配置，另一个在application.xml配置而已。

    Open Session In View在request把session绑定到当前thread期间一直保持hibernate session在open状态，使session在request的整个期间都可以使用，如在View层里PO也可以lazy loading数据，如 ${ company.employees }。当View 层逻辑完成后，才会通过Filter的doFilter方法或Interceptor的postHandle方法自动关闭session。

OpenSessionInViewInterceptor配置

   
    <beans>
   
      <bean name="openSessionInViewInterceptor"
   
    class="org.springframework.orm.hibernate3.support.OpenSessionInViewInterceptor">
   
        <property name="sessionFactory">
   
          <ref bean="sessionFactory"/>
   
        </property>
   
      </bean>
   
      <bean id="urlMapping"
   
    class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
   
        <property name="interceptors">
   
          <list>
   
            <ref bean="openSessionInViewInterceptor"/>
   
          </list>
   
        </property>
   
        <property name="mappings">
   
        ...
   
        </property>
   
      </bean>
   
    ...
   
    </beans>
   

OpenSessionInViewFilter配置

   
    <web-app>
   
    ...
   
      <filter>
   
        <filter-name>hibernateFilter</filter-name>
   
        <filter-class>
   
          org.springframework.orm.hibernate3.support.OpenSessionInViewFilter
   
        </filter-class>
   
        <!-- singleSession默认为true,若设为false则等于没用OpenSessionInView -->
   
        <init-param>
   
          <param-name>singleSession</param-name>
   
          <param-value>true</param-value>
   
        </init-param>
   
      </filter>
   
    ...
   
      <filter-mapping>
   
        <filter-name>hibernateFilter</filter-name>
   
        <url-pattern>*.do</url-pattern>
   
      </filter-mapping>
   
    ...
   
    </web-app>
   

很多人在使用OpenSessionInView过程中提及一个错误：

   
    org.springframework.dao.InvalidDataAccessApiUsageException: Write operations
   
    are not allowed in read-only mode (FlushMode.NEVER) - turn your Session into
   
    FlushMode.AUTO or remove 'readOnly' marker from transaction definition
   

看看OpenSessionInViewFilter里的几个方法

   
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response,FilterChain filterChain) throws ServletException, IOException {　SessionFactory sessionFactory = lookupSessionFactory();　logger.debug("Opening Hibernate Session in OpenSessionInViewFilter");　Session session = getSession(sessionFactory);　TransactionSynchronizationManager.bindResource(　　sessionFactory, new SessionHolder(session));　try {　　filterChain.doFilter(request, response);　}　finally {　TransactionSynchronizationManager.unbindResource(sessionFactory);　logger.debug("Closing Hibernate Session in OpenSessionInViewFilter");　closeSession(session, sessionFactory);　}}
   
    protected Session getSession(SessionFactory sessionFactory)throws DataAccessResourceFailureException {　Session session = SessionFactoryUtils.getSession(sessionFactory, true);　session.setFlushMode(FlushMode.NEVER);　return session;}
    protected void closeSession(Session session, SessionFactory sessionFactory)throws CleanupFailureDataAccessException {　SessionFactoryUtils.closeSessionIfNecessary(session, sessionFactory);}

           关于绑定session的方式，通过看spring里TransactionSynchronizationManager的实现，发现：它维护一个java.lang.ThreadLocal类型的resources，resources负责持有线程局部变量，这里resources持有的是一个HashMap，通过TransactionSynchronizationManager.bindResource()方法在map里绑定和线程相关的所有变量到他们的标识上，包括如上所述的绑定在sessionFactory上的线程局部session。sessionHolder只不过是存放可以hold一个session并可以和transtaction同步的容器。可以看到OpenSessionInViewFilter在getSession的时候,会把获取回来的session的flush mode 设为FlushMode.NEVER。然后把该sessionFactory绑定到TransactionSynchronizationManager，使request的整个过程都使用同一个session，在请求过后再接除该sessionFactory的绑定，最后closeSessionIfNecessary根据该session是否已和transaction绑定来决定是否关闭session。绑定以后，就可以防止每次不会新开一个Session呢？看看HibernateDaoSupport的情况：

     1.  public final void setSessionFactory(SessionFactory sessionFactory) {    2.      this.hibernateTemplate = new HibernateTemplate(sessionFactory);    3.  }    4.  protected final HibernateTemplate getHibernateTemplate() {    5.      return hibernateTemplate;    6.  }
        我们的DAO将使用这个template进行操作.

public abstract class BaseHibernateObjectDao extends HibernateDaoSupport
implements BaseObjectDao {
     protected BaseEntityObject getByClassId(final long id) {
                BaseEntityObject obj =(BaseEntityObject) getHibernateTemplate().execute(new HibernateCallback() {
                        public Object doInHibernate(Session session) throws HibernateException {
                                    return session.get(getPersistentClass(),new Long(id));
                        }
                });
                return obj;
      }
     public void save(BaseEntityObject entity) {
                  getHibernateTemplate().saveOrUpdate(entity);
     }

    public void remove(BaseEntityObject entity) {
              try {
                     getHibernateTemplate().delete(entity);
              } catch (Exception e) {
                      throw new FlexEnterpriseDataAccessException(e);
             }
     }

      public void refresh(final BaseEntityObject entity) {
               getHibernateTemplate().execute(new HibernateCallback() {
                          public Object doInHibernate(Session session) throws HibernateException {
                                      session.refresh(entity);
                                      return null;
                          }
               });
      }

     public void replicate(final Object entity) {
                getHibernateTemplate().execute(new HibernateCallback() {
                          public Object doInHibernate(Session session)throws HibernateException {
                                      session.replicate(entity,ReplicationMode.OVERWRITE);
                                      return null;
               }
                });
      }
}

        而HibernateTemplate试图每次在execute之前去获得Session，执行完就力争关闭Session

  1. public Object execute(HibernateCallback action) throws DataAccessException {  2.    Session session = (!this.allowCreate ?  3.          SessionFactoryUtils.getSession(getSessionFactory(),   4.                false) :  5.          SessionFactoryUtils.getSession(getSessionFactory(),  6.                 getEntityInterceptor(),  7.                 getJdbcExceptionTranslator()));  8.     boolean existingTransaction =    9.         TransactionSynchronizationManager.hasResource(getSessionFactory());  10.    if (!existingTransaction && getFlushMode() == FLUSH_NEVER) {  11.          session.setFlushMode(FlushMode.NEVER);  12.    }  13.    try {  14.          Object result = action.doInHibernate(session);  15.          flushIfNecessary(session, existingTransaction);  16.          return result;  17.    }  18.    catch (HibernateException ex) {  19.          throw convertHibernateAccessException(ex);  20.    }  21.    finally {  22.          SessionFactoryUtils.closeSessionIfNecessary(  23.                  session, getSessionFactory());  24.    }  25. }
      而这个SessionFactoryUtils能否得到当前的session以及closeSessionIfNecessary是否真正关闭session，端取决于这个session是否用sessionHolder和这个sessionFactory在我们最开始提到的TransactionSynchronizationManager绑定。

     public static void closeSessionIfNecessary(Session session, SessionFactory sessionFactory)

   
          throws CleanupFailureDataAccessException {
   
        if (session == null || TransactionSynchronizationManager.hasResource(sessionFactory)) {
   
          return;
   
        }
   
        logger.debug("Closing Hibernate session");
   
        try {
   
          session.close();
   
        }
   
        catch (JDBCException ex) {
   
          // SQLException underneath
   
          throw new CleanupFailureDataAccessException("Could not close Hibernate session", ex.getSQLException());
   
        }
   
        catch (HibernateException ex) {
   
          throw new CleanupFailureDataAccessException("Could not close Hibernate session", ex);
   
        }
   
      }
   

    在这个过程中，若HibernateTemplate 发现自当前session有不是readOnly的transaction，就会获取到FlushMode.AUTO Session，使方法拥有写权限。也即是，如果有不是readOnly的transaction就可以由Flush.NEVER转为Flush.AUTO,拥有insert,update,delete操作权限，如果没有transaction，并且没有另外人为地设flush model的话，则doFilter的整个过程都是Flush.NEVER。所以受transaction保护的方法有写权限，没受保护的则没有。

可能的解決方式有：
1、将singleSession设为false，这样只要改web.xml，缺点是Hibernate Session的Instance可能会大增，使用的JDBC Connection量也会大增，如果Connection Pool的maxPoolSize设得太小，很容易就出问题。
2、在控制器中自行管理Session的FlushMode，麻烦的是每个有Modify的Method都要多几行程式。
      session.setFlushMode(FlushMode.AUTO);
      session.update(user);
      session.flush();
3、Extend OpenSessionInViewFilter，Override protected Session getSession(SessionFactory sessionFactory)，将FlushMode直接改为Auto。
4、让方法受Spring的事务控制。这就是常使用的方法：
采用spring的事务声明,使方法受transaction控制

   
      <bean id="baseTransaction" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"           abstract="true">         <property name="transactionManager" ref="transactionManager"/>         <property name="proxyTargetClass" value="true"/>         <property name="transactionAttributes">             <props>                 <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>                 <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>                 <prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>                 <prop key="save*">PROPAGATION_REQUIRED</prop>                 <prop key="add*">PROPAGATION_REQUIRED</prop>                 <prop key="update*">PROPAGATION_REQUIRED</prop>                 <prop key="remove*">PROPAGATION_REQUIRED</prop>             </props>         </property>     </bean>
   
        <bean id="userService" parent="baseTransaction">         <property name="target">             <bean class="com.phopesoft.security.service.impl.UserServiceImpl"/>         </property>     </bean>

 
对于上例，则以save,add,update,remove开头的方法拥有可写的事务，如果当前有某个方法，如命名为importExcel()，则因没有transaction而没有写权限，这时若方法内有insert,update,delete操作的话，则需要手动设置flush model为Flush.AUTO,如

   
       
         session.setFlushMode(FlushMode.AUTO);
       
         session.save(user);
       
         session.flush();
       
   
   
     尽管Open Session In View看起来还不错，其实副作用不少。看回上面OpenSessionInViewFilter的doFilterInternal方法代码，这个方法实际上是被父类的doFilter调用的，因此，我们可以大约了解的OpenSessionInViewFilter调用流程: request(请求)->open session并开始transaction->controller->View(Jsp)->结束transaction并close session.

     一切看起来很正确，尤其是在本地开发测试的时候没出现问题，但试想下如果流程中的某一步被阻塞的话，那在这期间connection就一直被占用而不释放。最有可能被阻塞的就是在写Jsp这步，一方面可能是页面内容大，response.write的时间长，另一方面可能是网速慢，服务器与用户间传输时间久。当大量这样的情况出现时，就有连接池连接不足，造成页面假死现象。

Open Session In View是个双刃剑，放在公网上内容多流量大的网站请慎用。

另外：这样会产生一点危险性，毕竟把数据库访问的环境放到了表现层。（用VO）

(1)当使用某个重载的SessionFactory.openSession()使用Interceptor作为参数调用打开一个session的时候，就指定了Session范围内的拦截器。

Session session = sf.openSession( new AuditInterceptor() );

(2)SessionFactory范围内的拦截器要通过Configuration中注册，而这必须在创建SessionFactory之前。在这种情况下，给出的拦截器会被这个SessionFactory所打开的所有session使用了；除非session打开时明确指明了使用的拦截器。SessionFactory范围内的拦截器，必须是线程安全的，因为多个session可能并发使用这个拦截器，要因此小心不要保存与session相关的状态。

new Configuration().setInterceptor( new AuditInterceptor() );

package com.jason.interceptor;
import java.io.Serializable;
import org.hibernate.EmptyInterceptor;
import org.hibernate.Transaction;
import org.hibernate.type.Type;

public class UserInterceptor extends EmptyInterceptor {
    private int updates;
    private int creates;
    private int loads;
    public void onDelete(Object entity,
                         Serializable id,
                         Object[] state,
                         String[] propertyNames,
                         Type[] types) {
        // do nothing
    }
    public boolean onFlushDirty(Object entity,
                                Serializable id,
                                Object[] currentState,
                                Object[] previousState,
                                String[] propertyNames,
                                Type[] types) {
        if ( entity instanceof User ) {
            updates++;
            
        }
        return false;
    }
    public boolean onLoad(Object entity,
                          Serializable id,
                          Object[] state,
                          String[] propertyNames,
                          Type[] types) {
        if ( entity instanceof User ) {
            loads++;
            for ( int i=0; i<propertyNames.length; i++ ) {
                if ( "password".equals( propertyNames[i] ) ) {
                 String temp = (state[i]).toString();
                    state[i] = temp.substring(3, temp.length()-3);
                    return true;
                }
            }
        }
        return false;
    }
    public boolean onSave(Object entity,
                          Serializable id,
                          Object[] state,
                          String[] propertyNames,
                          Type[] types) {
        if ( entity instanceof User ) {
            creates++;
            for ( int i=0; i<propertyNames.length; i++ ) {
                if ( "password".equals( propertyNames[i] ) ) {
                    state[i] = "abc" +state[i] + "xyz";
                    return true;
                }
            }
        }
        return false;
    }
    public void afterTransactionCompletion(Transaction tx) {
        if ( tx.wasCommitted() ) {
            System.out.println("Creations: " 
+ creates + ", Updates: " + updates + ",Loads: " + loads);
        }
        updates=0;
        creates=0;
        loads=0;
    }
}

【注】String[] propertyNames  -- 属性名称
      Object[] state         -- 属性对应的值

















test:
Session session = sf.openSession(new UserInterceptor());

session.load(class, id);
session.save(obj);

//HQL-Delete
String hql = "delete from Product where name = :name";
Query query = session.createQuery(hql);
query.setString("name","Product 1");
int rowCount = query.executeUpdate();

//HQL-Function
String hql = "select min(product.price), max(product.price) from Product product";
Query query = session.createQuery(hql);
List results = query.list();

//HQL-Fetch Associations HQL Inner Join
String hql = "from Supplier s inner join fetch s.products as p";
Query query = session.createQuery(hql);
List results = query.list();

//HQL-Named Parameters
String hql = "from Product where price > :price";
Query query = session.createQuery(hql);
query.setDouble("price",2.0);
List results = query.list();
String hql = "from Product as product where product.supplier=:supplier";
Query query = session.createQuery(hql);
query.setEntity("supplier",supplier);
List results = query.list();

//HQL-Update
String hql = "update Supplier set name = :newName where name = :name";
Query query = session.createQuery(hql);
query.setString("name","Supplier Name 1");
query.setString("newName","s1");
int rowCount = query.executeUpdate();

//HQL-where
String hql = "from Product where price > 2.0 and name like 'P%'";
Query query = session.createQuery(hql);
List results = query.list();

//HQL-Map
String hql = " select new map(usr.name as userName, usr.password as password) from User usr";
Query query = session.createQuery(hql);
List list = query.list();
Map goods =(Map)list.get(0);

【注】
   String hql = " select new map(usr.name as userName, usr.password as password)　from com.jason.User usr";
   String hql = " select new map(usr.name as userName, usr.password as password) from com.jason.User usr";
由于from之前的空格，引起unexpected token: 　from

查询语句可以返回值为任何类型的属性或对象，包括返回类型为某种组件(Component)的属性: select cust.name.firstName from Customer as cust select cat.mate from Cat cat 查询语句可以返回多个对象和（或）属性，存放在 Object[]队列中: select mother, offspr, mate.name from DomesticCat as mother     inner join mother.mate as mate     left join mother.kittens as offspr 或存放在一个List对象中: select new list(mother, offspr, mate.name) from DomesticCat as mother     inner join mother.mate as mate     left outer join mother.kittens as offspr 也可能直接返回一个实际的类型安全的Java对象(假设类Family有一个合适的构造函数): select new Family(mother, mate, offspr) from DomesticCat as mother     join mother.mate as mate     left join mother.kittens as offspr 也可以使用关键字as给“被选择了的表达式”指派别名: select max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n from Cat cat 这种做法在与子句select new map一起使用时最有用: select new map( max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n ) from Cat cat

 <!--
  create table t_orderdetail ( order_id bigint not null, item_id bigint not null, count bigint not null, primary key(order_id, item_id) )
 -->
 

  <set name="events" cascade="all">
   <key column="PERSON_ID"/>
   <one-to-many class="com.jason.collections.set.Event"/>
   <!--<element column="title" type="string" />-->
  </set>

 </class>
 <class name="com.jason.collections.set.Event" table="EVENT">
  <id name="id" column="EVENT_ID">
   <generator class="native"/>
  </id>
  <property name="title"/>
 </class>
 <!--
  CREATE TABLE person (person_Id int PRIMARY KEY, person_Name varchar(20))
  CREATE TABLE Event (Event_Id int PRIMARY KEY, PERSON_ID int not null, title varchar2(20))
 -->
 
 

 -->

<set name="addresses" table="PersonAddress" cascade="all">
      <key column="personId"/>
      <many-to-many column="addressId"
          unique="true"
          class="com.jason.associations.one2many.unilateralism.one2many.table.Address"/>
</set>

//set,Array,bag,map都行
<set name="addresses" table="PersonAddress" cascade="all">
       <key column="personId"/>
       <many-to-many column="addressId"
           unique="true"
           class="com.jason.associations.one2many.unilateralism.one2many.table.Address"/>
</set>

<many-to-one name="address"
   class="com.jason.associations.one2one.unilateralism.foreign.Address"  
   unique="true"
   column="addressId"
   cascade="all"
   not-null="true"/>

<one-to-one name="person"
   class="com.jason.associations.one2one.unilateralism.primary.Person"
   constrained="true"/>
   
1、都表示一对一 ,many-to-one指定了对应的column（和column相关的属性cascade，not-null...）
       而one-to-one没有对应的column，它主要用于id的generator class="foreign"中
2、同样也适用于<many-to-many unique="true">和<one-to-many>

<one-to-many>
<many-to-one>
不管哪个，对应的表是这样的，把one那张表的key，放到many对应的表中，相当于外键。

<set name="addresses" cascade="all">
 <!--key 是Address表的字段，最后要update Address表.personId = Person表.personId-->
 <key column="personId"  not-null="true"/>
 <one-to-many
     class="com.jason.associations.one2many.unilateralism.one2many.Address"/>
</set>

<id name="id" column="addressId">
    <generator class="foreign">
   <param name="property">person</param>
  </generator>
</id>
<one-to-one name="person"
  class="com.jason.associations.one2one.unilateralism.primary.Person"
  constrained="true"/>
  
<one-to-many>和<one-to-one>都没有column属性，因为one对应的那边不需要相应的列，
那么如何保持关系呢？
1、最好不使用，
2、向上面那样指定一下

<class name="Address">
    <id name="id" column="addressId">
        <generator class="native"/>
    </id>
    <join table="PersonAddress"
        inverse="true"
        optional="true">
        <key column="addressId"/>
        <many-to-one name="person"
            column="personId"
            not-null="true"/>
    </join>
</class>
         1、为了更好地提高执行效率，需要将“多”的一端设为主控方，就是将关联关系的维护工作交给“多”的一端。inverse="true" 说明主控表是Person表（Address表对面）inverse="false"本身，默认值：false

   2、inverse="true"可以出现在关联的任意一端，即collection端或者join端。

2、使用连接表的双向多对多关联
 <class name="com.jason.associations.many2many.both.Person" table="Person">
  <id name="id" column="personId">
   <generator class="native"/>
  </id>
  <set name="addresses" table="PersonAddress" cascade="all">
   <key column="personId" not-null="true"/>
   <many-to-many
    column="addressId"
    class="com.jason.associations.many2many.both.Address"/>
  </set>
  <property name="name" column="personName" type="string" />
 </class>
 
 <class name="com.jason.associations.many2many.both.Address" table="Address">
  <id name="id" column="addressId">
   <generator class="native"/>
  </id>
  <set name="persons" table="PersonAddress" inverse="false" cascade="all">
   <key column="addressId" not-null="true"/>
   <many-to-many
    column="personId"
    class="com.jason.associations.many2many.both.Person"/>
  </set>
  <property name="country" column="country" type="string" />
  <property name="city" column="city" type="string" />
 </class>
 <!--
  create table Person ( personId bigint not null primary key, personName varchar(20))
  create table PersonAddress ( personId bigint not null, addressId bigint not null, primary key (personId, addressId))
  create table Address ( addressId bigint not null primary key, country varchar(20), city varchar(20) )
 -->

1、基于外键关联的单向一对一关联
   和单向多对一关联几乎是一样的。唯一的不同就是单向一对一关联中的外键字段具有唯一性约束。

 <class name="com.jason.associations.one2one.unilateralism.foreign.Person" table="Person">
  <id name="id" column="personId">
   <generator class="native"/>
  </id>
  <many-to-one name="address"
   class="com.jason.associations.one2one.unilateralism.foreign.Address"
   column="addressId"
      unique="true"
      cascade="all"
      not-null="true"/>
 </class>
 
 <class name="com.jason.associations.one2one.unilateralism.foreign.Address" table="Address">
  <id name="id" column="addressId">
   <generator class="native"/>
  </id>
 </class>
 <!--
  create table Person ( personId bigint not null primary key, addressId bigint not null unique)
  create table Address ( addressId bigint not null primary key)
 -->

2、基于主键关联的单向一对一关联
   通常使用一个特定的id生成器。（请注意，在这个例子中我们掉换了关联的方向。）

 <class name="com.jason.associations.one2one.unilateralism.primary.Person" table="Person">
  <id name="id" column="personId">
   <generator class="native"/>
  </id>
 </class>
 
 <class name="com.jason.associations.one2one.unilateralism.primary.Address" table="Address">
  <id name="id" column="addressId">
      <generator class="foreign">
    <param name="property">person</param>
   </generator>
  </id>
  <one-to-one name="person"
   class="com.jason.associations.one2one.unilateralism.primary.Person"
   constrained="true"/>
 </class>
 <!--
  create table Person ( personId bigint not null primary key)
  create table Address ( addressId bigint not null primary key)  
  其中personId= addressId
 -->

3、基于连接表的单向一对一关联非常少见，但也是可行的。

 <class name="com.jason.associations.one2one.unilateralism.table.Person" table="Person">
  <id name="id" column="personId">
   <generator class="native"/>
  </id>
      <!--join 必须放在最下面-->
       <join table="PersonAddress" optional="true">
           <key column="personId" unique="true"/>
           <many-to-one name="address"
               column="addressId"
               not-null="true"
            cascade="all"
               unique="true"/>
        </join> 
 </class>
 
 <class name="com.jason.associations.one2one.unilateralism.table.Address" table="Address">
  <id name="id" column="addressId">
         <generator class="native"/>
  </id>
 </class>
 <!--
  create table Person ( personId bigint not null primary key)
  create table PersonAddress ( personId bigint not null primary key, addressId bigint not null unique )
  create table Address ( addressId bigint not null primary key)
 -->

4、对应的双向关联
a、单向关联和双向关联使用的表是一样的
b、双向关联类中多了属性
c、双向关联可以从任何一个对象开始操作（比如添加），而单向只能从特定的一方操作

每个类分层结构一张表

每个子类一个表

每个具体类一个表

表的个数

1

n

n-1

父表

一个表

1

0

子表

n-1

n-1

表的字段

每个类的所有属性＋类型鉴别

父表 --> 父类属性
子表 --> 子类属性＋父类 id

子表 --> 子类属性＋父类属性

表的关联 / 表的唯一

类型鉴别标识

父类 id

id

package com.jason.inheritance.three;
public class Professor extends Person {
 private int salary;
 /**
  * @hibernate.property
  */
 public int getSalary() {
  return salary;
 }
 public void setSalary(int salary) {
  this.salary = salary;
 }
}

<?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.jason.inheritance.three.Professor" table="Professor"
  dynamic-update="false" dynamic-insert="false" select-before-update="false"
  optimistic-lock="version">
  
  <id name="id" column="ID" type="java.lang.Long" unsaved-value="null">
   <generator class="hilo">
   </generator>
  </id>
  
  <property name="salary" type="int" update="true" insert="true"
   access="property" column="salary"/>
  
  <property name="name" type="java.lang.String" update="true" insert="true"
   access="property" column="name" length="24"/>
  
 </class>
 
</hibernate-mapping>

<?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.jason.inheritance.three.Student" table="Student"
  dynamic-update="false" dynamic-insert="false" select-before-update="false"
  optimistic-lock="version">
  
  <id name="id" column="ID" type="java.lang.Long" unsaved-value="null">
   <generator class="hilo">
   </generator>
  </id>
  
  <property name="studentNumber" type="java.lang.String" update="true"
   insert="true" access="property" column="studentNumber" length="24"/>
  
  <property name="name" type="java.lang.String" update="true" insert="true"
   access="property" column="name" length="24"/>
  
 </class>
 
</hibernate-mapping>

      显然对应的表是
      professor(id, name, salary)
      student(id, name, studentNumber)
      插入记录的sql如下：
      Hibernate: insert into Student (studentNumber, name, ID) values (?, ?, ?)

<?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.jason.inheritance.two.Vehicle" dynamic-update="false"

              dynamic-insert="false" select-before-update="false"

              optimistic-lock="version">

              

              <id name="id" column="ID" type="java.lang.Long" unsaved-value="null">

               <generator class="hilo">

                

               </generator>

              </id>

              

              <property name="name" type="java.lang.String" update="true" insert="true"

               access="property" column="name" length="24"/>

              

              <joined-subclass name="com.jason.inheritance.two.Truck"

               dynamic-update="false" dynamic-insert="false">

               <key column="id"/>

               <property name="load" type="java.lang.String" update="true"

                insert="true" access="property" column="loads" length="24"/>

               

              </joined-subclass>

              <joined-subclass name="com.jason.inheritance.two.Car"

               dynamic-update="false" dynamic-insert="false">

               <key column="id"/>

               <property name="seat" type="java.lang.String" update="true"

                insert="true" access="property" column="seat" length="24"/>

               

              </joined-subclass>

              

             </class>

             

            </hibernate-mapping>

      显然对应的表是
      vehicle(id, name)        car(id, seat)          truck(id, loads)   
      需要注意的是：car/truck 中的id 和vehicle中的id是一一对应的。    
      /*
      Truck truck = new Truck();
      truck.setName("西风卡车");
      truck.setLoad("10ton");
      sess.save(truck);*/
   插入记录的sql如下：
   Hibernate: insert into Vehicle (name, ID) values (?, ?)
   Hibernate: insert into Truck (loads, id) values (?, ?)
   保存一条truck信息，要先在Vehicle中保存记录，得到id，然后把得到的id和需要的值一同保存到Truck中。

参考：

package com.jason.inheritance;

/**

 * @hibernate.class 

 *   table="Animal" 

 *   discriminator-value="Animal"

 * @hibernate.discriminator 

 *   column="ANIMAL_TYPE" 

 *   type="string" 

 *   length = "10"

 */

public class Animal {

 private Long id;

 private String name;

 /**

  * @hibernate.id 

  *   column="ID" 

  *   generator-class="hilo" 

  *   unsaved-value="null"

  */

 public Long getId() {

  return id;

 }

 public void setId(Long id) {

  this.id = id;

 }

 /**

  * @hibernate.property 

  *   length = "24"

  */

 public String getName() {

  return name;

 }

 public void setName(String name) {

  this.name = name;

 }

 public void makeSound(){};

}

package com.jason.inheritance;

public  class Cat extends Animal {
privateString FurColor;
publicvoid makeSound() {
System.out.println("喵喵");
}
publicString getFurColor() {
return FurColor;
}
publicvoid setFurColor(String furColor) {
FurColor = furColor;
}
}

<?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.jason.inheritance.Animal" table="Animal"

              dynamic-update="false" dynamic-insert="true" select-before-update="false"

              optimistic-lock="version" discriminator-value="Animal">

              

              <id name="id" column="ID" type="java.lang.Long" unsaved-value="null">

               <generator class="hilo">

               </generator>

              </id>

              

              <discriminator column="ANIMAL_TYPE" type="string" length="10"/>

              

              <property name="name" type="java.lang.String" update="true" insert="true"

               access="property" column="name" length="24"/>

              

              <subclass name="com.jason.inheritance.Cat" dynamic-update="false"

               dynamic-insert="false" discriminator-value="Cat">

               

               <property name="furColor" type="java.lang.String" update="true"

                insert="true" access="property" column="furColor" length="24"/>

              </subclass>

              <subclass name="com.jason.inheritance.Dog" dynamic-update="false"

               dynamic-insert="false" discriminator-value="Dog">

               

               <property name="category" type="java.lang.String" update="true"

                insert="true" access="property" column="category" length="24"/>

              </subclass>

              

             </class>

             

            </hibernate-mapping>

      显然对应的表是Animal（ID, ANIMAL_TYPE, name, furColor, category）
      需要在表中使用识别字段来表示某一列（row）是属于某个子类别或父类别,
就是用ANIMAL_TYPE来表示的！
      插入记录的sql如下：
Hibernate: insert into Animal (name, ANIMAL_TYPE, ID) values (?, 'Animal', ?)
Hibernate: insert into Animal (name, furColor, ANIMAL_TYPE, ID) values (?, ?, 'Cat', ?)
Hibernate: insert into Animal (name, category, ANIMAL_TYPE, ID) values (?, ?, 'Dog', ?)

参考：

Hibernate 在其数据访问引擎中内置了乐观锁实现。如果不用考虑外部系统对数据库的更新操作，
利用Hibernate提供的透明化乐观锁实现，将大大提升我们的生产力。
Hibernate中可以通过class描述符的optimistic-lock属性结合version描述符指定。
现在，我们为之前示例中的TUser加上乐观锁机制。
1． 首先为TUser的class描述符添加optimistic-lock属性：


name="org.hibernate.sample.TUser"
table="t_user"
dynamic-update="true"
dynamic-insert="true"
optimistic-lock="version"
>
……

optimistic-lock属性有如下可选取值：
Ø none
无乐观锁
Ø version
通过版本机制实现乐观锁
Ø dirty
通过检查发生变动过的属性实现乐观锁
Ø all
通过检查所有属性实现乐观锁
其中通过version实现的乐观锁机制是Hibernate官方推荐的乐观锁实现，同时也
是Hibernate中，目前唯一在数据对象脱离Session发生修改的情况下依然有效的锁机
制。因此，一般情况下，我们都选择version方式作为Hibernate乐观锁实现机制。

      Session.find/iterate的区别：
      find方法将执行Select SQL从数据库中获得所有符合条件的记录并构造相应的实体对象，实体对象构建完毕之后，就将其纳入缓存。它对缓存只写不读，因此无法利用缓存。
      iterate方法首先执行一条Select SQL以获得所有符合查询条件的数据id，随即，iterate方法首先在本地缓存中根据id查找对应的实体对象是否存在，如果缓存中已经存在对应的数据，则直接以此数据对象作为查询结果，如果没有找到，再执行相应的Select语句获得对应的库表记录（iterate方法如果执行了数据库读取操作并构建了完整的数据对象，也会将其查询结果纳入缓存）。


[实际的情况是,如果使用了iterate方法返回Iterator类型的查询结果,那么你一旦关闭session,Iterator中的数据立即就会消失.而通过find得到的List则不会如此,我想大部分人的使用习惯都是操作完成后立即关闭session,很多公司也强制要求这样做.
Iterator的另一个麻烦事是fail-fast,在多线程环境下,很容易产生.使用线程安全的List子类,则不会有这个问题]

      Query Cache产生作用的情况：
      1.完全相同的Select SQL重复执行。
      2.在两次查询之间，此Select SQL对应的库表没有发生过改变。

      Session.save方法的执行步骤：
      1.在Session内部缓存中寻找待保存对象。内部缓存命中，则认为此数据已经保存（执行过insert操作），实体对象已经处于Persistent状态，直接返回。
      2.如果实体类实现了lifecycle接口，则调用待保存对象的onSave方法。
      3.如果实体类实现了validatable接口，则调用其validate()方法。
      4.调用对应拦截器的Interceptor.onSave方法（如果有的话）。
      5.构造Insert SQL，并加以执行。
      6.记录插入成功，user.id属性被设定为insert操作返回的新记录id值。
      7.将user对象放入内部缓存。
      8.最后，如果存在级联关系，对级联关系进行递归处理。

      Session.update方法的执行步骤：
      1.根据待更新实体对象的Key，在当前session的内部缓存中进行查找，如果发现，则认为当前实体对象已经处于Persistent状态，返回。
      2.初始化实体对象的状态信息（作为之后脏数据检查的依据），并将其纳入内部缓存。注意这里Session.update方法本身并没有发送Update SQL完成数据更新操作，Update SQL将在之后的Session.flush方法中执行，根据id更新所有的字段，如update user set name=?, password=? where id=?。

      Session.saveOrUpdate方法的执行步骤：
      1.首先在Session内部缓存中进行查找，如果发现则直接返回。
      2.执行实体类对应的Interceptor.isUnsaved方法（如果有的话），判断对象是否为未保存状态。
      3.根据unsaved-value判断对象是否处于未保存状态。
      4.如果对象未保存（Transient状态），则调用save方法保存对象。
      5.如果对象为已保存（Detached状态），调用update方法将对象与Session重新关联。

调用flush
1.直接调用Session.flush();
2.tx.commit();
//flush before commiting the transaction and closing the session
//Flushing is the process of synchronising the underlying persistent store with persistable state held in memory.

E1=Session.merge(E)
if E is transient instance,则insert数据库,E状态不变化,E1是一个持久化对象;
if E is detached instance,则重新load,变成persistent instance;
if E is persistent instance,则从缓存中选择;

// Copy   the   state   of   the   given   object   onto   the   persistent   object   with   the   same   identifier.  
// If   there   is   no   persistent   instance   currently   associated   with   the   session,  it  will   be   loaded.   Return   the   persistent   instance.  
// If   the   given   instance   is   unsaved,   save   a   copy   of   and   return   it   as   a   newly   persistent   instance.   The   given   instance   does   not   become   associated   with   the   session.  
// This   operation   cascades   to   associated   instances   if   the   association   is   mapped   with   cascade="merge".

persist() is well defined. It makes a transient instance persistent. However,
it doesn't guarantee that the identifier value will be assigned to the persistent
instance immediately, the assignment might happen at flush time. The spec doesn't say
that, which is the problem I have with persist().

persist() also guarantees that it will not execute an INSERT statement if it is
called outside of transaction boundaries. This is useful in long-running conversations
with an extended Session/persistence context.A method like persist() is required.

save() does not guarantee the same, it returns an identifier, and if an INSERT
has to be executed to get the identifier (e.g. "identity" generator, not "sequence"),
this INSERT happens immediately, no matter if you are inside or outside of a transaction. This is not good in a long-running conversation with an extended Session/persistence context."