Java Web Application 自架构 三 通用DAO类实现

        准备好了单元测试模块，就写个底层的数据访问的控制Handle类来试试吧。也就是通常我们所说的DAO类。一般而言，每个模型/实体类需要建立一个DAO类。 不过经验告诉我们，一些通用的CRUD方法几乎在每个DAO类中都是一样的，那么也就是说我们通常所写的DAO会有些代码冗余的问题，而且根据业务需要，日后的维护工作有可能添加一些新的实体类，写地越多，DAO类就越多，写的代码就越多余还浪费时间。如何将写好的一个DAO类进行代码重用成为了问题。其实笔者见过一个的系统里有做过将Hibernate框架人应用做成静态类，用到时直接HibernateUtil.save()的。今天，咱也做一个通用的DAO放一些通用的CRUD方法进去，用来做通用的CRUD操作。这样做既省去了不少代码量，加强了代码可读性，而且还方便快捷地架构起这个WebModel，可以重用到很多的系统中。当然，遇到特殊的Entity 需要建个别的DAO时再当别论。

       

      首先是接口的编写，我在接口的编写时加了很多的JavaDoc,就不贴出代码了，上传为附件方便读者下载吧。此处列出几个方法做简单说明

package com.xxxxx.webmodel.pin;

import java.util.List;
import java.util.Map;
      public interface IPersistencePin {
	public void createPersistingEntity(Object persistingObj) throws Exception;
	public <PerE> PerE retrievePersistedEntity(Class<PerE> persistedClass,
			long id) throws Exception;
	public <PerE> PerE retrievePersistedEntity(Class<PerE> persistedClass,
			String identifier) throws Exception;
	public <PerE> List<PerE> retrievePersistedEntityAllInList(
			Class<PerE> persistedClass) throws Exception;
	public void updatePersistedEntity(Object persistingObj) throws Exception;
	public void deletePersistedEntity(Object persistingObj) throws Exception;
}

 

接口的实现：

package com.xxxxx.webmodel.pin.impl;

/*省略多个import 语句*/
import com.gxino.webmodel.pin.IPersistencePin;
@Repository
public class HibernatePersistencePin implements Serializable,IPersistencePin {
	private static final long serialVersionUID = -295800418896667101L;
	private SessionFactory sessionFactory;
	public static long getSerialversionuid() {
		return serialVersionUID;
	}

	public SessionFactory getSessionFactory() {
		return sessionFactory;
	}
	@Resource
	public void setSessionFactory(SessionFactory sessionFactory) {
		this.sessionFactory = sessionFactory;
	}
}

       其中，第一个方法 createPersistingEntity(Object persistingObj) 将Map到Hibernate 中的任意Pojo的对象持久化，即将某实体类的一个对象的各项属性值存入数据库。

@Override
  public void createPersistingEntity(Object persistingObj) throws Exception {
	Session session = null;
	boolean needCloseSession = false;
	try{
		session = sessionFactory.getCurrentSession();
		if(session==null)throw new HibernateException("No current Session");
	}catch(HibernateException he){
		session = sessionFactory.openSession();
		needCloseSession = true;
	}
	try{
		session.save(persistingObj);
		if(needCloseSession)session.close();
	}catch(HibernateException he){
		throw new Exception("Save Pojo failed, because of "+he.getMessage());
	}
}

 

      笔者在该方法中做了currentSession与openSession双处理，也就是说该方法既可以是业务逻辑进行事务中的某一句，也可以无事务信赖地被单独调用。后面的update 方法与delete方法以及通过id从数据库中查出该对象的方法是如出一辙，只是session.save(persistingOjb)换成其他语句，就不贴代码了。贴一下另两个方法的第二个Try块中的代码吧:

 

      1，<PerE> PerE retrievePersistedEntity(Class<PerE> persistedClass,

String uniquePropertyName, Object propertyValue)

传入一个唯一键值的名值对找出类对象：

Criteria criteria = session.createCriteria(persistedClass);
criteria.add(Restrictions.eq(uniquePropertyName, propertyValue));
@SuppressWarnings("unchecked")
PerE result = (PerE)criteria.uniqueResult();
if(needCloseSession)session.close();
return result;

 

 

       这里用到了Hibernate的Criteria与Restrictions,其实还有个Example类。 关于这一点，网络上有好多高手有解盲它的专题用法的帖子，笔者就不作大篇文章说它了。感觉这个比起写hql更 『面向对象』 一点儿，好用且易理解，所以特意贴在这里一个，以提醒自己与读者们可以这样去写。其实用了它的代码都是白话文，简单提一下： 从Session中创建一个某pojo人“基准”，用一些 “条件”，或是举例的方式，限定这个查询基准，之后按这个限定的标准查出具体对象。

查找所有对象到一个List中也不多说了，criteria不add任何限制，直接criteria.list();就好.

 

       2，<PerE> PerE retrievePersistedEntity(Class<PerE> persistedClass,

String identifier) throws Exception;吧

        无需给出唯一键的名，只需要唯一键的值，即去查询到该实体类对象。不过由于一个表中，可能有多个唯一键，这样就会产生冲突。例如，用户名和Email两个唯一性字段，用户A用[e-mail]作用户名，用户B用[e-mail]作email，这种情况下查询到用户的结果就不仅是A而且还有B了。所以笔者将它在接口里就标了@deprecated。

同样，只贴第二个try块中应放的代码。

