`
CoderDream
  • 浏览: 478446 次
  • 性别: Icon_minigender_1
  • 来自: 武汉
社区版块
存档分类
最新评论

DBUnit最佳实践之增删改查

 
阅读更多

DBUnit最佳实践之增删改查 。

 

目录结构

  • 项目结构图
  • 源代码
    1. 数据库工具类

    2. 学生数据访问对象

    3. 测试辅助类
    4. 测试对象比对辅助类
    5. 数据库测试辅助类
    6. 测试类
    7. 数据文件
    8. Maven工程文件
    9. 数据库配置属性文件
    10. 数据库脚本
    11. 日志配置文件
  • 参考文档
  • 完整项目源代码

项目结构图

源代码

数据库工具类

DBUtil.java

package com.coderdream;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ResourceBundle;

/**
 * @author CoderDream
 * @date 2014年10月15日
 * 
 */
public class DBUtil {

	/**
	 * 获得数据库连接
	 * 
	 * @return
	 */
	public static Connection getConnection() {
		Connection conn = null;
		try {
			// 读取数据库配置文件
			ResourceBundle rs = ResourceBundle.getBundle("dbutil");
			// 加载驱动
			Class.forName(rs.getString("db.classname"));
			// 得到数据库连接
			conn = DriverManager.getConnection(rs.getString("db.url"), rs.getString("db.username"), rs.getString("db.password"));
		} catch (ClassNotFoundException e) {
			System.out.println("数据库驱动加载失败,堆栈轨迹如下");
			e.printStackTrace();
		} catch (SQLException e) {
			System.out.println("数据库连接创建失败,堆栈轨迹如下");
			e.printStackTrace();
		}
		return conn;
	}

	/**
	 * 关闭所有对象
	 * 
	 * @param rs
	 * @param pstmt
	 * @param conn
	 */
	public static void closeAll(ResultSet rs, PreparedStatement pstmt, Connection conn) {
		if (null != rs) {
			try {
				rs.close();
			} catch (SQLException e) {
				System.out.println("数据库操作的ResultSet关闭失败,堆栈轨迹如下");
				e.printStackTrace();
			}
		}
		if (null != pstmt) {
			try {
				pstmt.close();
			} catch (SQLException e) {
				System.out.println("数据库操作的PreparedStatement关闭失败,堆栈轨迹如下");
				e.printStackTrace();
			}
		}
		close(conn);
	}

	/**
	 * 关闭数据库连接
	 * 
	 * @param conn
	 */
	public static void close(Connection conn) {
		if (null != conn) {
			try {
				conn.close();
				if (conn.isClosed()) {
					System.out.println("此数据库连接已关闭-->" + conn);
				} else {
					System.out.println("此数据库连接关闭失败-->" + conn);
				}
			} catch (SQLException e) {
				System.out.println("数据库连接关闭失败,堆栈轨迹如下");
				e.printStackTrace();
			}
		}
	}

}

学生实体

Student.java

package com.coderdream;

/**
 * 实体类
 * 
 * @author CoderDream
 * @date 2014年10月15日
 * 
 */
public class Student {
	private String id;
	private String name;
	private String sex;
	private String birthday;

	public Student() {
	}

	public Student(String id, String name, String sex, String birthday) {
		super();
		this.id = id;
		this.name = name;
		this.sex = sex;
		this.birthday = birthday;
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

	public String getBirthday() {
		return birthday;
	}

	public void setBirthday(String birthday) {
		this.birthday = birthday;
	}

}

学生数据访问对象

StudentDao.java

 

package com.coderdream;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

/**
 * @author CoderDream
 * @date 2014年10月15日
 * 
 */
public class StudentDao {

	/**
	 * 增加学生
	 * 
	 * @param student
	 * @return
	 */
	public int addStudent(Student student) {
		int result = 0;
		Connection conn = null;
		try {
			conn = DBUtil.getConnection();
			String sql = "insert into student(id,name,sex,birthday) values(?,?,?,?)";
			PreparedStatement ps = conn.prepareStatement(sql);
			ps.setString(1, student.getId());
			ps.setString(2, student.getName());
			ps.setString(3, student.getSex());
			ps.setString(4, student.getBirthday());
			result = ps.executeUpdate();
		} catch (Exception ex) {
			ex.printStackTrace();
		} finally {
			if (null != conn) {
				try {
					conn.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
		}
		return result;
	}

	/**
	 * 修改学生
	 * 
	 * @param student
	 * @return
	 */
	public int updateStudent(Student student) {
		int result = 0;
		Connection conn = null;
		try {
			conn = DBUtil.getConnection();
			String sql = "update student set name=?,sex=?,birthday=? where id=?";
			PreparedStatement ps = conn.prepareStatement(sql);
			ps.setString(1, student.getName());
			ps.setString(2, student.getSex());
			ps.setString(3, student.getBirthday());
			ps.setString(4, student.getId());
			result = ps.executeUpdate();
		} catch (Exception ex) {
			ex.printStackTrace();
		} finally {
			if (null != conn) {
				try {
					conn.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
		}
		return result;
	}

	/**
	 * 查找学生
	 * 
	 * @param id
	 *            学生ID
	 * @return
	 */
	public Student findStudent(String id) {
		Student rtnStudent = null;
		List<Student> studentList = null;
		Connection conn = null;
		ResultSet rs = null;
		try {
			conn = DBUtil.getConnection();
			String sql = "select id,name,sex,birthday from student where id=?";
			PreparedStatement ps = conn.prepareStatement(sql);
			ps.setString(1, id);
			rs = ps.executeQuery();
			// 调用记录集对象的next方法，移动指针，如果到达了EOF返回false
			studentList = new ArrayList<Student>();
			Student student = null;
			while (rs.next()) {
				// 学员类对象
				student = new Student();
				// 为学员对象属性赋值
				student.setId(rs.getString(1));
				student.setName(rs.getString(2));
				student.setSex(rs.getString(3));
				student.setBirthday(rs.getString(4));

				// 为集合类添加对象
				studentList.add(student);
			}
		} catch (Exception ex) {
			ex.printStackTrace();
		} finally {
			if (null != rs) {
				try {
					rs.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
			if (null != conn) {
				try {
					conn.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
		}

		if (null != studentList && 0 < studentList.size()) {
			rtnStudent = studentList.get(0);
		}
		return rtnStudent;
	}

	/**
	 * 删除学生
	 * 
	 * @param id
	 *            学生ID
	 * @return
	 */
	public int deleteStudent(String id) {
		int result = 0;
		Connection conn = null;
		try {
			conn = DBUtil.getConnection();
			String sql = "delete from student where id=?";
			PreparedStatement ps = conn.prepareStatement(sql);
			ps.setString(1, id);
			result = ps.executeUpdate();
		} catch (Exception ex) {
			ex.printStackTrace();
		} finally {
			if (null != conn) {
				try {
					conn.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
		}
		return result;
	}

}

 

测试辅助类

AbstractDbUnitTestCase.java

 

package com.coderdream.util;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.sql.SQLException;

import junit.framework.Assert;

import org.dbunit.DatabaseUnitException;
import org.dbunit.database.DatabaseConnection;
import org.dbunit.database.IDatabaseConnection;
import org.dbunit.database.QueryDataSet;
import org.dbunit.dataset.DataSetException;
import org.dbunit.dataset.IDataSet;
import org.dbunit.dataset.xml.FlatXmlDataSet;
import org.dbunit.dataset.xml.FlatXmlDataSetBuilder;
import org.dbunit.operation.DatabaseOperation;
import org.junit.AfterClass;
import org.junit.BeforeClass;

import com.coderdream.DBUtil;

/**
 * @author CoderDream
 * @date 2014年10月15日
 *
 */
public class AbstractDbUnitTestCase {
	public static IDatabaseConnection dbunitCon;
	private File tempFile;

	private static String classPath = AbstractDbUnitTestCase.class.getResource("/").getPath();

	@BeforeClass
	public static void init() throws DatabaseUnitException, SQLException {
		dbunitCon = new DatabaseConnection(DBUtil.getConnection());
	}

	/**
	 * 实际结果取得
	 * 
	 * @return
	 * @throws Exception
	 */
	public static IDataSet createDataSet() throws Exception {
		IDataSet databaseDataSet = dbunitCon.createDataSet();
		return databaseDataSet;
	}

	/**
	 * @param tname
	 * @return
	 * @throws DataSetException
	 * @throws IOException
	 */
	public IDataSet createDataSet(String tname) throws DataSetException, IOException {
		InputStream is = AbstractDbUnitTestCase.class.getClassLoader().getResourceAsStream(tname + ".xml");
		Assert.assertNotNull("dbunit的基本数据文件不存在", is);
		return new FlatXmlDataSetBuilder().build(is);
	}

	public void backupAllTable() throws SQLException, IOException, DataSetException {
		IDataSet ds = dbunitCon.createDataSet();
		writeBackupFile(ds);
	}

	private void writeBackupFile(IDataSet ds) throws IOException, DataSetException {
		tempFile = File.createTempFile("back", "xml", new File(classPath));
		FlatXmlDataSet.write(ds, new FileWriter(tempFile));
	}

	public void backupCustomTable(String[] tname) throws DataSetException, IOException, SQLException {
		QueryDataSet ds = new QueryDataSet(dbunitCon);
		for (String str : tname) {
			ds.addTable(str);
		}
		writeBackupFile(ds);
	}

	public void bakcupOneTable(String tname) throws DataSetException, IOException, SQLException {
		backupCustomTable(new String[] { tname });
	}

	public void resumeTable() throws Exception {
		IDataSet ds = new FlatXmlDataSetBuilder().build(tempFile);
		DatabaseOperation.CLEAN_INSERT.execute(dbunitCon, ds);
	}

	@AfterClass
	public static void destory() {
		try {
			if (dbunitCon != null)
				dbunitCon.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}

}

 

 

测试对象比对辅助类

EntitiesHelper.java

 

package com.coderdream.util;

import junit.framework.Assert;

import com.coderdream.Student;

public class EntitiesHelper {
	private static Student baseStudent = new Student("0001", "翁仔", "m", "1979-12-31");

	public static void assertStudent(Student expected, Student actual) {
		Assert.assertNotNull(expected);
		Assert.assertEquals(expected.getId(), actual.getId());
		Assert.assertEquals(expected.getName(), actual.getName());
		Assert.assertEquals(expected.getSex(), actual.getSex());
		Assert.assertEquals(expected.getBirthday(), actual.getBirthday());
	}

	public static void assertStudent(Student expected) {
		assertStudent(expected, baseStudent);
	}
}
 

 

数据库测试辅助类

DbUnitUtil.java

 

package com.coderdream.util;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.sql.SQLException;

import junit.framework.Assert;

import org.dbunit.DatabaseUnitException;
import org.dbunit.database.DatabaseConnection;
import org.dbunit.database.QueryDataSet;
import org.dbunit.dataset.DataSetException;
import org.dbunit.dataset.IDataSet;
import org.dbunit.dataset.xml.FlatXmlDataSet;
import org.dbunit.dataset.xml.FlatXmlDataSetBuilder;
import org.dbunit.operation.DatabaseOperation;

import com.coderdream.DBUtil;

public class DbUnitUtil {

	private static String classPath = DbUnitUtil.class.getResource("/").getPath();

	public static DatabaseConnection getConn() throws DatabaseUnitException, SQLException {
		DatabaseConnection dbunitCon = new DatabaseConnection(DBUtil.getConnection());
		return dbunitCon;
	}

	// 实际结果取得
	public static IDataSet createDataSet() throws Exception {
		IDataSet databaseDataSet = getConn().createDataSet();
		return databaseDataSet;
	}

	/**
	 * @param tname
	 * @return
	 * @throws DataSetException
	 * @throws IOException
	 */
	public static IDataSet createDataSet(String tname) throws Exception {
		InputStream is = DbUnitUtil.class.getClassLoader().getResourceAsStream(tname + ".xml");
		// InputStream is = AbstractDbUnitTestCase.class.getClassLoader().getResourceAsStream(classPath + tname + ".xml");
		Assert.assertNotNull("dbunit的基本数据文件不存在", is);
		return new FlatXmlDataSetBuilder().build(is);
	}

	public File backupAllTable() throws Exception {
		IDataSet ds = getConn().createDataSet();
		File tempFile = writeBackupFile(ds);
		return tempFile;
	}

	private File writeBackupFile(IDataSet ds) throws IOException, DataSetException {
		File tempFile = File.createTempFile("back", "xml", new File(classPath));
		FlatXmlDataSet.write(ds, new FileWriter(tempFile));
		return tempFile;
	}

	public File backupCustomTable(String[] tname) throws Exception {
		QueryDataSet ds = new QueryDataSet(getConn());
		for (String str : tname) {
			ds.addTable(str);
		}
		File tempFile = writeBackupFile(ds);
		return tempFile;
	}

	public File bakcupOneTable(String tname) throws Exception {
		File tempFile = backupCustomTable(new String[] { tname });
		return tempFile;
	}

	public void resumeTable(File tempFile) throws Exception {
		IDataSet ds = new FlatXmlDataSetBuilder().build(tempFile);
		DatabaseOperation.CLEAN_INSERT.execute(getConn(), ds);
	}

	public static void closeConn(DatabaseConnection dbunitCon) {
		try {
			if (dbunitCon != null) {
				dbunitCon.close();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}

}
 

 

测试类

  1. 继承TestCase的测试类
    StudentDaoTest.java
     
    package com.coderdream;

import java.io.File;
import java.io.FileOutputStream;
import java.sql.Connection;
import java.sql.SQLException;

import junit.framework.TestCase;

import org.dbunit.Assertion;
import org.dbunit.database.DatabaseConnection;
import org.dbunit.database.IDatabaseConnection;
import org.dbunit.database.QueryDataSet;
import org.dbunit.dataset.IDataSet;
import org.dbunit.dataset.ITable;
import org.dbunit.dataset.xml.FlatXmlDataSet;
import org.dbunit.dataset.xml.FlatXmlDataSetBuilder;
import org.dbunit.operation.DatabaseOperation;
import org.junit.Assert;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * <pre>
 * 继承TestCase
 * 在setUp()和tearDown()分别执行数据备份及待测试数据初始化和数据恢复工作
 * </pre>
 * 
 * @author CoderDream
 * @date 2014年10月15日
 * 
 */
public class StudentDaoTest extends TestCase {
	private static final Logger logger = LoggerFactory.getLogger(StudentDaoTest.class);
	private static String classPath = StudentDaoTest.class.getResource("/").getPath();
	private static Connection conn;
	private static IDatabaseConnection dbUnitConn;
	private static String DATA_BACKUP_FILE = "student_back";

	private File tempFile;
	private StudentDao studentDao;

	@Override
	protected void setUp() {
		try {
			super.setUp();
			studentDao = new StudentDao();
			// 获得数据库连接
			conn = DBUtil.getConnection();
			// 获得DB 连接
			dbUnitConn = new DatabaseConnection(conn);
			// 对数据库中的操作对象表student 进行备份
			QueryDataSet backupDataSet = new QueryDataSet(dbUnitConn);
			backupDataSet.addTable("student");
			tempFile = File.createTempFile(DATA_BACKUP_FILE, ".xml", new File(classPath));// 备份文件
			FlatXmlDataSet.write(backupDataSet, new FileOutputStream(tempFile));
			// 准备数据的读入
			IDataSet dataSet = new FlatXmlDataSetBuilder().build(new File(classPath + "student_pre.xml"));
			DatabaseOperation.CLEAN_INSERT.execute(dbUnitConn, dataSet);
		} catch (Exception e) {
			logger.error(e.getMessage());
			e.printStackTrace();
		}
	}

	/**
	 * 3 实装测试方法，详细见代码注释。 检索类方法，可以利用assertEquals() 方法，拿表的字段进行比较。
	 */
	@Test
	public void testFindStudent() throws Exception {
		// 执行findStudent 方法
		Student result = studentDao.findStudent("0001");
		// 预想结果和实际结果的比较
		assertNotNull(result);
		assertEquals("翁仔", result.getName());
		assertEquals("m", result.getSex());
		assertEquals("1979-12-31", result.getBirthday());
	}

	/**
	 * 更新，添加，删除等方法，可以利用Assertion.assertEquals() 方法，拿表的整体来比较。
	 */
	@Test
	public void testAddStudent() throws Exception {
		// 执行addStudent 方法
		// 被追加的记录
		Student newStudent = new Student("0088", "王耳朵", "m", "1982-01-01");
		// 执行追加方法
		int result = studentDao.addStudent(newStudent);
		Assert.assertEquals(1, result);
		// 预想结果和实际结果的比较
		// 预期结果取得
		IDataSet expectedDataSet = new FlatXmlDataSetBuilder().build(new File(classPath + "student_exp.xml"));
		ITable expectedTable = expectedDataSet.getTable("student");
		// 实际结果取得
		IDataSet databaseDataSet = dbUnitConn.createDataSet();
		ITable actualTable = databaseDataSet.getTable("student");
		// 比较
		Assertion.assertEquals(expectedTable, actualTable);
	}

	/**
	 * 更新，添加，删除等方法，可以利用Assertion.assertEquals() 方法，拿表的整体来比较。
	 */
	@Test
	public void testUpdateStudent() throws Exception {
		// 被更新的记录
		Student student = new Student("0002", "王翠花", "f", "1981-08-09");
		// 执行追加更新方法
		int result = studentDao.updateStudent(student);
		Assert.assertEquals(1, result);

		// 预想结果和实际结果的比较
		// 预期结果取得
		IDataSet expectedDataSet = new FlatXmlDataSetBuilder().build(new File(classPath + "student_update.xml"));
		ITable expectedTable = expectedDataSet.getTable("student");
		// 实际结果取得
		IDataSet databaseDataSet = dbUnitConn.createDataSet();
		ITable actualTable = databaseDataSet.getTable("student");
		// 比较
		Assertion.assertEquals(expectedTable, actualTable);
	}

	/**
	 * 更新，添加，删除等方法，可以利用Assertion.assertEquals() 方法，拿表的整体来比较。
	 */
	@Test
	public void testDeleteStudent() throws Exception {
		// 被删除的记录
		String id = "0001";
		// 执行删除方法
		int result = studentDao.deleteStudent(id);
		Assert.assertEquals(1, result);

		// 预想结果和实际结果的比较
		// 预期结果取得
		IDataSet expectedDataSet = new FlatXmlDataSetBuilder().build(new File(classPath + "student_delete.xml"));
		ITable expectedTable = expectedDataSet.getTable("student");
		// 实际结果取得
		IDataSet databaseDataSet = dbUnitConn.createDataSet();
		ITable actualTable = databaseDataSet.getTable("student");
		// 比较
		Assertion.assertEquals(expectedTable, actualTable);
	}

	@Override
	protected void tearDown() throws Exception {
		super.tearDown();

		IDataSet dataSet = new FlatXmlDataSetBuilder().build(tempFile);
		DatabaseOperation.CLEAN_INSERT.execute(dbUnitConn, dataSet);

		// close dbUnitConn
		try {
			if (dbUnitConn != null) {
				dbUnitConn.close();
			}
		} catch (SQLException e) {
			logger.error(e.getMessage());
			e.printStackTrace();
		}

		// close conn
		try {
			if (conn != null) {
				conn.close();
			}
		} catch (SQLException e) {
			logger.error(e.getMessage());
			e.printStackTrace();
		}
	}
}
     
  2. 继承AbstractDbUnitTestCase的测试类
    StudentDaoTest2.java
     
    package com.coderdream;

import java.io.File;
import java.io.IOException;
import java.sql.SQLException;

import org.dbunit.Assertion;
import org.dbunit.dataset.DataSetException;
import org.dbunit.dataset.IDataSet;
import org.dbunit.dataset.ITable;
import org.dbunit.dataset.xml.FlatXmlDataSetBuilder;
import org.dbunit.operation.DatabaseOperation;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

import com.coderdream.util.AbstractDbUnitTestCase;
import com.coderdream.util.EntitiesHelper;

/**
 * <pre>
 * 
 * 在AbstractDbUnitTestCase中有很多方法用于备份和恢复数据，
 * 本类继承AbstractDbUnitTestCase类，使用注解Before和After，
 * 在setUp()和tearDown()分别执行数据备份及待测试数据初始化和数据恢复工作。
 * </pre>
 * 
 * @author CoderDream
 * @date 2014年10月15日
 * 
 */
public class StudentDaoTest2 extends AbstractDbUnitTestCase {

	private static String classPath = StudentDaoTest.class.getResource("/").getPath();

	private StudentDao studentDao;

	@Before
	public void setUp() throws DataSetException, IOException, SQLException {
		studentDao = new StudentDao();
		bakcupOneTable("student");
	}

	@After
	public void tearDown() throws Exception {
		resumeTable();
	}

	/**
	 * 3 实装测试方法，详细见代码注释。 检索类方法，可以利用assertEquals() 方法，拿表的字段进行比较。
	 */
	@Test
	public void testFindStudent() throws Exception {
		IDataSet ds = createDataSet("student");
		DatabaseOperation.CLEAN_INSERT.execute(dbunitCon, ds);
		// 执行findStudent 方法
		Student result = studentDao.findStudent("0001");
		// 预想结果和实际结果的比较
		Assert.assertNotNull(result);
		Assert.assertEquals("翁仔", result.getName());
		Assert.assertEquals("m", result.getSex());
		Assert.assertEquals("1979-12-31", result.getBirthday());

		//
		Student student = new Student("0001", "翁仔", "m", "1979-12-31");
		EntitiesHelper.assertStudent(result, student);
	}

	/**
	 * 更新，添加，删除等方法，可以利用Assertion.assertEquals() 方法，拿表的整体来比较。
	 */
	@Test
	public void testAddStudent() throws Exception {
		IDataSet ds = createDataSet("student");
		DatabaseOperation.CLEAN_INSERT.execute(dbunitCon, ds);

		// 被追加的记录
		Student newStudent = new Student("0088", "王耳朵", "m", "1982-01-01");
		// 执行追加 addStudent 方法
		int result = studentDao.addStudent(newStudent);
		Assert.assertEquals(1, result);

		// 预期结果取得
		IDataSet expectedDataSet = new FlatXmlDataSetBuilder().build(new File(classPath + "student_add.xml"));
		ITable expectedTable = expectedDataSet.getTable("student");

		// 实际结果取得(取此时数据库中的数据)
		// Creates a dataset corresponding to the entire database
		IDataSet databaseDataSet = createDataSet();
		ITable actualTable = databaseDataSet.getTable("student");

		// 预想结果和实际结果的比较
		Assertion.assertEquals(expectedTable, actualTable);
	}

	/**
	 * 更新，添加，删除等方法，可以利用Assertion.assertEquals() 方法，拿表的整体来比较。
	 */
	@Test
	public void testUpdateStudent() throws Exception {
		IDataSet ds = createDataSet("student");
		DatabaseOperation.CLEAN_INSERT.execute(dbunitCon, ds);

		// 被追加的记录
		Student student = new Student("0002", "王翠花", "f", "1981-08-09");
		// 执行追加 addStudent 方法
		int result = studentDao.updateStudent(student);
		Assert.assertEquals(1, result);

		// 预期结果取得
		IDataSet expectedDataSet = new FlatXmlDataSetBuilder().build(new File(classPath + "student_update.xml"));
		ITable expectedTable = expectedDataSet.getTable("student");

		// 实际结果取得(取此时数据库中的数据)
		// Creates a dataset corresponding to the entire database
		IDataSet databaseDataSet = createDataSet();
		ITable actualTable = databaseDataSet.getTable("student");

		// 预想结果和实际结果的比较
		Assertion.assertEquals(expectedTable, actualTable);
	}

	/**
	 * 更新，添加，删除等方法，可以利用Assertion.assertEquals() 方法，拿表的整体来比较。
	 */
	@Test
	public void testDeleteStudent() throws Exception {
		IDataSet ds = createDataSet("student");
		DatabaseOperation.CLEAN_INSERT.execute(dbunitCon, ds);

		// 被追加的记录
		String id = "0001";
		// 执行删除方法
		int result = studentDao.deleteStudent(id);
		Assert.assertEquals(1, result);

		// 预期结果取得
		IDataSet expectedDataSet = new FlatXmlDataSetBuilder().build(new File(classPath + "student_delete.xml"));
		ITable expectedTable = expectedDataSet.getTable("student");

		// 实际结果取得(取此时数据库中的数据)
		// Creates a dataset corresponding to the entire database
		IDataSet databaseDataSet = createDataSet();
		ITable actualTable = databaseDataSet.getTable("student");

		// 预想结果和实际结果的比较
		Assertion.assertEquals(expectedTable, actualTable);
	}
}
     
  3. 继承DBTestCase的测试类
    StudentDaoTest3.java
     
    package com.coderdream;

import java.io.File;
import java.io.FileInputStream;

import org.dbunit.Assertion;
import org.dbunit.DBTestCase;
import org.dbunit.dataset.IDataSet;
import org.dbunit.dataset.ITable;
import org.dbunit.dataset.xml.FlatXmlDataSetBuilder;
import org.dbunit.operation.DatabaseOperation;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.coderdream.util.DbUnitUtil;
import com.coderdream.util.EntitiesHelper;

/**
 * <pre>
 * 继承DBTestCase
 * 每次测试执行之前都先执行getSetUpOperation()操作
 * 每次测试执行之后都会执行getTearDownOperation()操作
 * </pre>
 * 
 * @author CoderDream
 * @date 2014年10月15日
 * 
 */
public class StudentDaoTest3 extends DBTestCase {

	private static final Logger logger = LoggerFactory.getLogger(StudentDaoTest3.class);

	private static String classPath = StudentDaoTest3.class.getResource("/").getPath();

	private StudentDao studentDao;

	private DbUnitUtil dbUnitUtil;

	private File tempFile;

	@Before
	public void setUp() throws Exception {
		studentDao = new StudentDao();
		dbUnitUtil = new DbUnitUtil();
		tempFile = dbUnitUtil.bakcupOneTable("student");
	}

	@After
	public void tearDown() throws Exception {
		dbUnitUtil.resumeTable(tempFile);
	}

	/**
	 * <pre>
	 * 在每次测试执行之前都先执行getSetUpOperation()操作
	 * 
	 * 在setUpOperation中的默认操作是执行CLEAN_INSERT
	 * CLEAN_INSERT是DELETE_ALL和INSERT的组合，将xml文件中的数据恢复插入到数据库中。
	 * 
	 * REFRESH 刷新会更新xml内容到数据库中：
	 * 	数据库和xml中都存在的updata
	 * 	数据库不存在insert,
	 * 	数据库中有xml中没有的保持不变
	 * 
	 * </pre>
	 */
	public DatabaseOperation getSetUpOperation() throws Exception {
		logger.debug("### getSetUpOperation");
		return DatabaseOperation.CLEAN_INSERT;
		// return DatabaseOperation.REFRESH;
	}

	/**
	 * 每次测试执行之后会执行getTearDownOperation操作。
	 * 
	 * <pre>
	 * DatabaseOperation.NONE
	 * 	什么都不做--默认
	 * DatabaseOperation.DELETE_ALL
	 * 	清空数据库
	 * </pre>
	 * 
	 */
	public DatabaseOperation getTearDownOperation() throws Exception {
		logger.debug("### getTearDownOperation");
		// 什么都不做--默认
		// return DatabaseOperation.NONE;
		// 清空数据库
		return DatabaseOperation.DELETE_ALL;
	}

	/**
	 * 将数据文件转换成数据集,这个方法是在dbunit启动的时候自动启动
	 */
	@Override
	protected IDataSet getDataSet() throws Exception {
		logger.debug("### getDataSet");
		// 放在 src/test/resoures 里面的文件会编译到上面的路径下
		FlatXmlDataSetBuilder fdb = new FlatXmlDataSetBuilder();
		return fdb.build(new FileInputStream(classPath + "student_pre.xml"));
	}

	/**
	 * 3 实装测试方法，详细见代码注释。 检索类方法，可以利用assertEquals() 方法，拿表的字段进行比较。
	 */
	@Test
	public void testFindStudent() throws Exception {
		IDataSet ds = DbUnitUtil.createDataSet("student");
		DatabaseOperation.CLEAN_INSERT.execute(DbUnitUtil.getConn(), ds);
		// 执行findStudent 方法
		Student result = studentDao.findStudent("0001");
		// 预想结果和实际结果的比较
		Assert.assertNotNull(result);
		Assert.assertEquals("翁仔", result.getName());
		Assert.assertEquals("m", result.getSex());
		Assert.assertEquals("1979-12-31", result.getBirthday());

		//
		Student student = new Student("0001", "翁仔", "m", "1979-12-31");
		EntitiesHelper.assertStudent(result, student);
	}

	/**
	 * 更新，添加，删除等方法，可以利用Assertion.assertEquals() 方法，拿表的整体来比较。
	 */
	@Test
	public void testAddStudent() throws Exception {
		IDataSet ds = DbUnitUtil.createDataSet("student");
		DatabaseOperation.CLEAN_INSERT.execute(DbUnitUtil.getConn(), ds);

		// 被追加的记录
		Student newStudent = new Student("0088", "王耳朵", "m", "1982-01-01");
		// 执行追加 addStudent 方法
		int result = studentDao.addStudent(newStudent);
		Assert.assertEquals(1, result);

		// 预期结果取得
		IDataSet expectedDataSet = new FlatXmlDataSetBuilder().build(new File(classPath + "student_add.xml"));
		ITable expectedTable = expectedDataSet.getTable("student");

		// 实际结果取得(取此时数据库中的数据)
		// Creates a dataset corresponding to the entire database
		IDataSet databaseDataSet = DbUnitUtil.createDataSet();
		ITable actualTable = databaseDataSet.getTable("student");

		// 预想结果和实际结果的比较
		Assertion.assertEquals(expectedTable, actualTable);
	}

	/**
	 * 更新，添加，删除等方法，可以利用Assertion.assertEquals() 方法，拿表的整体来比较。
	 */
	@Test
	public void testUpdateStudent() throws Exception {
		IDataSet ds = DbUnitUtil.createDataSet("student");
		DatabaseOperation.CLEAN_INSERT.execute(DbUnitUtil.getConn(), ds);

		// 被追加的记录
		Student student = new Student("0002", "王翠花", "f", "1981-08-09");
		// 执行追加更新方法
		int result = studentDao.updateStudent(student);
		Assert.assertEquals(1, result);

		// 预期结果取得
		IDataSet expectedDataSet = new FlatXmlDataSetBuilder().build(new File(classPath + "student_update.xml"));
		ITable expectedTable = expectedDataSet.getTable("student");

		// 实际结果取得(取此时数据库中的数据)
		// Creates a dataset corresponding to the entire database
		IDataSet databaseDataSet = DbUnitUtil.createDataSet();
		ITable actualTable = databaseDataSet.getTable("student");

		// 预想结果和实际结果的比较
		Assertion.assertEquals(expectedTable, actualTable);
	}

	/**
	 * 更新，添加，删除等方法，可以利用Assertion.assertEquals() 方法，拿表的整体来比较。
	 */
	@Test
	public void testDeleteStudent() throws Exception {
		IDataSet ds = DbUnitUtil.createDataSet("student");
		DatabaseOperation.CLEAN_INSERT.execute(DbUnitUtil.getConn(), ds);

		// 被删除的记录
		String id = "0001";
		// 执行删除方法
		int result = studentDao.deleteStudent(id);
		Assert.assertEquals(1, result);

		// 预期结果取得
		IDataSet expectedDataSet = new FlatXmlDataSetBuilder().build(new File(classPath + "student_delete.xml"));
		ITable expectedTable = expectedDataSet.getTable("student");

		// 实际结果取得(取此时数据库中的数据)
		// Creates a dataset corresponding to the entire database
		IDataSet databaseDataSet = DbUnitUtil.createDataSet();
		ITable actualTable = databaseDataSet.getTable("student");

		// 预想结果和实际结果的比较
		Assertion.assertEquals(expectedTable, actualTable);
	}
}
     
  4. 不继承任何类的测试类
    StudentDaoTest4.java
     
    package com.coderdream;

import java.io.FileInputStream;
import java.io.FileWriter;
import java.sql.Connection;
import java.sql.SQLException;

import org.dbunit.Assertion;
import org.dbunit.DatabaseUnitException;
import org.dbunit.database.DatabaseConnection;
import org.dbunit.database.IDatabaseConnection;
import org.dbunit.database.QueryDataSet;
import org.dbunit.dataset.IDataSet;
import org.dbunit.dataset.ITable;
import org.dbunit.dataset.xml.FlatXmlDataSet;
import org.dbunit.dataset.xml.FlatXmlProducer;
import org.dbunit.operation.DatabaseOperation;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.xml.sax.InputSource;

/**
 * <pre>
 * DBUnit使用步骤
 *  1)下载地址为http://sourceforge.net/projects/dbunit/files/ 
 *  2)导入DBUnit所需两个jar文件(dbunit.jar和slf4j-api.jar)
 *  3)创建DBUnit用到的xml格式的测试数据,xml文件名建议与表名相同 
 *  4)创建DBUnit的Connection和DataSet,然后开始进行各项测试工作
 * 
 * 使用注解@BeforeClass，在globalInit()执行打开数据库操作；
 * 使用注解@AfterClass，在globalDestroy()执行数据库关闭操作；
 * 
 * 使用注解@Before，每次测试执行之前都先执行init()操作；
 * 使用注解@After，每次测试执行之后都会执行destroy()操作；
 * 
 * DBUtil提供数据库操作方法。
 * </pre>
 * @author CoderDream
 * @date 2014年10月15日
 * 
 */
public class StudentDaoTest4 {
	private static final Logger logger = LoggerFactory.getLogger(StudentDaoTest4.class);
	private static Connection conn;
	private static IDatabaseConnection dbUnitConn;
	private static String DATA_BACKUP_FILE = "dataBackup_student.xml";

	@BeforeClass
	public static void globalInit() {
		conn = DBUtil.getConnection();
		System.out.println("DB-Unit时获取到数据库连接-->" + conn);
		try {
			// DBUnit中用来操作数据文件的Connection需依赖于数据库连接的Connection
			dbUnitConn = new DatabaseConnection(conn);
		} catch (DatabaseUnitException e) {
			e.printStackTrace();
		}
	}

	@AfterClass
	public static void globalDestroy() {
		DBUtil.close(conn);
		if (null != dbUnitConn) {
			try {
				dbUnitConn.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * 备份数据库中所有表的数据，同时将student.xml的数据插入到数据库中
	 */
	// @Before
	// public void initAll() throws Exception {
	// logger.debug("Before #### initAll");
	// // 此时所创建的DataSet包含了数据库中所有表的数据
	// IDataSet backupDataSet = dbUnitConn.createDataSet();
	// // 备份数据库中所有表的数据
	// FlatXmlDataSet.write(backupDataSet, new FileWriter(DATA_BACKUP_FILE));
	//
	// // FlatXmlDataSet用来获取基于属性存储的属性值,XmlDataSet用来获取基于节点类型存储的属性值
	// IDataSet dataSet = new FlatXmlDataSet(new FlatXmlProducer(new InputSource(StudentDaoTest4.class.getClassLoader()
	// .getResourceAsStream("student.xml"))));
	// DatabaseOperation.CLEAN_INSERT.execute(dbUnitConn, dataSet);
	// }

	/**
	 * 备份数据库中某一张或某几张表的数据，同时将xml文件中的数据插入到数据库中
	 */
	@Before
	public void init() throws Exception {
		logger.debug("Before #### init");
		// 通过QueryDataSet可以有效的选择要处理的表来作为DataSet
		QueryDataSet dataSet = new QueryDataSet(dbUnitConn);
		// 这里指定只备份t_student表中的数据,如果想备份多个表,那就再addTable(tableName)即可
		dataSet.addTable("student");
		FlatXmlDataSet.write(dataSet, new FileWriter(DATA_BACKUP_FILE));
	}

	/**
	 * 还原表数据
	 */
	@After
	public void destroy() throws Exception {
		IDataSet dataSet = new FlatXmlDataSet(new FlatXmlProducer(new InputSource(new FileInputStream(DATA_BACKUP_FILE))));
		DatabaseOperation.CLEAN_INSERT.execute(dbUnitConn, dataSet);
	}

	/**
	 * <pre>
	 * 测试查询方法
	 * 		 DatabaseOperation类的几个常量值
	 * 		 CLEAN_INSERT----先删除数据库中的所有数据,然后将student.xml中的数据插入数据库
	 * 		 DELETE----------如果数据库存在与student.xml记录的相同的数据,则删除数据库中的该条数据
	 * 		 DELETE_ALL------删除数据库中的所有数据
	 * 		 INSERT----------将t_student.xml中的数据插入数据库
	 * 		 NONE------------nothing to do
	 * 		 REFRESH---------刷新数据库中的数据
	 * 		 TRUNCATE_TABLE--清空表中的数据
	 * 		 UPDATE----------将数据库中的那条数据更新为student.xml中的数据
	 * </pre>
	 */
	@Test
	public void testFindStudent() throws Exception {
		// 下面开始数据测试
		StudentDao studentDao = new StudentDao();
		Student student = studentDao.findStudent("0002");
		Assert.assertEquals(student.getId(), "0002");
		Assert.assertEquals(student.getName(), "王翠花");
		Assert.assertEquals(student.getSex(), "f");
		Assert.assertEquals(student.getBirthday(), "1982-08-09");
	}

	/**
	 * 更新，添加，删除等方法，可以利用Assertion.assertEquals() 方法，拿表的整体来比较。
	 */
	@Test
	public void testAddStudent() throws Exception {
		// 被追加的记录
		Student newStudent = new Student("0088", "王耳朵", "m", "1982-01-01");
		// 执行追加 addStudent 方法
		StudentDao studentDao = new StudentDao();
		int result = studentDao.addStudent(newStudent);
		Assert.assertEquals(1, result);

		// 预期结果取得
		IDataSet expectedDataSet = new FlatXmlDataSet(new FlatXmlProducer(new InputSource(StudentDaoTest4.class.getClassLoader()
				.getResourceAsStream("student_add.xml"))));
		ITable expectedTable = expectedDataSet.getTable("student");

		// 实际结果取得(取此时数据库中的数据)
		// Creates a dataset corresponding to the entire database
		IDataSet databaseDataSet = dbUnitConn.createDataSet();
		ITable actualTable = databaseDataSet.getTable("student");

		// 预想结果和实际结果的比较
		Assertion.assertEquals(expectedTable, actualTable);
	}

	/**
	 * 更新，添加，删除等方法，可以利用Assertion.assertEquals() 方法，拿表的整体来比较。
	 */
	@Test
	public void testUpdateStudent() throws Exception {
		// 被更新的记录
		Student student = new Student("0002", "王翠花", "f", "1981-08-09");
		// 执行追加 addStudent 方法
		StudentDao studentDao = new StudentDao();
		int result = studentDao.updateStudent(student);
		Assert.assertEquals(1, result);

		// 预期结果取得
		IDataSet expectedDataSet = new FlatXmlDataSet(new FlatXmlProducer(new InputSource(StudentDaoTest4.class.getClassLoader()
				.getResourceAsStream("student_update.xml"))));
		ITable expectedTable = expectedDataSet.getTable("student");

		// 实际结果取得(取此时数据库中的数据)
		// Creates a dataset corresponding to the entire database
		IDataSet databaseDataSet = dbUnitConn.createDataSet();
		ITable actualTable = databaseDataSet.getTable("student");

		// 预想结果和实际结果的比较
		Assertion.assertEquals(expectedTable, actualTable);
	}

	/**
	 * 更新，添加，删除等方法，可以利用Assertion.assertEquals() 方法，拿表的整体来比较。
	 */
	@Test
	public void testDeleteStudent() throws Exception {
		// 被删除记录的id
		String id = "0001";
		// 执行删除方法
		StudentDao studentDao = new StudentDao();
		int result = studentDao.deleteStudent(id);
		Assert.assertEquals(1, result);

		// 预期结果取得
		IDataSet expectedDataSet = new FlatXmlDataSet(new FlatXmlProducer(new InputSource(StudentDaoTest4.class.getClassLoader()
				.getResourceAsStream("student_delete.xml"))));
		ITable expectedTable = expectedDataSet.getTable("student");

		// 实际结果取得(取此时数据库中的数据)
		// Creates a dataset corresponding to the entire database
		IDataSet databaseDataSet = dbUnitConn.createDataSet();
		ITable actualTable = databaseDataSet.getTable("student");

		// 预想结果和实际结果的比较
		Assertion.assertEquals(expectedTable, actualTable);
	}
}

数据文件

  1. student_pre.xml
     
    <?xml version="1.0" encoding="UTF-8"?>
<dataset>
	<student id="0001" name="翁仔" sex="m" birthday="1979-12-31" />
	<student id="0002" name="王翠花" sex="f" birthday="1982-08-09" />
</dataset>
     
  2. student_add.xml
     
    <?xml version="1.0" encoding="UTF-8"?>
<dataset>
	<student id="0001" name="翁仔" sex="m" birthday="1979-12-31" />
	<student id="0002" name="王翠花" sex="f" birthday="1982-08-09" />
	<student id="0088" name="王耳朵" sex="m" birthday="1982-01-01" />
</dataset>
     
  3. student_update.xml
     
    <?xml version="1.0" encoding="UTF-8"?>
<dataset>
	<student id="0001" name="翁仔" sex="m" birthday="1979-12-31" />
	<student id="0002" name="王翠花" sex="f" birthday="1981-08-09" />
</dataset>
     
  4. student_delete.xml
     
    <?xml version="1.0" encoding="UTF-8"?>
<dataset>
	<student id="0002" name="王翠花" sex="f" birthday="1982-08-09" />
</dataset>

Maven工程文件

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.coderdream</groupId>
	<artifactId>dbunit-export-import</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>DBUnitSample</name>
	<url>http://maven.apache.org</url>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	</properties>

	<dependencies>
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.24</version>
		</dependency>

		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>1.7.5</version>
		</dependency>

		<dependency>
			<groupId>org.dbunit</groupId>
			<artifactId>dbunit</artifactId>
			<version>2.4.8</version>
		</dependency>

	</dependencies>

</project>

数据库配置属性文件

dbutil.properties

db.classname=com.mysql.jdbc.Driver
db.url=jdbc:mysql://127.0.0.1:3306/dbup?characterEncoding=UTF-8
db.username=root
db.password=1234

数据库脚本

dbup.sql

/*
Navicat MySQL Data Transfer

Source Server         : localhost
Source Server Version : 50525
Source Host           : localhost:3306
Source Database       : dbup

Target Server Type    : MYSQL
Target Server Version : 50525
File Encoding         : 65001

Date: 2014-10-11 14:27:06
*/

SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for `role`
-- ----------------------------
DROP TABLE IF EXISTS `role`;
CREATE TABLE `role` (
  `id` varchar(20) NOT NULL DEFAULT '',
  `roleName` varchar(20) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of role
-- ----------------------------
INSERT INTO `role` VALUES ('1', '管理员');
INSERT INTO `role` VALUES ('2', '普通用户');

-- ----------------------------
-- Table structure for `student`
-- ----------------------------
DROP TABLE IF EXISTS `student`;
CREATE TABLE `student` (
  `id` varchar(20) NOT NULL DEFAULT '',
  `name` varchar(20) DEFAULT NULL,
  `sex` varchar(10) DEFAULT NULL,
  `birthday` varchar(20) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of student
-- ----------------------------
INSERT INTO `student` VALUES ('1', '2', '3', '4');

-- ----------------------------
-- Table structure for `user`
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
  `id` varchar(20) NOT NULL DEFAULT '',
  `name` varchar(20) DEFAULT NULL,
  `role_id` varchar(20) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `ref_id` (`role_id`),
  CONSTRAINT `ref_id` FOREIGN KEY (`role_id`) REFERENCES `role` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES ('1', '张三', '1');
INSERT INTO `user` VALUES ('2', '李四', '2');

日志配置文件

log4j.properties

# Set root logger level to DEBUG and its only appender to A1.
log4j.rootLogger=DEBUG, A1

# A1 is set to be a ConsoleAppender.
log4j.appender.A1=org.apache.log4j.ConsoleAppender

# A1 uses PatternLayout.
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n

运行前准备
    1、在MySQL的客户端（如Navicat Premium）中执行sql文件夹中的dbup.sql文件，创建数据库和表；
    2、选择pom.xml文件，右键， Run As -> Maven install。
运行前准运行与结果
    1、运行测试类（DBUnitPractise\src\test\java\com\coderdream\StudentDaoTest.java）；
    2、运行测试类（DBUnitPractise\src\test\java\com\coderdream\StudentDaoTest2.java）；
    3、运行测试类（DBUnitPractise\src\test\java\com\coderdream\StudentDaoTest3.java）；
    4、运行测试类（DBUnitPractise\src\test\java\com\coderdream\StudentDaoTest4.java）；

参考文档

  1. 高效使用DBUnit
  2. DBUnit入门实践

完整源代码

 

 

  • 大小: 30.8 KB
分享到：
| DBUnit最佳实践之使用ant命令
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    DBUnit最佳实践之数据备份与恢复

    这篇“DBUnit最佳实践之数据备份与恢复”博文中，作者分享了如何有效地利用DBUnit进行数据备份和恢复，这对于开发和测试环境中的数据管理至关重要。 首先，我们需要了解DBUnit的基本概念。DBUnit是一个JUnit扩展，...

    DBUnit最佳实践之使用ant命令

    DBUnit 是一个 Java 开发者常用的数据库测试工具，它与JUnit等测试框架配合，能够帮助开发者在测试...通过以上实践，我们可以高效地利用DBUnit与Ant集成，实现数据库的自动化测试和管理，提升项目的测试效率和质量。

    dbunit-2.4.7所有jar以及dbunit入门教程

    DBUnit 是一个开源的 Java 库，专门用于数据库测试，它是 xUnit 测试框架（如 JUnit）的一个扩展。在数据库驱动的项目中，DBUnit 可以帮助开发者确保数据库状态的一致性，使得测试更加可靠。DBUnit 2.4.7 版本包含了...

    dbunit-2.4.9 源码

    DBUnit 是一个开源的 Java 库，专门用于数据库测试，它是 xUnit 测试框架的一部分，提供了数据驱动测试的解决方案。在版本 2.4.9 中，DBUnit 提供了一系列的功能，帮助开发者在进行单元测试时能够管理和操作数据库的...

    Dbunit数据库连接下载

    Dbunit 是一个强大的Java库，专门用于数据库的测试和数据管理。它被广泛应用于软件开发过程中，特别是对于那些依赖于数据库的应用程序，因为Dbunit能够帮助开发者有效地管理和控制数据库的状态，确保测试的一致性...

    DBUnit 进行单元测试

    通过阅读链接中的博文（https://virgoooos.iteye.com/blog/186859），可以获取更多关于如何在实际项目中使用DBUnit 的具体示例和最佳实践。 总之，DBUnit 是一个强大的工具，为Java开发者提供了一种有效的方法来...

    DBUNIT 基类DBUNIT 基类DBUNIT 基类DBUNIT 基类DBUNIT 基类

    DBUNIT 基类DBUNIT 基类DBUNIT 基类DBUNIT 基类DBUNIT 基类DBUNIT 基类DBUNIT 基类DBUNIT 基类DBUNIT 基类DBUNIT 基类DBUNIT 基类DBUNIT 基类DBUNIT 基类DBUNIT 基类DBUNIT 基类DBUNIT 基类DBUNIT 基类DBUNIT 基类...

    DBUNIT使用

    DBUNIT 使用 DbUnit 是一种用于数据库集成测试的重要工具，它提供了TestCase 子类，用户可以在自己的测试类中扩展它们，但也可以独立于 JUnit 以其他方式来使用 DbUnit。DbUnit 的主要用途是准备数据库和验证数据库...

    dbunit帮助文档(HTML版)

    **dbunit帮助文档(HTML版)** DBUnit是一款开源的Java库，专门用于数据库测试，它遵循TestNG或JUnit测试框架。...通过深入学习和实践，你可以更有效地管理和维护数据库状态，确保测试的质量和可靠性。

    dbunit2.2

    DBUnit 是一个开源的Java库，它扩展了JUnit框架，为数据库相关的单元测试提供了一种结构化的方法。在“dbunit2.2”这个压缩包中，包含了DBUnit 2.2版本的所有必要文件，使得开发者能够有效地进行数据库的单元测试。 ...

    dbunit开发文档

    DBUnit 是一个开源的 Java 库，专门用于数据库测试，它是 xUnit 测试框架（如 JUnit）的一个扩展。在数据库驱动的项目中，DBUnit 提供了一种结构化的方法来设置和验证数据库状态，从而确保测试的一致性和可靠性。这...

    dbunit使用必需Jar包

    2. **junit.jar**：JUnit 是一个流行的单元测试框架，DBUnit 常常与之配合使用，提供对数据库层的测试支持。它提供了断言、测试套件和测试监听器等机制，使得编写和运行测试变得简单。 3. **commons-dbcp.jar** 或 ...

    dbunit测试demo

    DBUnit 是一个 Java 编程语言的开源工具，专门用于数据库的单元测试。它与JUnit 结合使用，提供了一种结构化的方法来设置和验证数据库的状态，确保代码的正确性。在进行数据库驱动的应用程序开发时，DBUnit 可以帮助...

    dbunit-2.2.jar

    dbunit的jar包，版本2.2

    dbunit的jar包-基于2.5.0修改，支持excel2007+

    网上下载到的dbunit的jar包默认不支持excel2007及以上版本的数据表导入导出功能，因项目需要，本人对源码进行了部分修改。 目前数据库的导入导出等功能已经在excel2013版本上测试通过。 ps：个人下载资源需求较多，...

    单元测试JUnit4和DbUnit

    为了更好地学习和实践这些概念，文档"单元测试JUnit4和DbUnit.doc"可能包含了详细的步骤和示例代码，而"dbunitAndJunit4"和"junit4"这两个文件夹可能包含了相关的练习项目或者源码，通过阅读和运行这些代码，可以...

Magicbox
Global site tag (gtag.js) - Google Analytics