新接触一个框架的目的就是想利用这个框架来为我们做一些工作，或者是让他来简化我们的工作，利用这个框架无非就是要利用这个框架所给我们提供的API去操作我们的数据，所以利用一个框架的好坏很大一部分取决于你对这个框架API的理解程度，所以在此篇博客中我们就一起来看一下Hibernate 的API和配置文件的相信情况。下面我们一一来看一下：

一：使用SchemaExport自动创建数据库表

         我相信在此之前大家应该都是用最原始的方法：SQL建立数据库相关的表，然后再Java写映射写配置文件.现在我们学习了hibernate以后就可以用一些偷懒的方式了，我们可以使用SchemaExport自动创建数据库，建立根据你的对象建立数据库表。下面我们来看一下具体操作：

首先当然要建好POJO object, XML Mapping File(也可以使用工具根据POJO class建立)，配置文件(hibernate.cfg.xml)，然后运行下面的Java代码

[java] 
view plain 
copy 
print 
?

1. import org.hibernate.cfg.Configuration;   
3. import org.hibernate.tool.hbm2ddl.SchemaExport;  
6. publicclass SchemaUtil {  
7. publicstaticvoid main(String[] args) {  
9.         Configuration cfg = new Configuration().configure();  
11.         SchemaExport schemaExport= new SchemaExport(cfg);  
13.         schemaExport.create(false, true);  
15.     }  
16. }  

再看看数据库，表是不是已经帮你建好了，对于我这样不熟悉数据库的人真是太方便了。

二．使用Hibernate操作数据库需要七个步骤

（1）读取并解析配置文件

Configuration conf = new Configuration().configure();

（2）读取并解析映射信息，创建SessionFactory

SessionFactory sf = conf.buildSessionFactory();

（3）打开Session

Session session = sf.openSession();

（4）开始一个事务（增删改操作必须，查询操作可选）

Transaction tx = session.beginTransaction();

（5）数据库操作

session.save(user);//或其它操作

（6）提交事务（回滚事务）

tx.commit();(tx.rollback();)

（7）关闭session

session.close();

下面我们来详细看一下这七大步骤的API：

Configuration:负责管理Hibernate的配置信息，这些配置信息都是从配置文件hibernate.cfg.xml或者Hibernate.properties读取的，当然也可以自定义文件名称，只要在实例化Configuration的时候指定具体的路径就可以了；他为什么会自动加载hibernate.cfg.xml文件的呢？我们看一下configure源码就一目了然了

[java] 
view plain 
copy 
print 
?

1. public Configuration configure() throws HibernateException {  
3. configure( “/hibernate.cfg.xml” );  
5. returnthis;  
7. }  

从这里我们可以看出，在hibernate源码中，他就是默认的加载hibernate.cfg.xml，当然你也可以指定加载配置文件，Configuration提供了相应的方法：

public Configuration configure(String resource)

public Configuration configure(URL url)

public Configuration configure(File configFile)

SessionFactiory：Configuration的实例会根据当前的配置信息，构造SessionFactory实例。SessionFactory是线程安全的，一般情况下一个应用中一个数据库共享一个SessionFactory实例。

 Hibernate的SessionFactory接口提供Session类的实例，Session类用于完成对数据库的操作。由于SessionFactory实例是线程安全的（而Session实例不是线程安全的），所以每个操作都可以共用同一个SessionFactory来获取Session。

Hibernate配置文件分为两种格式，一种是xml格式的配置文件，另一种是Java属性文件格式的配置文件，因此构建SessionFactory也有两种方法，下面分别介绍。

1 . 从XML文件读取配置信息构建SessionFactory
从XML文件读取配置信息构建SessionFactory的具体步骤如下。

（1）创建一个Configuration对象，并通过该对象的configure()方法加载Hibernate配置文件，代码如下。

Configuration config = new Configuration().configure();

（2）完成配置文件和映射文件的加载后，将得到一个包括所有Hibernate运行期参数的Configuration实例，通过Configuration实例的buildSessionFactory()方法可以构建一个惟一的SessionFactory，代码如下。

SessionFactory sessionFactory = config.buildSessionFactory();

构建SessionFactory要放在静态代码块中，因为它只在该类被加载时执行一次。

2  从Java属性文件读取配置信息构建SessionFactory
从Java属性文件读取配置信息构建SessionFactory的具体步骤如下。

（1）创建一个Configuration对象，此时Hibernate会默认加载classpath中的配置文件hibernate.properties，代码如下。

Configuration config = new Configuration();

（2）由于在配置文件中缺少相应的配置映射文件的信息，所以此处需要通过编码方式加载，这可以通过Configuration对象的

addClass()方法实现，具体代码如下。

config.addClass(BranchForm.class);

addClass()方法用于加载实体类。

（3）完成配置文件和映射文件的加载后，将得到一个包括所有Hibernate运行期参数的Configuration实例，通过Configuration实例

的buildSessionFactory()方法可以构建一个惟一的SessionFactory，代码如下。

SessionFactory sessionFactory = config.buildSessionFactory();

