Merge 92734dbb0d into 7e6874ad80

Closes gh-35580

framework-docs/modules/ROOT/pages/core/beans/annotation-config/autowired.adoc

@@ -37,18 +37,18 @@ Kotlin::
 ----
 ======
 
-[NOTE]
+[TIP]
 ====
-As of Spring Framework 4.3, an `@Autowired` annotation on such a constructor is no longer
-necessary if the target bean defines only one constructor to begin with. However, if
-several constructors are available and there is no primary/default constructor, at least
-one of the constructors must be annotated with `@Autowired` in order to instruct the
-container which one to use. See the discussion on
-xref:core/beans/annotation-config/autowired.adoc#beans-autowired-annotation-constructor-resolution[constructor resolution] for details.
+An `@Autowired` annotation on such a constructor is not necessary if the target bean
+defines only one constructor. However, if several constructors are available and there is
+no primary or default constructor, at least one of the constructors must be annotated
+with `@Autowired` in order to instruct the container which one to use. See the discussion
+on xref:core/beans/annotation-config/autowired.adoc#beans-autowired-annotation-constructor-resolution[constructor resolution]
+for details.
 ====
 
-You can also apply the `@Autowired` annotation to _traditional_ setter methods,
-as the following example shows:
+You can apply the `@Autowired` annotation to _traditional_ setter methods, as the
+following example shows:
 
 [tabs]
 ======
@@ -84,8 +84,8 @@ Kotlin::
 ----
 ======
 
-You can also apply the annotation to methods with arbitrary names and multiple
-arguments, as the following example shows:
+You can apply `@Autowired` to methods with arbitrary names and multiple arguments, as the
+following example shows:
 
 [tabs]
 ======
@@ -176,14 +176,15 @@ Kotlin::
 ====
 Make sure that your target components (for example, `MovieCatalog` or `CustomerPreferenceDao`)
 are consistently declared by the type that you use for your `@Autowired`-annotated
-injection points. Otherwise, injection may fail due to a "no type match found" error at runtime.
+injection points. Otherwise, injection may fail due to a "no type match found" error at
+runtime.
 
 For XML-defined beans or component classes found via classpath scanning, the container
 usually knows the concrete type up front. However, for `@Bean` factory methods, you need
 to make sure that the declared return type is sufficiently expressive. For components
 that implement several interfaces or for components potentially referred to by their
-implementation type, consider declaring the most specific return type on your factory
-method (at least as specific as required by the injection points referring to your bean).
+implementation type, declare the most specific return type on your factory method (at
+least as specific as required by the injection points referring to your bean).
 ====
 
 .[[beans-autowired-annotation-self-injection]]Self Injection
@@ -312,8 +313,8 @@ through `@Order` values in combination with `@Primary` on a single bean for each
 ====
 
 Even typed `Map` instances can be autowired as long as the expected key type is `String`.
-The map values contain all beans of the expected type, and the keys contain the
-corresponding bean names, as the following example shows:
+The map values are all beans of the expected type, and the keys are the corresponding
+bean names, as the following example shows:
 
 [tabs]
 ======
@@ -431,7 +432,7 @@ annotated constructor does not have to be public.
 ====
 
 Alternatively, you can express the non-required nature of a particular dependency
-through Java 8's `java.util.Optional`, as the following example shows:
+through Java's `java.util.Optional`, as the following example shows:
 
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
@@ -445,8 +446,8 @@ through Java 8's `java.util.Optional`, as the following example shows:
 ----
 
 You can also use a parameter-level `@Nullable` annotation (of any kind in any package --
-for example, `javax.annotation.Nullable` from JSR-305) or just leverage Kotlin built-in
-null-safety support:
+for example, `org.jspecify.annotations.Nullable` from JSpecify) or just leverage Kotlin's
+built-in null-safety support:
 
 [tabs]
 ======
@@ -477,13 +478,6 @@ Kotlin::
 ----
 ======
 
-[NOTE]
-====
-A type-level `@Nullable` annotation such as from JSpecify is not supported in Spring
-Framework 6.2 yet. You need to upgrade to Spring Framework 7.0 where the framework
-detects type-level annotations and consistently declares JSpecify in its own codebase.
-====
-
 You can also use `@Autowired` for interfaces that are well-known resolvable
 dependencies: `BeanFactory`, `ApplicationContext`, `Environment`, `ResourceLoader`,
 `ApplicationEventPublisher`, and `MessageSource`. These interfaces and their extended
