added a concrete GenericStoredProcedure class to make it possible to configure using application context (SPR-3987)

org.springframework.jdbc/src/main/java/org/springframework/jdbc/object/GenericSqlQuery.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2002-2009 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.jdbc.object;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.Map;
+
+import org.springframework.jdbc.core.RowMapper;
+import org.springframework.util.Assert;
+import org.springframework.dao.InvalidDataAccessApiUsageException;
+
+public class GenericSqlQuery extends SqlQuery {
+
+	Class rowMapperClass;
+
+	RowMapper rowMapper;
+
+	public void setRowMapperClass(Class rowMapperClass)
+			throws IllegalAccessException, InstantiationException {
+		this.rowMapperClass = rowMapperClass;
+		if (!RowMapper.class.isAssignableFrom(rowMapperClass))
+			throw new IllegalStateException("The specified class '" + 
+					rowMapperClass.getName() + " is not a sub class of " +
+					"'org.springframework.jdbc.core.RowMapper'");
+	}
+
+	public void afterPropertiesSet() {
+		super.afterPropertiesSet();
+		Assert.notNull(rowMapperClass, "The 'rowMapperClass' property is required");
+	}
+
+	protected RowMapper newRowMapper(Object[] parameters, Map context) {
+		try {
+			return (RowMapper) rowMapperClass.newInstance();
+		}
+		catch (InstantiationException e) {
+			throw new InvalidDataAccessApiUsageException("Unable to instantiate RowMapper", e);
+		}
+		catch (IllegalAccessException e) {
+			throw new InvalidDataAccessApiUsageException("Unable to instantiate RowMapper", e);
+		}
+	}
+}

org.springframework.jdbc/src/main/java/org/springframework/jdbc/object/GenericStoredProcedure.java

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2002-2009 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.jdbc.object;
+
+/**
+ * Concrete implementation making it possible to define the RDBMS stored procedures
+ * in an application context without writing a custom Java implementation class.
+ * <p>
+ * This implementation does not provide a typed method for invocation so executions
+ * must use one of the generic {@link StoredProcedure#execute(java.util.Map)} or
+ * {@link StoredProcedure#execute(org.springframework.jdbc.core.ParameterMapper)} methods.
+ *
+ * @author Thomas Risberg
+ * @see org.springframework.jdbc.object.StoredProcedure
+ */
+public class GenericStoredProcedure extends StoredProcedure {
+
+}

org.springframework.jdbc/src/test/java/org/springframework/jdbc/datasource/TestDataSourceWrapper.java

@@ -0,0 +1,23 @@
+package org.springframework.jdbc.datasource;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import javax.sql.DataSource;
+
+public class TestDataSourceWrapper extends AbstractDataSource {
+
+	private DataSource target;
+
+	public void setTarget(DataSource target) {
+		this.target = target;
+	}
+
+	public Connection getConnection() throws SQLException {
+		return target.getConnection();
+	}
+
+	public Connection getConnection(String username, String password) throws SQLException {
+		return target.getConnection(username, password);
+	}
+
+}

org.springframework.jdbc/src/test/java/org/springframework/jdbc/object/GenericStoredProcedureTests.java

