Spring整合ORM技术 -- 集成Hibernate

1、Spring整合ORM方案的好处：

  • 方便基础设施的搭建。不同的ORM技术都有一套自己的方案以初始化框架、搭建基础设施等。在搭建基础设施中，数据源是不可或缺的资源，不同的ORM框架的实现方式各不相同。Spring针对不同的ORM框架，采用相同的方式配置数据源，并为不同的ORM框架提供相同的FactoryBean，用以初始化ORM框架的基础设施，可以把它们当成普通Bean对待。
  • 异常封装。Spring能够转化各种ORM框架抛出的异常，将ORM框架专有的或检查型异常转换为SpringDAO异常体系中的标准异常。这样用户就可以有选择地在适当的地方处理感兴趣的异常，忽略不可恢复的异常。
  • 统一的事务管理。通过使用基于SpringDAO模板编程风格，甚至使用原生的ORM框架的API，只要遵循Spring所提出的少量编程要求，就可以使用Spring提供的事务管理功能。Spring为不同的ORM框架提供了对应的事务管理器，可用声明式事务管理，并且透明地实现本地事务管理到全局JTA事务管理的切换。
  • 允许混合使用多个ORM框架。Spring在DAO层异常、事务、资源等高级层次建立了抽象，可以让业务层对DAO具体实现的技术不敏感。这样开发者就可以在底层选用合适的实现方式，甚至可以混合使用多种ORM，一般的CRUD使用Hibernate，而数据查询使用iBatis或SpringJDBC。
  • 方便单元测试。Spring容器使得替换不同的实现和配置方式变得很简单，这有利于单元测试

2、Spring整合Hibernate步骤

2.1 配置SessionFactory（可自动完成）

使用Hibernate框架的第一个工作是编写Hibernate的配置文件，接着使用这些配置文件实例化SessionFactory，创建好Hibernate的基础设施。Spring为创建SessionFactory提供了FactoryBean工厂类：org.springframework.orm.hibernate3.LocalSessionFactoryBean，通过一些必要的配置，即可或缺一个SessionFactoryBean。

<?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:context="http://www.springframework.org/schema/context"
 xmlns:aop="http://www.springframework.org/schema/aop" 
 xmlns:tx="http://www.springframework.org/schema/tx"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.1.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx-3.1.xsd">
    
    <context:component-scan base-package="org.worm.biz.springmvc"/>
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
     destroy-method="close"
     p:driverClassName="${jdbc.driverClassName}"
     p:url="${jdbc.url}"
     p:username = "${jdbc.username}"
     p:password = "${jdbc.password}"/>
    <!-- 也可以使用p:mappingDirectoryLocations来指定多个放置Hibernate映入文件的目录 --> 
    <bean id="sessionFactory" class = "org.springframework.orm.hibernate3.LocalSessionFactoryBean"
     p:dataSource-ref = "dataSource"
     p:mappingLocations="classpath:org/worm/biz/springmvc/dao/*.hbm.xml">
     <!-- 指定Hibernate配置文件 -->
     <property name="hibernateProperties">
      <props>
       <prop key="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</prop>
       <prop key="hibernate.show_sql">true</prop>
       <prop key="hibernate.formate_sql">true</prop>
      </props>
     </property> 
    </bean>
    
    <!-- 配置HibernateTemplate Bean -->
    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate"
     p:sessionFactory-ref="sessionFactory"/>
    <!-- 配置Hibernate事务管理 -->
    <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"
     p:sessionFactory-ref="sessionFactory"/>
    <tx:annotation-driven transaction-manager="transactionManager"/>
    </beans>

2.2、使用HibernateTemplate

基于模板类使用Hibernate是最简单的方式，它可以在不牺牲Hibernate强大功能的情况下，以一种更简洁的方式使用Hibernate，极大地降低了Hibernate的使用难度。

package org.worm.biz.springmvc.dao.hibernate;
import java.util.List;
public interface IBaseDao<T> {
 /**
  * 保存实体对象
  * @param t 实体对象
  * */
 public void addEntity(T t);
 
 /**
  * 更新实体对象
  * @param t 实体对象
  * */
 public  void updateEntity(T t);
 
 /**
  * 获取实体对象
  * @param serialNo 主键
  * */
 public  T getEntity(String serialNo,T t);
 
 /**
  * 获取实体对象集
  * @param hql 查询语句
  * @param params 查询条件
  * */
 public  List<T> getEntities(String hql,Object[] params);
 
 /**
  * 获取实体对象集
  * */
 public  List<T> getEntitiesByExample(T t);
}

package org.worm.biz.springmvc.dao.hibernate;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate3.HibernateTemplate;
public class BaseDao<T> implements IBaseDao<T> {
 private Class entityClass;//Dao的泛型类型，即子类所指定的T所对应的类型
 
