通用属性

Javascript相关属性

入门：
配置Struts数据库连接池
对于Struts和Spring两种MVC框架的比较

进阶：
用Struts建立MVC应用的介绍

图 1 struts uml图

1、fetch 的优先级高于 lazy，一般情况下（另外一般情况下除外，下篇会讲到）fetch的优先级高于 lazy，若出现了 fetch，则忽略 lazy。

2、在配置文件中多对一时，一定要明确声明 lazy=false 或 true，在多对一时，默认情况下，lazy 即不是 true 也不是 false。你若不明确指出，它执行的时候是按照 lazy=true 这种方式执行的，但是你若明确写上 lazy=true，指报出错误，一般情况下明确写上 lazy=false。

3、你的代码若像 Student student = (Student)session.get(Student.class, 1)，hibernate 会正确按照配置文件的策略来执行，有 fetch 则执行fetch，有 lazy 则执行 lazy；但你的代码若像 Query query = session.createQuery("from Student")，它会忽略配置文件中的 fetch，它不会执行  fetch=join，lazy 会被正确执行，Student 的属性（这里假定是Team，它是对象）的配置文件中的 fetch 会被正确执行。

4、Query query = session.createQuery("from Student s left outer join s.team")，会忽略 Student 和 Team 类的配置文件的 fetch，但它们类中的 lazy 会被正确执行。

1-1、类别

● 本地事务
  如果事务只和一个资源管理器有关，则为本地事物。在本地事务中，事务管理器只是将事务的管理委托给底层的资源管理器。

● 分布式事务
  分布式事务和多个可能不同的资源管理器以一种协调的方式进行交互。

1-2、Java 中事务处理

  JDBC 事务：由底层数据库事务管理器控制，操作比较简单，但是不适合控制多个应用程序组件的事务，并且没有传播的上下问。

  JTA 和 JTS：Java 事务 API 和 Java 事务服务，可以跨越多个组件和数据库使用事务。在应用程序使用 JTA 控制事务操作时，需要从 JNDI 上下文中获取 UserTranscation 和数据源。
UserTranscation ut = (UserTranscation) ctx.lookup("UserTranscation");

1-3、Hibernate 事务
 
● 基于 JDBC

  Transcation 事务对象必须从 Session 中获取，即事务必须和一个 Session 相关联。

采用 Hibernate 内置的 current session 和上下文管理。
<property name="current_session_context_class">thread</property>
...
sessionFactory.getCurrentSession().beginTranscation();

● 基于 JTA

  提供了跨 Session 的事务管理能力。
使用 SessionFactory.getCurrentSession() 方法简化事务上下文的传播，即在事务绑定 Session。

  虽然一个 Session 范围内可以存在多个事务操作，但是 Hibernate 并不支持嵌套的事务模型。
tx1
tx2
...
tx2.commit();

//数据库操作，操作无效
tx1.commit();

  如果事务都是串行执行，则许多资源将处于空闲状态。为了充分利用资源，发挥数据库共享资源的优势，必须允许多个事务并发地执行。

  在单处理机系统中，事务并发执行实际上是这些并行事务轮流交叉执行，即交叉并发方式，并不是真正的并行执行。在多处理机系统中，每个处理机运行一个事务，实现事务真正意义上的并存运行，即同时并发方式。

  当多个用户并发地存取数据库时，就会产生多个事务同时存取同一数据的情况。所以，必须实现一个控制系统，使一个事务所做的修改不会对其他事务所做的修改产生负面影响，这就是并发控制。

 
2-1、封锁

  对并发操作进行的正确调度，防止并发操作破坏了事务的隔离性。采用封锁技术，事务 T 可以向系统发出请求，对某个对象例如表、记录加锁，在事务 T 释放锁之前，其他事务不能更新这些数据对象。
 
  基本的封锁有：
排他锁（Exclusive Locks，X 锁）：写锁或者独占锁。
共享锁（Share Locks，S 锁）：读锁。允许和其他事务一起读取数据对象D，但不能对D 做任何修改。

2-2、事务隔离

  使用封锁技术，事务对申请的资源加锁，但是会影响数据库性能。根据数据对象封锁的程度，可以分成多种不同的事务隔离级别。

  数据并发执行时，产生不一致的现象：

丢失更新（Lost Update）
  两个事务读入同一数据并修改，然后提交修改，T2 提交的结果破坏了 T1 提交的结果，导致 T1 的修改丢失。

② 不可重复读
  事务T1 读取数据后，事务T2 执行了同一数据的跟新操作，使得事务 T1 无法再现前一次读取的结果。
    事务1 读取某一数据后，事务2 对该数据作了修改，事务1 再次读取时，得到数据和前一次不一致。
    ① 事务1 读取某一些记录后，事务2 删除了同一数据源的部分数据，事务1 再次读取时，发现某些记录丢失。
    ① 事务1 读取某一些记录后，事务2 插入了同一数据源的新数据，事务1 再次读取时，发现某些记录增加。

③ 读“脏”数据
  事务T1 修改某一数据，并将其写回物理数据库。事务T2 读取同一数据后，事务T1 由于某种原因被撤销，数据库将已经修改的数据恢复原值，导致事务T2 保持的数据和数据库中的数据产生了不一致。

  ANSI SQL-99 标准定义了下列隔离级别：

● 未提交读（Read Uncommitted）：隔离事务的最低级别，只能保证不会读取到物理上损坏的数据。H:1；允许产生：①②③

● 已提交读（Read Committed）：常见数据库引擎的默认级别，保证一个事务不会读取到另一个事务已修改但未提交的数据。H:2；允许产生：①②

