单元测试作为保证软件质量及重构的基础，早已获得广大开发人员的认可。单元测试是一种细粒度的测试，越来越多的开发人员在提交功能模块时也同时提交相应的单元测试。对于大多数开发人员来讲，编写单元测试已经成为开发过程中必须的流程和最佳实践。

　　对普通的逻辑组件编写单元测试是一件容易的事情，由于逻辑组件通常只需要内存资源，因此，设置好输入输出即可编写有效的单元测试。对于稍微复杂一点的组件，例如Servlet，我们可以自行编写模拟对象，以便模拟HttpRequest和HttpResponse等对象，或者，使用EasyMock之类的动态模拟库，可以对任意接口实现相应的模拟对象，从而对依赖接口的组件进行有效的单元测试。

　　在J2EE开发中，对DAO组件编写单元测试往往是一件非常复杂的任务。和其他组件不通，DAO组件通常依赖于底层数据库，以及JDBC接口或者某个ORM框架（如Hibernate），对DAO组件的测试往往还需引入事务，这更增加了编写单元测试的复杂性。虽然使用EasyMock也可以模拟出任意的JDBC接口对象，或者ORM框架的主要接口，但其复杂性往往非常高，需要编写大量的模拟代码，且代码复用度很低，甚至不如直接在真实的数据库环境下测试。不过，使用真实数据库环境也有一个明显的弊端，我们需要准备数据库环境，准备初始数据，并且每次运行单元测试后，其数据库现有的数据将直接影响到下一次测试，难以实现“即时运行，反复运行”单元测试的良好实践。

　　本文针对DAO组件给出一种较为合适的单元测试的编写策略。在JavaEE开发网的开发过程中，为了对DAO组件进行有效的单元测试，我们采用HSQLDB这一小巧的纯Java数据库作为测试时期的数据库环境，配合Ant，实现了自动生成数据库脚本，测试前自动初始化数据库，极大地简化了DAO组件的单元测试的编写。
在Java领域，JUnit作为第一个单元测试框架已经获得了最广泛的应用，无可争议地成为Java领域单元测试的标准框架。本文以最新的JUnit 4版本为例，演示如何创建对DAO组件的单元测试用例。

　　JavaEEdev的持久层使用Hibernate 3.2，底层数据库为MySQL。为了演示如何对DAO进行单元测试，我们将其简化为一个DAOTest工程：

　　由于将Hibernate的Transaction绑定在Thread上，因此，HibernateUtil类负责初始化SessionFactory以及获取当前的Session：

　public class HibernateUtil {

  private static final  SessionFactory sessionFactory;

  static {

  try {

  sessionFactory =  new AnnotationConfiguration()

  .configure()

  .buildSessionFactory();

  }

  catch(Exception e) {

  throw new  ExceptionInInitializerError(e);

  }

  }
  public static Session  getCurrentSession() {

  return  sessionFactory.getCurrentSession();

  }

  }

  HibernateUtil还包含了一些辅助方法，如：

  public static Object query(Class clazz, Serializable id);
  public static void createEntity(Object entity);
  public static Object queryForObject(String hql, Object[] params);
  public static List queryForList(String hql, Object[] params);
  　　在此不再多述。