 public BaseDao() {
  Type genType = getClass().getGenericSuperclass();
  Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
  entityClass = (Class) params[0];
 }
 @Autowired
 private HibernateTemplate hibernateTemplate;
 public HibernateTemplate getHibernateTemplate() {
  return hibernateTemplate;
 }
 public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
  this.hibernateTemplate = hibernateTemplate;
 }
 
 @Override
 public void addEntity(T t) {
  // TODO Auto-generated method stub
  getHibernateTemplate().save(t);
 }
 @Override
 public  void updateEntity(T t) {
  // TODO Auto-generated method stub
  getHibernateTemplate().update(t);
 }
 @Override
 public  T getEntity(String serialNo) {
  // TODO Auto-generated method stub
  return (T) getHibernateTemplate().get(entityClass, Integer.valueOf(serialNo));
 }
 @Override
 public  List<T> getEntities(String hql, Object[] params) {
  // TODO Auto-generated method stub
  return (List<T>) getHibernateTemplate().find(hql, params);
 }
 @Override
 public  List<T> getEntitiesByExample(T t) {
  // TODO Auto-generated method stub
  return getHibernateTemplate().findByExample(t);
 }
}

package org.worm.biz.springmvc.dao.hibernate;
import org.springframework.stereotype.Repository;
import org.worm.biz.springmvc.dao.User;
@Repository
public class UserDao extends BaseDao<User>{
 //添加自身独有的业务
}

2.3、使用Hibernate原生Hibernate API

使用Hibernate原生API与在Spring中使用HibernateTemplate中使用和事务绑定的Session相同

package org.worm.biz.springmvc.dao.hibernate;
import java.util.List;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.worm.biz.springmvc.dao.User;
public class BaseDao implements IBaseDao<User> {
// @Autowired
// private HibernateTemplate hibernateTemplate;
//
// public HibernateTemplate getHibernateTemplate() {
//  return hibernateTemplate;
// }
//
// public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
//  this.hibernateTemplate = hibernateTemplate;
// }
 @Autowired
 private SessionFactory sessionFactory;
 
 @Override
 public void addEntity(User t) {
  // TODO Auto-generated method stub
//  getHibernateTemplate().save(t);
  sessionFactory.getCurrentSession().save(t);
 }
 @Override
 public  void updateEntity(User t) {
  // TODO Auto-generated method stub
//  getHibernateTemplate().update(t);
  sessionFactory.getCurrentSession().update(t);
 }
 @Override
 public  User getEntity(String serialNo, User t) {
  // TODO Auto-generated method stub
//  return (User) getHibernateTemplate().get(t.getClass(), Integer.valueOf(serialNo));
  return (User) sessionFactory.getCurrentSession().get(t.getClass(), Integer.valueOf(serialNo));
 }
 @Override
 public  List<User> getEntities(String hql, Object[] params) {
  // TODO Auto-generated method stub
//  return (List<User>) getHibernateTemplate().find(hql, params);
  return null;
 }
 @Override
 public  List<User> getEntitiesByExample(User t) {
  // TODO Auto-generated method stub
//  return getHibernateTemplate().findByExample(t);
  return null;
 }
}

2.4、使用注解配置Entity

package org.worm.biz.springmvc.dao;
import javax.persistence.*;

@Entity
//@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
@Table(name = "t_user")
public class User{
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "user_no")
    protected int userId;
    @Column(name = "user_nick_name")
    protected String userName;
    protected String password;
    
    @Column(name = "user_age")
    protected String userAge;
    
    public int getUserId() {
        return userId;
    }
    public void setUserId(int userId) {
        this.userId = userId;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
 public String getUserAge() {
  return userAge;
 }
 public void setUserAge(String userAge) {
  this.userAge = userAge;
 }
    
}

Hibernate通过AnnotationConfiguration的addAnnotatedClass()方法加载使用JPA注解的实体类，获取映射的元数据信息， 并在此基础上创建SessionFactory实例。AnnotationSessionFactoryBean扩展了LocalSessionFactoryBean类，增强的功能是：可以根据实体类的注解获取ORM的配置信息。也允许混合使用XML配置和注解配置对象关系映射，Hibernate内部自动整合这些元数据信息，不会产生冲突。Spring为了可以通过扫描方式加载带注解的实体类，提供了一个好用的packagesToScan属性，可以指定一系列的包名，Spring将扫描并加载这些包（包含子包）路径的所有带注解实体类。

<?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:context="http://www.springframework.org/schema/context"
 xmlns:aop="http://www.springframework.org/schema/aop" 
 xmlns:tx="http://www.springframework.org/schema/tx"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.1.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx-3.1.xsd">
    
    <context:component-scan base-package="org.worm.biz.springmvc"/>
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
     destroy-method="close"
     p:driverClassName="${jdbc.driverClassName}"
     p:url="${jdbc.url}"
     p:username = "${jdbc.username}"
     p:password = "${jdbc.password}"/>
    <!-- 也可以使用p:mappingDirectoryLocations来指定多个放置Hibernate映入文件的目录 --> 
