3、Hibernate的DAO實現
DAO對象是模塊化的數據庫訪問組件，DAO對象通常包括：對持久化類的基本CRUD操作（插入、查詢、更新、刪除）操作。Spring對Hibernate的DAO實現提供了良好的支持。主要有如下兩種方式的DAO實現：
繼承HibernateDaoSupport的實現DAO
基于Hibernate3.0實現DAO
不管采用哪一種實現，這種DAO對象都極好地融合到Spring的ApplicationContext中，遵循依賴注入模式，提高解耦。
繼承HibernateDaoSupport實現DAO
Spring為Hibernate的DAO提供工具類：HibernateDaoSupport。該類主要提供如下兩個方法，方便DAO的實現：
public final HibernateTemplate getHibernateTemplate()
public final void setSessionFactory(SessionFactory sessionFactory)
其中，setSessionFactory方法用來接收Spring的ApplicationContext的依賴注入，可接收配置在Spring的SessionFactory實例，getHibernateTemplate方法則用來根據剛才的SessionFactory產生Session，最后生成HibernateTemplate來完成數據庫訪問。
HibernateTemplate的常規用法
HibernateTemplate提供非常多的常用方法來完成基本的操作，比如通常的增加、刪除、修改、查詢等操作，Spring 2.0更增加對命名SQL查詢的支持，也增加對分頁的支持。大部分情況下，使用Hibernate的常規用法，就可完成大多數DAO對象的CRUD操作。下面是HibernateTemplate的常用方法簡介：
void delete(Object entity)：刪除指定持久化實例
deleteAll(Collection entities)：刪除集合內全部持久化類實例
find(String queryString)：根據HQL查詢字符串來返回實例集合
findByNamedQuery(String queryName)：根據命名查詢返回實例集合
get(Class entityClass, Serializable id)：根據主鍵加載特定持久化類的實例
save(Object entity)：保存新的實例
saveOrUpdate(Object entity)：根據實例狀態，選擇保存或者更新
update(Object entity)：更新實例的狀態，要求entity是持久狀態
setMaxResults(int maxResults)：設置分頁的大小
Hibernate的復雜用法HibernateCallback
HibernateTemplate還提供一種更加靈活的方式來操作數據庫，通過這種方式可以完全使用Hibernate的操作方式。HibernateTemplate的靈活訪問方式是通過如下兩個方法完成：
Object execute(HibernateCallback action)
List execute(HibernateCallback action)
這兩個方法都需要一個HibernateCallback的實例，HibernateCallback實例可在任何有效的Hibernate數據訪問中使用。程序開發者通過HibernateCallback，可以完全使用Hibernate靈活的方式來訪問數據庫，解決Spring封裝Hibernate后靈活性不足的缺陷。HibernateCallback是一個接口，該接口只有一個方法doInHibernate(org.hibernate.Session session)，該方法只有一個參數Session。
通常，程序中采用實現HibernateCallback的匿名內部類來獲取HibernateCallback的實例，方法doInHibernate的方法體就是Spring執行的持久化操作
注意：方法doInHibernate方法內可以訪問Session，該Session對象是綁定到該線程的Session實例。該方法內的持久層操作，與不使用Spring時的持久層操作完全相同。這保證對于復雜的持久層訪問，依然可以使用Hibernate的訪問方式。
下面，讓我們看一下接 CRUD的一些方法的實現吧：
import java.io.Serializable;
import java.sql.SQLException;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang.StringUtils;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.ObjectRetrievalFailureException;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import test.dao.Dao;
public class DaoImpl extends HibernateDaoSupport implements Dao{
public List findAllBy(final Class clazz, final String name, final Object value) {
// 實現根據屬性名和屬性值查詢對象，返回唯一對象
return getHibernateTemplate().executeFind(new HibernateCallback(){
public Object doInHibernate(Session session) throws HibernateException,SQLException{
Criteria criteria=session.createCriteria(clazz);
criteria.add(Restrictions.eq(name, value));
criteria.setCacheable(true);
return criteria.list();
}
});
}
public List findAllBy(final Class clazz, final Map filter,final Map sorMap,final int pageNo,final int pageSize) {
// 實現返回 根據Map中過濾條件和分頁參數查詢
return getHibernateTemplate().executeFind(new HibernateCallback(){
public Object doInHibernate(Session session) throws HibernateException,SQLException{
Criteria criteria=session.createCriteria(clazz);
filterCriteria(criteria, filter);
sortCriteria(criteria,sorMap);
if (pageNo != -1) {
criteria.setFirstResult(pageNo > 1
? (pageNo - 1) * pageSize
: 0);
criteria.setMaxResults(pageSize);
}
criteria.setCacheable(true);
return criteria.list();
}
});
}
/**
* 構造criteria的過濾條件的回調函數
*/
protected void filterCriteria(Criteria criteria, Map filter) {
if (MapUtils.isNotEmpty(filter)) {
for (Iterator iterator = filter.keySet().iterator(); iterator.hasNext();) {
String fieldName = (String) iterator.next();
criteria.add(Restrictions.eq(fieldName, filter.get(fieldName)));
}
}
}
/**
* 構造Criteria的排序條件.
*
* @param sortMap 排序條件.
* @param criteria Criteria實例.
*/
protected void sortCriteria(Criteria criteria, Map sortMap) {
if (MapUtils.isNotEmpty(sortMap)) {
for (Iterator iterator = sortMap.keySet().iterator(); iterator.hasNext();) {
String fieldName = (String) iterator.next();
String orderType = (String) sortMap.get(fieldName);
criteria.addOrder(StringUtils.equalsIgnoreCase("asc", orderType)
? Order.asc(fieldName)
: Order.desc(fieldName));
}
}
}
public Object findBy(final Class clazz, final String name, final Object value) {
// 實現根據對象屬性名和屬性值，返回唯一對象
return getHibernateTemplate().execute(new HibernateCallback(){
public Object doInHibernate(Session session) throws HibernateException, SQLException {
// TODO Auto-generated method stub
Criteria criteria=session.createCriteria(clazz);
criteria.add(Restrictions.eq(name,value));
List list=criteria.list();
return list==null ||list.isEmpty()?null:list.iterator().next();
}
});
}
public Object getObject(Class clazz, Serializable id) {
// 實現返回與此類對應主鍵為id的所有值
Object o=getHibernateTemplate().get(clazz, id);
if(o==null){
throw new ObjectRetrievalFailureException(clazz,id);
}
return o;
}
public List getObjects(Class clazz) {
// 實現返回entity類型值
return getHibernateTemplate().loadAll(clazz);
}
public void removeObject(Class clazz, Serializable id) {
// 實現根據數據庫中與此類對應表的主鍵（id）刪除此對象
getHibernateTemplate().delete(getObject(clazz,id));
}
public void removeObject(Object o) {
// 實現刪除對象
getHibernateTemplate().delete(o);
}
public void removeObjects(Collection objects) {
// TODO Auto-generated method stub
getHibernateTemplate().deleteAll(objects);
}
public Serializable saveObject(Object o) {
// 實現序列化保存對象
return getHibernateTemplate().save(o);
}
public int total(Class clazz, Map filter) {
return 0;
// TODO Auto-generated method stub
}
public void updateObject(Object o) {
// 實現更新對象
getHibernateTemplate().update(o);
}
}
然后，我們要配置.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE
beans
PUBLIC
"-//SPRING//DTD BEAN 2.0//EN"
"http://www.springframework.org/dtd/spring-beans-2.0.dtd">
<beans>
<bean
id="Dao"
class="test.dao.hibernate.DaoImpl">
<property
name="sessionFactory"
ref="sessionFactory" />
</bean>
</beans>
首先，我們先要理解一下相關知識點：
1、對象的序列化：Serializable
對象序列化是對象永久化的一種機制，可以把序列化當成一種深度克隆的方法，確切的說應該是對象的序列化，一般程序在運行時，產生對象，這些對象隨著程序的停止運行而消失，但如果我們想把某些對象（因為是對象，所以有各自不同的特性）保存下來，在程序終止運行后，這些對象仍然存在，可以在程序再次運行時讀取這些對象的值，或者在其他程序中利用這些保存下來的對象。這種情況下就要用到對象的序列化。一般對象序列化后會保存在存儲設備（硬盤）上，以文件的形式出現。
2、CRUD
CRUD是增加、讀取、更新和刪除幾個單詞的首字母簡寫 即Create,Read,Update,Delete四個單詞的縮寫，主要被用在描述軟件系統中數據庫或者持久層的基本操作功能。
(In computing, CRUD is an acronym for
create, retrieve, update, and delete. It is used to refer to the basic
functions of a database or persistence layer in a software system.)
在進行Hibernate開發過程中，我們通常會使用DAO模式，有一些通用的數據操作方法，如CRUD，我們通常會將這些方法集中在一個DAO，這樣會簡便很多。DAO數據訪問接口如下：
import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import java.util.Map;
public interface Dao {
List getObjects(Class clazz);//返回數據庫中與此類對應的表的所有值，即entity類型中的所有信息
Object getObject(Class clazz, Serializable id);//返回與此類對應的表主鍵為id的所有值
Serializable saveObject(Object o);//序列化保存對象。
void updateObject(Object o);//更新此對象
void removeObject(Class clazz, Serializable id);//根據數據庫中與此類對應表的主鍵（id）刪除此對象
void removeObject(Object o);//刪除此對象
void removeObjects(Collection objects);
/*
* 根據屬性名和屬性值查詢對象，返回唯一對象
*/
Object findBy(Class clazz, String name, Object value);
/*
* 根據屬性名和屬性值查詢對象，返回所以符合條件的對象
*/
List findAllBy(Class clazz, String name, Object value);
/**
* 根據Map中過濾條件和分頁參數查詢.
*
* @param filter 過濾條件.
* @param sortMap 排序條件.
* @param pageNo 當前頁碼
* @param pageSize 每頁顯示記錄數.
*/
List findAllBy(Class clazz, Map filter, Map sorMap, int pageNo, int pageSize);
/**
* 符合filter過濾條件的記錄總數
* @param clazz
* @param filter
* @return
*/
int total(Class clazz, Map filter);
}