Spring整合Hibernate

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

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

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:cache="http://www.springframework.org/schema/cache"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
    http://www.springframework.org/schema/cache
    http://www.springframework.org/schema/cache/spring-cache-4.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-4.0.xsd">
    <!-- 定义数据源Bean，使用C3P0数据源实现，并注入数据源的必要信息 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
        destroy-method="close"
        p:driverClass="com.mysql.jdbc.Driver"
        p:jdbcUrl="jdbc:mysql://localhost/test?useUnicode=true&amp;characterEncoding=UTF-8"
        p:user="root"
        p:password=""
        p:maxPoolSize="40"
        p:minPoolSize="2"
        p:initialPoolSize="2"
        p:maxIdleTime="30" />
    <!-- 定义Hibernate的SessionFactory, SessionFactory需要依赖数据源，注入dataSource -->
    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"
        p:dataSource-ref="dataSource">
        <!-- annotatedClasses用来列出全部持久化类 -->    
        <property name="annotatedClasses">
            <list>
                <!-- 以下用来列出所有PO类 -->
                <value>com.entity.Book</value>
            </list>
        </property>
        <!-- 定义Hibernate的sessionFactory属性 -->
        <property name="hibernateProperties">
            <props>
                <!-- 指定Hibernate的连接方言 -->
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
                <!-- 是否根据Hibernate映射表创建数据表 -->
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>
    </bean>
    <!-- 配置Hibernate的局部数据管理器，使用HibernateTransactionManager类 -->
    <!-- 该类是PlatformTransactionManager接口针对Hibernate的特定实现 -->
    <!-- 配置HibernateTransactionManager需要注入sessionFactory -->
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate4.HibernateTransactionManager"
        p:sessionFactory-ref="sessionFactory" />
</beans>

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

public interface BaseDao<T> {
    //根据ID加载实体
    T get(Class<T> entityClazz, Serializable id);
    //保存实体
    Serializable save(T entity);
    //更新实体
    void update(T entity);
    //删除实体
    void delete(T entity);
    //根据ID删除实体
    void delete(Class<T> entityClazz, Serializable id);
    //获取所有实体
    List<T> finaAll(Class<T> entityClazz);
    //获取实体总数
    long findCount(Class<T> entityClazz);
}

一个实现类，

public class BaseDaoHibernate4<T> implements BaseDao<T> {
    //DAO组件进行持久化操作底层依赖的SessionFactory组件，将在XML文件中进行依赖注入
    private SessionFactory sessionFactory;
    
    public SessionFactory getSessionFactory() {
        return sessionFactory;
    }

    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }
    @Override
    public T get(Class entityClazz, Serializable id) {
        return (T)getSessionFactory().getCurrentSession().get(entityClazz, id);
    }

    @Override
    public Serializable save(T entity) {
        return getSessionFactory().getCurrentSession().save(entity);
    }

    @Override
    public void update(T entity) {
        getSessionFactory().getCurrentSession().saveOrUpdate(entity);
    }

    @Override
    public void delete(Object entity) {
        getSessionFactory().getCurrentSession().delete(entity);
    }

    //根据ID来删除
    @Override
    public void delete(Class entityClazz, Serializable id) {
        getSessionFactory().getCurrentSession().createQuery("delete" + entityClazz.getSimpleName() 
                + " en where en.id = ?0")
                .setParameter("0" ,  id)
                .executeUpdate();
    }

    @Override
    public List finaAll(Class entityClazz) {
        return find("select en from " + entityClazz.getSimpleName() + " en");
                
    }

    @SuppressWarnings("unchecked")
    protected List<T> find(String hql) {
        return (List<T>)getSessionFactory().getCurrentSession().createQuery(hql).list();
    }
    
    @SuppressWarnings("unchecked")
    protected List<T> find(String hql, Object... params) {
        Query query = getSessionFactory().getCurrentSession().createQuery(hql);
        for (int i = 0, len = params.length; i < len ; i++) {
            query.setParameter(i + "", params[i]);
        }
        return (List<T>)query.list();
    }
    
    /**
     * 使用HQL进行分页查询
     * @param hql HQL语句
     * @param pageNo 查询第pageNo页的记录
     * @param pageSize  每页显示页显示的记录数
     * @return 返回当前页的所有记录
     */
    @SuppressWarnings("unchecked")
    protected List<T> findByPage(String hql, int pageNo, int pageSize) {
        return getSessionFactory().getCurrentSession().createQuery(hql)
                .setFirstResult((pageNo -1) * pageSize)
                .setMaxResults(pageSize)
                .list();
    }
    
    /**
     * 使用HQL进行分页查询
     * @param hql HQL语句
     * @param pageNo 查询第pageNo页的记录
     * @param pageSize  每页显示页显示的记录数
     * @param params 如果hql带占位符，params用于传入占位符参数
     * @return 返回当前页的所有记录
     */
    @SuppressWarnings("unchecked")
    protected List<T> findByPage(String hql, int pageNo, int pageSize, Object... params) {
        Query query = getSessionFactory().getCurrentSession().createQuery(hql);
        for (int i = 0, len = params.length ; i < len ; i++) {
            query.setParameter(i + "" , params[i]);
        }
        return query.setFirstResult((pageNo - 1) * pageSize)
                .setMaxResults(pageSize)
                .list();
    }
    @Override
    public long findCount(Class entityClazz) {
        // TODO Auto-generated method stub
        return 0;
    }
}

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