Spring数据库访问之ORM（三）

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

Java代码  

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<Course> 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，同一个事务内来执行，达到使用事务的效果。 
    将代码修改完成后，就要来修改配置文件了： 

Xml代码  

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的持久化对象就配置完毕了，在示例程序中来执行，就会看到效果。修改测试程序如下： 

Java代码  

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(2011, 2, 1).getTime());  
16.         course.setEndDate(new GregorianCalendar(2011, 3, 1).getTime());  
17.         course.setFee(100);  
18.         courseDAO.save(course);  
19.         List<Course> 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的配置文件中，我们加入如下内容： 

Xml代码  

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

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

Java代码  

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<Course> 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实例就好了。配置文件修改为： 

Xml代码  

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实例。