Add Coroutines support to Spring AOP

This commit adds support for Kotlin Coroutines to Spring AOP
by leveraging CoroutinesUtils#invokeSuspendingFunction in
AopUtils#invokeJoinpointUsingReflection to convert it to the
equivalent Publisher return value, like in other parts of Spring
Framework.

That allows method interceptors with Reactive support to process
related return values.

CglibAopProxy#processReturnType and JdkDynamicAopProxy#invoke
take care of the conversion from the Publisher return value
to Kotlin Coroutines.

Reactive transactional and HTTP service interface support
have been refined to leverage those new generic capabilities.

Closes gh-22462

spring-aop/src/test/java/org/springframework/aop/support/AopUtilsTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2019 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -29,12 +29,14 @@ import org.springframework.aop.testfixture.interceptor.NopInterceptor;
 import org.springframework.beans.testfixture.beans.TestBean;
 import org.springframework.core.testfixture.io.SerializationTestUtils;
 import org.springframework.lang.Nullable;
+import org.springframework.util.ReflectionUtils;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * @author Rod Johnson
  * @author Chris Beams
+ * @author Sebastien Deleuze
  */
 public class AopUtilsTests {
 
@@ -88,4 +90,13 @@ public class AopUtilsTests {
 		assertThat(SerializationTestUtils.serializeAndDeserialize(ExposeInvocationInterceptor.INSTANCE)).isSameAs(ExposeInvocationInterceptor.INSTANCE);
 	}
 
+	@Test
+	public void testInvokeJoinpointUsingReflection() throws Throwable {
+		String name = "foo";
+		TestBean testBean = new TestBean(name);
+		Method method = ReflectionUtils.findMethod(TestBean.class, "getName");
+		Object result = AopUtils.invokeJoinpointUsingReflection(testBean, method, new Object[0]);
+		assertThat(result).isEqualTo(name);
+	}
+
 }

spring-aop/src/test/kotlin/org/springframework/aop/support/AopUtilsKotlinTests.kt

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2002-2023 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
+ *
+ *      https://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.aop.support
+
+import kotlinx.coroutines.CoroutineName
+import kotlinx.coroutines.delay
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+import org.springframework.util.ReflectionUtils
+import reactor.core.publisher.Mono
+import kotlin.coroutines.Continuation
+
+/**
+ * Tests for Kotlin support in [AopUtils].
+ *
+ * @author Sebastien Deleuze
+ */
+class AopUtilsKotlinTests {
+
+    @Test
+    fun `Invoking suspending function should return Mono`() {
+        val value = "foo"
+        val method = ReflectionUtils.findMethod(AopUtilsKotlinTests::class.java, "suspendingFunction",
+			String::class.java, Continuation::class.java)!!
+        val continuation = Continuation<Any>(CoroutineName("test")) { }
+		val result = AopUtils.invokeJoinpointUsingReflection(this, method, arrayOf(value, continuation))
+        assertThat(result).isInstanceOfSatisfying(Mono::class.java) {
+            assertThat(it.block()).isEqualTo(value)
+        }
+    }
+
+    @Suppress("unused")
+    suspend fun suspendingFunction(value: String): String {
+        delay(1)
+        return value;
+    }
+
+}