【前言】hibernate作為持久層ORM技術(shù)，它對JDBC進(jìn)行非常輕量級對象封裝，使得我們可以隨心所欲的使用面向對象的思想來(lái)操作數據庫。同時(shí)，作為后臺開(kāi)發(fā)的支撐，的確扮演了一個(gè)舉足輕重的角色，那么我們在項目中如何靈活應用hibernate，也會(huì )給項目維護以及項目開(kāi)發(fā)帶來(lái)便利，下面我將展示我們項目中是如何來(lái)對hibernate進(jìn)行應用和操作。
【目錄】
-----1.自定義異常
-----2.泛型Dao搭建(SimpleHibernateDao)
-----3.hibernate與spring整合
【內容】
一、自定義異常（BussienssException),相信大家對java異常處理機制還是比較熟悉，我們在業(yè)務(wù)層定義異常，那么可以對Jdbc中出現的如SqlException,DataAccessException進(jìn)行統一處理，這樣做的好處是，便于我們向前臺發(fā)送異常消息，記錄異常信息日志，控制事務(wù)回滾，下面就講BussienssException羅列出來(lái)，其實(shí)很簡(jiǎn)單：
/**
* @author fisher
* @description 自定義業(yè)務(wù)異常
*/
public class ServiceException extends RuntimeException {
/**
*
*/
private static final long serialVersionUID = 1L;
public ServiceException() {
super();
}
public ServiceException(String message) {
super(message);
}
public ServiceException(Throwable cause) {
super(cause);
}
public ServiceException(String message, Throwable cause) {
super(message, cause);
}
}
復制代碼
二：hibernate泛型Dao（SimpleHibernateDao），封裝了原生hibernateAPI操作，實(shí)現了對不同Pojo對象進(jìn)行操作，解決了常用的Crud，代碼注釋寫(xiě)得很詳細，我就不啰嗦了，具體看代碼：
/**
* 封裝Hibernate原生API的DAO泛型基類(lèi).
*
* 可在Service層直接使用, 也可以擴展泛型DAO子類(lèi)使用, 見(jiàn)兩個(gè)構造函數的注釋. 參考Spring2.5自帶的Petlinc例子,
* 取消了HibernateTemplate, 直接使用Hibernate原生API.
*
* @param <T>
* DAO操作的對象類(lèi)型
* @param <PK>
* 主鍵類(lèi)型
*
* @author
*/
@SuppressWarnings("unchecked")
public class SimpleHibernateDao<T, PK extends Serializable> {
protected Logger logger = LoggerFactory.getLogger(getClass());
protected SessionFactory sessionFactory;
protected Class<T> entityClass;
/**
* 用于Dao層子類(lèi)使用的構造函數. 通過(guò)子類(lèi)的泛型定義取得對象類(lèi)型Class. eg. public class UserDao extends
* SimpleHibernateDao<User, Long>
*/
public SimpleHibernateDao() {
this.entityClass = ReflectionUtils.getSuperClassGenricType(getClass());
}
/**
* 用于用于省略Dao層, 在Service層直接使用通用SimpleHibernateDao的構造函數. 在構造函數中定義對象類(lèi)型Class.
* eg. SimpleHibernateDao<User, Long> userDao = new SimpleHibernateDao<User,
* Long>(sessionFactory, User.class);
*/
public SimpleHibernateDao(final SessionFactory sessionFactory,
final Class<T> entityClass) {
this.sessionFactory = sessionFactory;
this.entityClass = entityClass;
}
/**
* 取得sessionFactory.
*/
public SessionFactory getSessionFactory() {
return sessionFactory;
}
/**
* 采用@Autowired按類(lèi)型注入SessionFactory, 當有多個(gè)SesionFactory的時(shí)候在子類(lèi)重載本函數.
*/
@Autowired
public void setSessionFactory(final SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}
/**
* 取得當前Session.
*/
public Session getSession() {
return sessionFactory.getCurrentSession();
}
/**
* 保存新增或修改的對象.
*/
public void save(final T entity) {;
getSession().saveOrUpdate(entity);
logger.debug("save entity: {}", entity);
}
/**
* 刪除對象.
*
* @param entity
* 對象必須是session中的對象或含id屬性的transient對象.
*/
public void delete(final T entity) {
getSession().delete(entity);
logger.debug("delete entity: {}", entity);
}
/**
* 按id刪除對象.
*/
public void delete(final PK id) {
delete(get(id));
logger.debug("delete entity {},id is {}", entityClass.getSimpleName(),
id);
}
/**
* 按id獲取對象.
*/
public T get(final PK id) {
return (T) getSession().load(entityClass, id);
}
/**
* 按id列表獲取對象列表.
*/
public List<T> get(final Collection<PK> ids) {
return find(Restrictions.in(getIdName(), ids));
}
/**
* 獲取全部對象.
*/
public List<T> getAll() {
return find();
}
/**
* 獲取全部對象, 支持按屬性行序.
*/
public List<T> getAll(String orderByProperty, boolean isAsc) {
Criteria c = createCriteria();
if (isAsc) {
c.addOrder(Order.asc(orderByProperty));
} else {
c.addOrder(Order.desc(orderByProperty));
}
return c.list();
}
/**
* 按屬性查找對象列表, 默認匹配方式為L(cháng)ike.
*/
public List<T> findByProperty(final String propertyName, final Object value) {
Assert.hasText(propertyName, "propertyName不能為空");
Criterion criterion = Restrictions.like(propertyName, (String) value,
MatchMode.ANYWHERE);
return find(criterion);
}
/**
* 按屬性查找唯一對象, 默認匹配方式為L(cháng)ike.
*/
public T findUniqueByProperty(final String propertyName, final Object value) {
Assert.hasText(propertyName, "propertyName不能為空");
Criterion criterion = Restrictions.like(propertyName, (String) value,
MatchMode.ANYWHERE);
return (T) createCriteria(criterion).uniqueResult();
}
/**
* 按HQL查詢(xún)對象列表.
*
* @param <X>
*
* @param values
* 數量可變的參數,按順序綁定.
*/
public <X> List<X> find(final String hql, final Object... values) {
return createQuery(hql, values).list();
}
/**
* 按HQL查詢(xún)對象列表.
*
* @param values
* 命名參數,按名稱(chēng)綁定.
*/
public <X> List<X> find(final String hql, final Map<String, ?> values) {
return createQuery(hql, values).list();
}
/**
* 按HQL查詢(xún)唯一對象.
*
* @param values
* 數量可變的參數,按順序綁定.
*/
public <X> X findUnique(final String hql, final Object... values) {
return (X) createQuery(hql, values).uniqueResult();
}
/**
* 按HQL查詢(xún)唯一對象.
*
* @param values
* 命名參數,按名稱(chēng)綁定.
*/
public <X> X findUnique(final String hql, final Map<String, ?> values) {
return (X) createQuery(hql, values).uniqueResult();
}
/**
* 執行HQL進(jìn)行批量修改/刪除操作.
*
* @param values
* 數量可變的參數,按順序綁定.
* @return 更新記錄數.
*/
public int batchExecute(final String hql, final Object... values) {
return createQuery(hql, values).executeUpdate();
}
/**
* 執行HQL進(jìn)行批量修改/刪除操作.
*
* @param values
* 命名參數,按名稱(chēng)綁定.
* @return 更新記錄數.
*/
public int batchExecute(final String hql, final Map<String, ?> values) {
return createQuery(hql, values).executeUpdate();
}
/**
* 根據查詢(xún)HQL與參數列表創(chuàng )建Query對象. 與find()函數可進(jìn)行更加靈活的操作.
*
* @param values
* 數量可變的參數,按順序綁定.
*/
public Query createQuery(final String queryString, final Object... values) {
Assert.hasText(queryString, "queryString不能為空");
Query query = getSession().createQuery(queryString);
if (values != null) {
for (int i = 0; i < values.length; i++) {
query.setParameter(i, values[i]);
}
}
return query;
}
/**
* 根據查詢(xún)HQL與參數列表創(chuàng )建Query對象. 與find()函數可進(jìn)行更加靈活的操作.
*
* @param values
* 命名參數,按名稱(chēng)綁定.
*/
public Query createQuery(final String queryString,
final Map<String, ?> values) {
Query query = getSession().createQuery(queryString);
if (values != null) {
query.setProperties(values);
}
return query;
}
/**
* 按Criteria查詢(xún)對象列表.
*
* @param criterions
* 數量可變的Criterion.
*/
public List<T> find(final Criterion... criterions) {
return createCriteria(criterions).list();
}
/**
* 按Criteria查詢(xún)唯一對象.
*
* @param criterions
* 數量可變的Criterion.
*/
public T findUnique(final Criterion... criterions) {
return (T) createCriteria(criterions).uniqueResult();
}
/**
* 根據Criterion條件創(chuàng )建Criteria. 與find()函數可進(jìn)行更加靈活的操作.
*
* @param criterions
* 數量可變的Criterion.
*/
public Criteria createCriteria(final Criterion... criterions) {
Criteria criteria = getSession().createCriteria(entityClass);
for (Criterion c : criterions) {
criteria.add(c);
}
return criteria;
}
/**
* 初始化對象. 使用load()方法得到的僅是對象Proxy, 在傳到View層前需要進(jìn)行初始化. 如果傳入entity,
* 則只初始化entity的直接屬性,但不會(huì )初始化延遲加載的關(guān)聯(lián)集合和屬性. 如需初始化關(guān)聯(lián)屬性,需執行:
* Hibernate.initialize(user.getRoles())，初始化User的直接屬性和關(guān)聯(lián)集合.
* Hibernate.initialize
* (user.getDescription())，初始化User的直接屬性和延遲加載的Description屬性.
*/
public void initProxyObject(Object proxy) {
Hibernate.initialize(proxy);
}
/**
* Flush當前Session.
*/
public void flush() {
getSession().flush();
}
/**
* 為Query添加distinct transformer. 預加載關(guān)聯(lián)對象的HQL會(huì )引起主對象重復, 需要進(jìn)行distinct處理.
*/
public Query distinct(Query query) {
query.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
return query;
}
/**
* 為Criteria添加distinct transformer. 預加載關(guān)聯(lián)對象的HQL會(huì )引起主對象重復, 需要進(jìn)行distinct處理.
*/
public Criteria distinct(Criteria criteria) {
criteria.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
return criteria;
}
/**
* 取得對象的主鍵名.
*/
public String getIdName() {
ClassMetadata meta = getSessionFactory().getClassMetadata(entityClass);
return meta.getIdentifierPropertyName();
}
/**
* 判斷對象的屬性值在數據庫內是否唯一.
*
* 在修改對象的情景下,如果屬性新修改的值(value)等于屬性原來(lái)的值(orgValue)則不作比較.
*/
public boolean isPropertyUnique(final String propertyName,
final Object newValue, final Object oldValue) {
if (newValue == null || newValue.equals(oldValue)) {
return true;
}
Object object = findUniqueByProperty(propertyName, newValue);
return (object == null);
}
}
復制代碼
三、spring與hibernate整合，關(guān)于spring與hibernate的整合問(wèn)題，我分兩步來(lái)談：
1.配置spring的數據源Datasource,關(guān)系配置數據庫連接，相信很多童鞋對它很熟悉，我們要獲取數據庫連接，首先是從連接池中去找，那么常用的連接池分3種（DBCP,C3P0，Proxool），這里以mysql與DBCP為例：
datasource.properties:
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost/test?useUnicode=true&characterEncoding=utf-8
jdbc.username=root
jdbc.password=
復制代碼
applicationContext.xml
<!-- 定義屬性文件路徑 -->
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<list>
<!-- 標準配置,路徑都以項目classpath為準-->
<value>classpath:/datasource.properties</value>
</list>
</property>
</bean>
<!-- 數據源配置, 使用應用中的DBCP數據庫連接池 -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<!-- Connection Info -->
<property name="driverClassName" value="${jdbc.driver}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
<!-- Connection Pooling Info -->
<property name="maxActive" value="${dbcp.maxActive}" />
<property name="maxIdle" value="${dbcp.maxIdle}" />
<property name="defaultAutoCommit" value="false" />
<property name="timeBetweenEvictionRunsMillis" value="3600000"/>
<property name="minEvictableIdleTimeMillis" value="3600000"/>
</bean>
復制代碼
2.配置Sessionfactory、transactionManager，這樣我們就有了對事務(wù)的控制、以及可以獲取到hibernate的會(huì )話(huà)。
applicationContext.xml：
<!-- Hibernate配置 -->
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"">
<property name="dataSource" ref="dataSource" />
<property name="mappingLocations">
<list>
<value>這里是Hbm文件</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">${hibernate.dialect}</prop>
<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
<prop key="hibernate.format_sql">${hibernate.format_sql}</prop>
<prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop>
<prop key="hibernate.cache.provider_configuration_file_resource_path">ehcache/ehcache-hibernate-local.xml</prop>
</props>
</property>
</bean>
<!--注入simplehibernateDao-->
<bean id="simplehibernateDao" class="com.dao.SimpleHibernateDao">
復制代碼
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
<!--####{事務(wù)管理器}#### -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<!-- ####{事務(wù)傳播特性 }#### -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="save*" propagation="REQUIRED" rollback-for="Exception"/>
<tx:method name="update*" propagation="REQUIRED" rollback-for="Exception"/>
<tx:method name="delete*" propagation="REQUIRED" rollback-for="Exception"/>
<tx:method name="get*" propagation="SUPPORTS" read-only="true" />
<tx:method name="*" read-only="false" />
</tx:attributes>
</tx:advice>
<!-- ####{配置切入點(diǎn)和通知}#### -->
<aop:config>
<aop:pointcut id="allServiceMethod" expression="execution(* com.mis.service..*.*(..))" />
<aop:advisor pointcut-ref="allServiceMethod" advice-ref="txAdvice" />
<aop:aspect id="logBean" ref="systemLogAspectService">
<aop:before method="beforeCut" pointcut-ref="allServiceMethod"/>
<aop:after method="afterCut" pointcut-ref="allServiceMethod"/>
</aop:aspect>
</aop:config>
復制代碼
【總結】 關(guān)于持久層的技術(shù)，hibernat它的優(yōu)勢非常明顯，能讓java程序員很直觀(guān)去通過(guò)對象去操作數據庫，但是在處理報表或者非常復雜的數據庫查詢(xún)的時(shí)候也顯得有點(diǎn)棘手，上面的泛型dao只是針對常用操作進(jìn)行封裝，對于處理特殊情況我建議還是采用原生Sql方式去處理，這篇文章也就差不多了。相信用過(guò)hibernate的人都知道如何去編寫(xiě)hbm映射文件，添加依賴(lài)包，這里我就沒(méi)有詳細介紹，也沒(méi)有實(shí)際例子來(lái)實(shí)現，還是那句話(huà)，我是從項目架構出發(fā)，給大家在搭建系統的時(shí)候提供思路和參考。