　　实体类User使用JPA注解，代表一个用户：

  @Entity
  @Table(name="T_USER")
  public class User {
  public static final  String REGEX_USERNAME = "[a-z0-9][a-z0-9\\-]{1,18}[a-z0-9]";
  public static final  String REGEX_PASSWORD = "[a-f0-9]{32}";
  public static final  String REGEX_EMAIL = "([0-9a-zA-Z]([-.\\w]*[0-9a-zA-Z])*@([0-9a-zA-Z][-\\w]*[0-9a-zA-Z]\\.)+[a-zA-Z]{2,9})"; 
  private String  username;     // 用户名
  private String  password;     // MD5口令
  private boolean  admin;       // 是否是管理员
  private String  email;        // 电子邮件
  private int  emailValidation; // 电子邮件验证码
  private long  createdDate;    // 创建时间
  private long  lockDate;       // 锁定时间  
  public User() {} 
  public User(String  username, String password, boolean admin, long lastSignOnDate) {
  this.username = username;
  this.password =  password;
  this.admin = admin;
  } 
  @Id
  @Column(updatable=false,  length=20)
  @Pattern(regex=REGEX_USERNAME)
  public String  getUsername() { return username; }
  public void setUsername(String  username) { this.username = username; } 
  @Column(nullable=false,  length=32)
  @Pattern(regex=REGEX_PASSWORD)
  public String  getPassword() { return password; }
  public void  setPassword(String password) { this.password = password; } 
  @Column(nullable=false,  length=50)
  @Pattern(regex=REGEX_EMAIL)
  public String getEmail()  { return email; }
  public void  setEmail(String email) { this.email = email; } 
  @Column(nullable=false)
  public boolean getAdmin()  { return admin; }
  public void  setAdmin(boolean admin) { this.admin = admin; } 
  @Column(nullable=false,  updatable=false)
  public long  getCreatedDate() { return createdDate; }
  public void  setCreatedDate(long createdDate) { this.createdDate = createdDate; } 
  @Column(nullable=false)
  public int  getEmailValidation() { return emailValidation; }
  public void  setEmailValidation(int emailValidation) { this.emailValidation =  emailValidation; } 
  @Column(nullable=false)
  public long getLockDate()  { return lockDate; }
  public void  setLockDate(long lockDate) { this.lockDate = lockDate; }
  @Transient
  public boolean  getEmailValidated() { return emailValidation==0; } 
  @Transient
  public boolean  getLocked() {
  return !admin  && lockDate>0 && lockDate>System.currentTimeMillis();
  }
  }
  　　实体类PasswordTicket代表一个重置口令的请求：

  @Entity
  @Table(name="T_PWDT")
  public class PasswordTicket {
  private String id;
  private User user;
  private String ticket;
  private long createdDate;
  @Id
  @Column(nullable=false, updatable=false,  length=32)
  @GeneratedValue(generator="system-uuid")
  @GenericGenerator(name="system-uuid",  strategy="uuid")
  public String getId() {  return id; }
  protected void  setId(String id) { this.id = id; }
  @ManyToOne
  @JoinColumn(nullable=false, updatable=false)
  public User getUser() {  return user; }
  public void setUser(User  user) { this.user = user; }
  @Column(nullable=false,  updatable=false, length=32)
  public String getTicket()  { return ticket; }
  public void  setTicket(String ticket) { this.ticket = ticket; }
  @Column(nullable=false,  updatable=false)
  public long  getCreatedDate() { return createdDate; }
  public void  setCreatedDate(long createdDate) { this.createdDate = createdDate; }
  }
  　　UserDao接口定义了对用户的相关操作：

　public interface UserDao {
  User  queryForSignOn(String username);
  User queryUser(String  username);
  void createUser(User  user);
  void updateUser(User  user);
  boolean  updateEmailValidation(String username, int ticket);
  String  createPasswordTicket(User user);
  boolean  updatePassword(String username, String oldPassword, String newPassword);
  boolean  queryResetPassword(User user, String ticket);
  boolean  updateResetPassword(User user, String ticket, String password);
  void updateLock(User  user, long lockTime);
  void updateUnlock(User  user);
  }
  　　UserDaoImpl是其实现类：

　public class UserDaoImpl implements UserDao {
  public User  queryForSignOn(String username) {
  User user =  queryUser(username);
  if(user.getLocked())
  throw new  LockException(user.getLockDate());
  return user;
  }
　public User  queryUser(String username) {
  return (User)  HibernateUtil.query(User.class, username);
  }
　public void  createUser(User user) {
  user.setEmailValidation((int)(Math.random() * 1000000) + 0xf);
  HibernateUtil.createEntity(user);
  }
  // 其余方法略
  ...
  }
  　　由于将Hibernate事务绑定在Thread上，因此，实际的客户端调用DAO组件时，还必须加入事务代码：

　Transaction tx =  HibernateUtil.getCurrentSession().beginTransaction();
  try {
  dao.xxx();
  tx.commit();
  }
  catch(Exception e) {
  tx.rollback();
  throw e;
  }

