Hibernate有很多值得學習的地方,這里我們簡單介紹一個Hibernate，重點介紹Hibernate部署，希望讀者看后受益匪淺。

一. 什么是hibernate？

答：Hibernate是一個開放源代碼的對象關系映射框架，它對JDBC進行了非常輕量級的對象封裝，使得Java程序員可以隨心所欲的使用對象編程思維來操縱數據庫。 Hibernate可以應用在任何使用JDBC的場合，既可以在Java的客戶端程序使用，也可以在Servlet/JSP的Web應用中使用，最具革命意義的是，Hibernate可以在應用EJB的J2EE架構中取代CMP，完成數據持久化的重任。

二. 快速構建。

在此先要說明一下。由于本人懶惰，記不住hibernate的配置選項，所以，此系列的實例都是使用myeclipse進行快速開發。各位對myeclipse不齒的，就請見諒。然后，數據庫都是mysql。
下面開始利用hibernate進行數據庫的訪問。
需求：實現對用戶的增、刪、改、查。為了方便，用戶就2個屬性 用戶ID和用戶名。實體模型如下：

建立工程:HibernateQuickUse，并且建立包。如下：

根據實體，創建類User，代碼如下：

 
package org.py.hib.quickstart;  
 
/**  
 * User entity.  
 * @author MyEclipse Persistence Tools  
 */  
 
@SuppressWarnings("serial")  
public class User implements java.io.Serializable  
{  
 private String id;  
 private String name;  
 
 public User()  
 {  
 }  
 
 public String getId()  
 {  
  return this.id;  
 }  
 
 public void setId(String id)  
 {  
  this.id = id;  
 }  
 
 public String getName()  
 {  
  return this.name;  
 }  
 
 public void setName(String name)  
 {  
  this.name = name;  
 }  
}  

根據hibernate實體，創建數據表。sql如下：

use HibernateQuickUse;  
drop table if exists User;  
 
create table user (  
 id varchar(32) primary key,  
 name varchar(32)  
);  

這里的id，我沒有采用Integer auto_increment, 原因是為了數據庫的數據能方便的導入到另外一種數據庫里面，比方說：oracle。當然，這個是以犧牲部分效率為前提的。因為id是integer的，能更加快速查詢。不過，從數據庫會自動為 primary key 建立 index來看，效率也不會相差太多。
要想通過hibernate訪問數據庫。首先要建立描述數據庫的文件：hibernate.cfg.xml。放到src下面。內容如下：

xml version='1.0' encoding='UTF-8'?> 
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"  
          "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"> 
 
<hibernate-configuration> 
 
 <session-factory> 
  <property name="dialect">org.hibernate.dialect.MySQLDialectproperty> 
  <property name="connection.url">jdbc:mysql://localhost:3306/hibernatequickUseproperty> 
  <property name="connection.username">rootproperty> 
  <property name="connection.password">rootproperty> 
  <property name="connection.driver_class">com.mysql.jdbc.Driverproperty> 
    
  <property name="show_sql">trueproperty> 
  <mapping resource="org/py/hib/quickstart/User.hbm.xml" /> 
 
   
 session-factory> 
 
hibernate-configuration> 
 

說說上面的 "dialect", 這個對應著hibernate生成哪種數據庫的sql。然后是："show_sql", 這個是為了調試時候輸出sql語句到屏幕用的。

注意"mapping resource"部分。這個部分表示你的 實體- 數據庫 映射文件的位置。（什么是實體-數據庫 映射文件，看下面。）

 實體-數據庫映射文件 -- 主要是告訴hibernate，這個User類，對應著哪個table，User類里面的那個屬性對應著table里面的哪個字段。我們可以建立 實體-數據庫 的xml映射文件，也可以采用Annotations映射，但是目前只說xml映射方式。如下：

xml version="1.0" encoding="utf-8"?> >  <hibernate-mapping>  <class name="org.py.hib.quickstart.User" table="user">                 <id name="id" type="java.lang.String" column="id" length="32">    <generator class="uuid" />   id>    <property name="name"  type="java.lang.String" column="name" length="32" />  class> hibernate-mapping>    

上面的xml還是很好理解的。注意一個generator中的class，他可以有很多。我們這用的是uuid。什么是uuid。這個可以google一下。呵呵。google是最好的教科書。還能有很多其他的，比方說：native。具體的同樣請教google。有了上面的準備，那么我們開始來測試一下。這里我們用junit。具體怎么使用junit，呵呵。答案我想大家都知道了，也不用我說了。其實我對test 和 使用它也不熟練。

我把測試用力放到了test/org.py.hib.quickstart下面。代碼如下：

package org.py.hib.quickstart;  
 
import junit.framework.Assert;  
import junit.framework.TestCase;  
 
import org.hibernate.Session;  
import org.hibernate.SessionFactory;  
import org.hibernate.Transaction;  
import org.hibernate.cfg.Configuration;  
import org.junit.After;  
import org.junit.Before;  
 
public class QuickStartTest extends TestCase  
{  
 SessionFactory factory;  
 
 String m_name = "ryanpoy";  
 
 String m_name2 = "ryanpoy2";  
 
 @Before  
 public void setUp() throws Exception  
 {  
  Configuration conf = new Configuration().configure();  
  factory = conf.buildSessionFactory();  
 }  
 
