import java.util.Iterator;
import java.util.List;

import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;

import com.kela.hb.pojo.KelaStudent;
import com.kela.hb.util.HibernateUtil;

/**
 * @author kangfeng(kela.kf@gmail.com)
 *
 */
public class StudentHQL {
 
  /*
   * 实体查询(查询数据库表中所有的纪录)
   */
  public void exampleSelect_1(){
    Session session;
    Query query;
  
    String hql;
    try {
       session = HibernateUtil.currentSession();
   
       //查询符合相应编号和年龄大于25的学生纪录
       hql = " from com.kela.hb.pojo.KelaStudent as kelaStudent " +
                " where kelaStudent.stuID = '402880fc07dfe16f0107dfe173640001' " +
                " or kelaStudent.stuAge > 25";
      query = session.createQuery(hql);
      List list = query.list();
      Iterator it = list.iterator();
      while(it.hasNext()) {
         KelaStudent kelaStudent = (KelaStudent)it.next();
         System.out.print("    姓名:" + kelaStudent.getStuName());
         System.out.print("    性别:" + kelaStudent.getStuSex());
         System.out.print("    年龄:" + kelaStudent.getStuAge());
         System.out.print("    地址:" + kelaStudent.getStuAddress());
         System.out.println();
       }
    } catch(HibernateException he) {
       System.out.println("[提示]: 查询数据发生错误," + he.getMessage());
    } finally {
       HibernateUtil.closeSession();
    }
 }
 
 /*
  * 属性查询(查询数据库表中需要的若干个字段)
  * 返回类型为数组方式
  */
 public void exampleSelect_2(){
   Session session;
   Query query;
  
   String hql;
   try {
      session = HibernateUtil.currentSession();
   
      //查询KELA_STUDENT中字段为StuName，StuAge，StuAddress的所有纪录
      //同样也可以加一些条件
      hql = " select kelaStudent.stuName, kelaStudent.stuAge, kelaStudent.stuAddress " +
               " from com.kela.hb.pojo.KelaStudent as kelaStudent ";
      query = session.createQuery(hql);
      List list = query.list();
      Iterator it = list.iterator();
      while(it.hasNext()) {
         Object[] rs = (Object[])it.next();
         System.out.print("    姓名:" + rs[0]);
         System.out.print("    年龄:" + rs[1]);
         System.out.print("    地址:" + rs[2]);
         System.out.println();
      }
    } catch(HibernateException he) {
       System.out.println("[提示]: 查询数据发生错误," + he.getMessage());
    } finally {
       HibernateUtil.closeSession();
    }
  }
 
 /*
  * 参数绑定(使用顺序占位符 ? ),相当于我们经常使用的：
  * select * from KELA_STUDENT where KelaID = ?    and KelaAge > ?
  */
  public void exampleSelect_3(){
    Session session;
    Query query;
  
    String hql;
     try {
        session = HibernateUtil.currentSession();
   
        //查询符合相应编号和年龄大于20的学生纪录
       hql = " from KelaStudent as kelaStudent " +
                " where kelaStudent.stuID = ? or kelaStudent.stuAge >= ?";
       query = session.createQuery(hql);
       //注意了是从0开始的
       query.setString(0, "402880fc07dfe16f0107dfe173640001");
       query.setInteger(1, 20);
       List list = query.list();
       Iterator it = list.iterator();
       while(it.hasNext()) {
           KelaStudent kelaStudent = (KelaStudent)it.next();
           System.out.print("    姓名:" + kelaStudent.getStuName());
           System.out.print("    性别:" + kelaStudent.getStuSex());
           System.out.print("    年龄:" + kelaStudent.getStuAge());
           System.out.print("    地址:" + kelaStudent.getStuAddress());
           System.out.println();
       }
    } catch(HibernateException he) {
       System.out.println("[提示]: 查询数据发生错误," + he.getMessage());
    } finally {
       HibernateUtil.closeSession();
    }
  }
 