　　下面，我们开始对DAO组件编写单元测试。前面提到了HSQLDB这一小巧的纯Java数据库。HSQLDB除了提供完整的JDBC驱动以及事务支持外，HSQLDB还提供了进程外模式（与普通数据库类似）和进程内模式（In-Process），以及文件和内存两种存储模式。我们将HSQLDB设定为进程内模式及仅使用内存存储，这样，在运行JUnit测试时，可以直接在测试代码中启动HSQLDB。测试完毕后，由于测试数据并没有保存在文件上，因此，不必清理数据库。

　　此外，为了执行批量测试，在每个独立的DAO单元测试运行前，我们都执行一个初始化脚本，重新建立所有的表。该初始化脚本是通过HibernateTool自动生成的，稍后我们还会讨论。下图是单元测试的执行顺序：
 

　　在编写测试类之前，我们首先准备了一个TransactionCallback抽象类，该类通过Template模式将DAO调用代码通过事务包装起来：

　public abstract class TransactionCallback {
  public final Object  execute() throws Exception {
  Transaction tx =  HibernateUtil.getCurrentSession().beginTransaction();
  try {
  Object r =  doInTransaction();
  tx.commit();
  return r;
  }
  catch(Exception e) {
  tx.rollback();
  throw e;
  }
  }
  // 模板方法：
  protected abstract Object  doInTransaction() throws Exception;
  }
  　　其原理是使用JDK提供的动态代理。由于JDK的动态代理只能对接口代理，因此，要求DAO组件必须实现接口。如果只有具体的实现类，则只能考虑CGLIB之类的第三方库，在此我们不作更多讨论。

　　下面我们需要编写DatabaseFixture，负责启动HSQLDB数据库，并在@Before方法中初始化数据库表。该DatabaseFixture可以在所有的DAO组件的单元测试类中复用：

　public class DatabaseFixture {
  private static Server  server = null; // 持有HSQLDB的实例
  private static final  String DATABASE_NAME = "javaeedev"; // 数据库名称
  private static final  String SCHEMA_FILE = "schema.sql"; // 数据库初始化脚本
  private static final  List<String> initSqls = new ArrayList<String>();
　@BeforeClass // 启动HSQLDB数据库
  public static void  startDatabase() throws Exception {
  if(server!=null)
  return;
  server = new  Server();
  server.setDatabaseName(0,  DATABASE_NAME);
  server.setDatabasePath(0, "mem:" + DATABASE_NAME);
  server.setSilent(true);
  server.start();
  try {
  Class.forName("org.hsqldb.jdbcDriver");
  }
  catch(ClassNotFoundException cnfe) {
  throw new  RuntimeException(cnfe);
  }
  LineNumberReader  reader = null;
  try {
  reader = new  LineNumberReader(new  　　　InputStreamReader(DatabaseFixture.class.getClassLoader().getResourceAsStream(SCHEMA_FILE)));
  for(;;) {
  String line =  reader.readLine();
  if(line==null) break;
  // 将text类型的字段改为varchar(2000)，因为HSQLDB不支持text：
  line =  line.trim().replace(" text ", " varchar(2000)  ").replace(" 　text,", " varchar(2000),");
  if(!line.equals(""))
  initSqls.add(line);
  }
  }
  catch(IOException e)  {
  throw new  RuntimeException(e);
  }
  finally {
  if(reader!=null)  {
  try {  reader.close(); } catch(IOException e) {}
  }
  }
  }
　@Before // 执行初始化脚本
  public void initTables()  {
  for(String sql :  initSqls) {
  executeSQL(sql);
  }
  }
static Connection  getConnection() throws SQLException {
  return  DriverManager.getConnection("jdbc:hsqldb:mem:" + DATABASE_NAME,  "sa", "");
  }
static void  close(Statement stmt) {
  if(stmt!=null) {
  try {
  stmt.close();
  }
  catch(SQLException e) {}
  }
  }
static void  close(Connection conn) {
  if(conn!=null) {
  try {
  conn.close();
  }
  catch(SQLException e) {}
  }
  }
static void  executeSQL(String sql) {
  Connection conn =  null;
  Statement stmt =  null;
  try {
  conn =  getConnection();
  boolean  autoCommit = conn.getAutoCommit();
  conn.setAutoCommit(true);
  stmt = conn.createStatement();
  stmt.execute(sql);
  conn.setAutoCommit(autoCommit);
  }
  catch(SQLException e)  {
  log.warn("Execute failed: " + sql + "\nException: "  + e.getMessage());
  }
  finally {
  close(stmt);
  close(conn);
  }
  }
public static Object  createProxy(final Object target) {
  return  Proxy.newProxyInstance(
  target.getClass().getClassLoader(),
  target.getClass().getInterfaces(),
  new  InvocationHandler() {
  public  Object invoke(Object proxy, final Method method, final Object[] args) throws  Throwable {
  return new TransactionCallback() {
  @Override
  protected Object doInTransaction() throws Exception {
  return method.invoke(target, args);
  }
  }.execute();
  }
  }
  );
  }
  }
  　　注意DatabaseFixture的createProxy()方法，它将一个普通的DAO对象包装为在事务范围内执行的代理对象，即对于一个普通的DAO对象的方法调用前后，自动地开启事务并根据异常情况提交或回滚事务。

