集成spring,hibernate4,junit

论坛上有另外一篇更全面的帖子，jinnianshilongnian写的：http://www.iteye.com/topic/1120924 

本文的环境是： 
spring-framework-3.1.0 
hibernate-4.1.6 
junit-4.10 

这里大部分是参考我以前熟悉的配置方法，只是把hibernate3升级到hibernate4，其实差不了很多，只要注意几个要点： 

1、以前集成hibernate3和spring的时候，spring的ORM包里提供了HibernateSupport和HibernateTemplate这两个辅助类，我用的是HibernateTemplate。不过在Hibernate4里，spring不再提供这种辅助类，用的是hibernate4的原生API 

2、集成hibernate4之后，最小事务级别必须是Required，如果是以下的级别，或者没有开启事务的话，无法得到当前的Session 

Java代码  

1. sessionFactory.getCurrentSession();  

执行这行代码，会抛出No Session found for current thread 

对于运行时，这个可能不是很大的问题，因为在Service层一般都会开启事务，只要保证级别高于Required就可以了。可是由于在Dao层是不会开启事务的，所以针对Dao层进行单元测试就有困难了。 

解决的办法是，或者在Dao层的单元测试类上，开启事务。或者专门准备一个for unit test的配置文件，在Dao层就开启事务。我采用的是前者 

首先是目录结构，这里暂时还没有集成struts2、spring-mvc等web框架，也尚未包含js、css、jsp等目录 

 

这里除了servlet规范规定的web.xml必须放在WEB-INF下之外，其他的所有配置文件，都放在src根目录下。这样做的好处是，后续所有需要引用配置文件的地方，都可以统一用classpath:前缀找到配置文件。之前试过有的文件放在WEB-INF下，有的放在src根目录下，所以在引用的地方会不太统一，比较麻烦。 

当然无论配置文件怎么放，只要恰当使用classpath:和file:前缀，都是能找到的，只是个人选择的问题。另外，由于现在配置文件还比较少，所以直接扔到src根目录下没什么问题，如果配置文件增多了，可以再进行划分 

接下来是web.xml 

Xml代码  

