RESOLVED - issue BATCH-76: ItemWriter for SQL batch updates

http://jira.springframework.org/browse/BATCH-76

spring-batch-infrastructure/src/main/java/org/springframework/batch/io/support/BatchSqlUpdateItemWriter.java

@@ -0,0 +1,227 @@
+/*
+ * Copyright 2006-2007 the original author or authors.
+ *
+ * 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.springframework.batch.io.support;
+
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+import org.springframework.batch.item.ItemWriter;
+import org.springframework.batch.item.exception.ClearFailedException;
+import org.springframework.batch.item.exception.FlushFailedException;
+import org.springframework.batch.repeat.RepeatContext;
+import org.springframework.batch.repeat.synch.RepeatSynchronizationManager;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.dao.DataAccessException;
+import org.springframework.jdbc.core.JdbcOperations;
+import org.springframework.jdbc.core.PreparedStatementCallback;
+import org.springframework.transaction.support.TransactionSynchronizationManager;
+import org.springframework.util.Assert;
+
+/**
+ * {@link ItemWriter} that uses the batching features from
+ * {@link PreparedStatement} if available and can take some rudimentary steps to
+ * locate a failure during a flush, and identify the items that failed. When one
+ * of those items is encountered again the batch is flushed aggressively so that
+ * the bad item is eventually identified and can be dealt with in isolation.<br/>
+ * 
+ * The user must provide an SQL query and a special callback
+ * {@link ItemPreparedStatementSetter}, which is responsible for mapping the
+ * item to a PreparedStatement.
+ * 
+ * @author Dave Syer
+ * 
+ */
+public class BatchSqlUpdateItemWriter implements ItemWriter, InitializingBean {
+
+	/**
+	 * Key for items processed in the current transaction {@link RepeatContext}.
+	 */
+	protected static final String ITEMS_PROCESSED = BatchSqlUpdateItemWriter.class.getName() + ".ITEMS_PROCESSED";
+
+	private Set failed = new HashSet();
+
+	private JdbcOperations jdbcTemplate;
+
+	private ItemPreparedStatementSetter preparedStatementSetter;
+
+	private String sql;
+
+	/**
+	 * Public setter for the query string to execute on write. The parameters
+	 * should correspond to those known to the
+	 * {@link ItemPreparedStatementSetter}.
+	 * @param sql the query to set
+	 */
+	public void setSql(String sql) {
+		this.sql = sql;
+	}
+
+	/**
+	 * Public setter for the {@link ItemPreparedStatementSetter}.
+	 * @param preparedStatementSetter the {@link ItemPreparedStatementSetter} to
+	 * set
+	 */
+	public void setItemPreparedStatementSetter(ItemPreparedStatementSetter preparedStatementSetter) {
+		this.preparedStatementSetter = preparedStatementSetter;
+	}
+
+	/**
+	 * Public setter for the {@link JdbcOperations}.
+	 * @param jdbcTemplate the {@link JdbcOperations} to set
+	 */
+	public void setJdbcTemplate(JdbcOperations jdbcTemplate) {
+		this.jdbcTemplate = jdbcTemplate;
+	}
+
+	/**
+	 * Check mandatory properties - there must be a delegate.
+	 * 
+	 * @see org.springframework.dao.support.DaoSupport#initDao()
+	 */
+	public void afterPropertiesSet() throws Exception {
+		Assert.notNull(jdbcTemplate, "BatchSqlUpdateItemWriter requires an data source.");
+		Assert.notNull(preparedStatementSetter, "BatchSqlUpdateItemWriter requires a ItemPreparedStatementSetter");
+	}
+
+	/**
+	 * Buffer the item in a transaction resource, but flush aggressively if the
+	 * item was previously part of a failed chunk.
+	 * 
+	 * @throws Exception
+	 * 
+	 * @see org.springframework.batch.io.OutputSource#write(java.lang.Object)
+	 */
+	public void write(Object output) throws Exception {
+		bindTransactionResources();
+		getProcessed().add(output);
+		flushIfNecessary(output);
+	}
+
+	/**
+	 * Accessor for the list of processed items in this transaction.
+	 * 
+	 * @return the processed
+	 */
+	private Set getProcessed() {
+		Assert.state(TransactionSynchronizationManager.hasResource(ITEMS_PROCESSED),
+				"Processed items not bound to transaction.");
+		Set processed = (Set) TransactionSynchronizationManager.getResource(ITEMS_PROCESSED);
+		return processed;
+	}
+
+	/**
+	 * Set up the {@link RepeatContext} as a transaction resource.
+	 * 
+	 * @param context the context to set
+	 */
+	private void bindTransactionResources() {
+		if (TransactionSynchronizationManager.hasResource(ITEMS_PROCESSED)) {
+			return;
+		}
+		TransactionSynchronizationManager.bindResource(ITEMS_PROCESSED, new HashSet());
+	}
+
+	/**
+	 * Remove the transaction resource associated with this context.
+	 */
+	private void unbindTransactionResources() {
+		if (!TransactionSynchronizationManager.hasResource(ITEMS_PROCESSED)) {
+			return;
+		}
+		TransactionSynchronizationManager.unbindResource(ITEMS_PROCESSED);
+	}
+
+	/**
+	 * Accessor for the context property.
+	 * 
+	 * @param output
+	 * 
+	 * @return the context
+	 */
+	private void flushIfNecessary(Object output) throws Exception {
+		boolean flush;
+		synchronized (failed) {
+			flush = failed.contains(output);
+		}
+		if (flush) {
+			RepeatContext context = RepeatSynchronizationManager.getContext();
+			// Force early completion to commit aggressively if we encounter a
+			// failed item (from a failed chunk but we don't know which one was
+			// the problem).
+			context.setCompleteOnly();
+			// Flush now, so that if there is a failure this record can be
+			// skipped.
+			doFlush();
+		}
+	}
+
+	/**
+	 * Flush the hibernate session from within a repeat context.
+	 */
+	private void doFlush() {
+		final Set processed = getProcessed();
+		try {
+			if (!processed.isEmpty()) {
+				jdbcTemplate.execute(sql, new PreparedStatementCallback() {
+					public Object doInPreparedStatement(PreparedStatement ps) throws SQLException, DataAccessException {
+						for (Iterator iterator = processed.iterator(); iterator.hasNext();) {
+							Object item = (Object) iterator.next();
+							preparedStatementSetter.setValues(item, ps);
+							ps.addBatch();
+						}
+						return ps.executeBatch();
+					}
+				});
+			}
+		}
+		catch (RuntimeException e) {
+			synchronized (failed) {
+				failed.addAll(processed);
+			}
+			throw e;
+		}
+		finally {
+			getProcessed().clear();
+		}
+	}
+
+	/**
+	 * Unbind transaction resources, effectively clearing the item buffer.
+	 * 
+	 * @see org.springframework.batch.item.ItemWriter#clear()
+	 */
+	public void clear() throws ClearFailedException {
+		unbindTransactionResources();
+	}
+
+	/**
+	 * Flush the internal item buffer and record failures if there are any.
+	 * 
+	 * @see org.springframework.batch.item.ItemWriter#flush()
+	 */
+	public void flush() throws FlushFailedException {
+		try {
+			doFlush();
+		}
+		finally {
+			unbindTransactionResources();
+		}
+	}
+
+}

