博客
关于我
强烈建议你试试无所不能的chatGPT,快点击我
集成spring3、hibernate4、junit
阅读量:5858 次
发布时间:2019-06-19

本文共 13675 字,大约阅读时间需要 45 分钟。

hot3.png

坛上有另外一篇更全面的帖子,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等目录
9522b1a6-a6c8-385d-bf6c-594191344b12.png
这里除了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层的结构
0ab83587-fbbf-30ed-9995-5cffad37d65f.png
首先有一个通用的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.   
  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
7951a257-d88e-3015-88d8-4660ca848bee.png
这里要注意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.        
  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.        
  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.        
  26.     public void testDelete() {  
  27.         String id = "test_1";  
  28.         Book target = bookDAO.queryById(id);  
  29.         bookDAO.delete(target);  
  30.     }  
  31.   
  32.        
  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.        
  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.        
  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注解

转载于:https://my.oschina.net/tiancai/blog/86237

你可能感兴趣的文章
我的友情链接
查看>>
移动端多端适配
查看>>
uefi与GPT
查看>>
我的友情链接
查看>>
读取配置(初稿)
查看>>
设计模式-原型模式
查看>>
SSH框架与MVC架构之间的关系
查看>>
javascript基本数据类型
查看>>
TLB
查看>>
ubuntu 安装 hazelcast命令
查看>>
我的友情链接
查看>>
Python中直接在MySQL执行SQL命令
查看>>
nagios安装详细过程
查看>>
android开发 零碎知识
查看>>
原来屏幕可以这样——数字魔方之电影院篇
查看>>
Mint 7 初体验
查看>>
地震产生的原因和征兆
查看>>
我的友情链接
查看>>
[转载] 七龙珠第一部——第049话 朗奇的危机
查看>>
linux运行级别和开机过程
查看>>