Spring数据库访问之ORM（二）

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

Java代码  

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

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

Xml代码  

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的容器中获取对象就可以了： 

Java代码  

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

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

Xml代码  

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： 

Xml代码  

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配置即可，如下： 

Xml代码  

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的配置方式，使用注入来进行： 

Java代码  

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

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

Xml代码  

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

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

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配置就很简单了： 

Xml代码  

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进行如下的配置： 

Xml代码  

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文件中的内容： 

Xml代码  

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

    已经不需要再使用Hibernate的配置文件了，这样就可以了，再次执行测试程序，就可以得到如下输出信息： 
 
    在JDBC模块中，Spring的JDBC模板简化了SQL的操作，使得使用SQL非常简便，不需要很多的代码就能完成数据库操作，同样，在ORM模块中，Spring的模板技术也有应用，这里我们主要来看Hibernate模板和JPA模板技术。使用HibernateTemplate非常简单，在DAO的实现类中进行注入即可，使用Hibernate模板为我们提供的方法来执行ORM操作，非常的简便： 

Java代码  

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<Course> 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容器知道我们的做法，进行如下配置： 

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="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前缀，只需加上相应的命名空间说明即可，这也很简单。修改主程序： 

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, 1, 1).getTime());  
16.         course.setEndDate(new GregorianCalendar(2011, 2, 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.         courseDAO.delete(course);  
24.     }  
25. }  

    运行主程序，就可以看到执行效果了： 
 
    相对于HibernateTemplate，JpaTemplate也可以实现相同功能，我们来看如下代码： 

Java代码  

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<Course> 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方法需要首先将脱管态的对象变为持久态的才能进行操作，否则就会发生异常。同样，对于配置文件，也要做响应的调整： 

Xml代码  

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()方法来执行操作： 

Java代码  

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

    JPA的则是： 

Java代码  

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

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

Java代码  

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<Course> 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. }  

    同时修改配置文件： 

Xml代码  

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

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

Java代码  

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<Course> 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. }  

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

Xml代码  

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