　　下面是UserDaoImpl的单元测试类：

　public class UserDaoImplTest extends DatabaseFixture {
  private UserDao userDao =  new UserDaoImpl();
  private UserDao proxy =  (UserDao)createProxy(userDao);
　@Test
  public void  testQueryUser() {
  User user =  newUser("test");
  proxy.createUser(user);
  User t =  proxy.queryUser("test");
  assertEquals(user.getEmail(), t.getEmail());
  }
  }
  　　注意到UserDaoImplTest持有两个UserDao引用，userDao是普通的UserDaoImpl对象，而proxy则是将userDao进行了事务封装的对象。

　　对于普通的测试，如UserDao.queryUser()方法，直接调用proxy.queryUser()即可在事务内执行查询，获得返回结果。

　　对于异常测试，例如期待一个ResourceNotFoundException，就不能直接调用proxy.queryUser()方法，否则，将得到一个UndeclaredThrowableException：

　　这是因为通过反射调用抛出的异常被代理类包装为UndeclaredThrowableException，因此，对于异常测试，只能使用原始的userDao对象配合TransactionCallback实现：

　@Test(expected=ResourceNotFoundException.class)

  public void testQueryNonExistUser() throws Exception {

  new TransactionCallback()  {

  protected Object  doInTransaction() throws Exception {

  userDao.queryUser("nonexist");

  return null;

  }

  }.execute();

  }
  

　　到此为止，对DAO组件的单元测试已经实现完毕。下一步，我们需要使用HibernateTool自动生成数据库脚本，免去维护SQL语句的麻烦。相关的Ant脚本片段如下：

　<target name="make-schema" depends="build"  description="create schema">

  <taskdef  name="hibernatetool" classname="org.hibernate.tool.ant.HibernateToolTask">

  <classpath  refid="build-classpath"/>

  </taskdef>

  <taskdef  name="annotationconfiguration"  classname="org.hibernate.tool.ant.AnnotationConfigurationTask">

  <classpath  refid="build-classpath"/>

  </taskdef>

  <annotationconfiguration  configurationfile="${src.dir}/hibernate.cfg.xml"/>

  <hibernatetool  destdir="${gen.dir}">

  <classpath  refid="build-classpath"/>

  <annotationconfiguration  configurationfile="${src.dir}/hibernate.cfg.xml"/>

  <hbm2ddl

  export="false"

  drop="true"

  create="true"

  delimiter=";"

  outputfilename="schema.sql"

  destdir="${src.dir}"

  />

  </hibernatetool>

  </target>
  

　　完整的Ant脚本以及Hibernate配置文件请参考项目工程源代码。

　　利用HSQLDB，我们已经成功地简化了对DAO组件进行单元测试。我发现这种方式能够找出许多常见的bug：

• HQL语句的语法错误，包括SQL关键字和实体类属性的错误拼写，反复运行单元测试就可以不断地修复许多这类错误，而不需要等到通过Web页面请求而调用DAO时才发现问题；
• 传入了不一致或者顺序错误的HQL参数数组，导致Hibernate在运行期报错；
• 一些逻辑错误，包括不允许的null属性（常常由于忘记设置实体类的属性），更新实体时引发的数据逻辑状态不一致。

　　总之，单元测试需要根据被测试类的实际情况，编写最简单最有效的测试用例。本文旨在给出一种编写DAO组件单元测试的有效方法。