Ich denke, es gibt immer noch viele Fälle (2020), in denen DBUnit als Unit-Test-Tool in Java + RDBMS-Entwicklungsprojekten verwendet wird. DBUnit ist ein sehr praktisches und effektives Tool zur Arbeitsersparnis in der Entwicklung, da es das XLS-Format und das CSV-Format für Anfangsdaten von DB- und Assertionsdaten nach der Ausführung verwenden kann, jedoch aufgrund von Problemen mit dem Excel-Datenformat und den POI-Spezifikationen etwas schwierig zu verwenden ist. Es gibt einen Punkt.
Insbesondere besteht, wie im Betreff erwähnt, das Problem, dass es nicht möglich ist, zwischen einer leeren Zeichenfolge vom Typ variabler Zeichenfolge (Typ VARCHAR) und NULL zu unterscheiden, und dass der Wert des Datumstyps (DATETIME, TIMESTAMP, DATE, TIME usw.) nicht genau eingestellt werden kann. Es gibt.
Dieser Artikel beschreibt den Umgang damit. Die Version von DbUnit in diesem Artikel ist 2.5.4.
In DBUnit ruft die Methode "getValue (int row, String column)" der Klasse "XlsTable" den Wert der Excel-Zelle ab und konvertiert ihn in den in der DB festgelegten Wert.
XlsTable#Auszug aus getValue
int type = cell.getCellType();
switch (type)
{
case HSSFCell.CELL_TYPE_NUMERIC:
if (HSSFDateUtil.isCellDateFormatted(cell))
{
return cell.getDateCellValue();
}
return new BigDecimal(cell.getNumericCellValue());
case HSSFCell.CELL_TYPE_STRING:
return cell.getStringCellValue();
case HSSFCell.CELL_TYPE_FORMULA:
throw new DataTypeException("Formula not supported at row=" +
row + ", column=" + column);
case HSSFCell.CELL_TYPE_BLANK:
return null;
case HSSFCell.CELL_TYPE_BOOLEAN:
return cell.getBooleanCellValue() ? Boolean.TRUE : Boolean.FALSE;
case HSSFCell.CELL_TYPE_ERROR:
throw new DataTypeException("Error at row=" + row +
", column=" + column);
default:
throw new DataTypeException("Unsupported type at row=" + row +
", column=" + column);
}
Wie Sie dem obigen Code entnehmen können, handelt es sich bei dem Zellendatentyp um einen Datentyp, wenn er numerisch und in einem bestimmten Format ist. Wenn die Zelle leer ist, wird sie auf NULL gesetzt. Daher wird die Differenz zwischen den in der Datenbank festgelegten Datumstypwerten in Abhängigkeit von der Genauigkeit der Datumsdaten in Excel angezeigt. In Excel kann das, was Sie in "2020/1/24 10: 00" eingeben, beispielsweise zu "2020/1/24 10: 00: 01" in der Spalte "DATETIME-Typ" der DB werden. Wenn der Zellenwert leer ist, ist er einheitlich null, sodass keine leeren Zeichenfolgendaten erstellt werden können.
DBUnit bietet auch eine Funktion zum Ausgeben der aus der DB gelesenen (aber nicht beschränkten) Daten in eine Excel-Datei. Die Ausgabe nach Excel erfolgt mit der Methode "write (IDataSet dataSet, OutputStream out)" der Klasse "XlsDataSet". Der in der Zelle einzustellende Wert wird innerhalb der Schreibmethode erfasst.
XlsDataSet#Auszug aus dem Schreiben
// write table data
for (int j = 0; j < table.getRowCount(); j++)
{
HSSFRow row = sheet.createRow(j + 1);
for (int k = 0; k < columns.length; k++)
{
Column column = columns[k];
Object value = table.getValue(j, column.getColumnName());
if (value != null)
{
HSSFCell cell = row.createCell((short)k);
cell.setEncoding(HSSFCell.ENCODING_UTF_16);
cell.setCellValue(DataType.asString(value));
}
}
}
Der obige Code ruft den in "ITable" in "IDataSet" gespeicherten Wert ab und legt ihn in der Zelle fest. Wenn der Wert "null" ist, wird die Zelle nicht generiert, sodass es sich um eine leere Zelle in der Excel-Anzeige handelt.
Aus dem oben gezeigten DBUnit-Quellcode können Sie auch ersehen, dass der Benutzer die Konvertierungsmethode des Werts in der Excel-Zelle für den Datentyp zusätzlich zum Inhalt der DBUnit-Verarbeitung selbst nicht ändern kann. Um DBUnit bequem zu verwenden, werde ich daher den Quellcode von "XlsTable" und "XlsDataSet" ändern, um meine eigene Klasse zu erstellen und DBUnit aus dieser Klasse zu verwenden.
Ändern Sie in der Methode "XlsTable # getValue" den Zellendatentyp, um den Datumstyp festzulegen, wenn er mit dem Datumstypmuster übereinstimmt, auch wenn es sich um einen Zeichenfolgentyp handelt. Wenn Sie "null" in die Zelle schreiben, legen Sie in der Datenbank einen NULL-Wert fest.
XlsTable#Fix getValue
int type = cell.getCellType();
switch (type)
{
case HSSFCell.CELL_TYPE_NUMERIC:
if (HSSFDateUtil.isCellDateFormatted(cell))
{
return cell.getDateCellValue();
}
return new BigDecimal(cell.getNumericCellValue());
case HSSFCell.CELL_TYPE_STRING:
/*Ursprüngliche Implementierung (von hier)*/
String cellValue = cell.getRichStringCellValue().getString();
//Der Zellenwert ist"null"Auf NULL setzen für
if ("null".equals(cellValue)) { return null; }
//Der Zellenwert ist"yyyy/MM/dd HH:mm:ss"Im Falle eines Formats durch Parsen auf Datumstyp festlegen
if (Pattern.compile("\\d{4}/\\d{2}/\\d{2} \\d{2}:\\d{2}:\\d{2}").matcher(cellValue).matches()) {
return new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").parse(cellValue);
}
//Stellen Sie den Zellenwert anders als oben angegeben ein
return cellValue;
/*Ursprüngliche Implementierung (bis hier)*/
case HSSFCell.CELL_TYPE_FORMULA:
throw new DataTypeException("Formula not supported at row=" +
row + ", column=" + column);
case HSSFCell.CELL_TYPE_BLANK:
//Wenn die Zelle leer ist, geben Sie eine leere Zeichenfolge zurück
return "";
case HSSFCell.CELL_TYPE_BOOLEAN:
return cell.getBooleanCellValue() ? Boolean.TRUE : Boolean.FALSE;
case HSSFCell.CELL_TYPE_ERROR:
throw new DataTypeException("Error at row=" + row +
", column=" + column);
default:
throw new DataTypeException("Unsupported type at row=" + row +
", column=" + column);
}
Wenn Sie nur die anfänglichen Dateneinstellungen von JUnit- und DB-Daten vergleichen möchten, müssen Sie nur das Lesen von Zelleninformationen korrigieren. Sie können jedoch auch die Ausgabe von DB-Daten im XLS-Format verwenden, um die Erstellung von Testdaten zu optimieren. Daher wird die Ausgabeverarbeitung der Zelleninformationen auch gemäß der Korrektur des Lesens der Zelleninformationen korrigiert.
XlsDataSet#Fix schreiben
// write table data
for (int j = 0; j < table.getRowCount(); j++)
{
HSSFRow row = sheet.createRow(j + 1);
for (int k = 0; k < columns.length; k++)
{
Column column = columns[k];
Object value = table.getValue(j, column.getColumnName());
/*Ursprüngliche Implementierung (von hier)*/
if (null == value) {
cell.setCellValue("null");
} else if (value instanceof java.sql.Timestamp) {
cell.setCellValue(new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(value));
} else {
cell.setCellValue(DataType.asString(value));
}
/*Ursprüngliche Implementierung (bis hier)*/
}
}
Wenn der Wert null ist, setzen Sie den Zellenwert auf die Zeichenfolge "null". Wenn der Datentyp Zeitstempeltyp ist, legen Sie die Zeichenfolge im Format "JJJJ / MM / TT HH: MM: SS" fest.
Mit der obigen Richtlinie leihen wir uns tatsächlich den Quellcode von "XlsDataSet" und "XlsTable" aus, um unsere eigene Klasse zu definieren. Da der geänderte Teil nur die JDK-Bibliothek verwendet, kann er meiner Meinung nach kompiliert werden, wenn die Umgebung DBUnit verwenden kann.
Definieren Sie die MyXlsDataSet-Klasse als modifizierte Version des XlsDataSet. Die Klasse "XlsTable" ist als private Paketklasse definiert und kann von externen Paketen nicht aufgerufen werden. Hier definieren wir die "MyXlsTable" -Klasse als eine innere Klasse von "MyXlsDataSet".
Berücksichtigen Sie in Bezug auf den Datumstyp zusätzlich zum Typ DATETIME den Typ DATE und TIME, definieren Sie eine HashMap mit dem Schlüssel DateFormat als Wert und legen Sie das Muster jedes Schlüssels der Map fest. Wenn es überprüft wird und übereinstimmt, wird es durch den Wert "DateFormat" analysiert, der dem Schlüssel zugeordnet ist. Dies kann eine "Liste" oder ein Array sein, in dem eine Kombination aus "Muster" und "Datumsformat" anstelle von "Karte" gespeichert ist.
Bitte beachten Sie, dass dieser Code nur zu Testzwecken dient und keine Synchronisation berücksichtigt. Wenn Sie diese Klasse zum Lesen einer Excel-Datei aus mehreren Threads verwenden möchten, müssen Sie festlegen, ob jedes Mal "SimpleDateFormat" erstellt oder in "ThreadLocal" gespeichert werden soll.
MyXlsDataSet
public class MyXlsDataSet extends AbstractDataSet {
private static final Logger logger = LoggerFactory.getLogger(MyXlsDataSet.class);
/*Ursprüngliche Implementierung (von hier)*/
private static final SimpleDateFormat TIMESTAMP_FORMAT = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyy/MM/dd");
private static final SimpleDateFormat TIME_FORMAT = new SimpleDateFormat("HH:mm:ss");
/*Ursprüngliche Implementierung (bis hier)*/
private final ITable[] _tables;
/**
* Creates a new XlsDataSet object that loads the specified Excel document.
*/
public DateFormattedXlsDataSet(File file) throws IOException, DataSetException {
this(new FileInputStream(file));
}
/**
* Creates a new XlsDataSet object that loads the specified Excel document.
*/
public DateFormattedXlsDataSet(InputStream in) throws IOException, DataSetException {
HSSFWorkbook workbook = new HSSFWorkbook(in);
_tables = new ITable[workbook.getNumberOfSheets()];
for (int i = 0; i < _tables.length; i++) {
_tables[i] = new DateFormattedXlsTable(workbook.getSheetName(i), workbook.getSheetAt(i));
}
}
/**
* Write the specified dataset to the specified Excel document.
*/
public static void write(IDataSet dataSet, OutputStream out)
throws IOException, DataSetException {
logger.debug("write(dataSet=" + dataSet + ", out=" + out + ") - start");
HSSFWorkbook workbook = new HSSFWorkbook();
int index = 0;
ITableIterator iterator = dataSet.iterator();
while (iterator.next()) {
// create the table i.e. sheet
ITable table = iterator.getTable();
ITableMetaData metaData = table.getTableMetaData();
HSSFSheet sheet = workbook.createSheet(metaData.getTableName());
// write table metadata i.e. first row in sheet
// workbook.setSheetName(index, metaData.getTableName(), HSSFWorkbook.ENCODING_UTF_16);
workbook.setSheetName(index, metaData.getTableName());
HSSFRow headerRow = sheet.createRow(0);
Column[] columns = metaData.getColumns();
for (int j = 0; j < columns.length; j++) {
Column column = columns[j];
HSSFCell cell = headerRow.createCell((short) j);
// cell.setEncoding(HSSFCell.ENCODING_UTF_16);
cell.setCellValue(column.getColumnName());
}
// write table data
for (int j = 0; j < table.getRowCount(); j++) {
HSSFRow row = sheet.createRow(j + 1);
for (int k = 0; k < columns.length; k++) {
Column column = columns[k];
Object value = table.getValue(j, column.getColumnName());
/*Ursprüngliche Implementierung (von hier)*/
HSSFCell cell = row.createCell((short) k);
if (null == value) {
cell.setCellValue("null");
} else if (value instanceof java.sql.Timestamp) {
cell.setCellValue(TIMESTAMP_FORMAT.format(value));
} else if (value instanceof java.sql.Date) {
cell.setCellValue(DATE_FORMAT.format(value));
} else if (value instanceof Time) {
cell.setCellValue(TIME_FORMAT.format(value));
} else {
cell.setCellValue(DataType.asString(value));
}
/*Ursprüngliche Implementierung (bis hier)*/
// if (value != null) {
// HSSFCell cell = row.createCell((short) k);
// cell.setEncoding(HSSFCell.ENCODING_UTF_16);
// cell.setCellValue(DataType.asString(value));
// }
}
}
index++;
}
// write xls document
workbook.write(out);
out.flush();
}
////////////////////////////////////////////////////////////////////////////
// AbstractDataSet class
protected ITableIterator createIterator(boolean reversed) throws DataSetException {
// logger.debug("createIterator(reversed=" + reversed + ") - start");
return new DefaultTableIterator(_tables, reversed);
}
private static class MyXlsTable extends AbstractTable {
/*Ursprüngliche Implementierung (von hier)*/
//Da es sich um UT handelt, wird die Synchronisation nicht berücksichtigt
private static final HashMap<Pattern, SimpleDateFormat> DATETIME_PATTERN_MAP =
new HashMap<Pattern, SimpleDateFormat>();
static {
DATETIME_PATTERN_MAP.put(
Pattern.compile("\\d{4}/\\d{2}/\\d{2}"), new SimpleDateFormat("yyyy/MM/dd"));
DATETIME_PATTERN_MAP.put(
Pattern.compile("\\d{4}-\\d{2}-\\d{2}"), new SimpleDateFormat("yyyy-MM-dd"));
DATETIME_PATTERN_MAP.put(
Pattern.compile("\\d{4}/\\d{2}/\\d{2} \\d{2}:\\d{2}:\\d{2}"),
new SimpleDateFormat("yyyy/MM/dd HH:mm:ss"));
DATETIME_PATTERN_MAP.put(
Pattern.compile("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}"),
new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
}
/*Ursprüngliche Implementierung (bis hier)*/
// private static final Logger logger = LoggerFactory.getLogger(XlsTable.class);
private final ITableMetaData _metaData;
private final Sheet _sheet;
private final DecimalFormatSymbols symbols = new DecimalFormatSymbols();
public DateFormattedXlsTable(String sheetName, Sheet sheet) throws DataSetException {
int rowCount = sheet.getLastRowNum();
if (rowCount >= 0 && sheet.getRow(0) != null) {
_metaData = createMetaData(sheetName, sheet.getRow(0));
} else {
_metaData = new DefaultTableMetaData(sheetName, new Column[0]);
}
_sheet = sheet;
// Needed for later "BigDecimal"/"Number" conversion
symbols.setDecimalSeparator('.');
}
static ITableMetaData createMetaData(String tableName, Row sampleRow) {
logger.debug("createMetaData(tableName={}, sampleRow={}) - start", tableName, sampleRow);
List columnList = new ArrayList();
for (int i = 0; ; i++) {
Cell cell = sampleRow.getCell(i);
if (cell == null) {
break;
}
String columnName = cell.getRichStringCellValue().getString();
if (columnName != null) {
columnName = columnName.trim();
}
// Bugfix for issue ID 2818981 - if a cell has a formatting but no name also ignore it
if (columnName.length() <= 0) {
// logger.debug("The column name of column # {} is empty - will skip here assuming the
// last column was reached", String.valueOf(i));
break;
}
Column column = new Column(columnName, DataType.UNKNOWN);
columnList.add(column);
}
Column[] columns = (Column[]) columnList.toArray(new Column[0]);
return new DefaultTableMetaData(tableName, columns);
}
////////////////////////////////////////////////////////////////////////////
// ITable interface
public int getRowCount() {
logger.debug("getRowCount() - start");
return _sheet.getLastRowNum();
}
public ITableMetaData getTableMetaData() {
logger.debug("getTableMetaData() - start");
return _metaData;
}
public Object getValue(int row, String column) throws DataSetException {
if (logger.isDebugEnabled()) {
logger.debug("getValue(row={}, columnName={}) - start", Integer.toString(row), column);
}
assertValidRowIndex(row);
int columnIndex = getColumnIndex(column);
Cell cell = _sheet.getRow(row + 1).getCell(columnIndex);
if (cell == null) {
return null;
}
int type = cell.getCellType();
switch (type) {
case Cell.CELL_TYPE_NUMERIC:
CellStyle style = cell.getCellStyle();
if (DateUtil.isCellDateFormatted(cell)) {
return getDateValue(cell);
} else if (XlsDataSetWriter.DATE_FORMAT_AS_NUMBER_DBUNIT.equals(
style.getDataFormatString())) {
// The special dbunit date format
return getDateValueFromJavaNumber(cell);
} else {
return getNumericValue(cell);
}
case Cell.CELL_TYPE_STRING:
/*Ursprüngliche Implementierung (von hier)*/
String cellValue = cell.getRichStringCellValue().getString();
if ("null".equals(cellValue)) {
return null;
}
Set<Pattern> patternSet = DATETIME_PATTERN_MAP.keySet();
for (Pattern pattern : patternSet) {
if (pattern.matcher(cellValue).matches()) {
SimpleDateFormat format = DATETIME_PATTERN_MAP.get(pattern);
try {
return format.parse(cellValue);
} catch (ParseException e) {
continue;
}
}
}
return cellValue;
/*Ursprüngliche Implementierung (bis hier)*/
case Cell.CELL_TYPE_FORMULA:
throw new DataTypeException("Formula not supported at row=" + row + ", column=" + column);
case Cell.CELL_TYPE_BLANK:
return ""; //Ursprüngliche Implementierung
case Cell.CELL_TYPE_BOOLEAN:
return cell.getBooleanCellValue() ? Boolean.TRUE : Boolean.FALSE;
case Cell.CELL_TYPE_ERROR:
throw new DataTypeException("Error at row=" + row + ", column=" + column);
default:
throw new DataTypeException("Unsupported type at row=" + row + ", column=" + column);
}
}
protected Object getDateValueFromJavaNumber(Cell cell) {
logger.debug("getDateValueFromJavaNumber(cell={}) - start", cell);
double numericValue = cell.getNumericCellValue();
BigDecimal numericValueBd = new BigDecimal(String.valueOf(numericValue));
numericValueBd = stripTrailingZeros(numericValueBd);
return new Long(numericValueBd.longValue());
}
protected Object getDateValue(Cell cell) {
logger.debug("getDateValue(cell={}) - start", cell);
double numericValue = cell.getNumericCellValue();
Date date = DateUtil.getJavaDate(numericValue);
return new Long(date.getTime());
}
/**
* Removes all trailing zeros from the end of the given BigDecimal value up to the decimal
* point.
*
* @param value The value to be stripped
* @return The value without trailing zeros
*/
private BigDecimal stripTrailingZeros(BigDecimal value) {
if (value.scale() <= 0) {
return value;
}
String valueAsString = String.valueOf(value);
int idx = valueAsString.indexOf(".");
if (idx == -1) {
return value;
}
for (int i = valueAsString.length() - 1; i > idx; i--) {
if (valueAsString.charAt(i) == '0') {
valueAsString = valueAsString.substring(0, i);
} else if (valueAsString.charAt(i) == '.') {
valueAsString = valueAsString.substring(0, i);
// Stop when decimal point is reached
break;
} else {
break;
}
}
BigDecimal result = new BigDecimal(valueAsString);
return result;
}
protected BigDecimal getNumericValue(Cell cell) {
logger.debug("getNumericValue(cell={}) - start", cell);
String formatString = cell.getCellStyle().getDataFormatString();
String resultString = null;
double cellValue = cell.getNumericCellValue();
if ((formatString != null)) {
if (!formatString.equals("General") && !formatString.equals("@")) {
logger.debug("formatString={}", formatString);
DecimalFormat nf = new DecimalFormat(formatString, symbols);
resultString = nf.format(cellValue);
}
}
BigDecimal result;
if (resultString != null) {
try {
result = new BigDecimal(resultString);
} catch (NumberFormatException e) {
logger.debug("Exception occurred while trying create a BigDecimal. value={}",
resultString);
// Probably was not a BigDecimal format retrieved from the excel. Some
// date formats are not yet recognized by HSSF as DateFormats so that
// we could get here.
result = toBigDecimal(cellValue);
}
} else {
result = toBigDecimal(cellValue);
}
return result;
}
/**
* @param cellValue
* @return
* @since 2.4.6
*/
private BigDecimal toBigDecimal(double cellValue) {
String resultString = String.valueOf(cellValue);
// To ensure that intergral numbers do not have decimal point and trailing zero
// (to restore backward compatibility and provide a string representation consistent with
// Excel)
if (resultString.endsWith(".0")) {
resultString = resultString.substring(0, resultString.length() - 2);
}
BigDecimal result = new BigDecimal(resultString);
return result;
}
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append(getClass().getName()).append("[");
sb.append("_metaData=").append(this._metaData == null ? "null" : this._metaData.toString());
sb.append(", _sheet=").append(this._sheet == null ? "null" : "" + this._sheet);
sb.append(", symbols=").append(this.symbols == null ? "null" : "" + this.symbols);
sb.append("]");
return sb.toString();
}
}
}
Der angegebene Quellcode war der neueste 2.6.0 vom 24. Januar 2020, aber da die zur Überprüfung verwendete Version von DBUnit 2.5.4 ist, habe ich die Einstellungen für die Excel-Codierung auskommentiert. .. Wenn Sie 2.6.0 oder höher verwenden möchten, kommentieren Sie bitte die folgende Zeile aus.
// workbook.setSheetName(index, metaData.getTableName(), HSSFWorkbook.ENCODING_UTF_16);
// cell.setEncoding(HSSFCell.ENCODING_UTF_16);
DatabaseConnection connection = new DatabaseConnection(sqlConnection, schemaName);
connection.getConfig().setProperty(DatabaseConfig.FEATURE_ALLOW_EMPTY_FIELDS, true);
IDataSet xlsDataSet = new MyXlsDataset(new File(xlsFilePath));
DatabaseOperation.CLEAN_INSERT.execute(connection, compositDataSet);
DatabaseConnection connection = new DatabaseConnection(sqlConnection, schemaName);
connection.getConfig().setProperty(DatabaseConfig.FEATURE_ALLOW_EMPTY_FIELDS, true);
IDataSet expected= new MyXlsDataset(new File(expectedXlsFilePath));
QueryDataSet actual = new QueryDataSet(connection);
Assert.assertEquals(expected, actual);
DatabaseConnection connection = new DatabaseConnection(sqlConnection, schemaName);
connection.getConfig().setProperty(DatabaseConfig.FEATURE_ALLOW_EMPTY_FIELDS, true);
QueryDataSet dbDataSet= new QueryDataSet(connection);
FileOutputStream fileOutputStream = new FileOutputStream(outputFilePath);
MyXlsDataset.write(dbDataSet, fileOutputStream);
DBUnit hat eine LGPL-Lizenz. Bitte beachten Sie, dass Sie die LGPL-Lizenz einhalten müssen, wenn Sie den obigen Code in den Implementierungscode aufnehmen möchten, z. B. beim Verteilen des Testcodes des erstellten Programms.
Recommended Posts