Spring整合Hibernate

如果要用Spring整合 Hibernate，只需要在Spring容器中配置好SessionFactory,如果同需要加入事务控制，只需要配置好相应的事务管理器即可。

下面是一个Spring中的Hibernate的SessionFactory配置，

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xmlns:p="http://www.springframework.org/schema/p"
 5     xmlns:cache="http://www.springframework.org/schema/cache"
 6     xmlns:context="http://www.springframework.org/schema/context"
 7     xsi:schemaLocation="http://www.springframework.org/schema/beans 
 8     http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
 9     http://www.springframework.org/schema/cache
10     http://www.springframework.org/schema/cache/spring-cache-4.0.xsd
11     http://www.springframework.org/schema/context
12     http://www.springframework.org/schema/context/spring-context-4.0.xsd">
13     <!-- 定义数据源Bean，使用C3P0数据源实现，并注入数据源的必要信息 -->
14     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
15         destroy-method="close"
16         p:driverClass="com.mysql.jdbc.Driver"
17         p:jdbcUrl="jdbc:mysql://localhost/test?useUnicode=true&amp;characterEncoding=UTF-8"
18         p:user="root"
19         p:password=""
20         p:maxPoolSize="40"
21         p:minPoolSize="2"
22         p:initialPoolSize="2"
23         p:maxIdleTime="30" />
24     <!-- 定义Hibernate的SessionFactory, SessionFactory需要依赖数据源，注入dataSource -->
25     <bean id="sessionFactory"
26         class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"
27         p:dataSource-ref="dataSource">
28         <!-- annotatedClasses用来列出全部持久化类 -->    
29         <property name="annotatedClasses">
30             <list>
31                 <!-- 以下用来列出所有PO类 -->
32                 <value>com.entity.Book</value>
33             </list>
34         </property>
35         <!-- 定义Hibernate的sessionFactory属性 -->
36         <property name="hibernateProperties">
37             <props>
38                 <!-- 指定Hibernate的连接方言 -->
39                 <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
40                 <!-- 是否根据Hibernate映射表创建数据表 -->
41                 <prop key="hibernate.hbm2ddl.auto">update</prop>
42             </props>
43         </property>
44     </bean>
45     <!-- 配置Hibernate的局部数据管理器，使用HibernateTransactionManager类 -->
46     <!-- 该类是PlatformTransactionManager接口针对Hibernate的特定实现 -->
47     <!-- 配置HibernateTransactionManager需要注入sessionFactory -->
48     <bean id="transactionManager"
49         class="org.springframework.orm.hibernate4.HibernateTransactionManager"
50         p:sessionFactory-ref="sessionFactory" />
51 </beans>

实现DAO组件的基类，通常会面向接口编程，因此定义一下接口，

 1 public interface BaseDao<T> {
 2     //根据ID加载实体
 3     T get(Class<T> entityClazz, Serializable id);
 4     //保存实体
 5     Serializable save(T entity);
 6     //更新实体
 7     void update(T entity);
 8     //删除实体
 9     void delete(T entity);
10     //根据ID删除实体
11     void delete(Class<T> entityClazz, Serializable id);
12     //获取所有实体
13     List<T> finaAll(Class<T> entityClazz);
14     //获取实体总数
15     long findCount(Class<T> entityClazz);
16 }

一个实现类，

 1 public class BaseDaoHibernate4<T> implements BaseDao<T> {
 2     //DAO组件进行持久化操作底层依赖的SessionFactory组件，将在XML文件中进行依赖注入
 3     private SessionFactory sessionFactory;
 4     
 5     public SessionFactory getSessionFactory() {
 6         return sessionFactory;
 7     }
 8 
 9     public void setSessionFactory(SessionFactory sessionFactory) {
10         this.sessionFactory = sessionFactory;
11     }
12     @Override
13     public T get(Class entityClazz, Serializable id) {
14         return (T)getSessionFactory().getCurrentSession().get(entityClazz, id);
15     }
16 
17     @Override
18     public Serializable save(T entity) {
19         return getSessionFactory().getCurrentSession().save(entity);
20     }
21 
22     @Override
23     public void update(T entity) {
24         getSessionFactory().getCurrentSession().saveOrUpdate(entity);
25     }
26 
27     @Override
28     public void delete(Object entity) {
29         getSessionFactory().getCurrentSession().delete(entity);
30     }
31 
32     //根据ID来删除
33     @Override
34     public void delete(Class entityClazz, Serializable id) {
35         getSessionFactory().getCurrentSession().createQuery("delete" + entityClazz.getSimpleName() 
36                 + " en where en.id = ?0")
37                 .setParameter("0" ,  id)
38                 .executeUpdate();
39     }
40 
41     @Override
42     public List finaAll(Class entityClazz) {
43         return find("select en from " + entityClazz.getSimpleName() + " en");
44                 
45     }
46 
47     @SuppressWarnings("unchecked")
48     protected List<T> find(String hql) {
49         return (List<T>)getSessionFactory().getCurrentSession().createQuery(hql).list();
50     }
51     
52     @SuppressWarnings("unchecked")
53     protected List<T> find(String hql, Object... params) {
54         Query query = getSessionFactory().getCurrentSession().createQuery(hql);
55         for (int i = 0, len = params.length; i < len ; i++) {
56             query.setParameter(i + "", params[i]);
57         }
58         return (List<T>)query.list();
59     }
60     
61     /**
62      * 使用HQL进行分页查询
63      * @param hql HQL语句
64      * @param pageNo 查询第pageNo页的记录
65      * @param pageSize  每页显示页显示的记录数
66      * @return 返回当前页的所有记录
67      */
68     @SuppressWarnings("unchecked")
69     protected List<T> findByPage(String hql, int pageNo, int pageSize) {
70         return getSessionFactory().getCurrentSession().createQuery(hql)
71                 .setFirstResult((pageNo -1) * pageSize)
72                 .setMaxResults(pageSize)
73                 .list();
74     }
75     
76     /**
77      * 使用HQL进行分页查询
78      * @param hql HQL语句
79      * @param pageNo 查询第pageNo页的记录
80      * @param pageSize  每页显示页显示的记录数
81      * @param params 如果hql带占位符，params用于传入占位符参数
82      * @return 返回当前页的所有记录
83      */
84     @SuppressWarnings("unchecked")
85     protected List<T> findByPage(String hql, int pageNo, int pageSize, Object... params) {
86         Query query = getSessionFactory().getCurrentSession().createQuery(hql);
87         for (int i = 0, len = params.length ; i < len ; i++) {
88             query.setParameter(i + "" , params[i]);
89         }
90         return query.setFirstResult((pageNo - 1) * pageSize)
91                 .setMaxResults(pageSize)
92                 .list();
93     }
94     @Override
95     public long findCount(Class entityClazz) {
96         // TODO Auto-generated method stub
97         return 0;
98     }
99 }

以上是我们借助Hibernate API写的基于spring的数据库 CRUD 操作类，其实spring本身就为我们提供了相关类封装了 CRUD 操作，例如 Spring 为 Hibernate3 提供的HibernateTemplate工具类，就提供来以上所有的 CRUD 操作。另外还提供了 HibernateDAOSupport 工具类涌来获取HibernateTemplate实例, 项目中的DAO组件只需要继承这个工具类即可。