Session：一般的持久化方法（CRUD）都是通过Session来调用的，Session是非线程安全的。

Session的创建与关闭 ：Session是一个轻量级对象，通常将每个Session实例和一个数据库事务绑定，也就是每执行一个数据库事务，都应该先创建一个新的Session实例，在使用Session后，还需要关闭Session。

Session的创建

创建SessionFactory后，就可以通过SessionFactory创建Session实例，通过SessionFactory创建Session实例的代码如下。

Session session=sessionFactory.openSession();

创建Session后，就可以通过创建的Session进行持久化操作了。

Session的关闭

在创建Session实例后，不论是否执行事务，最后都需要关闭Session实例，释放Session实例占用的资源。

关闭Session实例的代码如下：

session.close();

下面来看一下：getCurrentSession 与 openSession() 的区别

1.getCurrentSession创建的session会和绑定到当前线程,而openSession不会。

2 getCurrentSession创建的线程会在事务回滚或事物提交后自动关闭,而openSession必须手动关闭

3. getCurrentSession () 使用当前的session，openSession() 重新建立一个新的session

这里getCurrentSession本地事务(本地事务:jdbc)时 要在配置文件里进行如下设置

 * 如果使用的是本地事务（jdbc事务）
  thread 
 * 如果使用的是全局事务（jta事务）
  jta 

openSession() 与 getCurrentSession() 有何不同和关联呢？

在 SessionFactory 启动的时候，Hibernate 会根据配置创建相应的 CurrentSessionContext，在 getCurrentSession() 被调用的时候，实际被执行的方法是 CurrentSessionContext.currentSession() 。在 currentSession() 执行时，如果当前 Session 为空，currentSession 会调用 SessionFactory 的 openSession。所以 getCurrentSession() 对于 Java EE 来说是更好的获取 Session 的方法。

事务transaction：Hibernate是对JDBC的轻量级对象封装，Hibernate本身是不具备Transaction处理功能的，Hibernate的Transaction实际上是底层的JDBC Transaction的封装，或者是JTA Transaction的封装，下面我们详细的分析：

Hibernate可以配置为JDBCTransaction或者是JTATransaction，这取决于你在hibernate.properties或者hibernate.cfg.xml中的配置，如果你什么都不配置，默认情况下使用JDBCTransaction，如果你配置为： hibernate.transaction.factory_class =net.sf.hibernate.transaction.JTATransactionFactory 

将使用JTATransaction 。

JDBCTransaction究竟是什么东西呢？来看看源代码就清楚了： 

Hibernate3.3.2源代码中的类 org.hibernate.transaction;.JDBCTransaction: 

[java] 
view plain 
copy 
print 
?

1. publicvoid begin() throws HibernateException {  
3.  …  
5. try {  
7. toggleAutoCommit= jdbcContext.connection().getAutoCommit();  
9. if ( log.isDebugEnabled() ) {  
11. log.debug(“currentautocommitstatus: “ + toggleAutoCommit);  
13. }  
15. if (toggleAutoCommit) {  
17. log.debug(“disabling autocommit”);  
19. jdbcContext.connection().setAutoCommit(false);  
21. }  
23. } … }   

这是启动Transaction的方法，看到 connection().setAutoCommit(false) 了吗？是不是很熟悉？ 再来看 

[java] 
view plain 
copy 
print 
?  

1. publicvoid commit() throws HibernateException {   
3. …   
5. try {  
7. commitAndResetAutoCommit();  
9. log.debug(“committed JDBC Connection”);  
11. committed = true;  
13. if ( callback ) {  
15. jdbcContext.afterTransactionCompletion( true, this );  
17. }  
19. notifyLocalSynchsAfterTransactionCompletion( Status.STATUS_COMMITTED );  
21. }… ; }   
23. commitAndResetAutoCommit方法源码：  
25. privatevoid commitAndResetAutoCommit() throws SQLException {  
27. try {  
29. jdbcContext.connection().commit();  
31. }  
33. finally {  
35. toggleAutoCommit();  
37. }}  

      这是提交方法，看到connection().commit() 了吗？下面就不用我多说了，这个类代码非常简单易懂，通过阅读使我们明白Hibernate的Transaction都在干了些什么？我现在把用Hibernate写的例子翻译成JDBC，大家就一目了然了： 

Connection conn = …; <— session = sf.openSession(); 

conn.setAutoCommit(false); <— tx = session.beginTransactioin(); … <— … conn.commit(); <— tx.commit(); (对应左边的两句)

 conn.setAutoCommit(true); conn.close(); <— session.close(); 

       看明白了吧，Hibernate的JDBCTransaction根本就是conn.commit而已，根本毫无神秘可言，只不过在Hibernate中，Session打开的时候，就会自动conn.setAutoCommit(false)，不像一般的JDBC，默认都是true，所以你最后不写commit也没有关系，由于Hibernate已经把AutoCommit给关掉了，所以用Hibernate的时候，你在程序中不写Transaction的话，数据库根本就没有反应。