spring-batch-infrastructure/src/main/java/org/springframework/batch/io/support/ItemPreparedStatementSetter.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2006-2007 the original author or authors.
+ *
+ * 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.springframework.batch.io.support;
+
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+
+import org.springframework.jdbc.core.RowMapper;
+
+/**
+ * A convenient strategy for SQL updates, acting effectively as the inverse of
+ * {@link RowMapper}.
+ * @author Dave Syer
+ * 
+ */
+public interface ItemPreparedStatementSetter {
+	/**
+	 * Set parameter values on the given PreparedStatement as determined from
+	 * the provided item.
+	 * @param ps the PreparedStatement to invoke setter methods on
+	 * @throws SQLException if a SQLException is encountered (i.e. there is no
+	 * need to catch SQLException)
+	 */
+	void setValues(Object item, PreparedStatement ps) throws SQLException;
+
+}

spring-batch-infrastructure/src/test/java/org/springframework/batch/io/support/BatchSqlUpdateItemWriterTests.java

@@ -0,0 +1,208 @@
+/*
+ * Copyright 2006-2007 the original author or authors.
+ *
+ * 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.springframework.batch.io.support;
+
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import junit.framework.TestCase;
+
+import org.easymock.MockControl;
+import org.springframework.batch.repeat.RepeatContext;
+import org.springframework.batch.repeat.context.RepeatContextSupport;
+import org.springframework.batch.repeat.synch.RepeatSynchronizationManager;
+import org.springframework.dao.DataAccessException;
+import org.springframework.jdbc.UncategorizedSQLException;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.core.PreparedStatementCallback;
+import org.springframework.transaction.support.TransactionSynchronizationManager;
+
+/**
+ * @author Dave Syer
+ * 
+ */
+public class BatchSqlUpdateItemWriterTests extends TestCase {
+
+	private BatchSqlUpdateItemWriter writer = new BatchSqlUpdateItemWriter();
+
+	private JdbcTemplate jdbcTemplate;
+
+	protected List list = new ArrayList();
+	
+	private RepeatContext context = new RepeatContextSupport(null);
+
+	private PreparedStatement ps;
+
+	private MockControl control = MockControl.createControl(PreparedStatement.class);
+
+	/*
+	 * (non-Javadoc)
+	 * @see junit.framework.TestCase#setUp()
+	 */
+	protected void setUp() throws Exception {
+		ps = (PreparedStatement) control.getMock();
+		jdbcTemplate = new JdbcTemplate() {
+			public Object execute(String sql, PreparedStatementCallback action) throws DataAccessException {
+				list.add(sql);
+				try {
+					return action.doInPreparedStatement(ps);
+				}
+				catch (SQLException e) {
+					throw new UncategorizedSQLException("doInPreparedStatement", sql, e);
+				}
+			}
+		};
+		writer.setSql("SQL");
+		writer.setJdbcTemplate(jdbcTemplate);
+		writer.setItemPreparedStatementSetter(new ItemPreparedStatementSetter() {
+			public void setValues(Object item, PreparedStatement ps) throws SQLException {
+				list.add(item);
+			}
+		});
+		TransactionSynchronizationManager.bindResource(BatchSqlUpdateItemWriter.ITEMS_PROCESSED, new HashSet(
+				Collections.singleton("spam")));
+		RepeatSynchronizationManager.register(context);
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see junit.framework.TestCase#tearDown()
+	 */
+	protected void tearDown() throws Exception {
+		Map map = TransactionSynchronizationManager.getResourceMap();
+		for (Iterator iterator = map.keySet().iterator(); iterator.hasNext();) {
+			String key = (String) iterator.next();
+			TransactionSynchronizationManager.unbindResource(key);
+		}
+		RepeatSynchronizationManager.clear();
+	}
+
+	/**
+	 * Test method for
+	 * {@link org.springframework.batch.io.support.BatchSqlUpdateItemWriter#afterPropertiesSet()}.
+	 * @throws Exception
+	 */
+	public void testAfterPropertiesSet() throws Exception {
+		try {
+			writer.afterPropertiesSet();
+		}
+		catch (IllegalArgumentException e) {
+			// expected
+			String message = e.getMessage().toLowerCase();
+			assertTrue("Message does not contain 'query'.", message.indexOf("query") >= 0);
+		}
+	}
+
+	/**
+	 * Test method for
+	 * {@link org.springframework.batch.io.support.BatchSqlUpdateItemWriter#write(java.lang.Object)}.
+	 * @throws Exception
+	 */
+	public void testWrite() throws Exception {
+		writer.setSql("foo");
+		writer.write("bar");
+		// Nothing happens till we flush
+		assertEquals(0, list.size());
+	}
+
+	/**
+	 * Test method for
+	 * {@link org.springframework.batch.io.support.BatchSqlUpdateItemWriter#clear()}.
+	 */
+	public void testClear() {
+		assertTrue(TransactionSynchronizationManager.hasResource(BatchSqlUpdateItemWriter.ITEMS_PROCESSED));
+		writer.clear();
+		assertFalse(TransactionSynchronizationManager.hasResource(BatchSqlUpdateItemWriter.ITEMS_PROCESSED));
+	}
+
+	/**
+	 * Test method for
+	 * {@link org.springframework.batch.io.support.BatchSqlUpdateItemWriter#flush()}.
+	 */
+	public void testFlush() {
+		assertTrue(TransactionSynchronizationManager.hasResource(BatchSqlUpdateItemWriter.ITEMS_PROCESSED));
+		writer.flush();
+		assertFalse(TransactionSynchronizationManager.hasResource(BatchSqlUpdateItemWriter.ITEMS_PROCESSED));
+		assertEquals(2, list.size());
+		assertTrue(list.contains("SQL"));
+	}
+
+	/**
+	 * Test method for
+	 * {@link org.springframework.batch.io.support.BatchSqlUpdateItemWriter#flush()}.
+	 * @throws Exception 
+	 */
+	public void testWriteAndFlush() throws Exception {
+		assertTrue(TransactionSynchronizationManager.hasResource(BatchSqlUpdateItemWriter.ITEMS_PROCESSED));
+		writer.write("bar");
+		writer.flush();
+		assertFalse(TransactionSynchronizationManager.hasResource(BatchSqlUpdateItemWriter.ITEMS_PROCESSED));
+		assertEquals(3, list.size());
+		assertTrue(list.contains("SQL"));
+	}
+	
+	public void testFlushWithFailure() throws Exception{
+		tearDown();
+		try {
+			writer.flush();
+			fail("Expected IllegalStateException");
+		} catch (IllegalStateException e) {
+			assertTrue("Message should contain hint about transaction: "+e.getMessage(), e.getMessage().indexOf("transaction")>=0);
+		}
+	}
+
+	public void testWriteAndFlushWithFailure() throws Exception {
+		final RuntimeException ex = new RuntimeException("bar");
+		writer.setItemPreparedStatementSetter(new ItemPreparedStatementSetter() {
+			public void setValues(Object item, PreparedStatement ps) throws SQLException {
+				list.add(item);
+				throw ex;
+			}
+		});
+		ps.addBatch();
+		control.setVoidCallable();
+		control.expectAndReturn(ps.executeBatch(), new int[] {123});
+		control.replay();
+		writer.write("foo");
+		try {
+			writer.flush();
+			fail("Expected RuntimeException");
+		} catch (RuntimeException e) {
+			assertEquals("bar", e.getMessage());
+		}
+		assertFalse(TransactionSynchronizationManager.hasResource(BatchSqlUpdateItemWriter.ITEMS_PROCESSED));
+		assertEquals(2, list.size());
+		writer.setItemPreparedStatementSetter(new ItemPreparedStatementSetter() {
+			public void setValues(Object item, PreparedStatement ps) throws SQLException {
+				list.add(item);
+			}
+		});
+		writer.write("foo");
+		writer.flush();
+		control.verify();
+		assertEquals(4, list.size());
+		assertTrue(list.contains("SQL"));
+		assertTrue(list.contains("foo"));
+		assertTrue(context.isCompleteOnly());
+	}
+
+}

spring-batch-infrastructure/src/test/java/org/springframework/batch/io/support/HibernateAwareItemWriterTests.java

@@ -88,6 +88,7 @@ public class HibernateAwareItemWriterTests extends TestCase {
 			String key = (String) iterator.next();
 			TransactionSynchronizationManager.unbindResource(key);			
 		}
+		RepeatSynchronizationManager.clear();
 	}
 
 	/**

spring-batch-samples/src/main/java/org/springframework/batch/sample/item/writer/BatchSqlCustomerCreditIncreaseWriter.java

@@ -0,0 +1,69 @@
+package org.springframework.batch.sample.item.writer;
+
+import java.math.BigDecimal;
+
+import org.springframework.batch.io.support.BatchSqlUpdateItemWriter;
+import org.springframework.batch.item.ItemWriter;
+import org.springframework.batch.item.exception.ClearFailedException;
+import org.springframework.batch.item.exception.FlushFailedException;
+import org.springframework.batch.sample.domain.CustomerCredit;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.util.Assert;
+
+/**
+ * Increases customer's credit by fixed amount, delegating to a
+ * {@link BatchSqlUpdateItemWriter} to push the result out to persistent
+ * storage.
+ * 
+ * @author Dave Syer
+ */
+public class BatchSqlCustomerCreditIncreaseWriter implements ItemWriter, InitializingBean {
+
+	private ItemWriter delegate;
+
+	public static final BigDecimal FIXED_AMOUNT = new BigDecimal(1000);
+
+	/**
+	 * Public setter for the {@link ItemWriter}, which must be an instance of
+	 * {@link BatchSqlUpdateItemWriter}.
+	 * @param delegate the delegate to set
+	 */
+	public void setDelegate(ItemWriter delegate) {
+		this.delegate = delegate;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet()
+	 */
+	public void afterPropertiesSet() throws Exception {
+		Assert.state(delegate instanceof BatchSqlUpdateItemWriter, "Delegate must be set and must be an instance of BatchSqlUpdateItemWriter");
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.batch.item.processor.DelegatingItemWriter#doProcess(java.lang.Object)
+	 */
+	public void write(Object data) throws Exception {
+		CustomerCredit customerCredit = (CustomerCredit) data;
+		customerCredit.increaseCreditBy(FIXED_AMOUNT);
+		delegate.write(customerCredit);
+	}
+
+	/**
+	 * @throws ClearFailedException
+	 * @see org.springframework.batch.io.support.BatchSqlUpdateItemWriter#clear()
+	 */
+	public void clear() throws ClearFailedException {
+		delegate.clear();
+	}
+
+	/**
+	 * @throws FlushFailedException
+	 * @see org.springframework.batch.io.support.BatchSqlUpdateItemWriter#flush()
+	 */
+	public void flush() throws FlushFailedException {
+		delegate.flush();
+	}
+
+}

spring-batch-samples/src/main/java/org/springframework/batch/sample/item/writer/CustomerCreditUpdatePreparedStatementSetter.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2006-2007 the original author or authors.
+ *
+ * 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.springframework.batch.sample.item.writer;
+
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+
+import org.springframework.batch.io.support.ItemPreparedStatementSetter;
+import org.springframework.batch.sample.domain.CustomerCredit;
+
+/**
+ * @author Dave Syer
+ *
+ */
+public class CustomerCreditUpdatePreparedStatementSetter implements ItemPreparedStatementSetter {
+
+	/* (non-Javadoc)
+	 * @see org.springframework.batch.io.support.ItemPreparedStatementSetter#setValues(java.lang.Object, java.sql.PreparedStatement)
+	 */
+	public void setValues(Object item, PreparedStatement ps) throws SQLException {
+		CustomerCredit customerCredit = (CustomerCredit) item;
+		ps.setBigDecimal(1, customerCredit.getCredit());
+		ps.setLong(2, customerCredit.getId());
+	}
+
+}

spring-batch-samples/src/main/java/org/springframework/batch/sample/mapping/CustomerCreditRowMapper.java

@@ -8,12 +8,14 @@ import org.springframework.jdbc.core.RowMapper;
 
 public class CustomerCreditRowMapper implements RowMapper {
 	
+	public static final String ID_COLUMN = "id";
 	public static final String NAME_COLUMN = "name";
 	public static final String CREDIT_COLUMN = "credit";
 
 	public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
         CustomerCredit customerCredit = new CustomerCredit();
 
+        customerCredit.setId(rs.getInt(ID_COLUMN));
         customerCredit.setName(rs.getString(NAME_COLUMN));
         customerCredit.setCredit(rs.getBigDecimal(CREDIT_COLUMN));
 

spring-batch-samples/src/main/resources/jobs/batchUpdateJob.xml

@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans" xmlns:aop="http://www.springframework.org/schema/aop"
+	xmlns:tx="http://www.springframework.org/schema/tx" xmlns:p="http://www.springframework.org/schema/p"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="
+		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
+		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
+		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
+
+	<description>Example for SQL Batch Update integration.</description>
+
+	<bean id="batchUpdateJob" parent="simpleJob">
+		<!-- set restartable=false so that this job can be used by more than one test -->
+		<property name="restartable" value="false" />
+		<property name="steps">
+			<bean id="step1" parent="simpleStep">
+				<property name="skipLimit" value="5" />
+				<property name="itemReader" ref="itemReader" />
+				<property name="itemWriter" ref="itemWriter" />
+				<property name="commitInterval" value="3" />
+			</bean>
+		</property>
+	</bean>
+
+	<bean id="itemWriter" class="org.springframework.batch.sample.item.writer.BatchSqlCustomerCreditIncreaseWriter">
+		<property name="delegate">
+			<bean class="org.springframework.batch.io.support.BatchSqlUpdateItemWriter">
+				<property name="jdbcTemplate" ref="jdbcTemplate" />
+				<property name="sql"><value><![CDATA[UPDATE CUSTOMER SET CREDIT=? WHERE ID=?]]></value></property>
+				<property name="itemPreparedStatementSetter">
+					<bean class="org.springframework.batch.sample.item.writer.CustomerCreditUpdatePreparedStatementSetter"/>
+				</property>
+			</bean>
+		</property>
+	</bean>
+
+	<bean id="itemReader" class="org.springframework.batch.io.cursor.JdbcCursorItemReader">
+		<property name="dataSource" ref="dataSource" />
+		<property name="sql" value="SELECT id, name, credit FROM customer " />
+		<property name="mapper">
+			<bean class="org.springframework.batch.sample.mapping.CustomerCreditRowMapper" />
+		</property>
+	</bean>
+
+</beans>

spring-batch-samples/src/main/resources/jobs/fixedLengthImportJob.xml

@@ -86,6 +86,4 @@
 	<bean id="fieldSetMapper"
 		class="org.springframework.batch.sample.mapping.TradeFieldSetMapper" />
 
-	<bean parent="customEditorConfigurer" />
-
 </beans>

spring-batch-samples/src/main/resources/jobs/parallelJob.xml

@@ -122,8 +122,6 @@
 	<bean id="fieldSetMapper"
 		class="org.springframework.batch.sample.mapping.TradeFieldSetMapper" />
 
-	<bean parent="customEditorConfigurer" />
-
 	<aop:config>
 		<aop:aspect id="moduleLogging" ref="logAdvice">
 			<aop:after

spring-batch-samples/src/test/java/org/springframework/batch/sample/BatchSqlUpdateJobFunctionalTests.java

@@ -0,0 +1,10 @@
+package org.springframework.batch.sample;
+
+/**
+ * Test for BatchSqlUpdateJob - checks that customer credit has been updated to expected value.
+ * 
+ * @author Robert Kasanicky
+ */
+public class BatchSqlUpdateJobFunctionalTests extends AbstractCustomerCreditIncreaseTests {
+
+}

spring-batch-samples/src/test/java/org/springframework/batch/sample/item/writer/BatchSqlCustomerCreditIncreaseWriterTests.java

@@ -0,0 +1,101 @@
+/*
+ * Copyright 2006-2007 the original author or authors.
+ *
+ * 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.springframework.batch.sample.item.writer;
+
+import java.math.BigDecimal;
+
+import junit.framework.TestCase;
+
+import org.easymock.MockControl;
+import org.springframework.batch.item.ItemWriter;
+import org.springframework.batch.sample.domain.CustomerCredit;
+
+/**
+ * @author Dave Syer
+ * 
+ */
+public class BatchSqlCustomerCreditIncreaseWriterTests extends TestCase {
+
+	private BatchSqlCustomerCreditIncreaseWriter writer = new BatchSqlCustomerCreditIncreaseWriter();
+
+	private ItemWriter delegate;
+
+	private MockControl control = MockControl.createControl(ItemWriter.class);
+
+	private CustomerCredit customerCredit;
+
+	/*
+	 * (non-Javadoc)
+	 * @see junit.framework.TestCase#setUp()
+	 */
+	protected void setUp() throws Exception {
+		delegate = (ItemWriter) control.getMock();
+		writer.setDelegate(delegate);
+		customerCredit = new CustomerCredit();
+		customerCredit.setId(13);
+		customerCredit.setCredit(new BigDecimal(1000));
+		customerCredit.setName("foo");
+	}
+	
+	public void testAfterPropertiesSet() throws Exception {
+		try {
+			writer.afterPropertiesSet();
+			fail("Expected IllegalStateException");
+		} catch (IllegalStateException e) {
+			// expected: wrong class
+			String message = e.getMessage();
+			assertTrue("Message does not contain 'instance'"+message, message.indexOf("instance")>=0);
+		}
+	}
+
+	/**
+	 * Test method for
+	 * {@link org.springframework.batch.sample.item.writer.BatchSqlCustomerCreditIncreaseWriter#write(java.lang.Object)}.
+	 * @throws Exception
+	 */
+	public void testWrite() throws Exception {
+		delegate.write(customerCredit);
+		control.setVoidCallable();
+		control.replay();
+		writer.write(customerCredit);
+		control.verify();
+	}
+
+	/**
+	 * Test method for
+	 * {@link org.springframework.batch.sample.item.writer.BatchSqlCustomerCreditIncreaseWriter#clear()}.
+	 */
+	public void testClear() {
+		delegate.clear();
+		control.setVoidCallable();
+		control.replay();
+		writer.clear();
+		control.verify();
+	}
+
+	/**
+	 * Test method for
+	 * {@link org.springframework.batch.sample.item.writer.BatchSqlCustomerCreditIncreaseWriter#flush()}.
+	 */
+	public void testFlush() {
+		delegate.flush();
+		control.setVoidCallable();
+		control.replay();
+		writer.flush();
+		control.verify();
+	}
+
+}

spring-batch-samples/src/test/java/org/springframework/batch/sample/item/writer/CustomerCreditUpdatePreparedStatementSetterTests.java

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2006-2007 the original author or authors.
+ *
+ * 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.springframework.batch.sample.item.writer;
+
+import java.math.BigDecimal;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+
+import junit.framework.TestCase;
+
+import org.easymock.MockControl;
+import org.springframework.batch.sample.domain.CustomerCredit;
+
+/**
+ * @author Dave Syer
+ *
+ */
+public class CustomerCreditUpdatePreparedStatementSetterTests extends TestCase {
+	
+	private CustomerCreditUpdatePreparedStatementSetter setter = new CustomerCreditUpdatePreparedStatementSetter();
+
+	private CustomerCredit credit;
+
+	private PreparedStatement ps;
+
+	private MockControl control = MockControl.createControl(PreparedStatement.class);
+
+	/* (non-Javadoc)
+	 * @see junit.framework.TestCase#setUp()
+	 */
+	protected void setUp() throws Exception {
+		ps = (PreparedStatement) control.getMock();
+		credit = new CustomerCredit();
+		credit.setId(13);
+		credit.setCredit(new BigDecimal(12000));
+		credit.setName("foo");
+	}
+	/**
+	 * Test method for {@link org.springframework.batch.sample.item.writer.CustomerCreditUpdatePreparedStatementSetter#setValues(java.lang.Object, java.sql.PreparedStatement)}.
+	 * @throws SQLException 
+	 */
+	public void testSetValues() throws SQLException {
+		ps.setBigDecimal(1, credit.getCredit());
+		control.setVoidCallable();
+		ps.setLong(2, credit.getId());
+		control.setVoidCallable();
+		control.replay();
+		setter.setValues(credit, ps);
+		control.verify();
+	}
+
+}

spring-batch-samples/src/test/java/org/springframework/batch/sample/mapping/CustomerCreditRowMapperTests.java

@@ -11,11 +11,16 @@ import org.springframework.jdbc.core.RowMapper;
 
 public class CustomerCreditRowMapperTests extends AbstractRowMapperTests {
 
+	/**
+	 * 
+	 */
+	private static final int ID = 12;
 	private static final String CUSTOMER = "Jozef Mak";
 	private static final BigDecimal CREDIT = new BigDecimal(0.1);
 
 	protected Object expectedDomainObject() {
 		CustomerCredit credit = new CustomerCredit();
+		credit.setId(ID);
 		credit.setCredit(CREDIT);
 		credit.setName(CUSTOMER);
 		return credit;
@@ -26,6 +31,8 @@ public class CustomerCreditRowMapperTests extends AbstractRowMapperTests {
 	}
 
 	protected void setUpResultSetMock(ResultSet rs, MockControl rsControl) throws SQLException {
+		rs.getInt(CustomerCreditRowMapper.ID_COLUMN);
+		rsControl.setReturnValue(ID);
 		rs.getString(CustomerCreditRowMapper.NAME_COLUMN);
 		rsControl.setReturnValue(CUSTOMER);
 		rs.getBigDecimal(CustomerCreditRowMapper.CREDIT_COLUMN);

spring-batch-samples/src/test/resources/org/springframework/batch/sample/BatchSqlUpdateJobFunctionalTests-context.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="
+		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
+
+	<import resource="classpath:/simple-job-launcher-context.xml" />
+	<import resource="classpath:/jobs/batchUpdateJob.xml" />
+
+</beans>