泛型DAO,SPRING声明式事务

最新推荐文章于 2024-08-11 20:00:32 发布

weixin_34000916

最新推荐文章于 2024-08-11 20:00:32 发布

阅读量114

点赞数

文章标签： java 测试数据库

原文链接：http://blog.51cto.com/tangjj/349226

版权

之前的博文中我们搭建了一个基本的开发环境，现在让我们给这个项目加上CRUD和基本的单元测试。

1、创建泛型DAO的相关类

在src\main\java\com\ceair\app\dao下创建GenericDao.java（APPFUSE2中的代码），代码内容如下：

package com.ceair.app.dao;
import java.io.Serializable;
import java.util.List;
import java.util.Map;
/**
* Generic DAO (Data Access Object) with common methods to CRUD POJOs.
*
* <p>Extend this interface if you want typesafe (no casting necessary) DAO's for your
* domain objects.
*
* @author <a href="mailto:bwnoll@gmail.com">Bryan Noll</a>
* @param <T> a type variable
* @param <PK> the primary key for that type
*/
public interface GenericDao <T, PK extends Serializable> {
/**
* Generic method used to get all objects of a particular type. This
* is the same as lookup up all rows in a table.
* @return List of populated objects
*/
List<T> getAll();
/**
* Generic method to get an object based on class and identifier. An
* ObjectRetrievalFailureException Runtime Exception is thrown if
* nothing is found.
*
* @param id the identifier (primary key) of the object to get
* @return a populated object
* @see org.springframework.orm.ObjectRetrievalFailureException
*/
T get(PK id);
/**
* Checks for existence of an object of type T using the id arg.
* @param id the id of the entity
* @return - true if it exists, false if it doesn't
*/
boolean exists(PK id);
/**
* Generic method to save an object - handles both update and insert.
* @param object the object to save
* @return the persisted object
*/
T save(T object);
/**
* Generic method to delete an object based on class and id
* @param id the identifier (primary key) of the object to remove
*/
void remove(PK id);
/**
* Gets all records without duplicates.
* <p>Note that if you use this method, it is imperative that your model
* classes correctly implement the hashcode/equals methods</p>
* @return List of populated objects
*/
List<T> getAllDistinct();
/**
* Find a list of records by using a named query
* @param queryName query name of the named query
* @param queryParams a map of the query names and the values
* @return a list of the records found
*/
List<T> findByNamedQuery(String queryName, Map<String, Object> queryParams);
}

在src\main\java\com\ceair\app\dao\hibernate中创建GenericDaoHibernate.java实现类，代码如下：