1. <?xml version="1.0" encoding="UTF-8"?>  
2.   
3. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
4.     xmlns="http://java.sun.com/xml/ns/javaee"   
5.     xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"   
6.     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"   
7.     id="WebApp_ID" version="3.0">  
8.     
9.     <display-name>DevelopFramework</display-name>  
10.     
11.     <context-param>  
12.         <param-name>contextConfigLocation</param-name>  
13.         <param-value>classpath:beans.xml</param-value>   
14.     </context-param>  
15.   
16.     <listener>    
17.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>    
18.     </listener>    
19.           
20.     <servlet>    
21.         <servlet-name>CXFServlet</servlet-name>    
22.         <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>    
23.         <load-on-startup>1</load-on-startup>    
24.     </servlet>    
25.     
26.     <servlet-mapping>    
27.         <servlet-name>CXFServlet</servlet-name>    
28.         <url-pattern>/webservice/*</url-pattern>    
29.     </servlet-mapping>  
30.         
31. </web-app>  

这里没有什么要特别注意的，只是声明了beans.xml的路径。这里的servlet是配置cxf的，与hibernate没有关系。因为目标是要搭一个完整的开发框架，所以把cxf也事先放上了 

接下来是spring的配置文件beans.xml 

Xml代码  

1. <?xml version="1.0" encoding="UTF-8"?>  
2.   
3. <beans xmlns="http://www.springframework.org/schema/beans"  
4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
5.     xmlns:context="http://www.springframework.org/schema/context"  
6.     xmlns:tx="http://www.springframework.org/schema/tx"  
7.     xmlns:jaxws="http://cxf.apache.org/jaxws"  
8.     xsi:schemaLocation="http://www.springframework.org/schema/beans  
9.                             http://www.springframework.org/schema/beans/spring-beans-3.1.xsd  
10.                             http://www.springframework.org/schema/context  
11.                             http://www.springframework.org/schema/context/spring-context-3.1.xsd  
12.                             http://www.springframework.org/schema/tx  
13.                             http://www.springframework.org/schema/tx/spring-tx-3.1.xsd  
14.                             http://cxf.apache.org/jaxws   
15.                             http://cxf.apache.org/schemas/jaxws.xsd">  
16.       
17.     <import resource="classpath:META-INF/cxf/cxf.xml" />  
18.       
19.     <context:component-scan base-package="com.huawei.inoc.framework" />  
20.       
21.     <bean id="propertyConfigurer"  
22.         class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
23.         <property name="locations">  
24.             <list>  
25.                 <value>classpath:jdbc.properties</value>  
26.             </list>  
27.         </property>  
28.     </bean>  
29.   
30.     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">  
31.         <property name="driverClass" value="${driverClass}" />  
32.         <property name="jdbcUrl" value="${jdbcUrl}" />  
33.         <property name="user" value="${user}" />  
34.         <property name="password" value="${password}" />  
35.     </bean>  
36.   
37.     <bean id="sessionFactory"  
38.         class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">  
39.         <property name="dataSource" ref="dataSource" />  
40.         <property name="mappingLocations" value="classpath:/com/huawei/inoc/framework/model/**/*.hbm.xml" />  
41.         <property name="hibernateProperties">  
42.             <props>  
43.                 <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>  
44.                 <prop key="hibernate.show_sql">true</prop>  
45.                 <prop key="hibernate.format_sql">true</prop>  
46.                 <prop key="hibernate.jdbc.fetch_size">50</prop>  
47.                 <prop key="hibernate.jdbc.batch_size">25</prop>  
48.                 <prop key="hibernate.temp.use_jdbc_metadata_defaults">false</prop>  
49.             </props>  
50.         </property>  
51.     </bean>  
52.       
53.     <bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">  
54.         <property name="sessionFactory" ref="sessionFactory" />  
55.     </bean>  
56.   
57.     <tx:annotation-driven transaction-manager="transactionManager" />  
58.       
59.     <jaxws:endpoint id="helloWorld" implementor="#helloWorldWebserviceImpl" address="/HelloWorld" />  
60.       
61.     <jaxws:client id="client"    
62.         serviceClass="com.huawei.inoc.dummy.webservice.IDemoSupport"    
63.         address="http://localhost:8080/Dummy/webservice/getDate" />    
64.       
65. </beans>  

这里有几点要注意的： 

Xml代码  

1. <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">  
2.         <property name="driverClass" value="${driverClass}" />  
3.         <property name="jdbcUrl" value="${jdbcUrl}" />  
4.         <property name="user" value="${user}" />  
5.         <property name="password" value="${password}" />  
6.     </bean>  

这里把jdbc驱动的参数，放到了专门的配置文件里，改动起来会比较方便。另外数据库连接池在实际生产环境可以考虑切换一下，比如听说阿里巴巴出的druid就挺不错，jboss和WAS自带的连接池也是不错的 

Xml代码  

1. <bean id="sessionFactory"  
2.         class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">  
3.         <property name="dataSource" ref="dataSource" />  
4.         <property name="mappingLocations" value="classpath:/com/huawei/inoc/framework/model/**/*.hbm.xml" />  
5.         <property name="hibernateProperties">  
6.             <props>  
7.                 <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>  
8.                 <prop key="hibernate.show_sql">true</prop>  
9.                 <prop key="hibernate.format_sql">true</prop>  
10.                 <prop key="hibernate.jdbc.fetch_size">50</prop>  
11.                 <prop key="hibernate.jdbc.batch_size">25</prop>  
12.                 <prop key="hibernate.temp.use_jdbc_metadata_defaults">false</prop>  
13.             </props>  
14.         </property>  
15.     </bean>  

这里的sessionFactory改成org.springframework.orm.hibernate4.LocalSessionFactoryBean，如果ORM映射采用的不是配置文件，是用注解的话，以前hibernate3有一个AnnotationSessionFactoryBean，在hibernate4里没看到

这里ORM映射用的是配置文件，其实用注解也差不多 

这一行： 

Xml代码  

1. <prop key="hibernate.temp.use_jdbc_metadata_defaults">false</prop>  

可以避免启动容器时报的一个错误： 
Disabling contextual LOB creation as createClob() method threw error : java.lang.reflect.InvocationTargetException 

