Java tutorial
/* * Copyright 2008, Unitils.org * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.unitils.dbunit.util; import static org.apache.commons.lang.StringUtils.isEmpty; import static org.dbunit.dataset.ITable.NO_VALUE; import static org.dbunit.dataset.datatype.DataType.UNKNOWN; import static org.unitils.thirdparty.org.apache.commons.io.IOUtils.closeQuietly; import java.io.File; import java.io.FileInputStream; import java.io.InputStream; import java.util.ArrayList; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import javax.xml.parsers.SAXParserFactory; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.dbunit.dataset.Column; import org.dbunit.dataset.ReplacementDataSet; import org.unitils.core.UnitilsException; import org.unitils.dbunit.datasetfactory.impl.DbUnitDataSet; import org.unitils.dbunit.datasetfactory.impl.DbUnitTable; import org.xml.sax.Attributes; import org.xml.sax.InputSource; import org.xml.sax.SAXException; import org.xml.sax.SAXParseException; import org.xml.sax.XMLReader; import org.xml.sax.helpers.DefaultHandler; /** * A reader for DbUnit xml datasets that creates a new ITable instance for each element (row). * <p/> * Following format is expected: * <code><pre> * <dataset> * <first_table myColumn1="value1" myColumn2="value2" /> * <second_table myColumnA="A" /> * <first_table myColumn2="other value2" /> * <empty_table /> * </dataset> * </pre></code> * <p/> * Elements for a table may occur more than once and anywhere in the data set. If multiple elements * exist, they may specify different attributes (columns). Missing attributes (columns) will be treated as null values. * <p/> * Namespaces can be used to specify tables from different database schemas. The namespace URI should contain the name * of the database schema: * <code><pre> * <dataset xmlns="SCHEMA_A" xmlns:b="SCHEMA_B"> * <first_table myColumn1="value1" myColumn2="value2" /> * <b:second_table myColumnA="A" /> * <first_table myColumn2="other value2" /> * <empty_table /> * </dataset> * </pre></code> * <p/> * This example defines 2 schemas: SCHEMA_A and SCHEMA_B. The first schema is set as default schema (=default namespace). * The 'first_table' table has no namespce and is therefore linked to SCHEMA_A. The 'second_table' table is prefixed * with namespace b which is linked to SCHEMA_B. If no default namespace is defined, the schema that is * passed as constructor argument is taken as default schema. * * @author Tim Ducheyne * @author Filip Neven */ public class MultiSchemaXmlDataSetReader { /* The logger instance for this class */ private static Log logger = LogFactory.getLog(MultiSchemaXmlDataSetReader.class); /* The schema name to use when none is specified */ private String defaultSchemaName; /** * Creates a data set reader. * * @param defaultSchemaName The schema name to use when none is specified, not null */ public MultiSchemaXmlDataSetReader(String defaultSchemaName) { this.defaultSchemaName = defaultSchemaName; } /** * Parses the datasets from the given files. * Each schema is given its own dataset and each row is given its own table. * * @param dataSetFiles The dataset files, not null * @return The read data set, not null */ public MultiSchemaDataSet readDataSetXml(File... dataSetFiles) { try { DataSetContentHandler dataSetContentHandler = new DataSetContentHandler(defaultSchemaName); XMLReader xmlReader = createXMLReader(); xmlReader.setContentHandler(dataSetContentHandler); xmlReader.setErrorHandler(dataSetContentHandler); for (File dataSetFile : dataSetFiles) { InputStream dataSetInputStream = null; try { dataSetInputStream = new FileInputStream(dataSetFile); xmlReader.parse(new InputSource(dataSetInputStream)); } finally { closeQuietly(dataSetInputStream); } } return dataSetContentHandler.getMultiSchemaDataSet(); } catch (Exception e) { throw new UnitilsException("Unable to parse data set xml.", e); } } /** * Factory method for creating the SAX xml reader. * * @return the XML reader, not null */ protected XMLReader createXMLReader() { try { SAXParserFactory saxParserFactory = SAXParserFactory.newInstance(); saxParserFactory.setNamespaceAware(true); // disable validation, so dataset can still be used when a DTD or XSD is missing disableValidation(saxParserFactory); return saxParserFactory.newSAXParser().getXMLReader(); } catch (Exception e) { throw new UnitilsException("Unable to create SAX parser to read data set xml.", e); } } /** * Disables validation on the given sax parser factory. * * @param saxParserFactory The factory, not null */ protected void disableValidation(SAXParserFactory saxParserFactory) { saxParserFactory.setValidating(false); try { saxParserFactory.setFeature("http://xml.org/sax/features/external-parameter-entities", false); } catch (Exception e) { logger.debug( "Unable to set http://xml.org/sax/features/external-parameter-entities feature on SAX parser factory to false. Igoring exception: " + e.getMessage()); } try { saxParserFactory.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false); } catch (Exception e) { logger.debug( "Unable to set http://apache.org/xml/features/nonvalidating/load-external-dtd feature on SAX parser factory to false. Igoring exception: " + e.getMessage()); } } /** * The xml content handler that is going to create the data sets. */ protected static class DataSetContentHandler extends DefaultHandler { /* The schema name to use when none is specified */ protected String defaultSchemaName; /* All created data sets per schema */ protected Map<String, DbUnitDataSet> dbUnitDataSetsPerSchemaName = new LinkedHashMap<String, DbUnitDataSet>(); /** * Creates a data set SAX content handler * * @param defaultSchemaName The schema name to use when none is specified, not null */ public DataSetContentHandler(String defaultSchemaName) { this.defaultSchemaName = defaultSchemaName; } /** * Gets the result data set. * * @return the data set, not null */ public MultiSchemaDataSet getMultiSchemaDataSet() { MultiSchemaDataSet multiSchemaDataSet = new MultiSchemaDataSet(); for (String schemaName : dbUnitDataSetsPerSchemaName.keySet()) { DbUnitDataSet dataSet = dbUnitDataSetsPerSchemaName.get(schemaName); // wrap data sets in replacement data sets, and replace [null] tokens by the null reference ReplacementDataSet replacementDataSet = new ReplacementDataSet(dataSet); replacementDataSet.addReplacementObject("[null]", null); multiSchemaDataSet.setDataSetForSchema(schemaName, replacementDataSet); } return multiSchemaDataSet; } /** * Processes an xml element. A new table is started for each element. * * @param uri the xml namespace uri (= schema name) * @param localName the local xml name * @param qName the element name (should be table name for table rows) * @param attributes the attributes (should be table columns for table rows) */ @Override public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException { // begin element of data set, if default namespace set, it will override the default schema if ("dataset".equals(localName)) { if (!isEmpty(uri)) { defaultSchemaName = uri; } return; } // Begin new table for row String schemaName = defaultSchemaName; if (!isEmpty(uri)) { schemaName = uri; } DbUnitDataSet dbUnitDataSet = dbUnitDataSetsPerSchemaName.get(schemaName); if (dbUnitDataSet == null) { dbUnitDataSet = new DbUnitDataSet(); dbUnitDataSetsPerSchemaName.put(schemaName, dbUnitDataSet); } DbUnitTable table = dbUnitDataSet.getDbUnitTable(localName); if (table == null) { table = new DbUnitTable(localName); dbUnitDataSet.addTable(table); } addRow(attributes, table); } /** * Gets column names and row values from the given attribute and adds a new row to the given table. * * @param table The table to add the row to, not null * @param attributes the attributes, not null */ protected void addRow(Attributes attributes, DbUnitTable table) { if (attributes.getLength() == 0) { return; } for (int i = 0; i < attributes.getLength(); i++) { Column column = new Column(attributes.getQName(i), UNKNOWN); table.addColumn(column); } List<Object> row = new ArrayList<Object>(10); for (String columnName : table.getColumnNames()) { Object value = NO_VALUE; if (attributes.getIndex(columnName) != -1) { value = attributes.getValue(columnName); } row.add(value); } table.addRow(row); } /** * Overridden to rethrow exception. * * @param e The exception */ @Override public void error(SAXParseException e) throws SAXException { throw e; } } }