● 可重复读（Repeatable Read）：保证一个事务不能更新已经由另一个事务读取但是未提交的数据。相当于应用中的已提交读和乐观并发控制。H:4；允许产生：①

● 可串行化（Serializable）：隔离事务的最高级别，事务之间完全隔离。系统开销最大。H:8；允许产生：

  在数据库中，可以手工设置事务的隔离级别。
  Hibernate 在配置文件中声明事务的隔离级别，Hibenate 获取数据库连接后，将根据隔离级别自动设置数据库连接为指定的事务隔离级别。
<property name="connection.isolation">8</property>

2-3、并发控制类型

  根据使用的锁定策略和隔离等级，可以把事务的并发控制分为两种：

① 悲观并发控制
 
  用户使用时锁定数据。主要应用于数据争用激烈的环境中，以及发生并发冲突时用锁保护数据的成本低于回滚事务成本的环境中。

  Hibernate 的悲观锁定不在内存中锁定数据，由底层数据库负责完成。

② 乐观并发控制
 
  用户读取数据时不锁定数据。当一个用户更新数据时，系统将进行检查该用户读取数据后其他用户是否更改了该数据，是则产生一个错误，一般情况下，收到错误信息的用户将回滚事务并重新开始。主要用户数据争用不大，且偶尔回滚事务的成本低于读取数据时锁定数据的成本的环境中。

  Hibernate 中使用元素 version 和 timestamp 实现乐观并发控制模式的版本控制，并提供多种编程方式。版本是数据库表中的一个字段，可以是一个递增的整数，也可以是一个时间戳，它们对应 Java 持久化类的一个属性。事务提交成功后，Hibernate 自动修改版本号。如果另外一个事务同时访问同一数据，若发现提交前的版本号和事前载入的版本号有出入，则认为发生了冲突，事务停止执行，撤销操作，并抛出异常。应用程序必须捕捉该异常并做出一定的处理。

⒈应用程序级别的版本控制
⒉长生命周期会话的自动化版本控制
⒊托管对象的自动化版本控制
⒋定制自动化版本控制

  Hibernate 提供两级缓存架构，第一级缓存是 Session 内的缓存，第二级缓存是一个可插拔的缓存，能够借助第三方的组件实现。如果应用程序中经常使用同样的条件查询数据，还可以使用查询缓存来提高查询效率。

  针对缓存的范围，可以将 Hibernate 持久层缓存分为三个层次：

① 事务级缓存
 
  缓存只能被当前事务访问。缓存的生命周期以来与事务的生命周期。事务缓存由 Session 实现。一个 Session 的缓存的内容只有在本 Session 实例范围内可用。

② 应用级缓存

  缓存在某个应用范围内被所有事务共享。缓存的生命周期依赖于应用程序的生命周期。应用级缓存由 SessionFactory 实现，Session 实例由其创建，并共享其缓存。

③ 分布式缓存

  集群环境中，缓存被一个 JVM 或多个 JVM 的进程共享。分布式缓存由多个应用级的缓存实例组成，缓存中的数据被复制到集群环境中的每个 JVM 节点，JVM 间通过远程通信来保证缓存中数据的一致性。

3-1、缓存查询结果

  经常使用同样的条件查询数据，则可使用查询缓存。查询缓存需要和二级缓存联合使用，在二级缓存中，可以专门为查询缓存开辟一个命名缓存区域。查询缓存启动后将创建两个缓存区域，org.hibernate.cache.StandardQueryCache 实现保存查询结果集；org.hibernate.cache.UpdateTimestampsCache 实现保存最近更新的查询表的时间戳。

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

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

//给查询缓存指定特定的命名缓存区域
query.setCacheRegion("queryCache");

//如果其他进程更新了结果集，强行刷新缓冲区域
query.setCacheMode(CacheMode.REFRESH);

//刷新某个或全部的缓存
SessionFactory.evictQueries() 方法

4-1、数据库连接池 ConnectionProvider

  J2SE 环境中使用建议。

4-2、使用数据源
  Hibernate 中，DatasourceConnectionProvider 实现了 ConnectionProvider 接口并封装了数据源的获取方法，充当了 Hibernate 和数据源间的适配器。

  J2EE 环境中使用建议。

4-3、过滤数据
 
  把公共的数据过滤条件提取出来。从 Hibernate 3.0 开始，可以利用 Hibernate Filter 对某个类或集合附加预先定义的过滤条件，在查询时过滤指定条件的数据。该过滤器是全局有效的，使用时候，还可以指定特定参数。

4-4、批量处理
 
  批量处理引发异常的根源在于缓存中保存了过多的持久化实例而耗尽内存。

① 应用程序级别的批处理

  指定 Hibernate 处理 SQL 语句时，必须积累到指定数量后再向数据库提交操作。
  <property name="jdbc.batch_size">20</property>

② 无状态 Session（StatelessSession）

  StatelessSession 接口没有持久化上下文，也不负责持久化实例的生命周期，没有一级缓存，操作也不会影响到二级和查询缓存。

③ 使用 DML 风格的 HQL 语句绕过内存直接进行数据处理

  "delete Product p where p.id > :id"

4-4、延迟加载

  设置延迟加载的属性和集合只能在该实例依附的 Session 范围内被访问，会话关闭后，实例从持久态转为托管态，再次访问该实例的一些属性时候，有可能会抛出 LazyInitializationException 异常。

① 属性延迟加载（大对象）
② 持久化类延迟加载
③ 集合延迟加载