package com.ceair.app.dao.hibernate;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.orm.ObjectRetrievalFailureException;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import com.ceair.app.dao.GenericDao;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
/**
* This class serves as the Base class for all other DAOs - namely to hold
* common CRUD methods that they might all use. You should only need to extend
* this class when your require custom CRUD logic.
*
* <p>To register this class in your Spring context file, use the following XML.
* <pre>
* <bean id="fooDao" class="org.appfuse.dao.hibernate.GenericDaoHibernate">
* <constructor-arg value="org.appfuse.model.Foo"/>
* <property name="sessionFactory" ref="sessionFactory"/>
* </bean>
* </pre>
*
* @author <a href="mailto:bwnoll@gmail.com">Bryan Noll</a>
* @param <T> a type variable
* @param <PK> the primary key for that type
*/
public class GenericDaoHibernate<T, PK extends Serializable> extends HibernateDaoSupport implements GenericDao<T, PK> {
/**
* Log variable for all child classes. Uses LogFactory.getLog(getClass()) from Commons Logging
*/
protected final Log log = LogFactory.getLog(getClass());
private Class<T> persistentClass;
/**
* Constructor that takes in a class to see which type of entity to persist
* @param persistentClass the class type you'd like to persist
*/
public GenericDaoHibernate(final Class<T> persistentClass) {
this.persistentClass = persistentClass;
}
/**
* {@inheritDoc}
*/
@SuppressWarnings("unchecked")
public List<T> getAll() {
return super.getHibernateTemplate().loadAll(this.persistentClass);
}
/**
* {@inheritDoc}
*/
@SuppressWarnings("unchecked")
public List<T> getAllDistinct() {
Collection result = new LinkedHashSet(getAll());
return new ArrayList(result);
}
/**
* {@inheritDoc}
*/
@SuppressWarnings("unchecked")
public T get(PK id) {
T entity = (T) super.getHibernateTemplate().get(this.persistentClass, id);
if (entity == null) {
log.warn("Uh oh, '" + this.persistentClass + "' object with id '" + id + "' not found...");
throw new ObjectRetrievalFailureException(this.persistentClass, id);
}
return entity;
}
/**
* {@inheritDoc}
*/
@SuppressWarnings("unchecked")
public boolean exists(PK id) {
T entity = (T) super.getHibernateTemplate().get(this.persistentClass, id);
return entity != null;
}
/**
* {@inheritDoc}
*/
@SuppressWarnings("unchecked")
public T save(T object) {
return (T) super.getHibernateTemplate().merge(object);
}
/**
* {@inheritDoc}
*/
public void remove(PK id) {
super.getHibernateTemplate().delete(this.get(id));
}
/**
* {@inheritDoc}
*/
@SuppressWarnings("unchecked")
public List<T> findByNamedQuery(
String queryName,
Map<String, Object> queryParams) {
String []params = new String[queryParams.size()];
Object []values = new Object[queryParams.size()];
int index = 0;
Iterator<String> i = queryParams.keySet().iterator();
while (i.hasNext()) {
String key = i.next();
params[index] = key;
values[index++] = queryParams.get(key);
}
return getHibernateTemplate().findByNamedQueryAndNamedParam(
queryName,
params,
values);
}
}

在src\test\java\com\ceair\app\dao下创建单元测试基类BaseDaoTestCase.java，代码如下：

package com.ceair.app.dao;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.SessionFactory;
import org.springframework.orm.hibernate3.HibernateTemplate;
import org.springframework.test.AbstractTransactionalDataSourceSpringContextTests;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.MissingResourceException;
import java.util.ResourceBundle;
/**
* Base class for running DAO tests.
* @author mraible
*/
public abstract class BaseDaoTestCase extends AbstractTransactionalDataSourceSpringContextTests {
/**
* Log variable for all child classes. Uses LogFactory.getLog(getClass()) from Commons Logging
*/
protected final Log log = LogFactory.getLog(getClass());
/**
* ResourceBundle loaded from src/test/resources/${package.name}/ClassName.properties (if exists)
*/
protected ResourceBundle rb;
/**
* Sets AutowireMode to AUTOWIRE_BY_NAME and configures all context files needed to tests DAOs.
* @return String array of Spring context files.
*/
protected String[] getConfigLocations() {
setAutowireMode(AUTOWIRE_BY_NAME);
return new String[] {
// "classpath:/applicationContext-resources.xml",
"classpath:/applicationContext-dao.xml",
"classpath*:/applicationContext.xml", // for modular projects
"classpath:/applicationContext-hibernate.xml"
// "classpath:**/applicationContext*.xml" // for web projects
};
}
/**
* Default constructor - populates "rb" variable if properties file exists for the class in
* src/test/resources.
*/
public BaseDaoTestCase() {
// Since a ResourceBundle is not required for each class, just
// do a simple check to see if one exists
String className = this.getClass().getName();
try {
rb = ResourceBundle.getBundle(className);
} catch (MissingResourceException mre) {
//log.warn("No resource bundle found for: " + className);
}
// super.setDefaultRollback(false); //不回滚数据
}
/**
* Utility method to populate a javabean-style object with values
* from a Properties file
* @param obj the model object to populate
* @return Object populated object
* @throws Exception if BeanUtils fails to copy properly
*/
protected Object populate(Object obj) throws Exception {
// loop through all the beans methods and set its properties from its .properties file
Map<String, String> map = new HashMap<String, String>();
for (Enumeration<String> keys = rb.getKeys(); keys.hasMoreElements();) {
String key = keys.nextElement();
map.put(key, rb.getString(key));
}
BeanUtils.copyProperties(map, obj);
return obj;
}
/**
* Create a HibernateTemplate from the SessionFactory and call flush() and clear() on it.
* Designed to be used after "save" methods in tests: http://issues.appfuse.org/browse/APF-178.
*/
protected void flush() {
HibernateTemplate hibernateTemplate =
new HibernateTemplate((SessionFactory) applicationContext.getBean("sessionFactory"));
hibernateTemplate.flush();
hibernateTemplate.clear();
}
}