  /*
   * 参数绑定(使用引用占位符 : ),相当于我们经常使用的：
   * select * from KELA_STUDENT where KelaID = ? and KelaAge > ?
   */
   public void exampleSelect_4(){
     Session session;
     Query query;
  
     String hql;
     try {
        session = HibernateUtil.currentSession();
   
         //查询符合相应编号的学生纪录
         hql = " from KelaStudent as kelaStudent " +
                  " where kelaStudent.stuID = :stuID ";
         query = session.createQuery(hql);
         //stuID 对应 :stuID
         query.setParameter("stuID", "402880fc07dfe16f0107dfe173640001");
         List list = query.list();
         Iterator it = list.iterator();
         while(it.hasNext()) {
             KelaStudent kelaStudent = (KelaStudent)it.next();
             System.out.print("    姓名:" + kelaStudent.getStuName());
             System.out.print("    性别:" + kelaStudent.getStuSex());
             System.out.print("    年龄:" + kelaStudent.getStuAge());
             System.out.print("    地址:" + kelaStudent.getStuAddress());
             System.out.println();
        }
     } catch(HibernateException he) {
         System.out.println("[提示]: 查询数据发生错误," + he.getMessage());
      } finally {
         HibernateUtil.closeSession();
      }
   }
 
   /*
    * 利用HQL的更新
    */
   public void exampleUpdate() {
     Session session;
     Transaction tran;
     Query query;
  
     String hql;
     try {

        session = HibernateUtil.currentSession();
        tran = session.beginTransaction();
   
         hql = " update KelaStudent " +
                  " set stuAge = 30 " +
                  " where stuID = '402880fc07dfe16f0107dfe173640001' ";
         query = session.createQuery(hql);
         System.out.println("更新的纪录条数是:" + query.executeUpdate());
         tran.commit();
     } catch (HibernateException he) {
         System.out.println("[提示]: 更新数据发生错误," + he.getMessage());
     } finally {
          HibernateUtil.closeSession();
      }
   }
 
  /*
   * 利用HQL的删除
   */
  public void exampleDelete() {
    Session session;
    Transaction tran;
    Query query;
  
    String hql;
    try {
        session = HibernateUtil.currentSession();
        tran = session.beginTransaction();
   
        hql = "delete KelaStudent where stuID = '402880fc080437200108043725760001'";
   
       query = session.createQuery(hql);
       System.out.println("删除纪录的条数是：" + query.executeUpdate());
        tran.commit();
     } catch(HibernateException he) {
        System.out.println("[提示]: 删除数据发生错误," + he.getMessage());
     } finally {
         HibernateUtil.closeSession();
     }
  }
  public static void main(String[] args) {
  
      StudentHQL studentHQL = new StudentHQL();
       studentHQL.exampleSelect_1();
  }

}

更多的使用方法和参数,参考Hibernate文档和深入浅出Hibernate等资料。

示例一：StudentCriteriaQuery.java 一个基本 Criteria Query 的查询

/**
 * StudentCriteriaQueryl.java
 *
 * 基于 Criteria Query 的对象化查询
 */
package com.kela.hb.model;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.Example;
import org.hibernate.criterion.Expression;

import com.kela.hb.pojo.KelaStudent;
import com.kela.hb.util.HibernateUtil;

/**
 * @author kangfeng(kela.kf@gmail.com)
 *
 */
public class StudentCriteriaQuery {
 
  /*
   * 带有表达式的 Criteria 查询
   */
   public void exampleSelect_1() {
      Session session;
      Criteria criteria;
      try {
         session = HibernateUtil.currentSession();
         criteria = session.createCriteria(KelaStudent.class);
   
          //关于Expression提供的对应查询限定机制, 可在Hibernate的文档中获得详细资料
          //如果没有一下的查询条件则查询所有的数据库 KELA_STUDENT 的纪录
   
          //查询数据库表 KELA_STUDENT 中　StuName = '邓立强'的纪录,
          //查询条件中的stuName对应com.kela.hb.pojo.KelaStudent的属性stuName
          //criteria.add(Expression.eq("stuName", "邓立强"));
   
          //查询年龄大于25岁的学生纪录
          criteria.add(Expression.gt("stuAge", new Integer(25)));
  
           //如果同时出现几个限定条件,如 StuName = '邓立强'; stuAge > 25 则取交集
   
           KelaStudent kelaStudent = new KelaStudent();
   
           List list = criteria.list();
           Iterator it = list.iterator();
           while(it.hasNext()) {
                kelaStudent = (KelaStudent)it.next();
                System.out.print("  编号:" + kelaStudent.getStuID());
                System.out.print("  名称:" + kelaStudent.getStuName());
                System.out.print("  性别:" + kelaStudent.getStuSex());
                System.out.print("  年龄:" + kelaStudent.getStuAge());
                System.out.print("  地址:" + kelaStudent.getStuAddress());
                System.out.println();
           }
       } catch (HibernateException e) {
            System.out.println("[提示]: 查询没有成功," + e.getMessage());
       } finally {
            HibernateUtil.closeSession();
     }
  }
 
