现在我们来看如何在Spring中配置ORM资源工厂,也就是在Spring中使用ORM框架。仍然以Hibernate为例来说明,要引入spring-orm和spring-context模块来做测试。首先我们可以修改一下DAO实现类的写法,因为用了Spring,就不用显式来new对象了,那么对于Hibernate的SessionFactory,使用注入的方式来进行配置,修改CourseDAOImpl类,如下设置:
去掉构造方法,为sessionFactory提供get方法即可。之后就是配置Spring了,很简单,要配置courseDao和sessionFactory:
把Hibernate配置对象的映射文件加上,之后修改测试方法,从Spring的容器中获取对象就可以了:
此时,我们还依赖Hibernate的配置文件,那么完全可以把Hibernate中的配置信息移入Spring之中,因为Spring的ORM模块完全支持Hibernate,可以如下进行,我们使用C3P0作为连接池:
将数据库的基本信息配置好后,数据源的配置就完成了。下面是配置Hibernate:
这里我们将实体映射一起配置进来,使用了*通配符,并配置了基本的Hibernate属性,比如方言,显示sql语句和自动建表。剩下的就是DAO的配置了,它不用做什么修改,仍然注入sessionFactory即可,然后执行测试:
从中可以看到启动信息和Hibernate生成的SQL语句。除了使用Hibernate的实体映射文件外,我们还可以使用注解,之前已经在Course持久化类中添加了注解,那么我们就来配置使用注解的方式,很简单,只需修改Spring中的Hibernate SessionFactory配置即可,如下:
这样就使用在持久化类中的注解信息而不需要单独编写HBM映射文件了,执行测试,结果是一样的。当然,在Spring中,还可以使用JPA的EntityManager来进行数据的持久化操作,那么又如何来进行呢?和前面介绍的类似,首先在JPA的DAO实现类中修改EntityManager的配置方式,使用注入来进行:
同理,修改Spring的配置文件,配置EntityManagerFactory,如下:
因为配置了persistenceUnitName,那么不要忘记了在META-INF目录下的persistence.xml文件,其中是这么写的:
因为还用到了hibernate.cfg.xml,不过要将mapping的映射信息全部去掉,之后的courseDaoJPA配置就很简单了:
在测试程序的ctx.getBean方法中换成courseDaoJPA就可以获得JPA的DAO实现对象了,从而进行数据库操作,这也非常简单。如果不使用hibernate的配置文件,那么需要对JPA进行如下的配置:
将数据源注入进来,并配置一些数据库方言,显示sql和生成ddl的信息,最后精简一下persistence.xml文件中的内容:
已经不需要再使用Hibernate的配置文件了,这样就可以了,再次执行测试程序,就可以得到如下输出信息:
在JDBC模块中,Spring的JDBC模板简化了SQL的操作,使得使用SQL非常简便,不需要很多的代码就能完成数据库操作,同样,在ORM模块中,Spring的模板技术也有应用,这里我们主要来看Hibernate模板和JPA模板技术。使用HibernateTemplate非常简单,在DAO的实现类中进行注入即可,使用Hibernate模板为我们提供的方法来执行ORM操作,非常的简便:
其中使用了注解进行事务说明,就不用写在配置文件中了,编写好代码,要让Spring容器知道我们的做法,进行如下配置:
使用tx前缀,只需加上相应的命名空间说明即可,这也很简单。修改主程序:
运行主程序,就可以看到执行效果了:
相对于HibernateTemplate,JpaTemplate也可以实现相同功能,我们来看如下代码:
这里不能忘了delete方法需要首先将脱管态的对象变为持久态的才能进行操作,否则就会发生异常。同样,对于配置文件,也要做响应的调整:
这样,我们修改测试程序中getBean获得的对象,就可以测试程序了,这都非常简单了。这里我们扩展说一点,使用了HibernateTemplate或jpaTemplate后,如果想获取Session或EntityManager,那么可以这么操作:hibernateTemplate.getSessionFactory().getCurrentSession(),对于JPA则是:jpaTemplate.getEntityManager(),除此之外,我们还可以使用他们的execute()方法来执行操作:
JPA的则是:
以上我们是在DAO实现类中直接注入模板来进行操作的,当然我们还可以让实现类继承各自的DaoSupport类来获得模板进行操作,这很简单,我们来看:
同时修改配置文件:
当然,也可以给该类注入HibernateTemplate,看一下该类的源码即可参照使用对应的实例进行注入了,这都很简单,JPA的修改也是相似的:
同时,将配置文件修改为:
- 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.MySQLDialect</prop>
- <prop key="hibernate.show_sql">true</prop>
- <prop key="hibernate.hbm2ddl.auto">update</prop>
- </props>
- </property>
- </bean>
这里我们将实体映射一起配置进来,使用了*通配符,并配置了基本的Hibernate属性,比如方言,显示sql语句和自动建表。剩下的就是DAO的配置了,它不用做什么修改,仍然注入sessionFactory即可,然后执行测试:
![](http://dl.iteye.com/upload/attachment/419075/2f0b764f-3af3-357d-a60e-279b36b8af77.jpg)
从中可以看到启动信息和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.Course</value>
- </list>
- </property>
- <property name="hibernateProperties">
- <props>
- <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
- <prop key="hibernate.show_sql">true</prop>
- <prop key="hibernate.hbm2ddl.auto">update</prop>
- </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的配置文件了,这样就可以了,再次执行测试程序,就可以得到如下输出信息:
![](http://dl.iteye.com/upload/attachment/419079/1eadf202-3fdb-3ec2-9646-789bd5931aae.jpg)
在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<Course> 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<Course> courses = courseDAO.findAll();
- Long courseId = courses.get(0).getId();
- course = courseDAO.findById(courseId);
- System.out.println(course);
- courseDAO.delete(course);
- }
- }
运行主程序,就可以看到执行效果了:
![](http://dl.iteye.com/upload/attachment/419081/358c77e8-8d80-3924-8477-f24c723d0c85.jpg)
相对于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<Course> 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<Course> 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<Course> 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>