这个类的注意点如下：

1、38-40行( classpath:/applicationContext-dao.xml等)是指向你的配置文件，等下我会列出这些配置文件的详细信息。

2、去掉59行那句代码( super.setDefaultRollback(false); )注释的话，如果有数据库操作，那么不回滚测试数据。

在src\main\resources下分别创建applicationContext.xml,applicationContext-dao.xml,applicationContext-hibernate.xml 我们把applicationContext.xml拆解成3个文件，有助于明确配置的作用。

applicationContext.xml 内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<bean id="helloWorldAction" class="com.ceair.app.HelloWorldAction" />
<bean id="userAction" class="com.ceair.app.action.UserAction"/>
<context:annotation-config/>
<context:component-scan base-package="com.ceair"/>
</beans>

注意点： 1、12-13行（<context:annotation-config/> 和<context:component-scan base- package = "com.ceair" /> ）的加入是因为在只有的单元测试类中要用到一些注解，如@Autowire

2、因为12-13行的加入，所以要增加第4行（xmlns:context= "http://www.springframework.org/schema/context"）和第8行（http: //www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd"> ）的声明。

applicationContext-dao.xml内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jee="http://www.springframework.org/schema/jee"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.0.xsd">
<bean id="userDao" class="com.ceair.app.dao.hibernate.GenericDaoHibernate">
<constructor-arg value="com.ceair.app.model.User"/>
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
</beans>

applicationContext-hibernate.xml 内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jee="http://www.springframework.org/schema/jee"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.0.xsd">
<bean id="propertyConfigurer"
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<list>
<value>classpath:jdbc.properties</value>
</list>
</property>
</bean>
<!--
DriverManagerDataSource不具备连接池的功能 <bean id="dataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource"
destroy-method="close"> <property name="driverClassName"
value="${hibernate.connection.driver_class}"/> <property name="url"
value="${hibernate.connection.url}"/> <property name="username"
value="${hibernate.connection.username}"/> <property name="password"
value="${hibernate.connection.password}"/> <property name="maxActive"
value="100"/> <property name="maxWait" value="1000"/> <property
name="poolPreparedStatements" value="true"/> <property
name="defaultAutoCommit" value="true"/> </bean>
-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
destroy-method="close">
<property name="driverClass">
<value>${hibernate.connection.driver_class}</value>
</property>
<property name="jdbcUrl">
<value>${hibernate.connection.url}</value>
</property>
<property name="user">
<value>${hibernate.connection.username}</value>
</property>
<property name="password">
<value>${hibernate.connection.password}</value>
</property>
<property name="minPoolSize">
<value>5</value>
</property>
<property name="maxPoolSize">
<value>30</value>
</property>
<property name="initialPoolSize">
<value>10</value>
</property>
<property name="maxIdleTime">
<value>60</value>
</property>
<property name="acquireIncrement">
<value>5</value>
</property>
<!--
JDBC的标准参数，用以控制数据源内加载的PreparedStatements数量。但由于预缓存的statements
属于单个connection而不是整个连接池。所以设置这个参数需要考虑到多方面的因素。
如果maxStatements与maxStatementsPerConnection均为0，则缓存被关闭。Default: 0
-->
<property name="maxStatements">
<value>150</value>
</property>
<property name="idleConnectionTestPeriod">
<value>60</value>
</property>
<property name="acquireRetryAttempts">
<value>30</value>
</property>
<!--
获取连接失败将会引起所有等待连接池来获取连接的线程抛出异常。但是数据源仍有效
保留，并在下次调用getConnection()的时候继续尝试获取连接。如果设为true，那么在尝试
获取连接失败后该数据源将申明已断开并永久关闭。Default: false
-->
<property name="breakAfterAcquireFailure">
<value>true</value>
</property>
<!--
因性能消耗大请只在需要的时候使用它。如果设为true那么在每个connection提交的
时候都将校验其有效性。建议使用idleConnectionTestPeriod或automaticTestTable
等方法来提升连接测试的性能。Default: false
-->
<property name="testConnectionOnCheckout">
<value>false</value>
</property>
</bean>
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="configLocation" value="classpath:hibernate.cfg.xml" />
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">${hibernate.dialect}</prop>
<prop key="hibernate.cache.use_second_level_cache">false</prop>
<prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop>
<prop key="show_sql">true</prop>
</props>
</property>
</bean>
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
</beans>