这个错误其实是无所谓的，不过还是不要报错好看一点 

Xml代码  

1. <bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">  
2.         <property name="sessionFactory" ref="sessionFactory" />  
3.     </bean>  
4.   
5.     <tx:annotation-driven transaction-manager="transactionManager" />  

这里是开启事务，用的是注解，比用配置文件简单一点。 

用配置文件的好处，是事务声明比较集中，不需要在每个Service层接口上单独声明。缺点是Service中的方法，命名规范需要事先约定好，否则事务就不能生效 

用注解的好处，是Service中的方法命名不需要特别规定，缺点是没有做到集中声明，如果在某个Service层的接口忘记声明事务，那么事务就无法生效 

两种方法各有好处，我个人更喜欢用注解 

然后是DAO层的结构 

 

首先有一个通用的DAO接口，然后有一个通用的DAO抽象实现类。每个具体业务DAO接口，继承通用DAO接口，具体业务DAO实现，继承通用DAO抽象实现类 

Java代码  

1. public interface IGenericDAO<T> {  
2.   
3.     void insert(T t);  
4.   
5.     void delete(T t);  
6.   
7.     void update(T t);  
8.   
9.     T queryById(String id);  
10.   
11.     List<T> queryAll();  
12.   
13. }  

因为只是示例，这里的方法不是很多，只包含了基本的增删改查方法 

Java代码  

1. public abstract class GenericDAO<T> implements IGenericDAO<T> {  
2.   
3.     private Class<T> entityClass;  
4.   
5.     public GenericDAO(Class<T> clazz) {  
6.         this.entityClass = clazz;  
7.     }  
8.   
9.     @Autowired  
10.     private SessionFactory sessionFactory;  
11.   
12.     @Override  
13.     public void insert(T t) {  
14.         sessionFactory.getCurrentSession().save(t);  
15.     }  
16.   
17.     @Override  
18.     public void delete(T t) {  
19.         sessionFactory.getCurrentSession().delete(t);  
20.     }  
21.   
22.     @Override  
23.     public void update(T t) {  
24.         sessionFactory.getCurrentSession().update(t);  
25.     }  
26.   
27.     @SuppressWarnings("unchecked")  
28.     @Override  
29.     public T queryById(String id) {  
30.         return (T) sessionFactory.getCurrentSession().get(entityClass, id);  
31.     }  
32.   
33.     @Override  
34.     public List<T> queryAll() {  
35.         String hql = "from " + entityClass.getSimpleName();  
36.         return queryForList(hql, null);  
37.     }  
38.   
39.     @SuppressWarnings("unchecked")  
40.     protected T queryForObject(String hql, Object[] params) {  
41.         Query query = sessionFactory.getCurrentSession().createQuery(hql);  
42.         setQueryParams(query, params);  
43.         return (T) query.uniqueResult();  
44.     }  
45.   
46.     @SuppressWarnings("unchecked")  
47.     protected T queryForTopObject(String hql, Object[] params) {  
48.         Query query = sessionFactory.getCurrentSession().createQuery(hql);  
49.         setQueryParams(query, params);  
50.         return (T) query.setFirstResult(0).setMaxResults(1).uniqueResult();  
51.     }  
52.   
53.     @SuppressWarnings("unchecked")  
54.     protected List<T> queryForList(String hql, Object[] params) {  
55.         Query query = sessionFactory.getCurrentSession().createQuery(hql);  
56.         setQueryParams(query, params);  
57.         return query.list();  
58.     }  
59.   
60.     @SuppressWarnings("unchecked")  
61.     protected List<T> queryForList(final String hql, final Object[] params,  
62.             final int recordNum) {  
63.         Query query = sessionFactory.getCurrentSession().createQuery(hql);  
64.         setQueryParams(query, params);  
65.         return query.setFirstResult(0).setMaxResults(recordNum).list();  
66.     }  
67.   
68.     private void setQueryParams(Query query, Object[] params) {  
69.         if (null == params) {  
70.             return;  
71.         }  
72.         for (int i = 0; i < params.length; i++) {  
73.             query.setParameter(i, params[i]);  
74.         }  
75.     }  
76.   
77. }  