4-5、数据抓取策略（Fetching strategies）

  可以在 Hibernate 中设定相应的数据抓取策略，减少系统产生的数据库查询操作，优化系统性能。

  在 Hibernate 中，延迟（lazy）定义了一种契约，用来表示托管状态实例中那些数据是有效的，而抓取（fetch）是用来调整 Hibernate 性能的。

4-5、监控性能
  org.hibernate.stat 包提供的工具类。

 5-1、XML 元数据

    18.2. XML映射元数据 - Hibernate reference 3.2.0 ga 正式版中文参考手册
    18.3. 操作XML数据 （通过dom4j会话读入和更新应用程序中的XML文档）

5-2、开源工具箱

CownewStudio 是一个基于 Eclipse 的 Hibernate 正向建模辅助工具。通过它用户能以图形化的方式建立对象模型，然后根据模型生成持久化类、映射文件和数据库表。

JDBMonitor。模拟一个 JDBC 驱动来代替真正的 JDBC 驱动，截取应用程序对数据库的操作，并以合适的方式记录下来，提供性能分析的来源和依据。

● 查询语句可以返回多个对象或属性，存放在 Object[] 队列中。

● 将查询结果的所有属性都存放在一个 List 对象中：
  select new list(xxx.xxxx,xx.xx) .....
这里的 new list 是实例化 java.util.ArraryList 对象。

● 将查询结果封装成一个安全的 Java 对象
  select new EncCustomer(xx.xxx, xx.xx)....

● 将查询结果封装成 Map 对象（利用别名）
  select new map(xx.xxx as aaaa, xx.xxxx as bb) .....
.....
  Map obj = (Map)list.get(i);
  obj.get("aaaa"); 
  obj.get("bb");

● distinct 删除重复数据

●
  q.setParameter("name", name);
  Hibernate 能根据参数值的 Java 类型推断出对应的映射类型，对于日期类型，如 java.util.Date 类型，会对应多种映射类型，这时候需要显示指定。
  q.setParameter("date", Hibernate.DATE);

●
  q.setProperties(obj);
  根据 obj 的属性名对应 HQL 语义中定义的命名参数进行查询。

  Session.createFilter(object, string);
  返回是 Query 类型
  参数 object 是持久化对象的集合。
  参数 string 是 HQL 的过滤条件

//过滤 prod 的集合 items
List items = session.createFilter(prod.getItems(),
 "this.unitCost<100 order by this.ListPrice desc").List();
//绑定过滤的结果 itmes 到属性
prod.setItems(items);

5-1、Restrictions 过滤结果集

5-2、结果集排序
 .addOrder(Order.asc("name"))
 .addOrder(Order.desc("category"))
 .list();

