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
机械工业出版社
侯志松 余周 郑焕 等编著

常用 JDBC 驱动名字和 URL 列表

ODBC  driver
sun.jdbc.odbc.JdbcOdbcDriver
jdbc:odbc:name

用 COM.ibm.db2.jdbc.net.DB2Driver 连接到 DB2 数据库
一个 DB2 URL 的示例:
jdbc:db2://aServer.myCompany.com:50002/name

用 com.sybase.jdbc.SybDriver连接到 Sybase 数据库
一个 Sybase URL 的示例:
jdbc:sybase:Tds:aServer.myCompany.com:2025

MySQL driver
com.mysql.jdbc.Driver
jdbc:mysql://hostname:3306/dbname?useUnicode=true&amp;characterEncoding=GBK

Microsoft SQL Server Driver
com.microsoft.jdbc.sqlserver.SQLServerDriver
jdbc:microsoft:sqlserver://127.0.0.1:1433;DatabaseName=WapSvc;User=sa;Password=pwd

Informix
com.informix.jdbc.IfxDriver
jdbc:informix-sqli://hostname:1526/dbname:INFORMIXSERVER=informixservername;user=username;password=password

Oracle
oracle.jdbc.driver.OracleDriver
jdbc:oracle:thin:@hostname:1521:<SID>

Postgresql
org.postgresql.Driver
jdbc:postgresql://localhost/soft

Apache Derby/Java DB
org.apache.derby.jdbc.ClientDriver
jdbc:derby://localhost:1527/databaseName;create=true

Access 是通过 ODBC 连接的. Excel 也可以. 甚至可以动态构造连接字符串:

这样可以直接连接到 Access 数据库文件.

jdbc:odbc:DRIVER={Microsoft Access Driver (*.mdb)};DBQ=c:\mydata.mdb

类似的 Excel 文件也可以用类似方法:

jdbc:odbc:Driver={Microsoft Excel Driver (*.xls)};DBQ=.\mydata.xls