  /*
   * 示例查询,根据已有的对象，查询属性与之相符的其它对象
   */
  public List exampleSelect_2(KelaStudent kelaStudent) {
      Session session;
      Criteria criteria;
      try {
          session = HibernateUtil.currentSession();
          criteria = session.createCriteria(KelaStudent.class);
          criteria.add(Example.create(kelaStudent));
          return criteria.list();
      } catch (HibernateException he) {
         System.out.println("[提示]: 查询发生错误," + he.getMessage());
         return null;
      } finally {
         HibernateUtil.closeSession();
      }
  }
 
  /*
   * 调用示例查询，并打印结果
   * 这种查询并不常用，但是在组合查询中非常的有用途。
   * 比如要查询的条件有多个，但不能确定的时候，可以按照下面的例子使用，直接设定查询的条件，
   * 然 后将对象传入即可查询。
   */
   public void exampleSelect_3() {
      KelaStudent kelaStudent = new KelaStudent();
      //在这里可以设置多个条件，如年龄，地址等
      kelaStudent.setStuName("邓立强");
  
     List list = exampleSelect_2(kelaStudent);
     Iterator it = list.iterator();
     while(it.hasNext()) {
         kelaStudent = (KelaStudent)it.next();
         System.out.print("  编号:" + kelaStudent.getStuID());
         System.out.print("  名称:" + kelaStudent.getStuName());
         System.out.print("  性别:" + kelaStudent.getStuSex());
         System.out.print("  年龄:" + kelaStudent.getStuAge());
         System.out.print("  地址:" + kelaStudent.getStuAddress());
         System.out.println();
     }
  
   }
 
   public static void main(String[] args) {
          StudentCriteriaQuery scq = new StudentCriteriaQuery();
  
          //查询年龄大于25的学生纪录
          scq.exampleSelect_1();

          //按照给定的条件进行查询，这里为 name = '邓立强'
          //scq.exampleSelect_3();
   }  

}

CREATE TABLE [dbo].[KELA_STUDENT] (
 [StuID] [varchar] (32) COLLATE Chinese_PRC_CI_AS NOT NULL ,        -- PK
 [StuName] [varchar] (50) COLLATE Chinese_PRC_CI_AS NULL ,            --学生姓名
 [StuSex] [char] (1) COLLATE Chinese_PRC_CI_AS NULL ,                      --学生性别
 [StuAge] [smallint] NULL ,                                                                             --学生年龄
 [StuAddress] [varchar] (255) COLLATE Chinese_PRC_CI_AS NULL         --学生地址
) ON [PRIMARY]
GO

3. 将 发行包下 ehcache.xml 文件复制到 src 下 
    在Hibernate3中, 如果没有这个文件会出现
        WARN Configurator:126 - No configuration found. Configuring ehcache from ehcache-failsafe.xml found in
         the classpath: jar:file:/D:/J2eeProject/HibernateProject/lib/ehcache-1.1.jar!/ehcache-failsafe.xml
        的错误。
    该文件为 Hibernate 的本身的 Cache 配置。
4. Hibernate 配置
    Hibernate 配置文件主要用于配置数据库连接和Hibernate运行时所需要的各种属性（如，连接池，SQL方言，是否现实SQL日志等）。
    Hibernate 同时支持 xml 格式的配置文件各传统的 properties 文件配置形式，这里采用 xml 。
    配置文件名默认为 hibernate.cfg.xml（或 hibernage.properties），Hibernate在初始化期间自动在 classPath中寻找这个文件，并读取其中的配置信息，并加载。
    以下是 hibernate.cfg.xml 文件（在项目 HibernateProject 的src 下放以下内容）：