5-3、createCriteria() 关联查询
  List list = sess.createCriteria(Product.class)
 .add(Restrictions.like("name", "%o%"))
 .createCriteria("items")  
 .add(Restrictions.ge("listPrice", new Float(100.0))
 .list();
//返回一个新的 Criteria 实例，该实例引用 items 集合中的元素，并且为该集合元素增加了元素属性 listPrice 大于等于 100.0 的过滤条件。

或者使用别名
 .createAlias("items", "ite")
 .add(Restrictions.ge("ite.listPrice", new Float(100.0))

5-4、设置加载策略
 .setFetchMode("items", FetchMode.EAGER)
 .list();

  DEFAULT：默认
  EAGER/JOIN：强制立即加载
  LAZY/SELECT：强制延迟加载

5-5、聚合和分组  org.hibernate.criterion.Projections

 .setProjection(Projections.rowCount())
 .uniqueResult()；

 .add(Projections.groupProperty("imagePath"))
 .list();

5-6、离线与子查询

  离线查询方式在 Session 范围之外定义一个离线查询，然后使用任意的 Session 执行查询。该方法主要通过 org.hibernate.criterion.DetachedCriteria 类实现。

   应用程序中使用与数据库相关的 SQL 查询语句

6-1、Native SQL 应用程序接口

  主要使用 SQLQuery.addEntity() 实现返回结果为实体的查询，SQLQuery.addScalar() 则返回标量值。
  SQLQuery.addJoin(String alias, String path) 用于将映射对象所关联的实体或集合对应起来。

 
6-2、命名查询
  sess.getNamedQuery(string);

  在 xml 文件中使用 <! [CDATA []] > 元表示其中的内容是区分其他元素定义的纯文本。例如： < 符号。

6-3、使用存储过程
  Hibernate 3.0 以上的版本已经支持和利用存储过程来进行查询，存储过程返回的参数是标量与实体，这里可以利用返回类型的定义将存储过程返回的参数映射到对象的属性中。

<sql-query name="productQuery" callable="true">
  <return alias="prod" class="petstore.domain.Product">
    <return-property name="productId" column="PRODUCTID" />
    <return-property name="description" column="DESCRIPTION" />
    <return-property name="name" column="NAME" />
  </return>
  {? = call getProduct(?)}
</sql-query>

List list = query.list();

1-1、单向多对一关联

 产品和分类的关系：多个不同产品属于同一种分类。
private Category category；
<many-to-one name="category" column="categoryId" not-null="true" />

1-2、一对多映射
private Set products = new HashSet();
<set name="products"  <!--Category 中集合属性名称为 products-->
  table="product"  <!--集合属性对应表的名称为 product-->
  schema="test"   <!--表的 schema 名称为 test-->
  lazy="true"   <!--此集合采用延时加载策略-->
  inverse="true"  <!--由关联属性的另一方作为关联的主控方-->
  cascade="delete"  <!--采用级联删除，当 Category 被删除时关联的此集合内容也将被删除-->
  sort="natural"  <!--自然排序集合内容-->
  order-by="productId asc" <!--按 productId 字段升序排列集合内容-->
  >
  <key column="category_fk" />
 
  <one-to-many class="petstore.domain.Product" />
</set>

1-3、继承映射

● 瞬时态（Transient）--VO（Value Ojbect）
  对象实例产生到被 JVM 垃圾回收为止并不受 Hibernate 框架管理。

● 持久态（Persistent）--PO（Persistent Ojbect）
  对象实例被 Hibernate 框架管理，该对象可能是刚被保存的，或刚从数据库中被加载的。Hibernate 会检测处于持久态的对象任何改动，在当前操作单元执行完毕将对象与数据库同步，即将对象的属性保存到数据库映射对应的字段中。简单点说就是该实体对象与 session 发生关系，而且处于 session 的有效期内。
 
● 托管态（Detached）--VO（Value Ojbect）
  与持久对象关联的 Session 被关闭后，对象就变为托管的，可继续被修改。托管对象如果重新关联到某个新的 Session 上，会再次变为持久的，同时改动也将会被持久化到数据库。这个期间的转变过程可以看作是应用程序事务，即中间会给用户思考时间的长时间运行的操作单元。
  处于托管态对象具有与数据库表记录间的联系（持久化标识，identifier）。

2-2、对象操作的应用程序接口

● 修改对象

  对于已经持久化的对象，不需要调用某个特定的方法就可以实现修改持久化，因为 Hibernate 会自动调用 flush() 方法保证与数据库的同步。

  对于处于托管状态的实例，Hibernate 通过提供 Session.update() 或 Session.merge() 方法，重新关联托管实例。但是需要注意的是：如果具有持久化标识（identifier）的对象之前已经被另一个会话连接（secondSession）装载了，应用程序关联操作会发生异常。

  使用 merge() 方法时，用户不必考虑 session 的状态，可随时将修改保存到数据库中。例如：Session 中存在相同标识的持久化实例时，Hibernate 便会根据用户给出的对象状态覆盖原有的持久化实例的状态。

  另外，Hibernate 还提供了 saveOrUpdate()方法，它即可分配新持久化标识（identifier），保存瞬时（transient）对象，又可更新/重新关联托管的（identifier）实例。

● 删除对象
  通过 HQL 语句，调用重载的 delete()，可以一次删除多个对象。
  session.delete("from Customer as c where c.customerId <3");

● 查询对象
  已知对象表示符值查询
  对象标识符未知查询 HQL
  根据某些特定条件查询 QBC，Query By Criteria
  按详例查询 QBE，Query By Example
  调用数据库查询 native SQL

  查询条件参数 ？ 查询条件参数索引，由 0 开始。
  查询条件实名 ：name
  外置命名查询

    在映射文件定义查询语句，将程序与查询语句分离：
    <query name="CategoryById"
 <! [CDATA[
  from Category c where c.categoryId>? ]]>
    </query>

    程序调用：
      Query q = sess.getNamedQuery("CategoryById");
      q.setLong(0, name);
      List cats = q.List();
   
  用 Query 提供的 iterate() 方法遍历查询结果，如果查询的结果在 session 或二级缓存（second-level cache）中，那么使用 iterate() 方法可以得到更好的性能。

  如果 JDBC 驱动支持可滚动的 ResuleSet，Query 接口可以使用 ScrollableResults，允许你在查询结果中灵活移动（需要保持数据库连接和游标 cursor 处于抑制打开状态）。

ScrollableResults cates = q.scroll();
cates.first()
cates.scroll(5);

● cascade 和 inverse 级联操作

inverse
  只对 set，one-to-many（或 many-to-many）有效，对于 many-to-one，one-to-one 无效
  对集合起整体作用

cascade
  对关系标记都有效
  对集合的一个元素起作用，如果集合为空，那么 cascade 不会引发关联操作
 
  作用时机：在 flush 时（commit 会自动执行 flush），hibernate 会自行判断每个 set 是否有变化，对有变化的 set 执行相应的 SQL，if (inverse) return。即：cascade 在前，inverse 在后。

异常：
org.hibernate.exception.ConstraintViolationException: could not insert

原因是 category_fk 字段约束不能为空，而在新建的 Product 对象时插入了空值，而且关联关系由 Caterogy 对象维持，而被关联的 Product 对象不知道自己与哪个 Category 对象关联。说到底就是 pro 对象的 categoryId 值为空。

1-1、使用 ThreadLocal 控制 Session

    应用程序根据配置文件构建应用程序运行的环境，建立全局范围内的 SessionFactory 对象。其内部包含了 Hibernate 运行的全部细节，是产生 Session 的工厂，它是线程安全的，只能在系统启动时实例化一次，系统运行期间不可修改。

    Session 对象是 Hibernate 操作数据的核心，数据库的操作、对象生命周期的管理、应用事务的划分，都需要在 Session 对象中完成。Session  对象不是线程安全的，如果试图让多个线程同时使用一个 Session 对象，将会产生数据混乱，造成数据库的数据不一致。而且频繁开关 Session 是巨大的系统消耗。

    为了安全地使用 Session 对象，需要应用 Java 语言中的线程绑定机制--ThreadLocal，它代表一个线程的私有存取空间，能够隔离多线程环境中的并发机制，减少 Session 对象的创建和销毁次数，降低系统资源浪费。

HibernateSessionFactory
 1public class HibernateSessionFactory {
 2
 3    private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();
 4
 5
 6    public static Session getSession() throws HibernateException {
 7        Session session = (Session) threadLocal.get();
 8
 9        if (session == null || !session.isOpen()) {
10            if (sessionFactory == null) {
11                rebuildSessionFactory();
12            }
13            session = (sessionFactory != null) ? sessionFactory.openSession()
14                    : null;
15            threadLocal.set(session);
16        }
17
18        return session;
19    }
20
21.
22
23    public static void closeSession() throws HibernateException {
24        Session session = (Session) threadLocal.get();
25        threadLocal.set(null);
26
27        if (session != null) {
28            session.close();
29        }
30    }
31
32
33
34}

    使用 Hibernate 时，设计生成数据库表结构的方式分成两种。

1、手工用 SQL 语句设计数据表结构

2、使用 Hibernate 根据映射文件自动构建数据库模式
    hibernate.cfg.xml:
 <property name="hbm2dll.auto">creat</property>
 <property name="show_sql">true</property>
    log4j.properties
 log4j.logger.org.hibernate.tool.hbm2dll=debug

Hibernate 自行管理的数据库表结构：
● none：不产生任何动作。
● create：在应用启动时，自动生成数据库表结构并导入到数据库中。
● create-drop：同 create，但在应用关闭时，删除已生成的数据库表结构；此方式常在测试时使用。
● update：在应用启动时，检查持久化类和映射文件的改变，更新数据库表结构，比如：持久化类添加一个属性后，Hibernate 能自动添加对应字段到对应的数据库表中。

● Configuration（org.hibernate.cfg.Configuration）
  Hibernate 应用的入口，它使用配置文件初始化运行环境，是 SessionFactory 的工厂。通常情况下，一个应用程序中只允许创建一个单例的 Configuration 实例。

● SessionFactory（org.hibernate.SessionFactory）
  是一个线程安全的高速缓存，其中包含了单一数据库和已编译映射文件的元数据，在运行环境不可改变。它是 Session 的工厂，并能从 ConnectionProvider 中获取 JDBC 连接。它可能持有一个可选的能在进程级别或者集群级别事务间重用的数据缓存（二级缓存）。SessionFactory 从 Configuration 中获取，在一个应用范围中，不允许改变。

● Session（org.hibernate.Session）
  单线程的短生命周期的对象，是应用程序和持久化存储的一次对话。封装了一个 JDBC 连接，也是 Transaction 的工厂。它保持一个持久化对象的强制缓存（一级缓存），用来遍历对象图或者根据标识符查询对象。Session 提供了一系列方法，可以方便地实现对象持久化操作。

● Transcation（org.hibernate.Transcation）
  可选，单线程、短生命周期的对象，应用程序用它来表示一批任务的原子操作。是底层 JDBC，JTA 或者 CORBA 事务的抽象。一个 Session 在某些情况下可能跨越多个 Transcation 事务。

● ConnectionProvider（org.hibernate.connection.ConnectionProvider）
  可选，JDBC 连接的工厂和连接池，是底层 Datasource 或 DriverManager 的抽象应用，对应用程序不可见。可扩展实现。

● TranscationFactory（org.hibernate.TranscationFactory）
  可选，事务实例工厂。对应用程序不可见。可扩展实现。

  在最小集合应用框架中，应用程序直接使用 JDBC/JTA，并自行完成事务处理。
 conn = DriverManager.getConnection(xxx);
 conn.setAutoCommit(false);
 ...
 conn.commit();

● 暂态状态。对象刚建立，还没有使用 Hibernate 进行保存。该对象在数据库中没有记录，也不在 session 缓存中。如果该对象是自动生成主键，则该对象的对象标识符为空。

● 持久化对象。对象已经通过 Hibernate 进行了持久化，数据库中已经存在对应的记录。如果该对象是自动生成主键，则该对象的对象标识符已被赋值。

● 托管对象。该对象是经过 Hibernate 保存过或者从数据库中取出的，但是与之关联的 session 已经被关闭。虽然它拥有对象标识符，且数据库中存在对应的记录，但是已经不再被 Hibernate 管理。

ps. [转] PO BO VO DTO POJO DAO概念及其作用（附转换图）

5-1、关系型数据库的主键生成机制
  序列生成主键，整数
  自动增长组件，整数
  全局统一标识符 GUID（Globally Unique Identifier），字符串主键

 
5-2、Java 环境中的对象识别机制
  引用比较，比地址 “==”
  内容比较，比数据 equals() 方法

5-3、Hibernate 对象识别符的作用
  在生成 Java 对象时，给标识属性分配一个唯一的值，用于区分同一个类的多个不同的实例。体现在 Hibernate 中就是对象标识符。

5-4、Hibernate 内置标识符生成器的使用方法
  org.hibernate.id.IdentifierGenerator 接口。

ps.  映射对象标识符

5-5、使用复合主键时组合标识符的使用方法（常用于遗留的系统中）
  嵌入式组合标识符/映射式组合标识符，映射多个主键字段和持久化类的多个属性。

Hibernate JDBC 配置属性
  hibernate.jdbc.fatch_size：指定 JDBC 抓取数据的数量大小，非零值
  hibernate.jdbc.batach_size：允许 Hibernate 使用 JDBC2 的批量更新，非零值，建议 5 到 30
  hibernate.jdbc.provider_class：自定义的 ConnectionProvider 类名，用于向 Hibernate 提供 JDBC 连接
  hibernate.jdbc.autocommit：确认是否开启 JDBC 自动提交功能，默认为 false 不自动提交

6-2、方言
  屏蔽底层数据库系统的方言机制，方便与数据库间迁移。
  MySQL：org.hibernate.dialect.MySQLDialect
  MySQL with InnoDB：org.hibernate.dialect.MySQLInnoDBDialect
  MySQL with MyISAM：org.hibernate.dialect.MySQLMyISAMDialect

6-3、Hibernate 日志系统
  使用 Log4J 作为  Hibernate 的日志系统，需要将 Log4J 的库文件 log4j.jar 放置到类路径下（其发布包以包含 Log4J 的库文件）。然后编写日志配置文件 log4j.properties 并放到 classpath 路径中。

  Log4J 中，几个日志输出级别的顺序是：只输出高于或等于 设定级别 的记录。
trace < debug < info < warn < error < fatal

  在开发模式中，可以选择 DEBUG 级别的输出；应用部署后，可以配置为 ERROR。 

log4j.properties
 1#设置日志根级别和输出路径
 2log4j.rootLogger=INFO,CONSOLE,FILE
 3
 4#日志输出路径——控制台
 5log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
 6log4j.appender.stdout.Target=System.out
 7log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
 8log4j.appender.CONSOLE.layout.ConversionPattern=%d|ABSOLUTE %5p %c|1|:%L - %m%n
 9
10#日志输出路径——文件
11log4j.appender.FILE=org.apache.log4j.FileAppender
12log4j.appender.FILE.File=hibernate.log
13log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
14log4j.appender.FILE.layout.ConversionPattern=%d|ABSOLUTE %5p %c|1|:%L - %m%n
15
16#日志输出级别
17log4j.logger.org.hibernate=INFO
18
19#日志输出类别
20log4j.logger.org.hibernate.hql.ast.AST=WARN
21log4j.logger.net.sf.ehcache=INFO
22log4j.logger.org.hibernate.SQL=DEBUG

7-1、时间日期映射类型（内置映射类型）

  Java 语言提供了 java.util.Date 和 java.util.Calendar 两个类实现时间的运算。此外，JDBC 还提供了 java.util.Date 的三个扩展类 java.sql.Timestamp、java.sql.Time 和 java.sql.Date 分别对应标准 SQL 数据类型中的 TIMESPAME/DATETIME（时间日期）、TIME（时间）、DATE（日期）。

java.util.Date/java.sql.Date                                  H:date                             SQL:DATE
java.util.Time/java.sql.Time                                H:time                             SQL:TIME
java.util.Date/java.sql.Timestamp                        H:timestamp                    SQL:TIMESTAMP/DATETIME
java.util.Calendar                                               H:calendar                       SQL:TIMESTAMP/DATETIME
java.util.Calendar                                               H:calendar_date               SQL:DATE

7-2、自定义映射类型

    关键点：如何高效地存取数据、简化编程模型、降低应用的复杂度

    在系统中引入持久层，负责所有相关数据的持久化操作，可以为整个应用系统提供一个高层、统一、安全、并发的数据持久机制。

1、对象持久化技术

1-1、Java 对象序列化
    序列化是 Java 语言中内置的轻量级数据持久化机制，该机制可以将任何实现了 java.io.Serializable 接口的对象转化为连续的字节流数据，保存在文件中，或者通过网络进行传输。这些数据日后可被还原为原先的对象状态。
    缺点：局限性大，查询只能返回数据流的下一个对象，不提供部分的读取和更新，不提供对象的生命周期管理，只是简单的读取和写入，不提供并发和事务特性。

1-2、使用 JDBC
    JDBC（Java Database Connectivity）是用来访问关系数据库系统的标准 Java API。JDBC 只是提供访问数据的接口，其底层实现有特定的数据库厂商实现。
    缺点：直接使用 JDBC 实现持久化时，SQL 语句和应用代码混杂在一起，逻辑混乱。另外直接使用 SQL 操作数据库，不是面向对象。

1-3、使用 JDO
    Java 数据对象（Java Data Object）是 JCP（Java Community Process）发布的一个规范，是 Java 对象持久化的标准。JDO 仅定义了标准的编程接口，而把关系映射的定义留给软件供应商实现。

1-4、实体 EJB
    实体 EJB（Enterpise Java Bean）是 Java 领域的数据持久化标准。

1-5、对象关系映射
    对象关系映射（Ojbect Relation Mapping）在对象模型和关系模型之间建立沟通的桥梁。ORM 技术封装了数据持久化的操作细节，为应用程序提供了一只访问的接口，使应用程序可以专注于业务逻辑的处理。它采用 POJO（Plain Old Java Object，简单的传统对象）作为域对象的表述，不涉及域对象之外的技术细节，降低的 ORM 技术的侵入性，实现简单，便于测试，具备高扩展性。

2、对象关系映射模型
    一个完整的对象关系映射框架，应具备以下四个方面：

①、一个元数据映射规范，负责持久化类、类属性的数据库表、字段的映射，实现对象和关系的语义连接。
②、一组对象操作接口，用于完成数据的增加、删除、修改和更新等操作。
③、一种面向对象的查询语言，该语言能理解继承、多态和关联等面向对象特性，实现基于对象的查询并在对象之间导航。
④、一系列与数据库现关的技术实现和最佳实践，保证系统的完整性并提高系统的可用性和扩展性。比如：事务、缓存和数据抓取策略等。

对象模型（类、属性、关联）   <==>   关系模型（表、字段、约束）

 

ps. <Hibernate 完全手册>
ISBN 978-7-111-23764-8
机械工业出版社
侯志松 余周 郑焕 等编著

可选项说明：

1) assigned 
         主键由外部程序负责生成，无需Hibernate参与。

2) hilo 
         通过hi/lo 算法实现的主键生成机制，需要额外的数据库表保存主键生成历史状态。

