Spring数据库访问之ORM

Spring数据库访问中另外一大模块就是ORM，ORM即对象/关系映射。Spring支持大多数ORM框架，比如Hibernate，JPA，JDO，TopLink和iBatis(Spring2支持iBatis2，现MyBatis3的Spring支持由MyBatis社区开发，并非Spring)。

首先我们从单独使用ORM框架开始，来介绍Spring对ORM的支持，以Hibernate为例。使用ORM框架，需要提供持久化类，以课程管理为背景，如下设计课程类：

Java代码

public class Course {     
  private Long id;     
  private String title;     
  private java.util.Date startDate;     
  private java.util.Date endDate;     
  private int fee;     
  //必须提供无参默认构造方法     
  public Course() {     
      super();     
  }     
  //省略其它构造方法，getter和setter等方法     
   

作为对数据访问的一种模式，我们仍然应用DAO模式，写DAO类已经很熟练了，如下设计即可：

package org.ourpioneer.course.dao;     
import java.util.List;     
import org.ourpioneer.course.bean.Course;     
public interface CourseDAO {     
    public void save(Course course);     
    public void delete(Course course);     
public void update(Course course);     
    public Course findById(Long courseId);     
    public List findAll();     
}    

非常简单的设计，包含CRUD操作，那么实现类中我们用Hibernate帮助我们进行数据库访问操作也非常简单：

package org.ourpioneer.course.dao;     
import java.util.List;     
import org.hibernate.Query;     
import org.hibernate.Session;     
import org.hibernate.SessionFactory;     
import org.hibernate.Transaction;     
import org.hibernate.cfg.Configuration;     
import org.ourpioneer.course.bean.Course;     
public class CourseDAOImpl implements CourseDAO {     
    private SessionFactory sessionFactory;     
    public CourseDAOImpl() {     
        Configuration cfg = new Configuration().configure();     
        sessionFactory = cfg.buildSessionFactory();     
    }     
    public List findAll() {     
        Session session = sessionFactory.openSession();     
        try {     
            Query query = session.createQuery("from Course");     
            return query.list();     
        } finally {     
            session.close();     
        }     
    }     
    public Course findById(Long courseId) {     
        Session session = sessionFactory.openSession();     
        try {     
            return (Course) session.get(Course.class, courseId);     
        } finally {     
            session.close();     
        }     
    }     
    public void save(Course course) {     
        Session session = sessionFactory.openSession();     
        Transaction tx = session.beginTransaction();     
        try {     
            tx.begin();     
            session.saveOrUpdate(course);     
            tx.commit();     
        } catch (RuntimeException e) {     
            tx.rollback();     
            throw e;     
        } finally {     
            session.close();     
        }     
    }     
}   

这里只展示几个方法作为代表，其它方法类似可以写出，非常简单。首先是构造方法，初始化实现类时创建Hibernate的配置对象，new Configuration().configure()时，Hibernate会在类路径的根路径下自动寻找名为hibernate.cfg.xml的配置文件并加载，之后就是创建Hibernate的Session对象，利用Session对象提供和衍生出的方法来进行数据库操作。下面来看配置文件，这是比较重要的，因为通过配置文件，把数据库信息和实体Bean的信息都告诉Hibernate，可以省去我们很多在数据库设计上的事情。

xml version='1.0' encoding='UTF-8'?>    
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"     
  "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">    
<hibernate-configuration>    
    <session-factory>    
        <property name="connection.driver_class">com.mysql.jdbc.Driverproperty>    
        <property name="connection.url">jdbc:mysql:///testproperty>    
        <property name="connection.username">rootproperty>    
        <property name="connection.password">123property>    
        <property name="dialect">org.hibernate.dialect.MySQLDialectproperty>    
        <property name="show_sql">trueproperty>    
        <property name="hbm2ddl.auto">updateproperty>    
        <mapping resource="org/ourpioneer/course/hbm/course.hbm.xml" />    
    session-factory>    
hibernate-configuration>    

这里我们告诉Hibernate使用mysql数据库，并配置数据库信息，所用方言，并在执行应用程序时在控制台打印出还原的SQL语句。使用hbm2ddl.auto可以让Hibernate根据实体Bean的配置信息来自动建表，这是很方便的，最后的mapping就是配置实体bean映射信息的文件，我们来看一下：

xml version="1.0" encoding="UTF-8"?>    
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">    
<hibernate-mapping package="org.ourpioneer.course.bean">    
    <class name="Course" table="course">    
        <id name="id" type="java.lang.Long" column="ID">    
            <generator class="identity" />    
        id>    
        <property name="title" type="java.lang.String" column="TITLE"    
            length="100" not-null="true" />    
        <property name="startDate" type="java.sql.Date" column="STARTDATE"    
            not-null="true" />    
        <property name="endDate" type="java.sql.Date" column="ENDDATE"    
            not-null="true" />    
        <property name="fee" type="java.lang.Integer" column="FEE"    
            not-null="true" />    
    class>    
hibernate-mapping>    

这里首先配置了实体bean的所在位置，类信息还有数据库中表对应的关系。之后创建主键信息id，使用了MySQL的自增主键特性，剩下就是对各个字段的描述了，都见名知意，易于理解。

准备好这些内容，就可以编写测试程序了，在项目中引入Hibernate的相关依赖。这里说明一下，Maven默认仓库是Apache的，其中的Hibernate版本还在3.3.2.GA(本文编写时)，而当前的Hibernate官方版本已经是3.6.0.Final了，我们想使用新版本，该怎么办?很简单，配置Maven仓库的位置，让其可以发现3.6.0.Final版的Hibernate并下载依赖。JBoss官方也提供一个Maven仓库，其中就有最新版的Hibernate，那么我们在项目的POM中配置一下这个地址：

<repositories>    
    <repository>    
        <releases>    
            <updatePolicy>alwaysupdatePolicy>    
        releases>    
        <snapshots>    
            <updatePolicy>alwaysupdatePolicy>    
        snapshots>    
        <id>Jbossid>    
        <name>Jboss Repositoryname>    
<url>https://repository.jboss.org/nexus/content/groups/publicurl>    
    repository>    
repositories>    

之后，为项目引入其它必要的依赖，使用Maven管理，我们不需自己再去寻找各种依赖了，非常简单的管理，如图所示：

 

下面来看示例程序：

package org.ourpioneer.course;     
import java.util.GregorianCalendar;     
import java.util.List;     
import org.ourpioneer.course.bean.Course;     
import org.ourpioneer.course.dao.CourseDAO;     
import org.ourpioneer.course.dao.CourseDAOImpl;     
public class Demo {     
    public static void main(String[] args) {     
        CourseDAO courseDAO = new CourseDAOImpl();     
        Course course = new Course();     
        course.setTitle("Spring ORM");     
        course.setStartDate(new GregorianCalendar(2011, 1, 1).getTime());     
        course.setEndDate(new GregorianCalendar(2011, 2, 1).getTime());     
        course.setFee(100);     
        courseDAO.save(course);     
        List courses = courseDAO.findAll();     
        Long courseId = courses.get(0).getId();     
        course = courseDAO.findById(courseId);     
        System.out.println(course);     
        courseDAO.delete(course);     
    }     
}    

首先创建的是Course对象，并设置其中的属性，使用save方法将其持久化到数据库中，之后通过findAll方法查询数据库中的全部记录，当然现在只有一条。并拿到Id，在通过findById方法获取出来，然后打印结果。最终删除记录。执行该程序，我们可以得到如下输出信息：

我们之前并没有在数据库中建表，而Hibernate在执行插入之前会为我们自动建表，然后执行插入操作，两次查询操作，并打印出对象信息，最后执行了删除操作，从SQL语句中可以看到Hibernate最终的执行结果是什么。而此时回到数据库中，会发现一个建好的表。

 

Hibernate的简单ORM映射操作就介绍完了，下面来看使用JPA注解和Hibernate的API来持久化对象，首先修改持久化类：

package org.ourpioneer.course.bean;     
import java.sql.Date;     
import javax.persistence.Column;     
import javax.persistence.Entity;     
import javax.persistence.GeneratedValue;     
import javax.persistence.GenerationType;     
import javax.persistence.Id;     
import javax.persistence.Table;     
    
/**    
 * 课程信息描述bean    
 *     
 * @author Nanlei    
 *     
 */    
@Entity    
@Table(name = "course")     
public class Course {     
    @Id    
    @GeneratedValue(strategy = GenerationType.IDENTITY)     
    @Column(name = "ID")     
    private Long id;     
    @Column(name = "TITLE", length = 100, nullable = false)     
    private String title;     
    @Column(name = "STARTDATE",nullable=false)     
    private java.util.Date startDate;     
    @Column(name = "ENDDATE",nullable=false)     
    private java.util.Date endDate;     
    @Column(name = "FEE",nullable=false)     
    private int fee;     
    // 其余内容不变，省略     
}   

使用JPA的注解，首先对类进行注解，使用@Entity，并关联数据库表，使用@Table。下面就是对字段进行主键了，标识符（主键）字段要使用@Id，还要指定生成策略和对应的列名，剩下的字段只需指定列信息即可。现在告诉Hibernate我们使用JPA注解，而不使用映射文件了，如下配置：

    
<mapping class="org.ourpioneer.course.bean.Course"/>    

修改DAO实现类的构造方法，使用注解配置方式创建SessionFactory，如下即可：

public CourseDAOImpl() {     
    // Configuration cfg = new Configuration().configure();     
    Configuration cfg = new AnnotationConfiguration().configure();     
    sessionFactory = cfg.buildSessionFactory();     
}    

此时再次执行测试方法，反馈的信息没有任何变化，但是我们就使用了JPA注解而并非Hibernate的映射信息了。下面来看看使用Hibernate作为JPA引擎的持久化步骤。先配置依赖，引入：

<dependency>    
    <groupId>org.hibernategroupId>    
    <artifactId>hibernate-entitymanagerartifactId>    
    <version>3.6.0.Finalversion>    
    <type>jartype>    
    <scope>compilescope>    
dependency>    
<dependency>    
    <groupId>jbossgroupId>    
    <artifactId>jboss-archive-browsingartifactId>    
    <version>5.0.0alpha-200607201-119version>    
    <type>jartype>    
    <scope>compilescope>    
dependency>   

如果在Java EE容器中运行JPA，可以通过容器来配置JPA，如果是在Java SE中运行JPA，那么需要在类路径的META-INF下配置persistence.xml来配置持久化单元，在本例中我们使用Hibernate作为JPA的引擎，就可以这么来写：

'1.0' encoding='UTF-8'?>    
"http://java.sun.com/xml/ns/persistence"    
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    
    xsi:schemaLocation="http://java.sun.com/xml/ns/persistence     
http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"     
    version="1.0">    
    "course">    
            