<?xml version="1.0" encoding="GB2312"?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
 <session-factory>
  
  <!-- 是否将运行期生成的SQL输出到日志以供调试 -->
  <property name="hibernate.show_sql">
   true
  </property>
  
  <!-- SQL 方言-->
  <property name="hibernate.dialect">
   org.hibernate.dialect.SQLServerDialect
  </property>
  
  <!-- 数据库用户 -->
  <property name="hibernate.connection.username">
   sa
  </property>
  
  <!-- 数据库密码 -->
  <property name="hibernate.connection.password">
   123456
  </property>
  
  <!-- 数据库 JDBC 驱动-->
   <property name="hibernate.connection.driver_class">
   com.microsoft.jdbc.sqlserver.SQLServerDriver
  </property>
  
  <!-- 数据库 URL -->
  <property name="hibernate.connection.url">
   jdbc:microsoft:sqlserver://127.0.0.1:1433;DatabaseName=hbdb
  </property>
  
  <!-- 事务管理类型 -->
  <!-- Hibernate 3 对包名做了修改 （ net.sf.hibernate  => org.hibernate ）-->
  <property name="hibernate.transaction.factory_class">
   org.hibernate.transaction.JDBCTransactionFactory
  </property>
  
  <!-- c3p0 连接池 -->
  <property name="hibernate.connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
  <property name="hibernate.c3p0.max_size">2</property>
  <property name="hibernate.c3p0.min_size">2</property>
  <property name="hibernate.c3p0.timeout">50000</property>
  <property name="hibernate.c3p0.max_statements">100</property>
  <property name="hibernate.c3p0.idle_test_period">3000</property>
  <property name="hibernate.c3p0.acquire_increment">2</property>
  <property name="hibernate.c3p0.validate">false</property>
 
  
  <!-- 映射的配置文件，对应数据库表 KELA_STUDENT 的映射文件，在后面将看到这个文件的配置 -->
  <mapping resource="com/kela/hb/pojo/KelaStudent.hbm.xml"/>
 </session-factory>
</hibernate-configuration>

5. 日志配置
在Hibernate发行包的etc目录下找到 log4j.properties 示例配置文件，可以修改其中的日志级别，也可直接使用。
在src下，放置 log4j.properties 文件，内容如下：
# log4j #
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

log4j.rootLogger=warn, stdout

#设置显示 error以上级别log
log4j.logger.org.hibernate=error 

6. 构建 POJO 类和Hibernate映射( .hbm.xml)文件
        说明：根据数据库定义导出表结构，并自动生成对应的映射文件和POJO java代码，是实际开发当中最常用的方式，也是专家所推荐的。可以使用 MiddleGen -- Hibernate，Hibernate -- Extensions 等的工具，这些工具的使用非常的方便，只修修改相应的 ant 构建文件即可，在网络上可以很容易的找到这些工具的使用方法。
        这里采用手工编写 POJO 和映射文件的方法，是基于开发者更好理解 Hibernate 运作机制而考虑。付出手工编写会产生疏漏和错误的代价，我觉得在学习阶段是值得的。
      以下是这两个文件，他们的位置都在   com.kela.hb.pojo 下面。
POJO类：com.kela.hb.pojo.KelaStudent
 /**
  * KelaStudent.java
  */
package com.kela.hb.pojo;

import java.io.Serializable;

public class KelaStudent implements Serializable {

 private static final long serialVersionUID = 8365163573354176897L;
 
 String stuID;
 String stuName;
 String stuSex;
 Integer stuAge;
 String stuAddress;
 
 public KelaStudent() {
  
 }

 public String getStuAddress() {
  return stuAddress;
 }

 public void setStuAddress(String stuAddress) {
  this.stuAddress = stuAddress;
 }

 public Integer getStuAge() {
  return stuAge;
 }

 public void setStuAge(Integer stuAge) {
  this.stuAge = stuAge;
 }

 public String getStuID() {
  return stuID;
 }

 public void setStuID(String stuID) {
  this.stuID = stuID;
 }

 public String getStuName() {
  return stuName;
 }

 public void setStuName(String stuName) {
  this.stuName = stuName;
 }

 public String getStuSex() {
  return stuSex;
 }

 public void setStuSex(String stuSex) {
  this.stuSex = stuSex;
 }
}

