Merge branch '6.2.x'

# Conflicts:
#	spring-jdbc/src/main/java/org/springframework/jdbc/core/JdbcTemplate.java
#	spring-jms/src/main/java/org/springframework/jms/core/JmsTemplate.java
#	spring-messaging/src/main/java/org/springframework/messaging/core/AbstractDestinationResolvingMessagingTemplate.java
#	spring-messaging/src/main/java/org/springframework/messaging/core/AbstractMessageReceivingTemplate.java
#	spring-messaging/src/main/java/org/springframework/messaging/core/AbstractMessagingTemplate.java
#	spring-messaging/src/main/java/org/springframework/messaging/core/MessageRequestReplyOperations.java
#	spring-messaging/src/main/java/org/springframework/messaging/core/MessageSendingOperations.java

Author: jhoeller

spring-jdbc/src/main/java/org/springframework/jdbc/core/JdbcTemplate.java

@@ -1199,9 +1199,9 @@ public <T> int[][] batchUpdate(String sql, Collection<T> batchArgs, int batchSiz
 	public Map<String, Object> call(CallableStatementCreator csc, List<SqlParameter> declaredParameters)
 			throws DataAccessException {
 
-		final List<SqlParameter> updateCountParameters = new ArrayList<>();
-		final List<SqlParameter> resultSetParameters = new ArrayList<>();
-		final List<SqlParameter> callParameters = new ArrayList<>();
+		List<SqlParameter> updateCountParameters = new ArrayList<>();
+		List<SqlParameter> resultSetParameters = new ArrayList<>();
+		List<SqlParameter> callParameters = new ArrayList<>();
 
 		for (SqlParameter parameter : declaredParameters) {
 			if (parameter.isResultsParameter()) {

spring-jms/src/main/java/org/springframework/jms/core/JmsMessageOperations.java

@@ -242,7 +242,7 @@ void convertAndSend(String destinationName, Object payload, @Nullable Map<String
 	 * @param destinationName the name of the target destination
 	 * @param request payload for the request message to send
 	 * @param targetClass the target type to convert the payload of the reply to
-	 * @param requestPostProcessor post process to apply to the request message
+	 * @param requestPostProcessor post-process to apply to the request message
 	 * @return the payload of the reply message, possibly {@code null} if the message
 	 * could not be received, for example due to a timeout
 	 */
@@ -258,7 +258,7 @@ void convertAndSend(String destinationName, Object payload, @Nullable Map<String
 	 * @param destinationName the name of the target destination
 	 * @param request payload for the request message to send
 	 * @param targetClass the target type to convert the payload of the reply to
-	 * @param requestPostProcessor post process to apply to the request message
+	 * @param requestPostProcessor post-process to apply to the request message
 	 * @return the payload of the reply message, possibly {@code null} if the message
 	 * could not be received, for example due to a timeout
 	 */

spring-jms/src/main/java/org/springframework/jms/support/destination/JmsDestinationAccessor.java

@@ -69,7 +69,7 @@ public abstract class JmsDestinationAccessor extends JmsAccessor {
 	 * @see org.springframework.jms.support.destination.JndiDestinationResolver
 	 */
 	public void setDestinationResolver(DestinationResolver destinationResolver) {
-		Assert.notNull(destinationResolver, "'destinationResolver' must not be null");
+		Assert.notNull(destinationResolver, "DestinationResolver must not be null");
 		this.destinationResolver = destinationResolver;
 	}
 

spring-messaging/src/main/java/org/springframework/messaging/core/AbstractDestinationResolvingMessagingTemplate.java

@@ -21,6 +21,7 @@
 import org.jspecify.annotations.Nullable;
 
 import org.springframework.messaging.Message;
+import org.springframework.messaging.MessagingException;
 import org.springframework.util.Assert;
 
 /**
@@ -64,77 +65,85 @@ public void setDestinationResolver(@Nullable DestinationResolver<D> destinationR
 		return this.destinationResolver;
 	}
 
+	protected final D resolveDestination(String destinationName) throws DestinationResolutionException {
+		Assert.state(this.destinationResolver != null,
+				"DestinationResolver is required to resolve destination names");
+		return this.destinationResolver.resolveDestination(destinationName);
+	}
+
 
 	@Override
-	public void send(String destinationName, Message<?> message) {
+	public void send(String destinationName, Message<?> message) throws MessagingException {
 		D destination = resolveDestination(destinationName);
 		doSend(destination, message);
 	}
 
-	protected final D resolveDestination(String destinationName) {
-
-		Assert.state(this.destinationResolver != null, "DestinationResolver is required to resolve destination names");
-		return this.destinationResolver.resolveDestination(destinationName);
-	}
-
 	@Override
-	public <T> void convertAndSend(String destinationName, T payload) {
+	public <T> void convertAndSend(String destinationName, T payload) throws MessagingException {
 		convertAndSend(destinationName, payload, null, null);
 	}
 
 	@Override
-	public <T> void convertAndSend(String destinationName, T payload, @Nullable Map<String, Object> headers) {
+	public <T> void convertAndSend(String destinationName, T payload, @Nullable Map<String, Object> headers)
+			throws MessagingException {
+
 		convertAndSend(destinationName, payload, headers, null);
 	}
 
 	@Override
-	public <T> void convertAndSend(String destinationName, T payload, @Nullable MessagePostProcessor postProcessor) {
+	public <T> void convertAndSend(String destinationName, T payload, @Nullable MessagePostProcessor postProcessor)
+			throws MessagingException {
+
 		convertAndSend(destinationName, payload, null, postProcessor);
 	}
 
 	@Override
-	public <T> void convertAndSend(String destinationName, T payload,
-			@Nullable Map<String, Object> headers, @Nullable MessagePostProcessor postProcessor) {
+	public <T> void convertAndSend(String destinationName, T payload, @Nullable Map<String, Object> headers,
+			@Nullable MessagePostProcessor postProcessor) throws MessagingException {
 
 		D destination = resolveDestination(destinationName);
 		super.convertAndSend(destination, payload, headers, postProcessor);
 	}
 
 	@Override
-	public @Nullable Message<?> receive(String destinationName) {
+	public @Nullable Message<?> receive(String destinationName) throws MessagingException {
 		D destination = resolveDestination(destinationName);
 		return super.receive(destination);
 	}
 
 	@Override
-	public <T> @Nullable T receiveAndConvert(String destinationName, Class<T> targetClass) {
+	public <T> @Nullable T receiveAndConvert(String destinationName, Class<T> targetClass) throws MessagingException {
 		D destination = resolveDestination(destinationName);
 		return super.receiveAndConvert(destination, targetClass);
 	}
 
 	@Override
-	public @Nullable Message<?> sendAndReceive(String destinationName, Message<?> requestMessage) {
+	public @Nullable Message<?> sendAndReceive(String destinationName, Message<?> requestMessage)
+			throws MessagingException {
+
 		D destination = resolveDestination(destinationName);
 		return super.sendAndReceive(destination, requestMessage);
 	}
 
 	@Override
-	public <T> @Nullable T convertSendAndReceive(String destinationName, Object request, Class<T> targetClass) {
+	public <T> @Nullable T convertSendAndReceive(String destinationName, Object request, Class<T> targetClass)
+			throws MessagingException {
+
 		D destination = resolveDestination(destinationName);
 		return super.convertSendAndReceive(destination, request, targetClass);
 	}
 
 	@Override
 	public <T> @Nullable T convertSendAndReceive(String destinationName, Object request,
-			@Nullable Map<String, Object> headers, Class<T> targetClass) {
+			@Nullable Map<String, Object> headers, Class<T> targetClass) throws MessagingException {
 
 		D destination = resolveDestination(destinationName);
 		return super.convertSendAndReceive(destination, request, headers, targetClass);
 	}
 
 	@Override
 	public <T> @Nullable T convertSendAndReceive(String destinationName, Object request, Class<T> targetClass,
-			@Nullable MessagePostProcessor postProcessor) {
+			@Nullable MessagePostProcessor postProcessor) throws MessagingException {
 
 		D destination = resolveDestination(destinationName);
 		return super.convertSendAndReceive(destination, request, targetClass, postProcessor);
@@ -143,7 +152,7 @@ public <T> void convertAndSend(String destinationName, T payload,
 	@Override
 	public <T> @Nullable T convertSendAndReceive(String destinationName, Object request,
 			@Nullable Map<String, Object> headers, Class<T> targetClass,
-			@Nullable MessagePostProcessor postProcessor) {
+			@Nullable MessagePostProcessor postProcessor) throws MessagingException {
 
 		D destination = resolveDestination(destinationName);
 		return super.convertSendAndReceive(destination, request, headers, targetClass, postProcessor);

spring-messaging/src/main/java/org/springframework/messaging/core/AbstractMessageReceivingTemplate.java

@@ -19,6 +19,7 @@
 import org.jspecify.annotations.Nullable;
 
 import org.springframework.messaging.Message;
+import org.springframework.messaging.MessagingException;
 import org.springframework.messaging.converter.MessageConversionException;
 import org.springframework.messaging.converter.MessageConverter;
 
@@ -36,31 +37,22 @@ public abstract class AbstractMessageReceivingTemplate<D> extends AbstractMessag
 		implements MessageReceivingOperations<D> {
 
 	@Override
-	public @Nullable Message<?> receive() {
+	public @Nullable Message<?> receive() throws MessagingException {
 		return doReceive(getRequiredDefaultDestination());
 	}
 
 	@Override
-	public @Nullable Message<?> receive(D destination) {
+	public @Nullable Message<?> receive(D destination) throws MessagingException {
 		return doReceive(destination);
 	}
 
-	/**
-	 * Actually receive a message from the given destination.
-	 * @param destination the target destination
-	 * @return the received message, possibly {@code null} if the message could not
-	 * be received, for example due to a timeout
-	 */
-	protected abstract @Nullable Message<?> doReceive(D destination);
-
-
 	@Override
-	public <T> @Nullable T receiveAndConvert(Class<T> targetClass) {
+	public <T> @Nullable T receiveAndConvert(Class<T> targetClass) throws MessagingException {
 		return receiveAndConvert(getRequiredDefaultDestination(), targetClass);
 	}
 
 	@Override
-	public <T> @Nullable T receiveAndConvert(D destination, Class<T> targetClass) {
+	public <T> @Nullable T receiveAndConvert(D destination, Class<T> targetClass) throws MessagingException {
 		Message<?> message = doReceive(destination);
 		if (message != null) {
 			return doConvert(message, targetClass);
@@ -87,4 +79,12 @@ public abstract class AbstractMessageReceivingTemplate<D> extends AbstractMessag
 		return value;
 	}
 
+	/**
+	 * Actually receive a message from the given destination.
+	 * @param destination the target destination
+	 * @return the received message, possibly {@code null} if the message could not
+	 * be received, for example due to a timeout
+	 */
+	protected abstract @Nullable Message<?> doReceive(D destination);
+
 }

spring-messaging/src/main/java/org/springframework/messaging/core/AbstractMessageSendingTemplate.java

@@ -108,9 +108,6 @@ public void send(D destination, Message<?> message) {
 		doSend(destination, message);
 	}
 
-	protected abstract void doSend(D destination, Message<?> message);
-
-
 	@Override
 	public void convertAndSend(Object payload) throws MessagingException {
 		convertAndSend(payload, null, null);
@@ -162,6 +159,7 @@ public void convertAndSend(D destination, Object payload, @Nullable Map<String,
 		send(destination, message);
 	}
 
+
 	/**
 	 * Convert the given Object to serialized form, possibly using a
 	 * {@link MessageConverter}, wrap it as a message with the given
@@ -209,4 +207,11 @@ protected Message<?> doConvert(Object payload, @Nullable Map<String, Object> hea
 		return headers;
 	}
 
+	/**
+	 * Actually send the given message to the given destination.
+	 * @param destination the target destination
+	 * @param message the message to send
+	 */
+	protected abstract void doSend(D destination, Message<?> message);
+
 }

spring-messaging/src/main/java/org/springframework/messaging/core/AbstractMessagingTemplate.java

@@ -104,6 +104,14 @@ public abstract class AbstractMessagingTemplate<D> extends AbstractMessageReceiv
 	}
 
 
+	/**
+	 * Actually send the given request message to the given destination and
+	 * receive a reply message for it.
+	 * @param destination the target destination
+	 * @param requestMessage the message to send
+	 * @return the received reply, possibly {@code null} if the
+	 * message could not be received, for example due to a timeout
+	 */
 	protected abstract @Nullable Message<?> doSendAndReceive(D destination, Message<?> requestMessage);
 
 }

spring-messaging/src/main/java/org/springframework/messaging/core/DestinationResolvingMessageRequestReplyOperations.java

@@ -80,13 +80,13 @@ public interface DestinationResolvingMessageRequestReplyOperations<D> extends Me
 	 * Resolve the given destination name, convert the payload request Object
 	 * to serialized form, possibly using a
 	 * {@link org.springframework.messaging.converter.MessageConverter},
-	 * wrap it as a message, apply the given post process, and send the resulting
+	 * wrap it as a message, apply the given post-process, and send the resulting
 	 * message to the resolved destination, then receive a reply and convert its
 	 * body to the specified target class.
 	 * @param destinationName the name of the target destination
 	 * @param request the payload for the request message to send
 	 * @param targetClass the target class to convert the payload of the reply to
-	 * @param requestPostProcessor post process for the request message
+	 * @param requestPostProcessor post-process for the request message
 	 * @return the converted payload of the reply message, possibly {@code null} if
 	 * the message could not be received, for example due to a timeout
 	 */
@@ -97,14 +97,14 @@ public interface DestinationResolvingMessageRequestReplyOperations<D> extends Me
 	 * Resolve the given destination name, convert the payload request Object
 	 * to serialized form, possibly using a
 	 * {@link org.springframework.messaging.converter.MessageConverter},
-	 * wrap it as a message with the given headers, apply the given post process,
+	 * wrap it as a message with the given headers, apply the given post-process,
 	 * and send the resulting message to the resolved destination, then receive
 	 * a reply and convert its body to the specified target class.
 	 * @param destinationName the name of the target destination
 	 * @param request the payload for the request message to send
 	 * @param headers the headers for the request message to send
 	 * @param targetClass the target class to convert the payload of the reply to
-	 * @param requestPostProcessor post process for the request message
+	 * @param requestPostProcessor post-process for the request message
 	 * @return the converted payload of the reply message, possibly {@code null} if
 	 * the message could not be received, for example due to a timeout
 	 */

spring-messaging/src/main/java/org/springframework/messaging/core/DestinationResolvingMessageSendingOperations.java

@@ -69,11 +69,11 @@ <T> void convertAndSend(String destinationName, T payload, @Nullable Map<String,
 	 * Resolve the given destination name to a destination, convert the payload
 	 * Object to serialized form, possibly using a
 	 * {@link org.springframework.messaging.converter.MessageConverter},
-	 * wrap it as a message, apply the given post processor, and send the resulting
+	 * wrap it as a message, apply the given post-processor, and send the resulting
 	 * message to the resolved destination.
 	 * @param destinationName the destination name to resolve
 	 * @param payload the Object to use as payload
-	 * @param postProcessor the post processor to apply to the message
+	 * @param postProcessor the post-processor to apply to the message
 	 */
 	<T> void convertAndSend(String destinationName, T payload, @Nullable MessagePostProcessor postProcessor)
 			throws MessagingException;
@@ -82,12 +82,12 @@ <T> void convertAndSend(String destinationName, T payload, @Nullable MessagePost
 	 * Resolve the given destination name to a destination, convert the payload
 	 * Object to serialized form, possibly using a
 	 * {@link org.springframework.messaging.converter.MessageConverter},
-	 * wrap it as a message with the given headers, apply the given post processor,
+	 * wrap it as a message with the given headers, apply the given post-processor,
 	 * and send the resulting message to the resolved destination.
 	 * @param destinationName the destination name to resolve
 	 * @param payload the Object to use as payload
 	 * @param headers the headers for the message to send
-	 * @param postProcessor the post processor to apply to the message
+	 * @param postProcessor the post-processor to apply to the message
 	 */
 	<T> void convertAndSend(String destinationName, T payload, @Nullable Map<String, Object> headers,
 			@Nullable MessagePostProcessor postProcessor) throws MessagingException;

spring-messaging/src/main/java/org/springframework/messaging/core/MessageRequestReplyOperations.java

@@ -116,7 +116,7 @@ public interface MessageRequestReplyOperations<D> {
 	 * target class.
 	 * @param request payload for the request message to send
 	 * @param targetClass the target type to convert the payload of the reply to
-	 * @param requestPostProcessor post process to apply to the request message
+	 * @param requestPostProcessor post-process to apply to the request message
 	 * @return the payload of the reply message, possibly {@code null} if the message
 	 * could not be received, for example due to a timeout
 	 */
@@ -133,7 +133,7 @@ public interface MessageRequestReplyOperations<D> {
 	 * @param destination the target destination
 	 * @param request payload for the request message to send
 	 * @param targetClass the target type to convert the payload of the reply to
-	 * @param requestPostProcessor post process to apply to the request message
+	 * @param requestPostProcessor post-process to apply to the request message
 	 * @return the payload of the reply message, possibly {@code null} if the message
 	 * could not be received, for example due to a timeout
 	 */
@@ -148,7 +148,7 @@ public interface MessageRequestReplyOperations<D> {
 	 * the reply and convert its body of the given target class.
 	 * @param request payload for the request message to send
 	 * @param targetClass the target type to convert the payload of the reply to
-	 * @param requestPostProcessor post process to apply to the request message
+	 * @param requestPostProcessor post-process to apply to the request message
 	 * @return the payload of the reply message, possibly {@code null} if the message
 	 * could not be received, for example due to a timeout
 	 * @since 7.0
@@ -166,7 +166,7 @@ public interface MessageRequestReplyOperations<D> {
 	 * @param destination the target destination
 	 * @param request payload for the request message to send
 	 * @param targetClass the target type to convert the payload of the reply to
-	 * @param requestPostProcessor post process to apply to the request message
+	 * @param requestPostProcessor post-process to apply to the request message
 	 * @return the payload of the reply message, possibly {@code null} if the message
 	 * could not be received, for example due to a timeout
 	 */