3) seqhilo 
         与hilo 类似，通过hi/lo 算法实现的主键生成机制，只是主键历史状态保存在Sequence中，适用于支持Sequence的数据库，如Oracle。

4) increment
        主键按数值顺序递增。此方式的实现机制为在当前应用实例中维持一个变量，以保存着当前的最大值，之后每次需要生成主键的时候将此值加1作为主键。 
         这种方式可能产生的问题是：如果当前有多个实例访问同一个数据库，那么由于各个实例各自维护主键状态，不同实例可能生成同样的主键，从而造成主键重复异常。因此，如果同一数据库有多个实例访问，此方式必须避免使用。

5) identity 
         采用数据库提供的主键生成机制。如 DB2、SQL Server、MySQL 中的主键生成机制。

6) sequence 
         采用数据库提供的sequence 机制生成主键。如Oralce 中的Sequence。

7) native 
         由Hibernate根据底层数据库自行判断采用 identity、hilo、sequence 其中一种作为主键生成方式。

8) uuid.hex 
         由Hibernate基于128 位唯一值产生算法生成16 进制数值（编码后以长度32的字符串表示）作为主键。

9) uuid.string 
         与uuid.hex 类似，只是生成的主键未进行编码（长度16）。在某些数据库中可能出现问题（如PostgreSQL）。