String propertyName=null;
Method[] methodArray =persistedClass.getMethods();
if(methodArray!=null)for(Method method:methodArray){
	if(method.getName().startsWith("get")){
		Criteria criteria = session.createCriteria(persistedClass);
		Annotation anno = method.getAnnotation(Column.class);
		if(anno.toString().contains("unique=true")){
			propertyName = Character.toString(method.getName().charAt(3)).toLowerCase()+method.getName().substring(4);
			criteria.add(Restrictions.eq(propertyName, identifier));
		}
		@SuppressWarnings("unchecked")
		PerE result = (PerE)criteria.uniqueResult();
		if(needCloseSession)session.close();
		return result;
	}
}
if(needCloseSession)session.close();
return null;

 

        这方法的实现需要javax.persistence.Column这一注解到实体类中的每一个属性做配合。换句话说，Hibernate的Mapping是注解方式的。 Column注解在JPA的规范中, hibernate框架有JPA的实现，在hibernate-jpa-2.0-api-x.x.x-Final.jar包中。 上面代码用到了反射，主要意思是：找到该Pojo类中所有属性的getter，通过查看该getter上是否注解有@Column并且注解的一个属性unique值为true，来找到相应的属性名，然后用名值对限定查询标准去查出实体类对象。

 

        至于怎么用JPA注解配置Pojo，也可以作为专题发表一篇文章了，笔者就不多叙述，直接在附件夹带一些实体类了，实体类如何map到sessionFactory中也在第一篇《xxx 注解化配置》的ApplicationContext.java中出现，代码在配置sessionFactory 的@Bean的方法中：

@SuppressWarnings("rawtypes")
Class[] entities = new Class[2];
entities[0] = AccountEntity.class;
entities[1] = ActionLogEntity.class;
asfBean.setAnnotatedClasses(entities);

 

 

       另外，有些读者可能已经发现，上述通用DAO中的实现中，每个方法也几乎重用了好多地方，只是改变了中间的核心部分，可不可以用一个固定的方法将每个方法的核心语句包住，就像是让Spring代管Transactional一样，很明显，我们会想到AOP，顺便将log也做到AOP中，不过这一篇就不多讨论了。先就这样用着。

最后，别忘了写单元测试类。

package com.xxxxx.webmodel.test.pin;

import static org.junit.Assert.fail;

import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;

import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.TestExecutionListeners;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.support.DependencyInjectionTestExecutionListener;
import org.springframework.test.context.support.DirtiesContextTestExecutionListener;
import org.springframework.test.context.transaction.TransactionConfiguration;
import org.springframework.test.context.transaction.TransactionalTestExecutionListener;
import org.springframework.transaction.annotation.Transactional;

import com.xxxxx.webmodel.entity.AccountEntity;
import com.xxxxx.webmodel.entity.ActionLogEntity;
import com.xxxxx.webmodel.pin.IPersistencePin;
import com.xxxxx.webmodel.util.ApplicationContext;
import com.xxxxx.webmodel.util.WebConfiguration;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes={ApplicationContext.class})
@TestExecutionListeners( { DependencyInjectionTestExecutionListener.class, DirtiesContextTestExecutionListener.class, TransactionalTestExecutionListener.class })
@TransactionConfiguration(defaultRollback=true,transactionManager="hibernateTransactionManager")
@Transactional
public class PersistencePinTest {
	private IPersistencePin persistPin;
	private Map<String,Object> usedStuff;
	
	public IPersistencePin getPersistPin() {
		return persistPin;
	}
	@Resource
	public void setPersistPin(IPersistencePin persistPin) {
		this.persistPin = persistPin;
	}
	
	@BeforeClass
	public static void init() throws Exception{
			new WebConfiguration().onStartup(null);
	}
	
	@Before
	public void setUp() throws Exception{
		if(usedStuff==null)
			usedStuff = new HashMap<String,Object>();
		AccountEntity account = new AccountEntity();
		account.setUserName("junittest");
		account.setPassword("junittest");
		account.setEmail("[e-mail]");
		account.setAlias("unitTest");
		account.setAge((short)18);
		account.setGender("Male");
		account.setCreatedAt(new Date());
		persistPin.createPersistingEntity(account);
		usedStuff.put("userId", new Long(account.getId()));
		usedStuff.put("userName", account.getUserName());
		usedStuff.put("userEmail", account.getEmail());
        
		ActionLogEntity actionLog = new ActionLogEntity();
		actionLog.setAction("Junit Test");
		actionLog.setActor(account);
		actionLog.setHappenTime(new Date());
		try{persistPin.createPersistingEntity(actionLog);}
		catch(Exception e){
			e.printStackTrace();
			}
		usedStuff.put("actionId", new Long(actionLog.getId()));
		usedStuff.put("actionTime", actionLog.getHappenTime());
	}

	@Test
	@Ignore
	public final void testHibernateSession() throws Exception{
		/*Please not execute @Before setUp() method, for test this, and NO 				@TransactionConfiguration NO @Transactional*/
		/*Also make other test methods @Ignore*/
		AccountEntity account = new AccountEntity();
		account.setUserName("junittest");
		account.setPassword("junittest");
		account.setEmail("[e-mail]");
		account.setAlias("unitTest");
		account.setAge((short)18);
		account.setGender("Male");
		account.setCreatedAt(new Date());
		persistPin.createPersistingEntity(account);
		persistPin.deletePersistedEntity(account);
	}
}

 

具体的其他测试方法在附件的文件中，或是读者们自行去写会比笔者的要好很多。

附件中有源码，在很下面哦，请您仔细找一下