            "hibernate.ejb.cfgfile" value="/hibernate.cfg.xml" />    
            
        
    

加载配置文件仍然使用Hibernate的配置文件，或者也可以将其中的property写在persistence.xml中，那么因为在这里JPA已经可以获取持久化单元了，在Hibernate的配置中就需要配置持久化对象的映射了，去掉mapping信息即可。有了配置信息，还需要实现类，我们重写一个JPA的DAO实现，如下：

Java代码

 

package org.ourpioneer.course.dao;     
import java.util.List;     
import javax.persistence.EntityManager;     
import javax.persistence.EntityManagerFactory;     
import javax.persistence.EntityTransaction;     
import javax.persistence.Persistence;     
import javax.persistence.Query;     
import org.ourpioneer.course.bean.Course;     
public class CourseDAOImplJPA implements CourseDAO {     
    private EntityManagerFactory entityManagerFactory;     
    public CourseDAOImplJPA() {     
        entityManagerFactory = Persistence.createEntityManagerFactory("course");     
    }     
    public void delete(Course course) {     
        EntityManager manager = entityManagerFactory.createEntityManager();     
        EntityTransaction tx = manager.getTransaction();     
        try {     
            tx.begin();     
            manager.remove(manager.merge(course));     
            tx.commit();     
        } catch (RuntimeException e) {     
            tx.rollback();     
            throw e;     
        } finally {     
            manager.close();     
        }     
    }     
    public List findAll() {     
        EntityManager manager = entityManagerFactory.createEntityManager();     
        try {     
            Query query = manager     
                    .createQuery("select course from Course course");     
            return query.getResultList();     
        } finally {     
            manager.close();     
        }     
    }     
    public Course findById(Long courseId) {     
        EntityManager manager = entityManagerFactory.createEntityManager();     
        try {     
            return manager.find(Course.class, courseId);     
        } finally {     
            manager.close();     
        }     
    }     
    public void save(Course course) {     
        EntityManager manager = entityManagerFactory.createEntityManager();     
        EntityTransaction tx = manager.getTransaction();     
        try {     
            tx.begin();     
            manager.persist(course);     
            tx.commit();     
        } catch (RuntimeException e) {     
            tx.rollback();     
            throw e;     
        } finally {     
            manager.close();     
        }     
    }     
    public void update(Course course) {     
        EntityManager manager = entityManagerFactory.createEntityManager();     
        EntityTransaction tx = manager.getTransaction();     
        try {     
            tx.begin();     
            manager.merge(course);     
            tx.commit();     
        } catch (RuntimeException e) {     
            tx.rollback();     
            throw e;     
        } finally {     
            manager.close();     
        }     
    }     
}    

这里特别要注意的是delete方法，首先调用merge方法，否则当前对象是出于脱管态的，无法和Session进行关联，也就无法删除该对象。不加merge方法时候会抛出异常，大家可以测试一下，因为底层还是Hibernate进行的，Hibernate的持久化对象有三种状态，那么就要注意状态发生的变化。

#p#

现在我们来看如何在Spring中配置ORM资源工厂，也就是在Spring中使用ORM框架。仍然以Hibernate为例来说明，要引入spring-orm和spring-context模块来做测试。首先我们可以修改一下DAO实现类的写法，因为用了Spring，就不用显式来new对象了，那么对于Hibernate的SessionFactory，使用注入的方式来进行配置，修改CourseDAOImpl类，如下设置：

private SessionFactory sessionFactory;     
public void setSessionFactory(SessionFactory sessionFactory) {     
    this.sessionFactory = sessionFactory;     
}   

去掉构造方法，为sessionFactory提供get方法即可。之后就是配置Spring了，很简单，要配置courseDao和sessionFactory：

<bean id="sessionFactory"    
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">    
    <property name="configLocation" value="classpath:hibernate.cfg.xml" />    
bean>    
<bean id="courseDao" class="org.ourpioneer.course.dao.CourseDAOImpl">    
    <property name="sessionFactory" ref="sessionFactory">property>    
bean>  

把Hibernate配置对象的映射文件加上，之后修改测试方法，从Spring的容器中获取对象就可以了：

ApplicationContext ctx = new ClassPathXmlApplicationContext(     
        "classpath:applicationContext.xml");     
CourseDAO courseDAO = (CourseDAO) ctx.getBean("courseDao");    

此时，我们还依赖Hibernate的配置文件，那么完全可以把Hibernate中的配置信息移入Spring之中，因为Spring的ORM模块完全支持Hibernate，可以如下进行，我们使用C3P0作为连接池：

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"    
    scope="singleton" destroy-method="close">    
    <property name="driverClass" value="com.mysql.jdbc.Driver" />    
    <property name="jdbcUrl" value="jdbc:mysql:///test" />    
    <property name="user" value="root" />    
    <property name="password" value="123" />    
bean>    

将数据库的基本信息配置好后，数据源的配置就完成了。下面是配置Hibernate：

<bean id="sessionFactory"    
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">    
    <property name="dataSource" ref="dataSource" />    
    <property name="mappingLocations"    
        value="classpath:org/ourpioneer/course/hbm/*.hbm.xml" />    
    <property name="hibernateProperties">    
        <props>    
            <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialectprop>    
            <prop key="hibernate.show_sql">trueprop>    
            <prop key="hibernate.hbm2ddl.auto">updateprop>    
        props>    
    property>    
bean>    

这里我们将实体映射一起配置进来，使用了*通配符，并配置了基本的Hibernate属性，比如方言，显示sql语句和自动建表。剩下的就是DAO的配置了，它不用做什么修改，仍然注入sessionFactory即可，然后执行测试：

从中可以看到启动信息和Hibernate生成的SQL语句。除了使用Hibernate的实体映射文件外，我们还可以使用注解，之前已经在Course持久化类中添加了注解，那么我们就来配置使用注解的方式，很简单，只需修改Spring中的Hibernate SessionFactory配置即可，如下：

<bean id="sessionFactory"    
class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">    
    <property name="dataSource" ref="dataSource" />    
    <property name="annotatedClasses">    
        <list>    
            <value>org.ourpioneer.course.bean.Coursevalue>    
        list>    
    property>    
    <property name="hibernateProperties">    
        <props>    
            <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialectprop>    
            <prop key="hibernate.show_sql">trueprop>    
            <prop key="hibernate.hbm2ddl.auto">updateprop>    
        props>    
    property>    
bean>    

这样就使用在持久化类中的注解信息而不需要单独编写HBM映射文件了，执行测试，结果是一样的。当然，在Spring中，还可以使用JPA的EntityManager来进行数据的持久化操作，那么又如何来进行呢？和前面介绍的类似，首先在JPA的DAO实现类中修改EntityManager的配置方式，使用注入来进行：

private EntityManagerFactory entityManagerFactory;     
public void setEntityManagerFactory(     
        EntityManagerFactory entityManagerFactory) {     
    this.entityManagerFactory = entityManagerFactory;     
}    

同理，修改Spring的配置文件，配置EntityManagerFactory，如下：

<bean id="entityManagerFactory"    
class="org.springframework.orm.jpa.LocalEntityManagerFactoryBean">    
    <property name="persistenceUnitName" value="course" />    
bean>    

因为配置了persistenceUnitName，那么不要忘记了在META-INF目录下的persistence.xml文件，其中是这么写的：

<persistence-unit name="course">    
    <properties>    
        <property name="hibernate.ejb.cfgfile" value="/hibernate.cfg.xml" />    
    properties>    
persistence-unit>   

因为还用到了hibernate.cfg.xml，不过要将mapping的映射信息全部去掉，之后的courseDaoJPA配置就很简单了：

<bean id="courseDaoJPA" class="org.ourpioneer.course.dao.CourseDAOImplJPA">    
    <property name="entityManagerFactory" ref="entityManagerFactory" />    
bean>    

在测试程序的ctx.getBean方法中换成courseDaoJPA就可以获得JPA的DAO实现对象了，从而进行数据库操作，这也非常简单。如果不使用hibernate的配置文件，那么需要对JPA进行如下的配置：

<bean id="entityManagerFactory"    
class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">    
    <property name="persistenceUnitName" value="course" />    
    <property name="dataSource" ref="dataSource" />    
    <property name="jpaVendorAdapter">    
        <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">    
            <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect" />    
            <property name="showSql" value="true" />    
            <property name="generateDdl" value="true" />    
        bean>    
    property>    
bean>    