2、创建单元测试类

在src\test\java\com\ceair\app创建UserDaoTest.java，代码如下：

package com.ceair.app;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import com.ceair.app.dao.BaseDaoTestCase;
import com.ceair.app.dao.GenericDao;
import com.ceair.app.model.User;
public class UserDaoTest extends BaseDaoTestCase {
@Autowired
private GenericDao<User, Long> userDao;
@Test
public void testUserById() throws Exception {
User people = userDao.get(new Long(-2));
assertEquals("管理员", people.getName());
}
@Test
public void testAddAndRemovePerson() throws Exception {
User person = new User();
person.setId(new Long(3));
person.setName("陈小林");
person = userDao.save(person);
flush();
person = userDao.get(person.getId());
assertEquals("陈小林", person.getName());
assertNotNull(person.getId());
person.setName("陈小");
flush();
person = userDao.get(person.getId());
assertEquals("陈小", person.getName());
assertNotNull(person.getId());
}
}

注意：1、测试数据有的来自于sample-data.xml如21行（User people = userDao.get( new Long(- 2 )); ）主键为-2的对象。

以上工作全部完成后，打开命令行进入项目目录运行mvn test就可以运行单元测试。

如果我们除了CRUD功能还需要其它方法呢？我们接下去将演示自定义接口和声明式事务

1、在src\main\java\com\ceair\app\dao下创建UserDao.java，代码如下：

package com.ceair.app.dao;
import java.util.List;
import org.hibernate.criterion.DetachedCriteria;
import com.ceair.app.model.User;
public interface UserDao extends GenericDao<User, Long> {
public List<User> findByCrteria(DetachedCriteria crteria);
public void changeName(String id,String newName) throws Exception;
}

2、在src\main\java\com\ceair\app\dao\hibernate下创建UserDaoHibernate.java，代码如下：

package com.ceair.app.dao.hibernate;
import java.util.List;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Restrictions;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import com.ceair.app.dao.UserDao;
import com.ceair.app.model.User;
public class UserDaoHibernate extends GenericDaoHibernate<User, Long> implements UserDao {
public UserDaoHibernate() {
super(User.class);
}
@SuppressWarnings("unchecked")
//@Transactional(readOnly = true, propagation=Propagation.SUPPORTS) 执行读操作的时候，避免使用@Transactional，如果要使用，那就如此所示用法
public List<User> findByCrteria(DetachedCriteria crteria) {
return getHibernateTemplate().findByCriteria(crteria);
}
/*
* Required : 如果在一个事务中调用，就将该方法加到此事务中，如果没有启动事务，就创建新事务
*
* RequiredNew ：不管当前有没有事务，都启动新事务，如果有，会被挂起，直到此方法结束
*
* NotSupported ：不能在事务中执行此方法，如果有事务，会被挂起，直到此方法结束
*
* Supports ：如果有当前事务，此方法回加到当前事务，如果没有，容器不会启动新事务
*
* Mandatory ：必须在事务中执行此方法，否则会抛出异常： TransactionRequiredException
*
* Never ：必须不在事务中调用此方法，否则抛出RemoteException(远程调用)或EJBException(本地调用)
*
*/
@Transactional(
propagation = Propagation.REQUIRED,
isolation = Isolation.DEFAULT,//锁级别
rollbackFor = Exception.class
)
public void changeName(String id, String newName) throws Exception {
DetachedCriteria crteria = DetachedCriteria.forClass(User.class);
crteria.add(Restrictions.eq("id", new Long(id)));
List<User> userList = getHibernateTemplate().findByCriteria(crteria);
User user = userList.get(0);
user.setName(newName);
getHibernateTemplate().update(user);
// throw new Exception();//rollback
}
}