<!--     <bean id="sessionFactory" class = "org.springframework.orm.hibernate3.LocalSessionFactoryBean" -->
<!--      p:dataSource-ref = "dataSource" -->
<!--      p:mappingLocations="classpath:org/worm/biz/springmvc/dao/*.hbm.xml"> -->
<!--      <property name="hibernateProperties"> -->
<!--       <props> -->
<!--        <prop key="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</prop> -->
<!--        <prop key="hibernate.show_sql">true</prop> -->
<!--        <prop key="hibernate.formate_sql">true</prop> -->
<!--       </props> -->
<!--      </property>  -->
<!--     </bean> -->
    <!-- 带注解实体类 -->
    <bean id="sessionFactory_1" class = "org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean"
     p:dataSource-ref = "dataSource">
     <!-- 通过扫描方式加载带注解的实体类 -->
     <property name="packagesToScan" value="org.worm.biz.springmvc.dao"/>
     <!-- 指定Hibernate配置文件 -->
     <property name="hibernateProperties">
      <props>
       <prop key="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</prop>
       <prop key="hibernate.show_sql">true</prop>
       <prop key="hibernate.formate_sql">true</prop>
      </props>
     </property> 
    </bean>
    <!-- 配置HibernateTemplate Bean -->
    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate"
     p:sessionFactory-ref="sessionFactory"/>
    <!-- 配置Hibernate事务管理 -->
    <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"
     p:sessionFactory-ref="sessionFactory"/>
    <tx:annotation-driven transaction-manager="transactionManager"/>
    </beans>

2.5 统一使用事务管理，详情配置请见2.2

3、延迟加载问题

Hibernate允许对关联对象、属性进行延迟加载，但是必须保证延迟加载的操作限于同一个Hibernate Session范围之内进行。如果Service层返回一个启用了延迟加载功能领域对象给Web层，当Web层访问到那些需要延迟加载的数据时，由于加载领域对象的Hibernate Session已经关闭，将会导致延迟加载数据异常。因此Spring专门提供了一个OpenSessionInViewFilter过滤器，它的主要功能是使每个请求过程中绑定一个Hibernate Session，即使最初的事务已经完成了，可以在Web层进行延迟加载的操作。注意：对小型系统来说，使用OpenSessionInViewFilter确实可以降低延迟加载所引发的各种问题，使Service层代码更易开发和维护，但是对大型且高并发的应用来说，强烈建议不要使用OpenSessionInViewFilter。因为OpenSessionInViewFilter会让每个Web请求线程都绑定一个Hibernate的Session。知道Web请求处理时才会释放。这极大的影响了系统新能。

4、DAO层设计

为了增加代码复用率，强烈建议使用接口、基类和泛型来定义。详情见2.2.基类BaseDao<T>通过泛型方式允许子类Dao指定操作的实体类，以便简化常用的数据操作方法。同时，在BaseDao注入了一个HibernateTemplate，这样子类只要打上@Repository的注解就自然拥有HibernateTemplate成员变量了，无须各自声明。BaseDao的构造方法通过Java反射机制自动解析出子类T锁对应的类型，以便HibernateTemplate直接利用这个信息进行数据访问操作。

5、查询接口方法的设计

DAO层除了CRUD的数据操作之外，另外一个重要的操作就是根据查询条件执行数据查询，所有ORM框架都允许用户动态绑定参数确定查询条件。查询条件的数目往往是不固定的。因此实体DAO定义带参数的查询方法一般有：

  • 每一个条件项参数对应一个入参。List<T> findOrder(String hql,Date starttime,Date endtime,int deptId);这种方法优点是含义清晰，可读性强，内部逻辑简单，但是接口稳定性差，并且如果查询条件项过多，整个实体DAO类会显得很臃肿笨重。
  • 使用数组传递条件项参数。List<T> findOrder(String hql,Object[] params);这种方法的确定是可读性不强，调用者往往需要通过查看该接口的Javadoc才能正确使用。
  • 使用JDK5.0的不定参数。List<T> findOrder(String hql,Object... params);
  • 将查询条件项参数封装成对象。List<T> findOrder(String hql,OrderObject param);OrderObject查询条件对象封装了hql查询语句可能会用到的条件项参数，在查询方法内部，开发者必须判断查询条件对象的属性并正确绑定条件项参数。确定是会造成类数目的膨胀，有事甚至一个实体DAO需要对应多个查询条件参数类。
  • 使用Map传递条件项参数。List<T> findOrder(String hql,Map params)使用这样方式，接口方法签名可以在条件项发生变化的情况下保持稳定，同事通过键指定条件项参数名，这在一定程度上解决了接口的健壮性。

