Spring数据库访问之ORM

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

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

Java代码

 
 
 
 
  1. public class Course {     
  2.   private Long id;     
  3.   private String title;     
  4.   private java.util.Date startDate;     
  5.   private java.util.Date endDate;     
  6.   private int fee;     
  7.   //必须提供无参默认构造方法     
  8.   public Course() {     
  9.       super();     
  10.   }     
  11.   //省略其它构造方法,getter和setter等方法     
  12.    

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

 
 
 
 
  1. package org.ourpioneer.course.dao;     
  2. import java.util.List;     
  3. import org.ourpioneer.course.bean.Course;     
  4. public interface CourseDAO {     
  5.     public void save(Course course);     
  6.     public void delete(Course course);     
  7. public void update(Course course);     
  8.     public Course findById(Long courseId);     
  9.     public List  findAll();     
  10. }    

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

 
 
 
 
  1. package org.ourpioneer.course.dao;     
  2. import java.util.List;     
  3. import org.hibernate.Query;     
  4. import org.hibernate.Session;     
  5. import org.hibernate.SessionFactory;     
  6. import org.hibernate.Transaction;     
  7. import org.hibernate.cfg.Configuration;     
  8. import org.ourpioneer.course.bean.Course;     
  9. public class CourseDAOImpl implements CourseDAO {     
  10.     private SessionFactory sessionFactory;     
  11.     public CourseDAOImpl() {     
  12.         Configuration cfg = new Configuration().configure();     
  13.         sessionFactory = cfg.buildSessionFactory();     
  14.     }     
  15.     public List  findAll() {     
  16.         Session session = sessionFactory.openSession();     
  17.         try {     
  18.             Query query = session.createQuery("from Course");     
  19.             return query.list();     
  20.         } finally {     
  21.             session.close();     
  22.         }     
  23.     }     
  24.     public Course findById(Long courseId) {     
  25.         Session session = sessionFactory.openSession();     
  26.         try {     
  27.             return (Course) session.get(Course.class, courseId);     
  28.         } finally {     
  29.             session.close();     
  30.         }     
  31.     }     
  32.     public void save(Course course) {     
  33.         Session session = sessionFactory.openSession();     
  34.         Transaction tx = session.beginTransaction();     
  35.         try {     
  36.             tx.begin();     
  37.             session.saveOrUpdate(course);     
  38.             tx.commit();     
  39.         } catch (RuntimeException e) {     
  40.             tx.rollback();     
  41.             throw e;     
  42.         } finally {     
  43.             session.close();     
  44.         }     
  45.     }     
  46. }   

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

 
 
 
 
  1. xml version='1.0' encoding='UTF-8'?>    
  2.           "-//Hibernate/Hibernate Configuration DTD 3.0//EN"     
  3.   "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">    
  4. <hibernate-configuration>    
  5.     <session-factory>    
  6.         <property name="connection.driver_class">com.mysql.jdbc.Driver property>    
  7.         <property name="connection.url">jdbc:mysql:///test property>    
  8.         <property name="connection.username">root property>    
  9.         <property name="connection.password">123 property>    
  10.         <property name="dialect">org.hibernate.dialect.MySQLDialect property>    
  11.         <property name="show_sql">true property>    
  12.         <property name="hbm2ddl.auto">update property>    
  13.         <mapping resource="org/ourpioneer/course/hbm/course.hbm.xml" />    
  14.      session-factory>    
  15. hibernate-configuration>    

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

 
 
 
 
  1. xml version="1.0" encoding="UTF-8"?>    
  2. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">    
  3. <hibernate-mapping package="org.ourpioneer.course.bean">    
  4.     <class name="Course" table="course">    
  5.         <id name="id" type="java.lang.Long" column="ID">    
  6.             <generator class="identity" />    
  7.          id>    
  8.         <property name="title" type="java.lang.String" column="TITLE"    
  9.             length="100" not-null="true" />    
  10.         <property name="startDate" type="java.sql.Date" column="STARTDATE"    
  11.             not-null="true" />    
  12.         <property name="endDate" type="java.sql.Date" column="ENDDATE"    
  13.             not-null="true" />    
  14.         <property name="fee" type="java.lang.Integer" column="FEE"    
  15.             not-null="true" />    
  16.      class>    
  17. 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中配置一下这个地址:

 
 
 
 
  1. <repositories>    
  2.     <repository>    
  3.         <releases>    
  4.             <updatePolicy>always updatePolicy>    
  5.          releases>    
  6.         <snapshots>    
  7.             <updatePolicy>always updatePolicy>    
  8.          snapshots>    
  9.         <id>Jboss id>    
  10.         <name>Jboss Repository name>    
  11. <url>https://repository.jboss.org/nexus/content/groups/public url>    
  12.      repository>    
  13. repositories>    

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

 

下面来看示例程序:

 
 
 
 
  1. package org.ourpioneer.course;     
  2. import java.util.GregorianCalendar;     
  3. import java.util.List;     
  4. import org.ourpioneer.course.bean.Course;     
  5. import org.ourpioneer.course.dao.CourseDAO;     
  6. import org.ourpioneer.course.dao.CourseDAOImpl;     
  7. public class Demo {     
  8.     public static void main(String[] args) {     
  9.         CourseDAO courseDAO = new CourseDAOImpl();     
  10.         Course course = new Course();     
  11.         course.setTitle("Spring ORM");     
  12.         course.setStartDate(new GregorianCalendar(201111).getTime());     
  13.         course.setEndDate(new GregorianCalendar(201121).getTime());     
  14.         course.setFee(100);     
  15.         courseDAO.save(course);     
  16.         List  courses = courseDAO.findAll();     
  17.         Long courseId = courses.get(0).getId();     
  18.         course = courseDAO.findById(courseId);     
  19.         System.out.println(course);     
  20.         courseDAO.delete(course);     
  21.     }     
  22. }    

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

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

 

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

 
 
 
 
  1. package org.ourpioneer.course.bean;     
  2. import java.sql.Date;     
  3. import javax.persistence.Column;     
  4. import javax.persistence.Entity;     
  5. import javax.persistence.GeneratedValue;     
  6. import javax.persistence.GenerationType;     
  7. import javax.persistence.Id;     
  8. import javax.persistence.Table;     
  9.     
  10. /**    
  11.  * 课程信息描述bean    
  12.  *     
  13.  * @author Nanlei    
  14.  *     
  15.  */    
  16. @Entity    
  17. @Table(name = "course")     
  18. public class Course {     
  19.     @Id    
  20.     @GeneratedValue(strategy = GenerationType.IDENTITY)     
  21.     @Column(name = "ID")     
  22.     private Long id;     
  23.     @Column(name = "TITLE", length = 100, nullable = false)     
  24.     private String title;     
  25.     @Column(name = "STARTDATE",nullable=false)     
  26.     private java.util.Date startDate;     
  27.     @Column(name = "ENDDATE",nullable=false)     
  28.     private java.util.Date endDate;     
  29.     @Column(name = "FEE",nullable=false)     
  30.     private int fee;     
  31.     // 其余内容不变,省略     
  32. }   

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

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

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

 
 
 
 
  1. public CourseDAOImpl() {     
  2.     // Configuration cfg = new Configuration().configure();     
  3.     Configuration cfg = new AnnotationConfiguration().configure();     
  4.     sessionFactory = cfg.buildSessionFactory();     
  5. }    

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

 
 
 
 
  1. <dependency>    
  2.     <groupId>org.hibernate groupId>    
  3.     <artifactId>hibernate-entitymanager artifactId>    
  4.     <version>3.6.0.Final version>    
  5.     <type>jar type>    
  6.     <scope>compile scope>    
  7. dependency>    
  8. <dependency>    
  9.     <groupId>jboss groupId>    
  10.     <artifactId>jboss-archive-browsing artifactId>    
  11.     <version>5.0.0alpha-200607201-119 version>    
  12.     <type>jar type>    
  13.     <scope>compile scope>    
  14. dependency>   

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

 
 
 
 
  1. '1.0' encoding='UTF-8'?>    
  2. "http://java.sun.com/xml/ns/persistence"    
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    
  4.     xsi:schemaLocation="http://java.sun.com/xml/ns/persistence     
  5. http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"     
  6.     version="1.0">    
  7.      "course">    
  8.              
  9.              "hibernate.ejb.cfgfile" value="/hibernate.cfg.xml" />    
  10.             
  11.         
  12.     

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

Java代码

 

 
 
 
 
  1. package org.ourpioneer.course.dao;     
  2. import java.util.List;     
  3. import javax.persistence.EntityManager;     
  4. import javax.persistence.EntityManagerFactory;     
  5. import javax.persistence.EntityTransaction;     
  6. import javax.persistence.Persistence;     
  7. import javax.persistence.Query;     
  8. import org.ourpioneer.course.bean.Course;     
  9. public class CourseDAOImplJPA implements CourseDAO {     
  10.     private EntityManagerFactory entityManagerFactory;     
  11.     public CourseDAOImplJPA() {     
  12.         entityManagerFactory = Persistence.createEntityManagerFactory("course");     
  13.     }     
  14.     public void delete(Course course) {     
  15.         EntityManager manager = entityManagerFactory.createEntityManager();     
  16.         EntityTransaction tx = manager.getTransaction();     
  17.         try {     
  18.             tx.begin();     
  19.             manager.remove(manager.merge(course));     
  20.             tx.commit();     
  21.         } catch (RuntimeException e) {     
  22.             tx.rollback();     
  23.             throw e;     
  24.         } finally {     
  25.             manager.close();     
  26.         }     
  27.     }     
  28.     public List  findAll() {     
  29.         EntityManager manager = entityManagerFactory.createEntityManager();     
  30.         try {     
  31.             Query query = manager     
  32.                     .createQuery("select course from Course course");     
  33.             return query.getResultList();     
  34.         } finally {     
  35.             manager.close();     
  36.         }     
  37.     }     
  38.     public Course findById(Long courseId) {     
  39.         EntityManager manager = entityManagerFactory.createEntityManager();     
  40.         try {     
  41.             return manager.find(Course.class, courseId);     
  42.         } finally {     
  43.             manager.close();     
  44.         }     
  45.     }     
  46.     public void save(Course course) {     
  47.         EntityManager manager = entityManagerFactory.createEntityManager();     
  48.         EntityTransaction tx = manager.getTransaction();     
  49.         try {     
  50.             tx.begin();     
  51.             manager.persist(course);     
  52.             tx.commit();     
  53.         } catch (RuntimeException e) {     
  54.             tx.rollback();     
  55.             throw e;     
  56.         } finally {     
  57.             manager.close();     
  58.         }     
  59.     }     
  60.     public void update(Course course) {     
  61.         EntityManager manager = entityManagerFactory.createEntityManager();     
  62.         EntityTransaction tx = manager.getTransaction();     
  63.         try {     
  64.             tx.begin();     
  65.             manager.merge(course);     
  66.             tx.commit();     
  67.         } catch (RuntimeException e) {     
  68.             tx.rollback();     
  69.             throw e;     
  70.         } finally {     
  71.             manager.close();     
  72.         }     
  73.     }     
  74. }    

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

#p#

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

 
 
 
 
  1. private SessionFactory sessionFactory;     
  2. public void setSessionFactory(SessionFactory sessionFactory) {     
  3.     this.sessionFactory = sessionFactory;     
  4. }   

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

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

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

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

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

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

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

 
 
 
 
  1. <bean id="sessionFactory"    
  2. class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">    
  3.     <property name="dataSource" ref="dataSource" />    
  4.     <property name="mappingLocations"    
  5.         value="classpath:org/ourpioneer/course/hbm/*.hbm.xml" />    
  6.     <property name="hibernateProperties">    
  7.         <props>    
  8.             <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect prop>    
  9.             <prop key="hibernate.show_sql">true prop>    
  10.             <prop key="hibernate.hbm2ddl.auto">update prop>    
  11.          props>    
  12.      property>    
  13. bean>    

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

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

 
 
 
 
  1. <bean id="sessionFactory"    
  2. class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">    
  3.     <property name="dataSource" ref="dataSource" />    
  4.     <property name="annotatedClasses">    
  5.         <list>    
  6.             <value>org.ourpioneer.course.bean.Course value>    
  7.          list>    
  8.      property>    
  9.     <property name="hibernateProperties">    
  10.         <props>    
  11.             <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect prop>    
  12.             <prop key="hibernate.show_sql">true prop>    
  13.             <prop key="hibernate.hbm2ddl.auto">update prop>    
  14.          props>    
  15.      property>    
  16. bean>    

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

 
 
 
 
  1. private EntityManagerFactory entityManagerFactory;     
  2. public void setEntityManagerFactory(     
  3.         EntityManagerFactory entityManagerFactory) {     
  4.     this.entityManagerFactory = entityManagerFactory;     
  5. }    

同理,修改Spring的配置文件,配置EntityManagerFactory,如下:

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

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

 
 
 
 
  1. <persistence-unit name="course">    
  2.     <properties>    
  3.         <property name="hibernate.ejb.cfgfile" value="/hibernate.cfg.xml" />    
  4.      properties>    
  5. persistence-unit>   

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

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

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

 
 
 
 
  1. <bean id="entityManagerFactory"    
  2. class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">    
  3.     <property name="persistenceUnitName" value="course" />    
  4.     <property name="dataSource" ref="dataSource" />    
  5.     <property name="jpaVendorAdapter">    
  6.         <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">    
  7.             <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect" />    
  8.             <property name="showSql" value="true" />    
  9.             <property name="generateDdl" value="true" />    
  10.          bean>    
  11.      property>    
  12. bean>    

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

 
 
 
 
  1. <persistence-unit name="course" />    

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

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

 
 
 
 
  1. package org.ourpioneer.course.dao;     
  2. import java.util.List;     
  3. import org.ourpioneer.course.bean.Course;     
  4. import org.springframework.orm.hibernate3.HibernateTemplate;     
  5. import org.springframework.transaction.annotation.Transactional;     
  6. public class CourseDAOImplHibernate implements CourseDAO {     
  7.     private HibernateTemplate hibernateTemplate;     
  8.     public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {     
  9.         this.hibernateTemplate = hibernateTemplate;     
  10.     }     
  11.     @Transactional    
  12.     public void delete(Course course) {     
  13.         hibernateTemplate.delete(course);     
  14.     }     
  15.     @Transactional(readOnly = true)     
  16.     public List  findAll() {     
  17.         return hibernateTemplate.find("from Course");     
  18.     }     
  19.     @Transactional(readOnly = true)     
  20.     public Course findById(Long courseId) {     
  21.         return (Course) hibernateTemplate.get(Course.class, courseId);     
  22.     }     
  23.     @Transactional    
  24.     public void save(Course course) {     
  25.         hibernateTemplate.save(course);     
  26.     }     
  27.     @Transactional    
  28.     public void update(Course course) {     
  29.         hibernateTemplate.update(course);     
  30.     }     
  31. }  

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

 
 
 
 
  1. <tx:annotation-driven />    
  2.     <bean id="transactionManager"    
  3.     class="org.springframework.orm.hibernate3.HibernateTransactionManager">    
  4.         <property name="sessionFactory" ref="sessionFactory" />    
  5.      bean>    
  6.     <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">    
  7.         <property name="sessionFactory" ref="sessionFactory" />    
  8.      bean>    
  9.     <bean id="courseDaoHibernate" class="org.ourpioneer.course.dao.CourseDAOImplHibernate">    
  10.         <property name="hibernateTemplate" ref="hibernateTemplate" />    
  11.      bean>    

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

 
 
 
 
  1. package org.ourpioneer.course;     
  2. import java.util.GregorianCalendar;     
  3. import java.util.List;     
  4. import org.ourpioneer.course.bean.Course;     
  5. import org.ourpioneer.course.dao.CourseDAO;     
  6. import org.springframework.context.ApplicationContext;     
  7. import org.springframework.context.support.ClassPathXmlApplicationContext;     
  8. public class Demo {     
  9.     public static void main(String[] args) {     
  10.         ApplicationContext ctx = new ClassPathXmlApplicationContext(     
  11.                 "classpath:applicationContext.xml");     
  12.         CourseDAO courseDAO = (CourseDAO) ctx.getBean("courseDaoHibernate");     
  13.         Course course = new Course();     
  14.         course.setTitle("Spring ORM");     
  15.         course.setStartDate(new GregorianCalendar(201111).getTime());     
  16.         course.setEndDate(new GregorianCalendar(201121).getTime());     
  17.         course.setFee(100);     
  18.         courseDAO.save(course);     
  19.         List  courses = courseDAO.findAll();     
  20.         Long courseId = courses.get(0).getId();     
  21.         course = courseDAO.findById(courseId);     
  22.         System.out.println(course);     
  23.         courseDAO.delete(course);     
  24.     }     
  25. }    

 运行主程序,就可以看到执行效果了:

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

 
 
 
 
  1. package org.ourpioneer.course.dao;     
  2. import java.util.List;     
  3. import org.ourpioneer.course.bean.Course;     
  4. import org.springframework.orm.jpa.JpaTemplate;     
  5. import org.springframework.transaction.annotation.Transactional;     
  6. public class CourseDAOImplJPA implements CourseDAO {     
  7.     private JpaTemplate jpaTemplate;     
  8.     public void setJpaTemplate(JpaTemplate jpaTemplate) {     
  9.         this.jpaTemplate = jpaTemplate;     
  10.     }     
  11.     @Transactional    
  12.     public void delete(Course course) {     
  13.         jpaTemplate.remove(jpaTemplate.merge(course));     
  14.     }     
  15.     @Transactional(readOnly = true)     
  16.     public List  findAll() {     
  17.         return jpaTemplate.find("from Course");     
  18.     }     
  19.     @Transactional(readOnly = true)     
  20.     public Course findById(Long courseId) {     
  21.         return jpaTemplate.find(Course.class, courseId);     
  22.     }     
  23.     @Transactional    
  24.     public void save(Course course) {     
  25.         jpaTemplate.merge(course);     
  26.     }     
  27.     @Transactional    
  28.     public void update(Course course) {     
  29.         jpaTemplate.merge(course);     
  30.     }     
  31. }    

 

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

 
 
 
 
  1. <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">    
  2.     <property name="entityManagerFactory" ref="entityManagerFactory" />    
  3. bean>    
  4. <bean id="jpaTemplate" class="org.springframework.orm.jpa.JpaTemplate">    
  5.     <property name="entityManagerFactory" ref="entityManagerFactory" />    
  6. bean>    
  7. <bean id="courseDaoJPA" class="org.ourpioneer.course.dao.CourseDAOImplJPA">    
  8.     <property name="jpaTemplate" ref="jpaTemplate" />    
  9. bean>   

 

 

 

 

 

 

 

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

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

 

JPA的则是:

 

 
 
 
 
  1. jpaTemplate.execute(new JpaCallback() {     
  2.     public Object doInJpa(EntityManager em) throws PersistenceException {     
  3.     return null;     
  4.     }     
  5. });   

 

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

 

 
 
 
 
  1. package org.ourpioneer.course.dao;     
  2. import java.util.List;     
  3. import org.ourpioneer.course.bean.Course;     
  4. import org.springframework.orm.hibernate3.support.HibernateDaoSupport;     
  5. import org.springframework.transaction.annotation.Transactional;     
  6. public class CourseDAOImplHibernate extends HibernateDaoSupport implements    
  7.         CourseDAO {     
  8.     @Transactional    
  9.     public void delete(Course course) {     
  10.         getHibernateTemplate().delete(course);     
  11.     }     
  12.     @Transactional(readOnly = true)     
  13.     public List  findAll() {     
  14.         return getHibernateTemplate().find("from Course");     
  15.     }     
  16.     @Transactional(readOnly = true)     
  17.     public Course findById(Long courseId) {     
  18.         return (Course) getHibernateTemplate().get(Course.class, courseId);     
  19.     }     
  20.     @Transactional    
  21.     public void save(Course course) {     
  22.         getHibernateTemplate().save(course);     
  23.     }     
  24.     @Transactional    
  25.     public void update(Course course) {     
  26.         getHibernateTemplate().update(course);     
  27.     }     
  28. }    

 

同时修改配置文件:

 

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

 

 

 

 

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

 
 
 
 
  1. package org.ourpioneer.course.dao;     
  2. import java.util.List;     
  3. import org.ourpioneer.course.bean.Course;     
  4. import org.springframework.orm.jpa.support.JpaDaoSupport;     
  5. import org.springframework.transaction.annotation.Transactional;     
  6. public class CourseDAOImplJPA extends JpaDaoSupport implements CourseDAO {     
  7.     @Transactional    
  8.     public void delete(Course course) {     
  9.         getJpaTemplate().remove(getJpaTemplate().merge(course));     
  10.     }     
  11.     @Transactional(readOnly = true)     
  12.     public List  findAll() {     
  13.         return getJpaTemplate().find("from Course");     
  14.     }     
  15.     @Transactional(readOnly = true)     
  16.     public Course findById(Long courseId) {     
  17.         return getJpaTemplate().find(Course.class, courseId);     
  18.     }     
  19.     @Transactional    
  20.     public void save(Course course) {     
  21.         getJpaTemplate().merge(course);     
  22.     }     
  23.     @Transactional    
  24.     public void update(Course course) {     
  25.         getJpaTemplate().merge(course);     
  26.     }     
  27. }    

同时,将配置文件修改为:

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

#p#

 

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

 
 
 
 
  1. package org.ourpioneer.course.dao;     
  2. import java.util.List;     
  3. import org.hibernate.Query;     
  4. import org.hibernate.SessionFactory;     
  5. import org.ourpioneer.course.bean.Course;     
  6. import org.springframework.transaction.annotation.Transactional;     
  7. public class CourseDAOImplHibernate implements CourseDAO {     
  8.     private SessionFactory sessionFactory;     
  9.     public void setSessionFactory(SessionFactory sessionFactory) {     
  10.         this.sessionFactory = sessionFactory;     
  11.     }     
  12.     @Transactional    
  13.     public void delete(Course course) {     
  14.         sessionFactory.getCurrentSession().delete(course);     
  15.     }     
  16.     @Transactional(readOnly = true)     
  17.     public List  findAll() {     
  18.         Query query = sessionFactory.getCurrentSession().createQuery(     
  19.                 "from Course");     
  20.         return query.list();     
  21.     }     
  22.     @Transactional(readOnly = true)     
  23.     public Course findById(Long courseId) {     
  24.         return (Course) sessionFactory.getCurrentSession().get(Course.class,     
  25.                 courseId);     
  26.     }     
  27.     @Transactional    
  28.     public void save(Course course) {     
  29.         sessionFactory.getCurrentSession().saveOrUpdate(course);     
  30.     }     
  31.     @Transactional    
  32.     public void update(Course course) {     
  33.         sessionFactory.getCurrentSession().update(course);     
  34.     }     
  35. }   

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

 
 
 
 
  1. <tx:annotation-driven />    
  2.     <bean id="transactionManager"    
  3.     class="org.springframework.orm.hibernate3.HibernateTransactionManager">    
  4.         <property name="sessionFactory" ref="sessionFactory" />    
  5.      bean>    
  6.     <bean id="courseDaoHibernate" class="org.ourpioneer.course.dao.CourseDAOImplHibernate">    
  7.         <property name="sessionFactory" ref="sessionFactory" />    
  8.      bean>    

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

 
 
 
 
  1. package org.ourpioneer.course;     
  2. import java.util.GregorianCalendar;     
  3. import java.util.List;     
  4. import org.ourpioneer.course.bean.Course;     
  5. import org.ourpioneer.course.dao.CourseDAO;     
  6. import org.springframework.context.ApplicationContext;     
  7. import org.springframework.context.support.ClassPathXmlApplicationContext;     
  8. public class Demo {     
  9.     public static void main(String[] args) {     
  10.         ApplicationContext ctx = new ClassPathXmlApplicationContext(     
  11.                 "classpath:applicationContext.xml");     
  12.         CourseDAO courseDAO = (CourseDAO) ctx.getBean("courseDaoHibernate");     
  13.         Course course = new Course();     
  14.         course.setTitle("Spring ORM");     
  15.         course.setStartDate(new GregorianCalendar(201121).getTime());     
  16.         course.setEndDate(new GregorianCalendar(201131).getTime());     
  17.         course.setFee(100);     
  18.         courseDAO.save(course);     
  19.         List  courses = courseDAO.findAll();     
  20.         Long courseId = courses.get(0).getId();     
  21.         course = courseDAO.findById(courseId);     
  22.         System.out.println(course);     
  23.         course.setFee(200);     
  24.         courseDAO.update(course);     
  25.         System.out.println(course);     
  26.         courseDAO.delete(course);     
  27.     }     
  28. }    

在控制台,我们可以看到如下输出:

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

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

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

 
 
 
 
  1. package org.ourpioneer.course.dao;     
  2. import java.util.List;     
  3. import javax.persistence.EntityManager;     
  4. import javax.persistence.PersistenceContext;     
  5. import javax.persistence.Query;     
  6. import org.ourpioneer.course.bean.Course;     
  7. import org.springframework.transaction.annotation.Transactional;     
  8. public class CourseDAOImplJPA implements CourseDAO {     
  9.     @PersistenceContext    
  10.     private EntityManager entityManager;     
  11.     @Transactional    
  12.     public void delete(Course course) {     
  13.         entityManager.remove(entityManager.merge(course));     
  14.     }     
  15.     @Transactional(readOnly = true)     
  16.     public List  findAll() {     
  17.         Query query = entityManager.createQuery("from Course");     
  18.         return query.getResultList();     
  19.     }     
  20.     @Transactional(readOnly = true)     
  21.     public Course findById(Long courseId) {     
  22.         return entityManager.find(Course.class, courseId);     
  23.     }     
  24.     @Transactional    
  25.     public void save(Course course) {     
  26.         entityManager.merge(course);     
  27.     }     
  28.     @Transactional    
  29.     public void update(Course course) {     
  30.         entityManager.merge(course);     
  31.     }     
  32. }    

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

 
 
 
 
  1. <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">    
  2.     <property name="entityManagerFactory" ref="entityManagerFactory" />    
  3. bean>    
  4. <bean id="courseDaoJPA" class="org.ourpioneer.course.dao.CourseDAOImplJPA" />    
  5. <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框架集成
THE END