注意：1、去掉55行（ throw new Exception();//rollback ）的注释，会回滚数据库操作。

3、修改\src\main\resources下的applicationContext.xml文件，修改后文件内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<bean id="helloWorldAction" class="com.ceair.app.HelloWorldAction" />
<bean id="userAction" class="com.ceair.app.action.UserAction"/>
<context:annotation-config/>
<context:component-scan base-package="com.ceair"/>
<tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

注意：1、增加了13行（ <context:annotation-config/> ）声明（支持SPRING事务标注），增加第5（ xmlns:tx = "http://www.springframework.org/schema/tx"）,第8（ http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd ）行的命名空间声明。

4、修改\src\main\resources下的applicationContext-dao.xml文件，修改后文件内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jee="http://www.springframework.org/schema/jee"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.0.xsd">
<bean id="userCustomDao" class="com.ceair.app.dao.hibernate.UserDaoHibernate" >
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
</beans>

注意：1、增加7-8行，把原来的Bean userDao删除了

5、修改src\test\java\com\ceair\app下的UserDaoTest.java,修改后内容如下：

package com.ceair.app;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import com.ceair.app.dao.BaseDaoTestCase;
import com.ceair.app.dao.UserDao;
import com.ceair.app.model.User;
public class UserDaoTest extends BaseDaoTestCase {
@Autowired
private UserDao userCustomDao;
@Test
public void testUserById() throws Exception {
User people = userCustomDao.get(new Long(-2));
assertEquals("管理员", people.getName());
}
@Test
public void testAddAndRemovePerson() throws Exception {
User person = new User();
person.setId(new Long(3));
person.setName("陈小林");
person = userCustomDao.save(person);
flush();
person = userCustomDao.get(person.getId());
assertEquals("陈小林", person.getName());
assertNotNull(person.getId());
person.setName("陈小");
flush();
person = userCustomDao.get(person.getId());
assertEquals("陈小", person.getName());
assertNotNull(person.getId());
log.debug("removing person...");
}
}

6、在src\test\java\com\ceair\app下创建UserCustomDaoTest.java，代码内容如下：

package com.ceair.app;
import java.util.List;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Restrictions;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import com.ceair.app.dao.BaseDaoTestCase;
import com.ceair.app.dao.UserDao;
import com.ceair.app.model.User;
public class UserCustomDaoTest extends BaseDaoTestCase {
@Autowired
private UserDao userCustomDao;
@Test
public void testFindByCrteria() throws Exception {
DetachedCriteria crteria=DetachedCriteria.forClass(User.class);
crteria.add(Restrictions.eq("name", "管理员"));
List<User> userList=userCustomDao.findByCrteria(crteria);
assertEquals("管理员", userList.get(0).getName());
assertEquals(new Long(-2), userList.get(0).getId());
}
@Test
public void testChangeName() throws Exception {
userCustomDao.changeName("-2", "新管理员");
flush();
User people = userCustomDao.get(new Long(-2));
assertEquals("新管理员", people.getName());
}
}

注意：1、事务测试前可以把BaseDaoTestCase.java59行（不回滚测试产生的数据）和UserDaoHibernate .java55行（抛出异常，回滚事务）和的注释去除，然后去数据库中查看是否更改名字成功。

以上工作全部完成后，打开命令行进入项目目录运行mvn test就可以运行单元测试。

关于事务的深入研究可以查看 http://www.ibm.com/developerworks/cn/java/j-ts1.html

转载于:https://blog.51cto.com/tangjj/349226

weixin_34000916

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
泛型DAO,SPRING声明式事务

之前的博文中我们搭建了一个基本的开发环境，现在让我们给这个项目加上CRUD和基本的单元测试。1、创建泛型DAO的相关类在src\main\java\com\ceair\app\dao下创建GenericDao.java（APPFUSE2中的代码），代码内容如下：packagecom.ceair.app.dao; importjava.io.Serializab...
复制链接

扫一扫