 将数据源注入进来，并配置一些数据库方言，显示sql和生成ddl的信息，最后精简一下persistence.xml文件中的内容：

<persistence-unit name="course" />    

已经不需要再使用Hibernate的配置文件了，这样就可以了，再次执行测试程序，就可以得到如下输出信息：

在JDBC模块中，Spring的JDBC模板简化了SQL的操作，使得使用SQL非常简便，不需要很多的代码就能完成数据库操作，同样，在ORM模块中，Spring的模板技术也有应用，这里我们主要来看Hibernate模板和JPA模板技术。使用HibernateTemplate非常简单，在DAO的实现类中进行注入即可，使用Hibernate模板为我们提供的方法来执行ORM操作，非常的简便：

package org.ourpioneer.course.dao;     
import java.util.List;     
import org.ourpioneer.course.bean.Course;     
import org.springframework.orm.hibernate3.HibernateTemplate;     
import org.springframework.transaction.annotation.Transactional;     
public class CourseDAOImplHibernate implements CourseDAO {     
    private HibernateTemplate hibernateTemplate;     
    public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {     
        this.hibernateTemplate = hibernateTemplate;     
    }     
    @Transactional    
    public void delete(Course course) {     
        hibernateTemplate.delete(course);     
    }     
    @Transactional(readOnly = true)     
    public List findAll() {     
        return hibernateTemplate.find("from Course");     
    }     
    @Transactional(readOnly = true)     
    public Course findById(Long courseId) {     
        return (Course) hibernateTemplate.get(Course.class, courseId);     
    }     
    @Transactional    
    public void save(Course course) {     
        hibernateTemplate.save(course);     
    }     
    @Transactional    
    public void update(Course course) {     
        hibernateTemplate.update(course);     
    }     
}  

其中使用了注解进行事务说明，就不用写在配置文件中了，编写好代码，要让Spring容器知道我们的做法，进行如下配置：

<tx:annotation-driven />    
    <bean id="transactionManager"    
    class="org.springframework.orm.hibernate3.HibernateTransactionManager">    
        <property name="sessionFactory" ref="sessionFactory" />    
    bean>    
    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">    
        <property name="sessionFactory" ref="sessionFactory" />    
    bean>    
    <bean id="courseDaoHibernate" class="org.ourpioneer.course.dao.CourseDAOImplHibernate">    
        <property name="hibernateTemplate" ref="hibernateTemplate" />    
    bean>    

使用tx前缀，只需加上相应的命名空间说明即可，这也很简单。修改主程序：

package org.ourpioneer.course;     
import java.util.GregorianCalendar;     
import java.util.List;     
import org.ourpioneer.course.bean.Course;     
import org.ourpioneer.course.dao.CourseDAO;     
import org.springframework.context.ApplicationContext;     
import org.springframework.context.support.ClassPathXmlApplicationContext;     
public class Demo {     
    public static void main(String[] args) {     
        ApplicationContext ctx = new ClassPathXmlApplicationContext(     
                "classpath:applicationContext.xml");     
        CourseDAO courseDAO = (CourseDAO) ctx.getBean("courseDaoHibernate");     
        Course course = new Course();     
        course.setTitle("Spring ORM");     
        course.setStartDate(new GregorianCalendar(2011, 1, 1).getTime());     
        course.setEndDate(new GregorianCalendar(2011, 2, 1).getTime());     
        course.setFee(100);     
        courseDAO.save(course);     
        List courses = courseDAO.findAll();     
        Long courseId = courses.get(0).getId();     
        course = courseDAO.findById(courseId);     
        System.out.println(course);     
        courseDAO.delete(course);     
    }     
}    