10) foreign 
         使用外部表的字段作为主键。

         一般而言，利用uuid.hex方式生成主键将提供最好的性能和数据库平台适应性。

         另外由于常用的数据库，如Oracle、DB2、SQLServer、MySql 等，都提供了易用的主键生成机制（Auto-Increase 字段或者Sequence）。我们可以在数据库提供的主键生成机制上，采用 generator-class = native 的主键生成方式。

         不过值得注意的是，一些数据库提供的主键生成机制在效率上未必最佳，大量并发insert数据时可能会引起表之间的互锁。数据库提供的主键生成机制，往往是通过在一个内部表中保存当前主键状态（如对于自增型主键而言，此内部表中就维护着当前的最大值和递增量），之后每次插入数据会读取这个最大值，然后加上递增量作为新记录的主键，之后再把这个新的最大值更新回内部表中，这样，一次Insert操作可能导致数据库内部多次表读写操作，同时伴随的还有数据的加锁解锁操作，这对性能产生了较大影响。

         因此，对于并发Insert要求较高的系统，推荐采用uuid.hex 作为主键生成机制。

摘要
Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。



Hibernate的核心接口一共有5个，分别为:Session、SessionFactory、Transaction、Query和Configuration。这5个核心接口在任何开发中都会用到。通过这些接口，不仅可以对持久化对象进行存取，还能够进行事务控制。
下面对这五的核心接口分别加以介绍。