6、总结

Spring为其所支持的ORM框架提供了方面易用的FactoryBean，用以创建ORM框架的基础设施。Spring通过模板类在不损失框架功能的情况下大大降低了使用这些ORM技术的难度。此外Spring允许用户使用原生的API来构造DAO。使用原生API时，Spring能够保证用户获取到事务绑定的资源，Spring的事务管理机制同样有效。

Spring对Hibernate所提供的支持应该是最丰富的。

时间： 2024-10-10 00:16:58

Spring整合ORM技术 -- 集成Hibernate的相关文章

Spring学习（六）spring整合注解形式的hibernate

上篇博客中谈到spring中如何整合普通形式的hibernate,这次我们来总结下如何整合注解形式的hibernate. 我们知道在普通hibernate中,表与实体的映射关系是写在映射关系文件当中的,一个实体类对应一个映射关系配置文件.而在注解形式中是没有这个映射关系文件的,关系直接在实体类中通过注解的方式展现,所以写法上略有些不同. 下面我们通过一个例子来看看他们的区别.还是使用上篇博客的例子,先去掉这个hibernate反向生成的City.hbm.xml文件. Dao层里面是不需要修改的,

Spring（三）：Spring整合Hibernate

背景: 本文主要介绍使用spring-framework-4.3.8.RELEASE与hibernate-release-5.2.9.Final项目整合搭建的过程. 开发环境简介: 1).jdk 1.8 2).spring-framework-4.3.8.RELEASE.hibernate-release-5.2.9.Final 引入Spring到新建项目My-SSH中 1)导入Spring的required包到My-SSH项目 新建java的dynamic web 项目,之后把spring-f

Struts 2 + Hibernate + Spring 整合要点

Struts 2 和 Spring 的功能有重合,因此有必要说明下,整合中分别使用了两种框架的哪些技术. Struts 2 使用功能点: 1.拦截器.一处是对非登录用户购物进行拦截,一处是对文件上传的格式进行拦截.前者的拦截器文件需自己手动编写,后者可直接用 Struts 2 框架封装好的拦截器. 2.数据校验,重写 Validate() 方法.对用户注册信息进行校验. 3.核心控制器 FilterDispatcher,限制只有管理员才能访问后台. Spring 使用功能点: 1.配置 bean

Spring框架学习（4）spring整合hibernate

内容源自:spring整合hibernate    spring整合注解形式的hibernate 这里和上一部分学习一样用了模板模式, 将hibernate开发流程封装在ORM层提供的模板类HibernateTemplate中,通过在DAO中对模板类的使用,实现对传统hibernate开发流程的代替. 一.先来看看Hibernate的传统开发流程: 1) 配置SessionFactory对象 hibernate.cfg.xml <session-factory> a 数据源 driver_cl

Spring整合Hibernate中自动建表

Spring整合Hibernate中自动建表 博客分类: JavaEE Java代码   <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="dataSource"> <ref bean="dataSource" /> <

Spring 整合 Hibernate

Spring 整合 Hibernate •Spring 支持大多数流行的 ORM 框架, 包括 Hibernate JDO, TopLink, Ibatis 和 JPA. •Spring 对这些 ORM 框架的支持是一致的, 因此可以把和 Hibernate 整合技术应用到其他 ORM 框架上. •Spring 2.0 同时支持 Hibernate 2.x 和 3.x. 但 Spring 2.5 只支持 Hibernate 3.1 或更高版本 1.Spring 整合 Hibernate 整合什么

Spring整合hibernate(1)之基础整合

Spring整合hibernate3之基础整合 Spring集成hibernate3和4有一定的区别,目前基本都在使用3,所以此处内容以3为基础: 1.导入hibernate的包和Spring的包 1.1.导入Spring的依赖包 1.2.导入Log4j的依赖包:log4j-1.2.16.jar 1.3.导入dbcp的依赖包:commons-dbcp-1.4.jar.commons-pool-1.5.6.jar 1.4.导入hibernate3的依赖包 hibernate全部版本地址:http:

Spring集成Hibernate

在Spring中集成Hibernate,实际上就是将Hibernate中用到的数据源DataSource. SessionFactory实例(通常使用Hibernate访问数据库时,应用程序会先创建SessionFactory实例)以及事务管理器都交由Spring容器管理.整合时,可以只使用Spring配置文件(通常是applicationContext.xml文件,也可用其它命名)来完成两个框架初始化任务,不再使用hibernate.cfg.xml配置文件. 定义数据源DataSource <

Spring集成Hibernate（基于XML和注解配置）

配置Hibernate <?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:context="http://www.springfram