映射文件：KelaStudent.hbm.xml
<?xml version="1.0" encoding="GB2312"?>
<!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.kela.hb.pojo.KelaStudent" table="KELA_STUDENT">
  
  <!-- id 节点配置了表的主键-->
  <id
   name="stuID"                  //POJO类指的ID
   column="StuID"              //数据库中的主键名称
   type="java.lang.String"    //字符类型
  >
    <generator class="uuid.hex"/>   //这里的uuid.hex代表了一种主键的生成方式
  </id>
  
   <property
        name="stuName"       //POJO中的属性
      column="StuName"     //属性对应数据库字段的名称
      type="java.lang.String" //属性类型
     />
  
  <property
      name="stuSex"
      column="StuSex"
      type="java.lang.String"
     />
  
  <property
      name="stuAge"
      column="StuAge"
      type="java.lang.Integer"
     />
  
  <property
      name="stuAddress"
      column="StuAddress"
      type="java.lang.String"
     />
  
 </class>
</hibernate-mapping>

7. 测试代码
HelloTest  . java

package com.kela.test;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;

import com.kela.hb.pojo.KelaStudent;
import com.kela.hb.util.HibernateUtil;

public class HelloTest {

    Session session = null;
 
     public void testInsert() {

        Transaction tran = null;

        try {

           //从  HibernateUtil 得到 hibernate的session,  HibernateUtil .java 文件在后
           session = HibernateUtil.currentSession();
           //启动事务
           tran = session.beginTransaction();
   
           KelaStudent kelaStudent = new KelaStudent();
           //插入数据
           kelaStudent.setStuName("王小二");
           kelaStudent.setStuSex("T");
           kelaStudent.setStuAge(new Integer(26));
           kelaStudent.setStuAddress("甘肃兰州");
          
           //保存并提交事务
           session.save(kelaStudent);
           session.flush();
           tran.commit();
   
        } catch (HibernateException he){
   
           System.out.println("运行中发生了错误");
           try {
               HibernateUtil.closeSession();
           } catch (HibernateException he2) {
               System.out.println("关闭 session 没有成功");
           }
        }
 
    }
 
    public static void main(String[] args) {
        System.out.println(" ========= 开始测试 ==========");
        HelloTest helloTest = new HelloTest();
        helloTest.testInsert();
        System.out.println(" ========= SUCCESS ==========");
    }

}

下面是 HibernateUtil  . java
/**
 * HibernateUtil.java
 */
package com.kela.hb.util;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {

   private static Log log = LogFactory.getLog(HibernateUtil.class);

   private static final SessionFactory sessionFactory;

   static {
       try {
           sessionFactory = new Configuration().configure().buildSessionFactory();
       } catch (Throwable ex) {
           log.error("初始化 SessionFactory 发生错误.", ex);
           throw new ExceptionInInitializerError(ex);
       }
    }

     public static final ThreadLocal session = new ThreadLocal();

     public static Session currentSession() {
         Session s = (Session) session.get();
         if (s == null) {
            s = sessionFactory.openSession();
            session.set(s);
        }
     return s;
    }

    public static void closeSession() {
        Session s = (Session) session.get();
        if (s != null)
           s.close();
        session.set(null);
    }

}

8. 运行结果
    运行 HelloTest.java 文件，观察数据库中的结果，可以看到一条数据被添加了进来。

   数据库结果：
   402880fc07c68f690107c68f6dfd0001          王小二         T         26         甘肃兰州
   
   在控制台看到如下日志：
    Hibernate:
    insert into KELA_STUDENT (StuName, StuSex, StuAge, StuAddress, StuID) values (?, ?, ?, ?, ?)
  
    就是这么神奇。不需要指定 SQL 语句一样能实现SQL的功能。