　　·Session接口:Session接口负责执行被持久化对象的CRUD操作(CRUD的任务是完成与数据库的交流，包含了很多常见的SQL语句。)。但需要注意的是Session对象是非线程安全的。同时，Hibernate的session不同于JSP应用中的HttpSession。这里当使用session这个术语时，其实指的是Hibernate中的session，而以后会将HttpSesion对象称为用户session。
　　·SessionFactory接口:SessionFactroy接口负责初始化Hibernate。它充当数据存储源的代理，并负责创建Session对象。这里用到了工厂模式。需要注意的是SessionFactory并不是轻量级的，因为一般情况下，一个项目通常只需要一个SessionFactory就够，当需要操作多个数据库时，可以为每个数据库指定一个SessionFactory。
　　·Configuration接口:Configuration接口负责配置并启动Hibernate，创建SessionFactory对象。在Hibernate的启动的过程中，Configuration类的实例首先定位映射文档位置、读取配置，然后创建SessionFactory对象。
　　·Transaction接口:Transaction接口负责事务相关的操作。它是可选的，开发人员也可以设计编写自己的底层事务处理代码。
　　·Query和Criteria接口:Query和Criteria接口负责执行各种数据库查询。它可以使用HQL语言或SQL语句两种表达方式。

摘要
Hibernate是什么?从不同的角度有不同的解释:
1.它是连接Java应用程序和关系数据库的中间件.
2.它对JDBC API进行了封装,负责Java对象的持久化.
3.在分层的软件架构中它位于持久化层,封装了所有数据库访问细节,是业务逻辑层可以专注于实现业务逻辑.
4.它是一中ORM(对象关系模型)映射工具.能够建立面向对象的域模型和关系数据模型之间的映射.

持久化层封装了数据访问细节，为业务逻辑层提供了面向对象的API,完善的持久化层应该达到以下目标:
1.代码可重用性高,能够完成所有的数据库访问操作.
2.如果需要的话,能够支持多种数据库平台.
3.具有相对独立性,当持久层的实现发生变化时,不影响上层的实现. 

摘要
10、如何学习Hibernate
（1）Hibernate文档
Hibernate文档处处都是持久层设计的经验和最佳实践。Hibernate文档准确的来说，绝大部分内容都在讲对象的持久层设计，而不是简单的Hibernate使用。