@@ -0,0 +1,114 @@
+/*
+ * Copyright 2002-2009 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.jdbc.object;
+
+import static org.easymock.EasyMock.createMock;
+import static org.easymock.EasyMock.expect;
+import static org.easymock.EasyMock.expectLastCall;
+import static org.easymock.EasyMock.verify;
+
+import java.sql.CallableStatement;
+import java.sql.Types;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.easymock.EasyMock;
+import org.apache.commons.logging.LogFactory;
+import org.junit.Test;
+import org.junit.After;
+import org.junit.Before;
+
+import org.springframework.jdbc.AbstractJdbcTests;
+import org.springframework.jdbc.datasource.TestDataSourceWrapper;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.beans.factory.BeanFactory;
+import org.springframework.beans.factory.xml.XmlBeanFactory;
+import org.springframework.core.io.ClassPathResource;
+
+/**
+ * @author Thomas Risberg
+ */
+public class GenericStoredProcedureTests extends AbstractJdbcTests {
+
+	private final boolean debugEnabled = LogFactory.getLog(JdbcTemplate.class).isDebugEnabled();
+
+	private CallableStatement mockCallable;
+
+	private BeanFactory bf;
+
+	@Before
+	protected void setUp() throws Exception {
+		super.setUp();
+		mockCallable = createMock(CallableStatement.class);
+		bf = new XmlBeanFactory(
+				new ClassPathResource("org/springframework/jdbc/support/GenericStoredProcedureTests-context.xml"));
+		TestDataSourceWrapper testDataSource = (TestDataSourceWrapper) bf.getBean("dataSource");
+		testDataSource.setTarget(mockDataSource);
+	}
+
+	@After
+	protected void tearDown() throws Exception {
+		super.tearDown();
+		if (shouldVerify()) {
+			verify(mockCallable);
+		}
+	}
+
+	protected void replay() {
+		super.replay();
+		EasyMock.replay(mockCallable);
+	}
+
+	@Test
+	public void testAddInvoices() throws Exception {
+
+		mockCallable.setObject(1, new Integer(1106), Types.INTEGER);
+		expectLastCall();
+		mockCallable.setObject(2, new Integer(3), Types.INTEGER);
+		expectLastCall();
+		mockCallable.registerOutParameter(3, Types.INTEGER);
+		expectLastCall();
+		expect(mockCallable.execute()).andReturn(false);
+		expect(mockCallable.getUpdateCount()).andReturn(-1);
+		expect(mockCallable.getObject(3)).andReturn(new Integer(4));
+		if (debugEnabled) {
+			expect(mockCallable.getWarnings()).andReturn(null);
+		}
+		mockCallable.close();
+		expectLastCall();
+
+		mockConnection.prepareCall("{call " + "add_invoice" + "(?, ?, ?)}");
+		ctrlConnection.setReturnValue(mockCallable);
+
+		replay();
+
+		testAddInvoice(1106, 3);
+	}
+
+	private void testAddInvoice(final int amount, final int custid)
+		throws Exception {
+
+		StoredProcedure adder = (StoredProcedure) bf.getBean("genericProcedure");
+		Map<String, Object> in = new HashMap<String, Object>(2);
+		in.put("amount", amount);
+		in.put("custid", custid);
+		Map out = adder.execute(in);
+		Integer id = (Integer) out.get("newid");
+		assertEquals(4, id.intValue());
+	}
+
+}

org.springframework.jdbc/src/test/resources/org/springframework/jdbc/support/GenericStoredProcedureTests-context.xml

@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xmlns:util="http://www.springframework.org/schema/util"
+	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
+	http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-2.5.xsd">
+
+    <bean id="dataSource" class="org.springframework.jdbc.datasource.TestDataSourceWrapper"/>
+
+	<bean id="genericProcedure" class="org.springframework.jdbc.object.GenericStoredProcedure">
+        <property name="dataSource" ref="dataSource"/>
+		<property name="sql" value="add_invoice"/>
+		<property name="parameters">
+			<list>
+				<bean class="org.springframework.jdbc.core.SqlParameter">
+					<constructor-arg index="0" value="amount"/>
+					<constructor-arg index="1">
+						<util:constant static-field="java.sql.Types.INTEGER"/>
+					</constructor-arg> 
+				</bean>
+				<bean class="org.springframework.jdbc.core.SqlParameter">
+                    <constructor-arg index="0" value="custid"/>
+                    <constructor-arg index="1">
+                        <util:constant static-field="java.sql.Types.INTEGER"/>
+                    </constructor-arg>
+				</bean>
+				<bean class="org.springframework.jdbc.core.SqlOutParameter">
+                    <constructor-arg index="0" value="newid"/>
+                    <constructor-arg index="1">
+                        <util:constant static-field="java.sql.Types.INTEGER"/>
+                    </constructor-arg>
+				</bean>
+			</list>
+		</property>
+	</bean>
+
+</beans>