@@ -528,5 +522,6 @@ class MovieRecommender {
 The `@Autowired`, `@Inject`, `@Value`, and `@Resource` annotations are handled by Spring
 `BeanPostProcessor` implementations. This means that you cannot apply these annotations
 within your own `BeanPostProcessor` or `BeanFactoryPostProcessor` types (if any).
+
 These types must be 'wired up' explicitly by using XML or a Spring `@Bean` method.
 ====

spring-jdbc/src/main/java/org/springframework/jdbc/core/namedparam/NamedParameterJdbcOperations.java

@@ -16,6 +16,7 @@
 
 package org.springframework.jdbc.core.namedparam;
 
+import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Stream;
@@ -586,4 +587,16 @@ public interface NamedParameterJdbcOperations {
 	int[] batchUpdate(String sql, SqlParameterSource[] batchArgs, KeyHolder generatedKeyHolder,
 			String[] keyColumnNames);
 
+	/**
+	 * Executes the specified SQL update statement in multiple batches using the provided batch arguments.
+	 * @param sql the SQL statement to execute
+	 * @param batchArgs the collection of {@link SqlParameterSource} containing arguments for the query
+	 * @param batchSize batch size
+	 * @return a two-dimensional array containing results for each batch execution.
+	 * (may also contain special JDBC-defined negative values for affected rows such as
+	 * {@link java.sql.Statement#SUCCESS_NO_INFO}/{@link java.sql.Statement#EXECUTE_FAILED})
+	 * @throws DataAccessException if there is any problem issuing the update
+	 */
+	int[][] batchUpdate(String sql, Collection<SqlParameterSource> batchArgs, int batchSize);
+
 }

spring-jdbc/src/main/java/org/springframework/jdbc/core/namedparam/NamedParameterJdbcTemplate.java

@@ -18,6 +18,7 @@ package org.springframework.jdbc.core.namedparam;
 
 import java.sql.PreparedStatement;
 import java.sql.SQLException;
+import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 import java.util.function.Consumer;
@@ -434,6 +435,21 @@ public class NamedParameterJdbcTemplate implements NamedParameterJdbcOperations
 		}, generatedKeyHolder);
 	}
 