 /**  
  * 測試添加  
  * @throws Exception  
  */  
 public void testSave() throws Exception  
 {  
  System.out.println("\n=== test save ===");  
  User u = new User();  
  u.setName(m_name); // 設置用戶名 = m_name  
 
  Session session = null;  
  Transaction tran = null;  
  try  
  {  
   session = factory.openSession();  
   tran = session.beginTransaction();  
   session.save(u);  
   tran.commit();  
 
   Assert.assertEquals(u.getId() != null, true);  
  } catch (Exception ex)  
  {  
   tran.rollback();  
   throw ex;  
  } finally  
  {  
   if (session != null)  
   {  
    try  
    {  
     session.close();  
    } catch (Exception ex)  
    {  
     // nothing to do  
    } finally  
    {  
     if (session != null)  
      session = null;  
    }  
   }  
  }  
 }  
 
 /**  
  * 測試查詢  
  * @throws Exception  
  */  
 public void testFind() throws Exception  
 {  
  System.out.println("\n=== test find ===");  
  Session session = null;  
  try  
  {  
   session = factory.openSession();  
   User u = (User) session.createQuery("from User").list().get(0);  
 
   Assert.assertEquals(true, u.getId() != null);  
   Assert.assertEquals(m_name, u.getName());  
  } catch (Exception ex)  
  {  
   throw ex;  
  } finally  
  {  
   if (session != null)  
   {  
    try  
    {  
     session.close();  
    } catch (Exception ex)  
    {  
     // nothing to do  
    } finally  
    {  
     if (session != null)  
      session = null;  
    }  
   }  
  }  
 }  
 
 /**  
  * 測試修改  
  * @throws Exception  
  */  
 public void testModify() throws Exception  
 {  
  System.out.println("\n=== test modify ===");  
  Session session = null;  
  Transaction tran = null;  
  try  
  {  
   session = factory.openSession();  
   tran = session.beginTransaction();  
 
   User u = (User) session.createQuery("from User").list().get(0);  
   u.setName(m_name2);  // 修改用戶名 = m_name2.（原來用戶名= m_name）  
   tran.commit();  
 
  } catch (Exception ex)  
  {  
   throw ex;  
  } finally  
  {  
   if (session != null)  
   {  
    try  
    {  
     session.close();  
    } catch (Exception ex)  
    {  
     // nothing to do  
    } finally  
    {  
     if (session != null)  
      session = null;  
    }  
   }  
  }  
 
  /*  
   * 修改后再查詢  
   */  
  System.out.println("\n=== test find after modify ===");  
  try  
  {  
   session = factory.openSession();  
   User u = (User) session.createQuery("from User").list().get(0);  
 
   Assert.assertEquals(true, u.getId() != null);  
   Assert.assertEquals(m_name2, u.getName());  
  } catch (Exception ex)  
  {  
   throw ex;  
  } finally  
  {  
   if (session != null)  
   {  
    try  
    {  
     session.close();  
    } catch (Exception ex)  
    {  
     // nothing to do  
    } finally  
    {  
     if (session != null)  
      session = null;  
    }  
   }  
  }  
 }  
 
 /**  
  * 測試刪除  
  * @throws Exception  
  */  
 public void testDelete() throws Exception  
 {  
  System.out.println("\n=== test delete ===");  
  Session session = null;  
  Transaction tran = null;  
  try  
  {  
   session = factory.openSession();  
   tran = session.beginTransaction();  
 
   User u = (User) session.createQuery("from User").list().get(0);  
   session.delete(u);  
   tran.commit();  
 
  } catch (Exception ex)  
  {  
   throw ex;  
  } finally  
  {  
   if (session != null)  
   {  
    try  
    {  
     session.close();  
    } catch (Exception ex)  
    {  
     // nothing to do  
    } finally  
    {  
     if (session != null)  
      session = null;  
    }  
   }  
  }  
 
  /*  
   * 刪除后再查詢  
   */  
  System.out.println("\n=== test find after delete ===");  
  try  
  {  
   session = factory.openSession();  
   Integer num = (Integer) session.createQuery("from User").list().size();  
 
   Assert.assertEquals(0, num.intValue());  
  } catch (Exception ex)  
  {  
   throw ex;  
  } finally  
  {  
   if (session != null)  
   {  
    try  
    {  
     session.close();  
    } catch (Exception ex)  
    {  
     // nothing to do  
    } finally  
    {  
     if (session != null)  
      session = null;  
    }  
   }  
  }  
 }  
 
 /**  
  *   
  */  
 @After  
 public void tearDown() throws Exception  
 {  
  factory.close();  
 }  
 
}  

運行后，我們很欣慰的看到一路綠燈，全部通過了。那么測試沒有問題。呵呵(這里的測試可能還不完善。請大家指出。前面說過，我對測試這塊也不熟)。
看控制臺，會輸出如下信息：

=== test save ===  
Hibernate: insert into hibernatequickuse.user (name, id) values (?, ?)  
 
=== test find ===  
Hibernate: select user0_.id as id2_, user0_.name as name2_ from hibernatequickuse.user user0_ 
 
=== test modify ===  
Hibernate: select user0_.id as id4_, user0_.name as name4_ from hibernatequickuse.user user0_  
Hibernate: update hibernatequickuse.user set name=? where id=?  
 
=== test find after modify ===  
Hibernate: select user0_.id as id4_, user0_.name as name4_ from hibernatequickuse.user user0_ 
 
=== test delete ===  
Hibernate: select user0_.id as id6_, user0_.name as name6_ from hibernatequickuse.user user0_  
Hibernate: delete from hibernatequickuse.user where id=?  
 
=== test find after delete ===  
Hibernate: select user0_.id as id6_, user0_.name as name6_ from hibernatequickuse.user user0_  
 

   【編輯推薦】

1. Linq委托實例化淺談
2. Hibernate流行架構淺析
3. 淺析Hibernate 3二級緩存基礎
4. Hibernate update淺談
5. ASP.NET和PHP性能之戰再續：背景與延伸思考