 运行主程序，就可以看到执行效果了：

相对于HibernateTemplate，JpaTemplate也可以实现相同功能，我们来看如下代码：

package org.ourpioneer.course.dao;     
import java.util.List;     
import org.ourpioneer.course.bean.Course;     
import org.springframework.orm.jpa.JpaTemplate;     
import org.springframework.transaction.annotation.Transactional;     
public class CourseDAOImplJPA implements CourseDAO {     
    private JpaTemplate jpaTemplate;     
    public void setJpaTemplate(JpaTemplate jpaTemplate) {     
        this.jpaTemplate = jpaTemplate;     
    }     
    @Transactional    
    public void delete(Course course) {     
        jpaTemplate.remove(jpaTemplate.merge(course));     
    }     
    @Transactional(readOnly = true)     
    public List findAll() {     
        return jpaTemplate.find("from Course");     
    }     
    @Transactional(readOnly = true)     
    public Course findById(Long courseId) {     
        return jpaTemplate.find(Course.class, courseId);     
    }     
    @Transactional    
    public void save(Course course) {     
        jpaTemplate.merge(course);     
    }     
    @Transactional    
    public void update(Course course) {     
        jpaTemplate.merge(course);     
    }     
}    

 

这里不能忘了delete方法需要首先将脱管态的对象变为持久态的才能进行操作，否则就会发生异常。同样，对于配置文件，也要做响应的调整：

<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">    
    <property name="entityManagerFactory" ref="entityManagerFactory" />    
bean>    
<bean id="jpaTemplate" class="org.springframework.orm.jpa.JpaTemplate">    
    <property name="entityManagerFactory" ref="entityManagerFactory" />    
bean>    
<bean id="courseDaoJPA" class="org.ourpioneer.course.dao.CourseDAOImplJPA">    
    <property name="jpaTemplate" ref="jpaTemplate" />    
bean>   

 

 

 

 

 

 

 

这样，我们修改测试程序中getBean获得的对象，就可以测试程序了，这都非常简单了。这里我们扩展说一点，使用了HibernateTemplate或jpaTemplate后，如果想获取Session或EntityManager，那么可以这么操作：hibernateTemplate.getSessionFactory().getCurrentSession()，对于JPA则是：jpaTemplate.getEntityManager()，除此之外，我们还可以使用他们的execute()方法来执行操作：

hibernateTemplate.execute(new HibernateCallback() {     
        public Object doInHibernate(Session session) throws HibernateException,SQLException {     
        }     
    };    

 

JPA的则是：

 

jpaTemplate.execute(new JpaCallback() {     
    public Object doInJpa(EntityManager em) throws PersistenceException {     
    return null;     
    }     
});   

 

以上我们是在DAO实现类中直接注入模板来进行操作的，当然我们还可以让实现类继承各自的DaoSupport类来获得模板进行操作，这很简单，我们来看：

 

package org.ourpioneer.course.dao;     
import java.util.List;     
import org.ourpioneer.course.bean.Course;     
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;     
import org.springframework.transaction.annotation.Transactional;     
public class CourseDAOImplHibernate extends HibernateDaoSupport implements    
        CourseDAO {     
    @Transactional    
    public void delete(Course course) {     
        getHibernateTemplate().delete(course);     
    }     
    @Transactional(readOnly = true)     
    public List findAll() {     
        return getHibernateTemplate().find("from Course");     
    }     
    @Transactional(readOnly = true)     
    public Course findById(Long courseId) {     
        return (Course) getHibernateTemplate().get(Course.class, courseId);     
    }     
    @Transactional    
    public void save(Course course) {     
        getHibernateTemplate().save(course);     
    }     
    @Transactional    
    public void update(Course course) {     
        getHibernateTemplate().update(course);     
    }     
}    

 

同时修改配置文件：

 

<bean id="courseDaoHibernate" class="org.ourpioneer.course.dao.CourseDAOImplHibernate">    
    <property name="sessionFactory" ref="sessionFactory" />    
bean>    

 

 

 

 

当然，也可以给该类注入HibernateTemplate，看一下该类的源码即可参照使用对应的实例进行注入了，这都很简单，JPA的修改也是相似的：

package org.ourpioneer.course.dao;     
import java.util.List;     
import org.ourpioneer.course.bean.Course;     
import org.springframework.orm.jpa.support.JpaDaoSupport;     
import org.springframework.transaction.annotation.Transactional;     
public class CourseDAOImplJPA extends JpaDaoSupport implements CourseDAO {     
    @Transactional    
    public void delete(Course course) {     
        getJpaTemplate().remove(getJpaTemplate().merge(course));     
    }     
    @Transactional(readOnly = true)     
    public List findAll() {     
        return getJpaTemplate().find("from Course");     
    }     
    @Transactional(readOnly = true)     
    public Course findById(Long courseId) {     
        return getJpaTemplate().find(Course.class, courseId);     
    }     
    @Transactional    
    public void save(Course course) {     
        getJpaTemplate().merge(course);     
    }     
    @Transactional    
    public void update(Course course) {     
        getJpaTemplate().merge(course);     
    }     
}    

同时，将配置文件修改为：

<bean id="courseDaoJPA" class="org.ourpioneer.course.dao.CourseDAOImplJPA">    
    <property name="entityManagerFactory" ref="entityManagerFactory" />    
bean>    

#p#

 

之前我们使用的是HibernateTemplate来进行对象的持久化的，其实在DAO实现类中我们还可以使用Hibernate的上下文Session来持久化对象。也就是通过SessionFactory对象的getCurrentSession()对象来获得Session，然后通过Session来进行操作。
    我们调整一下代码：
 

package org.ourpioneer.course.dao;     
import java.util.List;     
import org.hibernate.Query;     
import org.hibernate.SessionFactory;     
import org.ourpioneer.course.bean.Course;     
import org.springframework.transaction.annotation.Transactional;     
public class CourseDAOImplHibernate implements CourseDAO {     
    private SessionFactory sessionFactory;     
    public void setSessionFactory(SessionFactory sessionFactory) {     
        this.sessionFactory = sessionFactory;     
    }     
    @Transactional    
    public void delete(Course course) {     
        sessionFactory.getCurrentSession().delete(course);     
    }     
    @Transactional(readOnly = true)     
    public List findAll() {     
        Query query = sessionFactory.getCurrentSession().createQuery(     
                "from Course");     
        return query.list();     
    }     
    @Transactional(readOnly = true)     
    public Course findById(Long courseId) {     
        return (Course) sessionFactory.getCurrentSession().get(Course.class,     
                courseId);     
    }     
    @Transactional    
    public void save(Course course) {     
        sessionFactory.getCurrentSession().saveOrUpdate(course);     
    }     
    @Transactional    
    public void update(Course course) {     
        sessionFactory.getCurrentSession().update(course);     
    }     
}   

这里要注意的是所有DAO的方法必须是支持事务的，这可以通过添加Transactional注解来完成，就很简单了，之前也有过介绍。这样就能保证DAO中所有方法都可以在同一个Session，同一个事务内来执行，达到使用事务的效果。
    将代码修改完成后，就要来修改配置文件了：

<tx:annotation-driven />    
    <bean id="transactionManager"    
    class="org.springframework.orm.hibernate3.HibernateTransactionManager">    
        <property name="sessionFactory" ref="sessionFactory" />    
    bean>    
    <bean id="courseDaoHibernate" class="org.ourpioneer.course.dao.CourseDAOImplHibernate">    
        <property name="sessionFactory" ref="sessionFactory" />    
    bean>    

这样，基于上下文Session的持久化对象就配置完毕了，在示例程序中来执行，就会看到效果。修改测试程序如下：

package org.ourpioneer.course;     
import java.util.GregorianCalendar;     
import java.util.List;     
import org.ourpioneer.course.bean.Course;     
import org.ourpioneer.course.dao.CourseDAO;     
import org.springframework.context.ApplicationContext;     
import org.springframework.context.support.ClassPathXmlApplicationContext;     
public class Demo {     
    public static void main(String[] args) {     
        ApplicationContext ctx = new ClassPathXmlApplicationContext(     
                "classpath:applicationContext.xml");     
        CourseDAO courseDAO = (CourseDAO) ctx.getBean("courseDaoHibernate");     
        Course course = new Course();     
        course.setTitle("Spring ORM");     
        course.setStartDate(new GregorianCalendar(2011, 2, 1).getTime());     
        course.setEndDate(new GregorianCalendar(2011, 3, 1).getTime());     
        course.setFee(100);     
        courseDAO.save(course);     
        List courses = courseDAO.findAll();     
        Long courseId = courses.get(0).getId();     
        course = courseDAO.findById(courseId);     
        System.out.println(course);     
        course.setFee(200);     
        courseDAO.update(course);     
        System.out.println(course);     
        courseDAO.delete(course);     
    }     
}    

在控制台，我们可以看到如下输出：

这种方式和使用HibernateTemplate有的不同是它们对异常的处理。HibernateTemplate会将异常统一翻译成Spring的数据访问异常体系中的某个异常，而我们使用上下文的Session时，抛出的就不是Spring的异常，而是HibernateException，如果我们还想看到Spring的异常体系，就需要做点设置，当然这也很简单。
    在DAO实现类上加@Respository注解，并且注册一个PersistenceExceptionTranslationPostProcessor实例即可。在Spring的配置文件中，我们加入如下内容：

<bean class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor">bean>    

这是使用Hibernate的情况，那么使用JPA的情况和这个类似，我们来修改JPA的DAO实现类：

package org.ourpioneer.course.dao;     
import java.util.List;     
import javax.persistence.EntityManager;     
import javax.persistence.PersistenceContext;     
import javax.persistence.Query;     
import org.ourpioneer.course.bean.Course;     
import org.springframework.transaction.annotation.Transactional;     
public class CourseDAOImplJPA implements CourseDAO {     
    @PersistenceContext    
    private EntityManager entityManager;     
    @Transactional    
    public void delete(Course course) {     
        entityManager.remove(entityManager.merge(course));     
    }     
    @Transactional(readOnly = true)     
    public List findAll() {     
        Query query = entityManager.createQuery("from Course");     
        return query.getResultList();     
    }     
    @Transactional(readOnly = true)     
    public Course findById(Long courseId) {     
        return entityManager.find(Course.class, courseId);     
    }     
    @Transactional    
    public void save(Course course) {     
        entityManager.merge(course);     
    }     
    @Transactional    
    public void update(Course course) {     
        entityManager.merge(course);     
    }     
}    

这里我们使用注解来声明了EntityManager，那么需要在配置文件中在声明一个PersistenceAnnotationBeanPostProcessor实例就好了。配置文件修改为：

<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">    
    <property name="entityManagerFactory" ref="entityManagerFactory" />    
bean>    
<bean id="courseDaoJPA" class="org.ourpioneer.course.dao.CourseDAOImplJPA" />    
<bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor">bean>    

之后，将测试程序中的getBean()换成courseDaoJPA即可。
    和HibernateTemplate一样，JpaTemplate也会将异常翻译为Spring的数据访问异常，而如果改成entityManagerFactory之后，异常就会变成Java SE的异常，比如非法参数，非法状态等异常。若要继续使用Spring的异常体系，那么要为JPA的DAO实现类加上@Repository注解，然后注册PersistenceExceptionTranslationPostProcessor实例。

至此，我们的Spring的ORM部分已经全部介绍完了。

源代码链接：http://sarin.javaeye.com/blog/938796

【编辑推荐】

1. Spring访问数据库异常的处理方法
2. 浅谈Spring框架中的JDBC应用
3. Spring框架的7个模块
4. 快速应用JDBC控件访问数据库资源
5. 将Flex与Spring框架集成