这个抽象类实现了IGenericDAO的所有方法，具体业务DAO的实现类，就不需要重复实现这些方法了。 

这里因为session.get()和session.load()方法，都需要传入一个Class类型的参数，所以定义了entityClass字段，在具体业务类的构造方法中传入，下面会看到。另外有一个办法是用反射的方法，来获取entityClass字段，就不需要在具体子类的构造方法中再传入了。不过我个人觉得传入也不是很麻烦，就没有这么做 

这个类除了实现了IGenericDAO里定义的public方法之外，还提供了protected的queryForObject()和queryForList()方法，可以为具体子类提供一些便利 

这个通用DAO还不是很完善，主要是还可以补充更多的方法，以及考虑分页。为了简化的需要，这里省略了 

Java代码  

1. public interface IUserDAO extends IGenericDAO<User> {  
2.   
3.     public User queryByName(String userName);  
4.   
5. }  

这是具体业务DAO的接口，除了通用的方法之外，增加了一个按照name查询的方法，所以就要单独定义此方法 

Java代码  

1. @Repository  
2. public class UserDAO extends GenericDAO<User> implements IUserDAO {  
3.   
4.     public UserDAO() {  
5.         super(User.class);  
6.     }  
7.   
8.     @Override  
9.     public User queryByName(String userName) {  
10.         String hql = "from User u where u.name = ?";  
11.         return queryForObject(hql, new Object[] { userName });  
12.     }  
13.   
14. }  

这是具体业务DAO的实现类，实现了接口里的queryByName()方法，并且在构造参数中传入了User.class，用于初始化GenericDAO里的entityClass字段 

此外，这个类需要用@Repository注解，声明为spring bean 

DAO层里是不能声明事务的，也不能自行捕获异常，如果有特殊需求必须捕获的话，也要在处理之后，重新抛出来。否则Service层的事务就失效了 

接下来是Service层 

Java代码  

1. @Transactional(propagation = Propagation.REQUIRED, readOnly = false)  
2. public interface IBookService {  
3.   
4.     void addBook(Book book);  
5.   
6. }  

只要在接口上用@Transactional注解，此接口内的所有方法就自动声明为事务了，方法即是事务的边界。 

注意事务是在接口上声明的，一般不在实现类上声明 

后面的propagation参数，至少要到REQUIRED，否则No Session found for current thread，我也不知道这算不算一个BUG，还是spring认为是一个强制要求 

Java代码  

1. @Service  
2. public class BookService implements IBookService {  
3.   
4.     @Autowired  
5.     private IBookDAO bookDAO;  
6.   
7.     @Override  
8.     public void addBook(Book book) {  
9.         bookDAO.insert(book);  
10.     }  
11.   
12. }  

这个Service的实现类就很简单了，不需要重复声明事务，但是需要用@Service注解将自身声明为一个spring bean（因为可能还会注入上层），另外用@Autowired注解，将之前声明的DAO注入 

接下来说明一下单元测试的方法，在想做单元测试的类上，用右键菜单New-->JUnit Test Case 

 

这里要注意Source folder选到test，不然就会生成到src目录下了，然后可以视情况勾选setUp() 

生成的单元测试类 

Java代码  

1. @RunWith(SpringJUnit4ClassRunner.class)  
2. @ContextConfiguration(locations = "classpath:beans.xml")  
3. @Transactional  
4. public class BookDAOTest {  
5.   
6.     @Autowired  
7.     private BookDAO bookDAO;  
8.   
9.     @Test  
10.     public void testQueryByIsbn() {  
11.         String isbn = "123";  
12.         Book result = bookDAO.queryByIsbn(isbn);  
13.         String name = result.getName();  
14.         assertEquals("thinking in java", name);  
15.     }  
16.   
17.     @Test  
18.     public void testInsert() {  
19.         Book book = new Book();  
20.         book.setName("bai ye xing");  
21.         book.setIsbn("be bought yesterday");  
22.         bookDAO.insert(book);  
23.     }  
24.   
25.     @Test  
26.     public void testDelete() {  
27.         String id = "test_1";  
28.         Book target = bookDAO.queryById(id);  
29.         bookDAO.delete(target);  
30.     }  
31.   
32.     @Test  
33.     public void testUpdate() {  
34.         String id = "test_1";  
35.         Book target = bookDAO.queryById(id);  
36.         target.setName("i am changeid");  
37.         bookDAO.update(target);  
38.     }  
39.   
40.     @Test  
41.     public void testQueryById() {  
42.         String id = "test_1";  
43.         Book target = bookDAO.queryById(id);  
44.         String name = target.getName();  
45.         assertEquals("thinking in java", name);  
46.     }  
47.   
48.     @Test  
49.     public void testQueryAll() {  
50.         List<Book> books = bookDAO.queryAll();  
51.         assertEquals(3, books.size());  
52.     }  
53.   
54. }  