+	@Override
+	public int[][] batchUpdate(String sql, Collection<SqlParameterSource> batchArgs, int batchSize) {
+		if (batchArgs.isEmpty() || batchSize <= 0) {
+			return new int[0][0];
+		}
+
+		ParsedSql parsedSql = getParsedSql(sql);
+		SqlParameterSource sqlParameterSource = batchArgs.iterator().next();
+		PreparedStatementCreatorFactory pscf = getPreparedStatementCreatorFactory(parsedSql, sqlParameterSource);
+
+		return getJdbcOperations().batchUpdate(pscf.getSql(), batchArgs, batchSize, (ps, argument) -> {
+			@Nullable Object[] values = NamedParameterUtils.buildValueArray(parsedSql, argument, null);
+			pscf.newPreparedStatementSetter(values).setValues(ps);
+		});
+	}
 
 	/**
 	 * Build a {@link PreparedStatementCreator} based on the given SQL and named parameters.

spring-jdbc/src/test/java/org/springframework/jdbc/core/namedparam/NamedParameterJdbcTemplateTests.java

@@ -53,6 +53,7 @@ import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
 
 /**
  * @author Rick Evans
@@ -580,4 +581,104 @@ class NamedParameterJdbcTemplateTests {
 		verify(connection, atLeastOnce()).close();
 	}
 
+
+	@Test
+	void testMultipleBatchUpdateWithSqlParameterSource() throws Exception {
+		List<SqlParameterSource> ids = List.of(
+				new MapSqlParameterSource("id", 100),
+				new MapSqlParameterSource("id", 200),
+				new MapSqlParameterSource("id", 300),
+				new MapSqlParameterSource("id", 400),
+				new MapSqlParameterSource("id", 500)
+		);
+
+		int[] rowsAffected1 = new int[]{1, 2};
+		int[] rowsAffected2 = new int[]{3, 4};
+		int[] rowsAffected3 = new int[]{5};
+
+		given(preparedStatement.executeBatch()).willReturn(rowsAffected1, rowsAffected2, rowsAffected3);
+		given(connection.getMetaData()).willReturn(databaseMetaData);
+
+		namedParameterTemplate = new NamedParameterJdbcTemplate(new JdbcTemplate(dataSource, false));
+
+		int batchSize = 2;
+
+		int[][] actualRowsAffected = namedParameterTemplate.batchUpdate(
+				"UPDATE NOSUCHTABLE SET DATE_DISPATCHED = SYSDATE WHERE ID = :id", ids, batchSize);
+
+		assertThat(actualRowsAffected.length).as("executed 3 batches").isEqualTo(3);
+		assertThat(actualRowsAffected[0]).isEqualTo(rowsAffected1);
+		assertThat(actualRowsAffected[1]).isEqualTo(rowsAffected2);
+		assertThat(actualRowsAffected[2]).isEqualTo(rowsAffected3);
+
+		verify(preparedStatement, times(5)).addBatch();
+		verify(connection, times(1)).prepareStatement("UPDATE NOSUCHTABLE SET DATE_DISPATCHED = SYSDATE WHERE ID = ?");
+		verify(preparedStatement).setObject(1, 100);
+		verify(preparedStatement).setObject(1, 200);
+		verify(preparedStatement).setObject(1, 300);
+		verify(preparedStatement).setObject(1, 400);
+		verify(preparedStatement).setObject(1, 500);
+		verify(preparedStatement, atLeastOnce()).close();
+		verify(connection, atLeastOnce()).close();
+	}
+
+	@Test
+	void testMultipleBatchUpdateWithEmptySqlParameterSourceArg() {
+		namedParameterTemplate = new NamedParameterJdbcTemplate(new JdbcTemplate(dataSource, false));
+
+		int batchSize = 2;
+
+		int[][] actualRowsAffected = namedParameterTemplate.batchUpdate(
+				"UPDATE NOSUCHTABLE SET DATE_DISPATCHED = SYSDATE WHERE ID = :id", Collections.emptyList(), batchSize);
+
+		assertThat(actualRowsAffected.length).as("executed 0 batches").isZero();
+		verifyNoInteractions(preparedStatement);
+		verifyNoInteractions(connection);
+	}
+
+	@Test
+	void testMultipleBatchUpdateWithSqlParameterSourceWithZeroBatchSize() {
+		namedParameterTemplate = new NamedParameterJdbcTemplate(new JdbcTemplate(dataSource, false));
+
+		int batchSize = 0;
+
+		int[][] actualRowsAffected = namedParameterTemplate.batchUpdate(
+				"UPDATE NOSUCHTABLE SET DATE_DISPATCHED = SYSDATE WHERE ID = :id",
+				List.of(new MapSqlParameterSource("id", 100)),
+				batchSize);
+
+		assertThat(actualRowsAffected.length).as("executed 0 batches").isZero();
+		verifyNoInteractions(preparedStatement);
+		verifyNoInteractions(connection);
+	}
+
+	@Test
+	void testMultipleBatchUpdateWithSqlParameterSourceSmallerThanBatchSize() throws Exception {
+		List<SqlParameterSource> ids = List.of(
+				new MapSqlParameterSource("id", 100),
+				new MapSqlParameterSource("id", 200)
+		);
+
+		int[] rowsAffected = new int[]{1, 2};
+
+		given(preparedStatement.executeBatch()).willReturn(rowsAffected);
+		given(connection.getMetaData()).willReturn(databaseMetaData);
+
+		namedParameterTemplate = new NamedParameterJdbcTemplate(new JdbcTemplate(dataSource, false));
+
+		int batchSize = 3;
+
+		int[][] actualRowsAffected = namedParameterTemplate.batchUpdate(
+				"UPDATE NOSUCHTABLE SET DATE_DISPATCHED = SYSDATE WHERE ID = :id", ids, batchSize);
+
+		assertThat(actualRowsAffected.length).as("executed 1 batch").isEqualTo(1);
+		assertThat(actualRowsAffected[0]).isEqualTo(rowsAffected);
+
+		verify(preparedStatement, times(2)).addBatch();
+		verify(connection, times(1)).prepareStatement("UPDATE NOSUCHTABLE SET DATE_DISPATCHED = SYSDATE WHERE ID = ?");
+		verify(preparedStatement).setObject(1, 100);
+		verify(preparedStatement).setObject(1, 200);
+		verify(preparedStatement, atLeastOnce()).close();
+		verify(connection, atLeastOnce()).close();
+	}
 }