9. 关于测试代码的解释
    在Hibernate中session完成持久化操作，要创建一个Session实例大致需要3个步骤：
    A. 初始化Hibernate配置管理类Configuration

         //读入默认的配置文件(hibernate.cfg.xml 或 hibernate.properties)来创建一个Configuration
         Configuration config = new Configuration().configure();  
    B. 通过Configuration类的实例来创建 Session 的工厂类 SessionFactory：
        
         SessionFactory sessionFactory = config.buildSessionFactory();

    C. 通过SessionFactory得到Session实例：
  
         session = sessionFactory.openSession();

    D. 通过Session实例完成持久化操作：

           //启动事务
           tran = session.beginTransaction();
   
           KelaStudent kelaStudent = new KelaStudent();
           //插入数据
           kelaStudent.setStuName("王小二");
           kelaStudent.setStuSex("T");
           kelaStudent.setStuAge(new Integer(26));
           kelaStudent.setStuAddress("甘肃兰州");
          
           //保存并提交事务
           session.save(kelaStudent);
           session.flush();
           tran.commit();

      说明：由于SessionFactory采取了线程安全的设计，可以有多个线程并发调用，大多数情况下，一个应用中针对一个数据库共享一个SessionFactory实例即可。
                  Session（这里的Session是Hibernate的Session）可以理解成相当于JDBC 的Connection），它的设计是非线程安全的也就是说一个Session实例只可以由一个线程使用。
                  有了以上两点的考虑，在 HelloTest.java中在得到Session实例使用了：

           //从  HibernateUtil 得到 hibernate的session,  HibernateUtil .java 文件在后
           session = HibernateUtil.currentSession();
          
           在HibernateUtil.java 文件中创建Session，关闭Session。（这段代码来自于Hibernate文档）
           这就相当于我们平时从数据库连接池中得到 Connection，用完了 close.conn() 是一样的道理。

    

               /*
                * 购物结算
                */
                public BigDecimal balance(String userID) {
                      conn = ......
                      try {
                            //获取当前等级， select
                            ......
                     } catch () { }
                     try {
                          //获得打折比率， select
                          //计算实际支付金额
                          ......
                    } catch () { }

                   try {
                        //将支付的金额累计到累积消费中， update
                        //修改客户现有的余额
                        ......
                  } catch () {}

                  //返回实际的消费金额
                  return new BigDecimal(****);
             }
         }
         B. 那另外的一些朋友他们会说，在A里面混杂的业务逻辑和数据访问代码极大的干扰了阅读程序的人，而且这样的代码将给日后的维护带来极大的困难（我也是这样认为哦 ~ ~）。如果我们的实际应用当中的业务逻辑变得非常庞大和复杂的时候，A的做法显然有忧缺点的。于是，就有了下面的改造：
         public calss NetShop {
              ......

              /*
               * 购物结算
               */
             public BigDecimal balance(String userID) {
                A a = new A();
                String gradeStr = null;  //客户级别
                long agioLong = 0.0;

               //获取当前等级
               gradeStr = a.getUserGarde(userID);

               //根据等级计算打折比率
               agioLong = a.getAgio(gradeStr);

               //累计客户消费金额
               a.updateCustMoney(userID, agioLong);

               //修改客户余额
               a.updateUserBalance(userID, agioLong);
        
              //返回消费金额
              return new BigDecimal(****);

            }
         }

          public class A {
               //去实现上面对方法
          }
          可以说B的实现方式，是我（呵呵，大多数可不敢乱说）经常使用的方式，在实际的应用当中结合一些数据库性能上的优化（连接池，预编译语句之类的），基本上已经实现了，业务和数据层的分离。
          然而，在现在客户的应用需求和公司考虑可重用等因素的影响下，我们有不得不去考虑，我们的应用能不能实现严格意义上的跨数据库使用，或者说，我们的应用从一个数据迁移到另外一个数据的时候，是不是只做很少的改动（因为，现在有很多的项目需要引入第三方的产品，它山之石可以攻玉嘛）。带着这样的疑问，那我们是不是会写很多的基于特定数据库的数据层处理代码（当然了，这也是个好办法）。现在我们就要引入Hibernate了，我觉得选择一个比我们自己的实现方式更好的实现方式，是一个更加聪明的决策。那么Hibernate能干什么？
           1）减少乏味的代码
                无论是A方法还是B方法我们都少不了大量的数据库连接，查询，关闭等代码，写得多了也就觉得烦了，Hibernate封装了数据库持久层大多数技术细节，如事物管理，连接管理，sql执行等。
                至少这点，我们是需要的。
           2）更加面向对象的设计
                 就是说像设计对象一样的去设计和操作数据库。这条可能现在还不能理解。
           3）更好的性能
                  我觉得这条好理解多了，系出名门和专家之手的框架，肯定提供了非常优秀的性能优化机制。比如，对连接池，PreparedSatatement 缓存，数据缓存等。这点我们可以大可放心，因为使用者决定了它的优秀。
            4）更好的移植性
                   我们只需要简单得修改其的配置参数，即可实现底层数据库的良好切换（这也是有前提的哦，可不能使用特定数据库都有的特性）。这条的好处是显而易见的。

            关于引入Hibernate有什么好处，我觉得以上就足够了，它确实能帮助我们。