注解为@Test的方法，会被认为是单元测试方法被执行，注解为@Before的方法，会在每个单元测试方法执行之前被执行 

Java代码  

1. @Autowired  
2.     private BookDAO bookDAO;  

这里是把要单元测试的目标类注入进来 

下面重点介绍一下类上面的几个注解： 

Java代码  

1. @RunWith(SpringJUnit4ClassRunner.class)  
2. @ContextConfiguration(locations = "classpath:beans.xml")  

加上@RunWith注解之后，单元测试类会在spring容器里执行，这会带来很多便利。 

@ContextConfiguration注解，可以指定要加载的spring配置文件路径。如果对spring配置文件进行了恰当的拆分，就可以在不同的单元测试类里，仅加载必要的配置文件 

Java代码  

1. @Transactional  

这行注解是最关键的，前面已经提到，因为在DAO层是没有声明事务的，所以如果直接执行的话，就会抛出No Session found for current thread 

所以需要加上这句注解，在执行单元测试时，开启事务，就可以规避这个问题。同时也不会影响到实际的事务 

此外还引入了一个额外的好处，就是加上了这个注解之后，单元测试对数据库的改动会被自动回滚，避免不同单元测试方法之间的耦合。这个特性在实际跑单元测试里是很方便的 

实际运行一下这个单元测试类，可以在控制台看到以下输出： 

2012-8-16 19:37:42 org.springframework.test.context.transaction.TransactionalTestExecutionListener startNewTransaction 
信息: Began transaction (1): transaction manager [org.springframework.orm.hibernate4.HibernateTransactionManager@183d59c]; rollback [true] 
1903 [main] WARN  o.h.hql.internal.ast.HqlSqlWalker - [DEPRECATION] Encountered positional parameter near line 1, column 60.  Positional parameter are considered deprecated; use named parameters or JPA-style positional parameters instead. 
Hibernate: 
    select 
        book0_.ID as ID0_, 
        book0_.NAME as NAME0_, 
        book0_.ISBN as ISBN0_ 
    from 
        developframeworkschema.book book0_ 
    where 
        book0_.ISBN=? 
2012-8-16 19:37:42 org.springframework.test.context.transaction.TransactionalTestExecutionListener endTransaction 
信息: Rolled back transaction after test execution for test context 

每个方法开始之前，都会开启一个新事务，在执行完毕之后，该事务都会被回滚 

其中还有一行警告信息：[DEPRECATION] Encountered positional parameter near line 1, column 60.  Positional parameter are considered deprecated; use named parameters or JPA-style positional parameters instead. 

这是因为在GenericDAO中采用了hibernate4不推荐的写法： 

Java代码  

1. private void setQueryParams(Query query, Object[] params) {  
2.         if (null == params) {  
3.             return;  
4.         }  
5.         for (int i = 0; i < params.length; i++) {  
6.             query.setParameter(i, params[i]);  
7.         }  
8.     }  

hibernate4的建议，是把 

Java代码  

1. String hql = "from User u where u.name = ?";  
2. Query query = sessionFactory.getCurrentSession().createQuery(hql);  
3. query.setParameter(0, name);  

改成 

Java代码  

1. String hql = "from User u where u.name = :name";  
2. Query query = this.getSession().createQuery(hql);  
3. query.setParameter("name", name);  

鉴于自动回滚这个特性很方便，对Service层组件进行单元测试的时候，也推荐加上@Transactional注解 

对于spring3和hibernate4的集成，本文就简单介绍到这里，欢迎补充