（2）学习要点
    所以学习Hibernate，主要是在学习持久层的设计模式，如果你把Hibernate文档都看完了，还整天只会提那些 Hibernate的配置问题，Hibernate的类调用问题，我觉得这样的人还没有真正的入门，算是白学了

    在学习Hibernate的时候即集中所有精力来理解Hibernate的运行原理，集中精力来掌握持久层设计应该把握的原则和技巧，这些才对我是最重用的东西----而如果在学习Hibernate时间，主要侧重于怎么配置，用工具怎么生成hbm文件，如果你把重点放在这里，基本上等于白学了Hibernate。
    因为，如果这样进行学习，学习完Hibernate，肯定会对JDBC的编程也提高了一大截，更不要说对于J2EE架构的持久层的框架设计，基本上是了然于胸了，即使将来换了API，不用Hibernate的，改用JDO，Castor什么的，这些经验一样照用。

（3）Hibernate的精华：在于无与伦比的灵巧的对象持久层设计
    这些持久层设计经验不会因为你不用Hibernate而丧失掉，我自己学习Hibernate，已经明显感觉到对持久层设计能力已经长了很多经验值了，这些经验甚至不光可以用在Java上，用在.net上也是一样。
    因为，不管JDO也好，Hibernate也好，TopLink也好，CocoBase也好，还是Castor，还是什么Torque，OJB，软件的使用和配置方法可以各异，但本质上都是ORM，都是对JDBC的对象持久层封装，所以万变不离其宗。

 (比较全面的介绍)            http://feelingsea.blog.hexun.com/7294376_d.html

摘要
16、一个重要的术语：Type
（1）一个Type对象能将一个Java类型映射到数据库中一个表的字段中
    Hibernate的设计者们发明了一个术语：Type，它在整个构架中是一个非常基础、有着强大功能的元素。一个Type对象能将一个Java类型映射到数据库中一个表的字段中去（实际上，它可以映射到表的多个字段中去）。

<hibernate-mapping>
    <class name="Event" table="EVENTS">
        <id name="id" column="EVENT_ID">
            <generator class="increment"/>
        </id>
        <property name="date" type="timestamp" column="EVENT_DATE"/>
        <property name="title"/>
    </class>
</hibernate-mapping>

    它是Hibernate mapping types，并不像我们假想的那样，是Java data type， 同时也不是SQL database type。这些类型被称作Hibernate mapping types，它们把数据类型从Java转换到SQL data types。
    持久类的所有属性都对应一个type，这种设计思想使用Hibernate有着高度的灵活性和扩展性。


（2）关于缺省的type类型
    如果映射的参数没有设置type类型，Hibernate也将尝试去确定正确的类型转换和它的映射类型。在某些情况下这个自动检测（在Java class上使用反射机制）不会产生你所期待或者需要的缺省值----因此，最好我们来设定其类型。
    上面的例子是关于date属性。Hibernate无法知道这个属性应该被映射成下面这些类型中的哪一个： SQL date，timestamp，time。 我们通过声明属性映射timestamp来表示我们希望保存所有的关于日期和时间的信息。

摘要
java数据类型，hibernate数据类型，标准sql数据类型之间的对应表

Java数据类型                             Hibernate数据类型                         标准SQL数据类型(PS:对于不同的DB可能有所差异) 
byte、java.lang.Byte                         byte                                                 TINYINT 
short、java.lang.Short                      short                                                 SMALLINT 
int、java.lang.Integer                         integer                                             INGEGER 
long、java.lang.Long                         long                                                 BIGINT 
float、java.lang.Float                         float                                                 FLOAT 
double、java.lang.Double                 double                                            DOUBLE 
java.math.BigDecimal                         big_decimal                                    NUMERIC 
char、java.lang.Character                 character                                         CHAR(1) 
boolean、java.lang.Boolean           boolean                                             BIT 
java.lang.String                                 string                                                 VARCHAR 
boolean、java.lang.Boolean             yes_no                                         CHAR(1)('Y'或'N') 
boolean、java.lang.Boolean             true_false                                     CHAR(1)('Y'或'N') 
java.util.Date、java.sql.Date             date                                                 DATE 
java.util.Date、java.sql.Time             time                                                 TIME 
java.util.Date、java.sql.Timestamp     timestamp                                 TIMESTAMP 
java.util.Calendar                                     calendarTIMES                         TAMP 
java.util.Calendar                                     calendar_date                             DATE 
byte[] binary                                         VARBINARY、                            BLOB 
java.lang.String                                             text                                         CLOB 
java.io.Serializable serializable             VARBINARY、                        BLOB 
java.sql.Clob                                                 clob                                         CLOB 
java.sql.Blob                                                 blob                                         BLOB 
java.lang.Class                                             class                                 VARCHAR 
java.util.Locale                                             locale                                 VARCHAR 
java.util.TimeZone                                     timezone                             VARCHAR 
java.util.Currency                                     currency                                 VARCHAR 

摘要
关于在Hibernate里使用select count(*) 返回值的问题说明 
由于我使用的是Hibernate 3.2版本，经确认，这个版本已经把以前返回 Integer的改成了 Long, 
因为JPA里面的返回值规定是Long, Hibernate为了兼容这个，所以修改了返回值。 

如果你从Hibernate 3.0.x/3.1.x升级到最新的3.2版，一定要注意，3.2版的很多sql函数如count(), sum()的唯一返回值已经从Integer变为Long，如果不升级代码，会得到一个ClassCastException。 

这个变化主要是为了兼容JPA，可以在hibernate.org的最新文档中找到说明。 

Hibernate Team也提供了一个与原来兼容的解决方案： 

  Configuration classicCfg = new Configuration(); 
  classicCfg.addSqlFunction( "count", new ClassicCountFunction()); 
  classicCfg.addSqlFunction( "avg", new ClassicAvgFunction()); 
  classicCfg.addSqlFunction( "sum", new ClassicSumFunction()); 
  SessionFactory classicSf = classicCfg.buildSessionFactory();