`
aaronjiu_00
  • 浏览: 67880 次
  • 性别: Icon_minigender_1
  • 来自: 杭州
社区版块
存档分类
最新评论

基于Spring的单元测试框架搭建及分布式数据源单元测试

单元测试框架Spring数据结构SNS
阅读更多

 

在Space 1st Apps的项目中，我们使用了基于Spring的单元测试 ,  并结合DBUnit对数据库应用程序做单元测试。

其中，数据源我们使用了Oracle、MySql数据库，Oracle数据源只有一个数据库，而MySQL数据源是一个由多台MySQL数据库组成的分布式多数据源。

 

对于单数据源Single DataSource的单元测试用例，如果你需要在测试用例运行之前准备一些种子数据，那么，你只需要简单地继承抽象类：AbstractDataSourceTest，例如：

@ContextConfiguration(locations = { "/spring/space-apps-poke.xml" })
public class PokeInfoManagerTest extends AbstractDataSourceTest {
    ……
	@Override
	protected String getSeedXmlFile() {
		return "/seeds/poke/pokeinfo.xml";
	}
    ……
}

 

其中，@ContextConfiguration的参数locations的值，表示类路径下的Spring配置文件的位置，例如：/spring/space-apps-poke.xml，在开发时，你将该文件放在了src/conf文件下面，将该文件夹作为源文件夹使用，这样该文件夹下面的所有文件，就都会在类路径下面了，如下图所示：



必须实现的抽象方法：

protected abstract String getSeedXmlFile()

该方法实现，需要你返回类路径下面的测试种子数据XML文件的位置，测试种子数据文件统一放到src/conf.test下面，如下图所示：



 在测试用例中，如果需要引用Spring的bean，只需像下面代码这样：

……
@Autowired
private PokeInfoManager pokeInfoManager;
……
 

 一旦加上了＠Autowired注解之后，id为“pokeInfoManager“的bean，就会自动注入到测试用例中。

 测试方法，只需在普通的方法前面加上注解@Test，就可以被单元测试框架运行，例如：

 

	@Test
	public void getAllPokeInfoNotCached() {
		memCachedTemplate.delete(AppsKeyAccessor.Memcached.SPACE_APPS_POKE);
		List<PokeInfo> pokeInfoList = pokeInfoManager.getAllPokeInfo();
		assertNotNull(pokeInfoList);
		assertTrue(!pokeInfoList.isEmpty());
	}
   

 

附上抽象超类的源码

@RunWith(SpringJUnit4ClassRunner.class)
@TestExecutionListeners( { DependencyInjectionTestExecutionListener.class,
		DirtiesContextTestExecutionListener.class })
@ContextConfiguration(locations = { "/spring/space-memcached.xml",
		"/spring/space-datasource.xml", "/spring/space-commons.xml",
		"/spring/space-datasource-multi.xml" })
public abstract class AbstractDataSourceTest {

	private Resource resource;
	private IDatabaseTester tester;
	@Autowired
	@Qualifier("spaceOracleDS")
	private DataSource dataSource;

	/**
	 * Returns the test data seeds file in XML format
	 */
	protected abstract String getSeedXmlFile();

	/**
	 * Creates a new IDatabaseTester.<br>
	 * Default implementation returns a {@link DataSourceDatabaseTester}
	 * configured with the value returned from {@link getDataSource()}.
	 */
	protected IDatabaseTester newDatabaseTester() {
		return new DataSourceDatabaseTester(getDataSource());
	}

	/**
	 *Returns the test DataSource.
	 */
	protected DataSource getDataSource() {
		return this.dataSource;
	}

	/**
	 * Gets the IDatabaseTester for this testCase.<br>
	 * If the IDatabaseTester is not set yet, this method calls
	 * newDatabaseTester() to obtain a new instance.
	 * 
	 * @throws Exception
	 */
	protected IDatabaseTester getDatabaseTester() throws Exception {
		if (this.tester == null) {
			this.tester = newDatabaseTester();
		}
		return this.tester;
	}

	/**
	 * Returns the database operation executed in test setup. default is
	 * DatabaseOperation.REFRESH
	 */
	protected DatabaseOperation getSetUpOperation() throws Exception {
		return DatabaseOperation.REFRESH;
	}

	/**
	 * Returns the database operation executed in test cleanup.default is
	 * DatabaseOperation.NONE
	 */
	protected DatabaseOperation getTearDownOperation() throws Exception {
		return DatabaseOperation.NONE;
	}

	/**
	 * Returns data set resource in spring resource mode. eg: /seeds/xxx.xml If
	 * the Resource is not set yet, this method calls newDataSetResource() to
	 * obtain a new instance.
	 */
	private Resource getDataSetResource() {
		if (this.resource == null) {
			this.resource = newDataSetResource();
		}
		return this.resource;
	}

	/**
	 * Creates a new Resource.<br>
	 * Default implementation returns a {@link ClassPathResource} configured
	 * with the value returned from {@link getSeedXmlFile()}.
	 */
	protected Resource newDataSetResource() {
		return new ClassPathResource(getSeedXmlFile());
	}

	/**
	 * Returns the test dataset. default is FlatXmlDataSet
	 */
	private IDataSet getDataSet() throws Exception {
		return new FlatXmlDataSet(getDataSetResource().getInputStream());
	}

	@Before
	public void setUp() throws Exception {
		final IDatabaseTester databaseTester = getDatabaseTester();
		databaseTester.setSetUpOperation(getSetUpOperation());
		databaseTester.setDataSet(getDataSet());
		databaseTester.onSetup();
	}

	@After
	public void tearDown() throws Exception {
		final IDatabaseTester databaseTester = getDatabaseTester();
		databaseTester.setTearDownOperation(getTearDownOperation());
		databaseTester.setDataSet(getDataSet());
		databaseTester.onTearDown();
		tester = null;
	}
}
 

 

如果你不需要测试种子数据，请不要继承AbstractDataSourceTest类，而是仅需继承Spring 测试框架自带的类：AbstractJUnit4SpringContextTests

 

如果你的测试用例想使用事务，譬如说，你不想每次运行测试用例，都把数据真实地插入到数据库中，你可以使用事务的自动回滚机制，这很简单，你只需要继承AbstractTransactionalDataSourceTest

@ContextConfiguration(locations = { "/spring/space-apps-album.xml" })
public class BoPhotoManagerTest extends AbstractTransactionalDataSourceTest {

    ……
	@Override
	protected String getSeedXmlFile() {
		return "/seeds/admin/bophoto/bophoto.xml";
	}
    ……
}
 

 以上代码和无事务支持，需要测试种子数据测试用例比较类似，在此，不再累赘。

 

 附上AbstractTransactionalDataSourceTest的源代码：

@TestExecutionListeners( { TransactionalTestExecutionListener.class })
@Transactional
@TransactionConfiguration(transactionManager = "jtaTransactionManager")
public abstract class AbstractTransactionalDataSourceTest extends
		AbstractDataSourceTest {
}
 

其中，注解@TransactionConfiguration的参数transactionManager的值为jtaTransactionManager，是Spring的bean的Id

 

如果测试用例需要多数据源分布式数据库，大致类似，简单说一下

 

对于需要测试种子数据的，请继承AbstractDistributedDataSourceTest，附上该类源码：

@RunWith(SpringJUnit4ClassRunner.class)
@TestExecutionListeners( { DependencyInjectionTestExecutionListener.class,
		DirtiesContextTestExecutionListener.class })
@ContextConfiguration(locations = { "/spring/space-memcached.xml",
		"/spring/space-datasource.xml", "/spring/space-commons.xml",
		"/spring/space-datasource-multi.xml" })
public abstract class AbstractDistributedDataSourceTest {

	private Resource resource;
	private IDistributedDatabaseTester tester;
	@Autowired
	@Qualifier("distributeDBDataSource")
	private DataSource dataSource;

	/**
	 * Returns the test data seeds file in XML format
	 */
	protected abstract String getSeedXmlFile();

	/**
	 * Creates a new IDistributedDatabaseTester.<br>
	 * Default implementation returns a
	 * {@link DistributedDataSourceDatabaseTester} configured with the value
	 * returned from {@link getDataSource()}.
	 */
	protected IDistributedDatabaseTester newDatabaseTester() {
		return new DistributedDataSourceDatabaseTester(getDataSource());
	}

	/**
	 *Returns the test DataSource.
	 */
	protected DataSource getDataSource() {
		return this.dataSource;
	}

	/**
	 * Gets the IDatabaseTester for this testCase.<br>
	 * If the IDatabaseTester is not set yet, this method calls
	 * newDatabaseTester() to obtain a new instance.
	 * 
	 * @throws Exception
	 */
	protected IDistributedDatabaseTester getDatabaseTester() throws Exception {
		if (this.tester == null) {
			this.tester = newDatabaseTester();
		}
		return this.tester;
	}

	/**
	 * Returns the database operation executed in test setup. default is
	 * DatabaseOperation.REFRESH
	 */
	protected DistributedDatabaseOperation getSetUpOperation() throws Exception {
		return DistributedDatabaseOperation.REFRESH;
	}

	/**
	 * Returns the database operation executed in test cleanup.default is
	 * DatabaseOperation.NONE
	 */
	protected DistributedDatabaseOperation getTearDownOperation()
			throws Exception {
		return DistributedDatabaseOperation.NONE;
	}

	/**
	 * Returns data set resource in spring resource mode. eg: /seeds/xxx.xml If
	 * the Resource is not set yet, this method calls newDataSetResource() to
	 * obtain a new instance.
	 */
	private Resource getDataSetResource() {
		if (this.resource == null) {
			this.resource = newDataSetResource();
		}
		return this.resource;
	}

	/**
	 * Creates a new Resource.<br>
	 * Default implementation returns a {@link ClassPathResource} configured
	 * with the value returned from {@link getSeedXmlFile()}.
	 */
	protected Resource newDataSetResource() {
		return new ClassPathResource(getSeedXmlFile());
	}

	/**
	 * Returns the test dataset. default is FlatXmlDataSet
	 */
	private IExtDataSet getDataSet() throws Exception {
		return new ExtXmlDataSet(getDataSetResource().getInputStream());
	}

	@Before
	public void setUp() throws Exception {
		final IDistributedDatabaseTester databaseTester = getDatabaseTester();
		databaseTester.setSetUpOperation(getSetUpOperation());
		databaseTester.setDataSet(getDataSet());
		databaseTester.onSetup();
	}

	@After
	public void tearDown() throws Exception {
		final IDistributedDatabaseTester databaseTester = getDatabaseTester();
		databaseTester.setTearDownOperation(getTearDownOperation());
		databaseTester.setDataSet(getDataSet());
		databaseTester.onTearDown();
		tester = null;
	}
}
   

 如果需要事务回滚机制，请继承AbstractTransactionalDistributedDataSourceTest，附上该类源码

@TestExecutionListeners( { TransactionalTestExecutionListener.class })
@Transactional
@TransactionConfiguration(transactionManager = "jtaTransactionManager")
public abstract class AbstractTransactionalDistributedDataSourceTest extends
		AbstractDistributedDataSourceTest {

}
 

 

好了，到目前为止，测试用例是写好了，但是测试种子数据，还没有准备，这个XML文件，看起来还蛮复杂的，大家看一下样本，

<?xml version='1.0' encoding='UTF-8'?>
<dataset>
	<FA_POKE_INFO POKEINFO_ID="01" POKE_NAME="微笑" POKE_IMG_PATH="/poke/poke_01.gif" POKE_TEMPLATE_CONTENT="{0}对{1}亲切地微笑了一下"
		GMT_CREATE="2009-06-09 12:53:43.0" GMT_MODIFIED="2009-06-09 12:53:43.0" CREATOR="sns" MODIFIER="sns" IS_DELETED="n" />
	<FA_POKE_INFO POKEINFO_ID="02" POKE_NAME="轻轻地碰" POKE_IMG_PATH="/poke/poke_02.gif" POKE_TEMPLATE_CONTENT="{0}轻轻地碰了{1}一下"
		GMT_CREATE="2009-06-09 12:53:43.0" GMT_MODIFIED="2009-06-09 12:53:43.0" CREATOR="sns" MODIFIER="sns" IS_DELETED="n" />
	<FA_POKE_INFO POKEINFO_ID="03" POKE_NAME="握手" POKE_IMG_PATH="/poke/poke_03.gif" POKE_TEMPLATE_CONTENT="{0}和{1}握了一下手"
		GMT_CREATE="2009-06-09 12:53:43.0" GMT_MODIFIED="2009-06-09 12:53:43.0" CREATOR="sns" MODIFIER="sns" IS_DELETED="n" />
	<FA_POKE_INFO POKEINFO_ID="04" POKE_NAME="依偎" POKE_IMG_PATH="/poke/poke_04.gif" POKE_TEMPLATE_CONTENT="{0}和{1}紧紧依偎在一起"
		GMT_CREATE="2009-06-09 12:53:43.0" GMT_MODIFIED="2009-06-09 12:53:43.0" CREATOR="sns" MODIFIER="sns" IS_DELETED="n" />
	<FA_POKE_INFO POKEINFO_ID="05" POKE_NAME="深情地飞吻" POKE_IMG_PATH="/poke/poke_05.gif" POKE_TEMPLATE_CONTENT="{0}深情地飞吻了{1}一下"
		GMT_CREATE="2009-06-09 12:53:43.0" GMT_MODIFIED="2009-06-09 12:53:43.0" CREATOR="sns" MODIFIER="sns" IS_DELETED="n" />
	<FA_POKE_INFO POKEINFO_ID="06" POKE_NAME="小心地捏" POKE_IMG_PATH="/poke/poke_06.gif" POKE_TEMPLATE_CONTENT="{0}小心地捏了{1}一下"
		GMT_CREATE="2009-06-09 12:53:43.0" GMT_MODIFIED="2009-06-09 12:53:43.0" CREATOR="sns" MODIFIER="sns" IS_DELETED="n" />
	<FA_POKE_INFO POKEINFO_ID="07" POKE_NAME="重重地扁" POKE_IMG_PATH="/poke/poke_07.gif" POKE_TEMPLATE_CONTENT="{0}把{1}重重地扁了一顿"
		GMT_CREATE="2009-06-09 12:53:43.0" GMT_MODIFIED="2009-06-09 12:53:43.0" CREATOR="sns" MODIFIER="sns" IS_DELETED="n" />
	……
</dataset>

 

以上XML片段是一个样本，根节点是dataset，每个子节点表示表的名称，如FA_POKE_INFO，每个节点的属性如POKE_INFO_ID，表示数据库表的列名，每个节点的属性的值就是数据表对应列的值

 

OK，从头开始写这么一个文件，我觉得你一定会没有耐心，还是有一些工作量的。

 

还好，我写了几个工具类，你只需要简单地修改几个参数， 然后运行一下，上述的XML代码就会生成了，好，我们来看代码说话，由于我们使用了Oracle和MySQL数据库，所以我使用了模板方法模式，做了少许抽象，DatabaseExporter源码：

public abstract class DatabaseExporter {

	private IDatabaseConnection databaseConnection;
	private Connection jdbcConnection;

	/**
	 * write DTD file
	 * 
	 * @param dtdFileName
	 * 
	 * @throws Exception
	 */
	protected void writeDataDtd(String dtdFileName) throws Exception {
		IDataSet dataSet = getDatabaseConnection().createDataSet();
		Writer out = new OutputStreamWriter(new FileOutputStream(dtdFileName));
		FlatDtdWriter datasetWriter = new FlatDtdWriter(out);
		datasetWriter.setContentModel(FlatDtdWriter.CHOICE);
		datasetWriter.write(dataSet);
	}

	private IDatabaseConnection getDatabaseConnection() throws Exception {
		if (this.databaseConnection == null) {
			this.databaseConnection = newDatabaseConnection(getJdbcConnection());
		}
		return this.databaseConnection;
	}

	private Connection getJdbcConnection() throws Exception {
		if (this.jdbcConnection == null) {
			this.jdbcConnection = newJdbcConnection();
		}
		return this.jdbcConnection;
	}

	/**
	 * full database export
	 * 
	 * @param fullXmlFileName
	 * @param isFlatXml
	 * 
	 * @throws Exception
	 */
	protected void exportFullDataSet(String fullXmlFileName, boolean isFlatXml)
			throws Exception {
		IDataSet fullDataSet = getDatabaseConnection().createDataSet();
		if (isFlatXml) {
			FlatXmlDataSet.write(fullDataSet, new FileOutputStream(
					fullXmlFileName));
		} else {
			XmlDataSet
					.write(fullDataSet, new FileOutputStream(fullXmlFileName));
		}
	}

	/**
	 * dependent tables database export: export table X and all tables that have
	 * a PK which is a FK on X, in the right order for insertion
	 * 
	 * @param rootTableName
	 * @param dependentXmlFileName
	 * @param isFlatXml
	 * @throws Exception
	 */
	protected void exportDependentDataSet(String rootTableName,
			String dependentXmlFileName, boolean isFlatXml) throws Exception {
		String[] depTableNames = TablesDependencyHelper.getAllDependentTables(
				getDatabaseConnection(), rootTableName);
		IDataSet depDataset = getDatabaseConnection().createDataSet(
				depTableNames);
		if (isFlatXml) {
			FlatXmlDataSet.write(depDataset, new FileOutputStream(
					dependentXmlFileName));
		} else {
			XmlDataSet.write(depDataset, new FileOutputStream(
					dependentXmlFileName));
		}
	}

	/**
	 * partial database export
	 * 
	 * @param tableName
	 * @param partialXmlFileName
	 * @param isFlatXml
	 * @throws Exception
	 */
	protected void exportPartialDataSet(String tableName,
			String partialXmlFileName, boolean isFlatXml) throws Exception {
		QueryDataSet partialDataSet = new QueryDataSet(getDatabaseConnection());
		partialDataSet.addTable(tableName);
		if (isFlatXml) {
			FlatXmlDataSet.write(partialDataSet, new FileOutputStream(
					partialXmlFileName));
		} else {
			XmlDataSet.write(partialDataSet, new FileOutputStream(
					partialXmlFileName));
		}
	}

	/**
	 * partial multiple database export
	 * 
	 * @param tableName2Query
	 * @param partialXmlFileName
	 * @param isFlatXml
	 * @throws Exception
	 */
	protected void exportMultiPartialDataSet(
			Map<String, String> tableName2Query, String partialXmlFileName,
			boolean isFlatXml) throws Exception {
		QueryDataSet partialDataSet = new QueryDataSet(getDatabaseConnection());
		Validate.notEmpty(tableName2Query,
				"Please check tableName2Query, it must not be null or empty");
		Map<String, String> treeMap = new TreeMap<String, String>(
				tableName2Query);
		Set<Map.Entry<String, String>> entrys = treeMap.entrySet();
		for (Entry<String, String> entry : entrys) {
			if (StringUtils.isBlank(entry.getValue())) {
				partialDataSet.addTable(entry.getKey());
			} else {
				partialDataSet.addTable(entry.getKey(), entry.getValue());
			}
		}

		if (isFlatXml) {
			FlatXmlDataSet.write(partialDataSet, new FileOutputStream(
					partialXmlFileName));
		} else {
			XmlDataSet.write(partialDataSet, new FileOutputStream(
					partialXmlFileName));
		}

	}

	/**
	 * partial database export
	 * 
	 * @param tableName
	 * @param query
	 * @param isFlatXml
	 * @throws Exception
	 */
	protected void exportPartialDataSet(String tableName, String query,
			String partialXmlFileName, boolean isFlatXml) throws Exception {
		QueryDataSet partialDataSet = new QueryDataSet(getDatabaseConnection());
		partialDataSet.addTable(tableName, query);
		if (isFlatXml) {
			FlatXmlDataSet.write(partialDataSet, new FileOutputStream(
					partialXmlFileName));
		} else {
			XmlDataSet.write(partialDataSet, new FileOutputStream(
					partialXmlFileName));
		}
	}

	protected abstract Connection newJdbcConnection() throws Exception;

	protected abstract IDatabaseConnection newDatabaseConnection(
			Connection jdbcConnection);

}
 

 MySQL 数据导出工具源代码：

public class MysqlDatabaseExporter extends DatabaseExporter {

	@Override
	protected IDatabaseConnection newDatabaseConnection(
			Connection jdbcConnection) {
		return new MySqlConnection(jdbcConnection, null);
	}

	@Override
	protected Connection newJdbcConnection() throws Exception {
		Class.forName("com.mysql.jdbc.Driver");
		return DriverManager.getConnection(
				"jdbc:mysql://10.2.225.151:3306/SNS", "sns", "alisoft");
	}

	/**
	 * @param args
	 * @throws Exception
	 */
	public static void main(String[] args) throws Exception {
		MysqlDatabaseExporter exporter = new MysqlDatabaseExporter();
		Map<String, String> map = new HashMap<String, String>();
		map.put("FA_GIFT_RECEIVER",
				"SELECT * FROM SNS.FA_GIFT_RECEIVER F limit 0,10;");
		map.put("FA_GIFT_SENDER",
				"SELECT * FROM SNS.FA_GIFT_SENDER F limit 0,10;");
		map.put("FA_GIFT_STAT", "SELECT * FROM SNS.FA_GIFT_STAT F limit 0,10;");
		exporter.exportMultiPartialDataSet(map, "statefullGift.xml", false);
		// exporter.writeDataDtd("myFile.dtd");
		// exporter.exportFullDataSet("full.xml", false);
		// exporter.exportDependentDataSet("FA_PHOTO", "dependents.xml", false);
	}
}
 

 Oracle 数据导出工具源代码：

public class OracleDatabaseExporter extends DatabaseExporter {

	@Override
	protected IDatabaseConnection newDatabaseConnection(
			Connection jdbcConnection) {
		OracleConnection connection = new OracleConnection(jdbcConnection, null);
		connection.getConfig().setFeature(
				DatabaseConfig.FEATURE_SKIP_ORACLE_RECYCLEBIN_TABLES, true);
		return connection;
	}

	@Override
	protected Connection newJdbcConnection() throws Exception {
		Class.forName("oracle.jdbc.driver.OracleDriver");
		return DriverManager.getConnection(
				"jdbc:oracle:thin:@10.2.224.34:1521:aepdb", "sns", "sns");
	}

	/**
	 * @param args
	 * @throws Exception
	 * @throws Exception
	 */
	public static void main(String[] args) throws Exception {
		OracleDatabaseExporter exporter = new OracleDatabaseExporter();
		exporter.exportPartialDataSet("FA_POKE_INFO", "partial.xml", false);
		exporter.writeDataDtd("myFile.dtd");
		// exporter.exportFullDataSet("full.xml", false);
		exporter.exportDependentDataSet("BO_PHOTO", "dependents.xml", false);
	}
}
   

代码很简单，如果你熟悉DBUnit，大家一看就会明白，我主要说说怎么个用法，对了，有一个小插曲，我们的多数据源分布式数据库，是根据用户的longId进行取模，然后选择不同的数据库的，这样为多数据源分布式数据库准备单元测试的种子数据，就会产生很大的障碍，我们必须能够让种子数据自动选择他们应该归属的数据库。

 

DBUnit的测试种子数据，大家使用最多的应该是FlatXMLFile，如上面的测试种子数据例子

 

在插入测试种子数据时，我们无法知道XML节点的哪个字段是作为选择多数据源的字段，我们使用isResourceId表示，平行化的结构很难表达这个ResourceId的意思。还好，DBUnit有一种非平行化的XML结构，如下XML代码所示：

<?xml version='1.0' encoding='UTF-8'?>
<dataset>
	<table name="FA_POKE">
		<column>POKE_ID</column>
		<column>SENDER_LONG_ID</column>
		<column isResourceId="true">RECEIVER_LONG_ID</column>
		<column>POKE_CONTENT</column>
		<column>GMT_CREATE</column>
		<column>GMT_MODIFIED</column>
		<column>IS_DELETED</column>
	</table>
</dataset>
   

以上XML片段中，dataset表示根节点，table表示一个表，name属性表示table的名称，column表示table的一个列，中间的文本表示列名。

像以上这样，我们就可以在某个数据列上面表示哪个是ResoutceId，如上面例子中：isResourceId="true"的列，RECEIVIER_LONG_I，当然，默认的DBUnit是不支持这种扩展的，为了这个扩展，我费了很多的力气，感觉DBUnit的扩展性不是很好，至于扩展的代码，有很多，这里就不一一列举了。

 

说说上面的Exporter的使用方法，为了导出数据库中某个表，使用：

protected void exportPartialDataSet(String tableName,
            String partialXmlFileName, boolean isFlatXml)
protected void exportPartialDataSet(String tableName, String query,
			String partialXmlFileName, boolean isFlatXml) throws Exception
  • tableName，表示你要导出数据库的表名
  • query，表示针对tableName的一个select查询语句，如："select * from tableName limit 0, 1000"
  • partialXmlFileName，表示导出的XML种子数据的文件名称
  • isFlatXml，表示导出的XML文件是否是Flat结构，true，表示Flat XML，false表示树状XML

 

为了导出数据库中的多个表数据到一个XML文件中，使用：

protected void exportMultiPartialDataSet(
			Map<String, String> tableName2Query, String partialXmlFileName,
			boolean isFlatXml) throws Exception
 
  • tableName2Query，表示tableName到query语句的map，key为tableName，value为query语句，可以为空
  • partialXmlFileName，表示导出的XML种子数据的文件名称
  • isFlatXml，表示导出的XML文件是否是Flat结构，true，表示Flat XML，false表示树状XML

另外，还有两个方法，其一：

protected void exportFullDataSet(String fullXmlFileName, boolean isFlatXml)
			throws Exception
 

该方法用于导出数据库中所有表到一个XML文件中，一般情况下，不需要使用该方法，尤其是数据量很大的时候，参数定义如下：

  • fullXmlFileName，表示导出的XML种子数据的文件名称
  • isFlatXml，表示导出的文件是否是Flat结构，true，表示Flat XML，false表示树状XML

其二：

protected void writeDataDtd(String dtdFileName) throws Exception

该方法用于导出数据库表结构到一个DTD文件中，注意：该方法，可能对Oracle 10i 以上开启回收站功能的数据库，运行会失败，解决方案，就是禁用这个功能，需要DBA支持，遇到该问题时，你可以Google一下。

 

好了，说了这么多了，希望对你有用

  • 大小: 30 KB
  • 大小: 12.7 KB
1
顶
0
踩
分享到：
| MemCached基础
评论
1 楼 CoderDream 2009-07-30  
不错，感谢分享！
发表评论

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

相关推荐

    大数据企业实训项目：基于SpringMVC+Spring+HBase+Maven搭建的Hadoop分布式云盘系统+源代码+文档说

    大数据企业实训项目：基于SpringMVC+Spring+HBase+Maven搭建的Hadoop分布式云盘系统。使用Hadoop HDFS作为文件存储系统、HBase作为数据存储仓库，采用SpringMVC+Spring框架实现，包括用户注册与登录、我的网盘、关注...

    分布式事务实践 解决数据一致性

    介绍分布式事务的定义、原则和实现原则，介绍使用Spring框架实现分布式事务的几种方式，包括使用JTA、Spring事务同步、链式事务等，并通过实战介绍其实现。除此以外还介绍了一些分布式事务相关的技术，如幂等性、...

    JMay:JMay是一款基于Spring、SpringMVC、Mybatis、Atomikos集成框架，用于快速搭建跨数据库、分布式事务(JTA)支持的java web项目

    JMay是什么JMay是一款基于Spring、SpringMVC、Mybatis、Atomikos集成框架，用于快速搭建跨数据库、分布式事务(XA规范)支持的Java web项目.JMay有哪些功能1.基于spring，如沐春风的体验；2.扩展Mybatis-Generator，...

    基于SSM架构实现的大型分布式购物网站-B2C项目源码+项目说明.zip

    - 1、配置数据源 - 2、让spring容器管理SqlSessionFactory,单例存在 - 3、把mapper的代理对象放到spring容器中。使用扫描包的方式加载mapper的代理对象。 ###Service层 - 1、事务管理 - 2、需要把service实现类放...

    新版本SpringCloud2学习手册

    SpringCloud微服务课程说明 1 网站架构演变过程 1 传统架构 1 分布式架构 1 SOA架构 1 微服务架构 2 微服务架构产生的原因 2 漫谈微服务架构 2 什么是微服务 2 微服务架构特征 3 微服务架构如何拆分 3 ...

    dubbo 服务端与客户端配置

    资源使用springMvc+spring+mabatis+dubbo分布式框架搭建完成，该资源完成了客户端与服务端rmi,dubbo,hessian多协议的支持。下载后配置zookeeper服务注册中心及数据源即可运行 其中有几个测试案例及完整的登陆测试

    Java秒杀系统方案优化高性能高并发学习实战源代码以及笔记..zip

    第1章-课程介绍及项目框架搭建 知识点 使用spring boot 搭建项目基础框架 使用Thymeleaf做页面展示,封装Result统一结果 集成 mybatis + druid 做数据操作 继承redis, 使用Jedis操作redis数据, 封装了统一的缓存key. ...

    Java毕业设计-基于springboot开发的开发精简博客系统设计与实现-毕业论文（附毕设源代码）.rar

    本资源包为基于Spring Boot开发的精简博客系统的设计与实现，涵盖了从需求分析、系统设计到具体实现的完整过程，并附带了完整的毕业论文及毕设源代码。此博客系统旨在提供一个轻量级、易扩展的博客平台，适用于个人...

    Eclipse开发分布式商城系统+完整视频代码及文档

    │ 淘淘商城源代码.zip │ ├─01.第一天 │ 01.课程计划.avi │ 02.淘淘商城介绍.avi │ 03.创建后台工程-taotao-parent.avi │ 04.创建taotao-manager.avi │ 05.svn的使用.avi │ 06.ssm框架整合思路.avi │ 07....

    毕业设计早餐外卖微信小程序课程设计源代码

    配置三个节点的Nginx作为负载均衡器，第一个Nginx负责请求分发给后面两个Nginx，最后再把请求发送到不同的...Spring+Spring MVC+Mybatis框架整合开发，聊天、搜索和后台使用SpringBoot搭建 根据用户的点击率和购买

    JavaEE求职简历-姓名-JAVA开发工程师.docx

    3.项目后台管理系统使用Shiro实现登录验证和权限管理(超级管理员、管理员、产品编辑员)，iBatis动态sql语句编写及性能优化实现快速维护数据功能，Drui作为数据源，SpringTest+JUnit简化DAO层数据访问测试、Ea

    sk-spring-cloud-master

    sk-spring-cloud-master简述定位用当下最流行的springcloud技术，搭建了一套易理解、高可用、高扩展的分布式微服务框架，方便实现快速开发。组织结构sk-spring-cloud-master├── sk-base -- 公共模块├───── ...

    2小时学会CAS+Security实现单点登录

    ?...学完SSM框架的同学就可以学习,能让你切身感受到企业级开发环境目标1：搭建单点登录服务端，开发单点登录客户端目标2：实现CAS 认证数据源设置目标3：更换CAS 登录页面目标4：掌握CAS与SpringSe

    hsweb(haʊswɛb)是一个用于快速搭建企业后台管理系统的基础项目

    hsweb (haʊs wɛb) 是一个用于快速搭建企业后台管理系统的基础项目,集成一揽子便捷功能如:通用增删改查，在线代码生成，权限管理(可控制到列和行)，动态多数据源分布式事务，动态脚本，动态定时任务，在线数据库...

    Java微服务架构l零从基础到精通高清视频教程全套 163课

    015修改数据源 016常用 APT 命令 017Linux 用户和组管理 018查看目录和文件的权限 019更改操作权限 020安装 Java 021安装 Tomcat 022安装 MySQL 023部署项目 第3章 Docker实战开发 042设置镜像标签 024Docker ...

    单点登录源码

    单点登录， SSM框架公共模块 ├── zheng-admin -- 后台管理模板 ├── zheng-ui -- 前台thymeleaf模板[端口:1000] ├── zheng-config -- 配置中心[端口:1001] ├── zheng-upms -- 用户权限管理系统 | ├── ...

    Java微服务架构163课

    015修改数据源 016常用 APT 命令 017Linux 用户和组管理 018查看目录和文件的权限 019更改操作权限 020安装 Java 021安装 Tomcat 022安装 MySQL 023部署项目 第3章 Docker实战开发 042设置镜像标签 ...

    趁早(quickearly)B2C早餐外卖微信小程序

    趁早(quickearly)B2C早餐外卖微信小程序，理想经营...Spring+Spring MVC+Mybatis框架整合开发，聊天、搜索和后台使用SpringBoot搭建 根据用户的点击率和购买记录为用户推荐 后台管理使用Dockerfile方式构建镜像并运行

    经典JAVA.EE企业应用实战.基于WEBLOGIC_JBOSS的JSF_EJB3_JPA整合开发.pdf

    4.1.3 使用WebLogic服务器管理的 数据源 182 4.1.4 使用JBoss服务器管理的数据源 187 4.2 事务和JTA 191 4.2.1 事务的基本概念 191 4.2.2 分布式事务处理、XA规范和 2PC协议 192 4.2.3 使用JTA全局事务保证多 数据库...

    积分管理系统java源码-learn:学

    Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。 SpringSecurity Docker Dock

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