From 8eb24458f82cf3c1f25bcf52a451317f1fc99950 Mon Sep 17 00:00:00 2001 From: "Bao.Ngo" Date: Mon, 25 Nov 2024 21:08:43 +0700 Subject: [PATCH 1/2] Use proper return type in AsyncExecutionInterceptor See gh-33957 --- .../AsyncExecutionInterceptor.java | 13 +++- .../AsyncExecutionInterceptorTests.java | 74 +++++++++++++++++++ 2 files changed, 86 insertions(+), 1 deletion(-) create mode 100644 spring-aop/src/test/java/org/springframework/aop/interceptor/AsyncExecutionInterceptorTests.java diff --git a/spring-aop/src/main/java/org/springframework/aop/interceptor/AsyncExecutionInterceptor.java b/spring-aop/src/main/java/org/springframework/aop/interceptor/AsyncExecutionInterceptor.java index 9333759224..a17ed63fe8 100644 --- a/spring-aop/src/main/java/org/springframework/aop/interceptor/AsyncExecutionInterceptor.java +++ b/spring-aop/src/main/java/org/springframework/aop/interceptor/AsyncExecutionInterceptor.java @@ -17,6 +17,7 @@ package org.springframework.aop.interceptor; import java.lang.reflect.Method; +import java.lang.reflect.Modifier; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.Executor; @@ -60,6 +61,7 @@ import org.springframework.lang.Nullable; * @author Juergen Hoeller * @author Chris Beams * @author Stephane Nicoll + * @author Bao Ngo * @since 3.0 * @see org.springframework.scheduling.annotation.Async * @see org.springframework.scheduling.annotation.AsyncAnnotationAdvisor @@ -125,7 +127,16 @@ public class AsyncExecutionInterceptor extends AsyncExecutionAspectSupport imple return null; }; - return doSubmit(task, executor, invocation.getMethod().getReturnType()); + return doSubmit( task, executor, determineReturnType( invocation, userMethod ) ); + } + + private static Class determineReturnType(MethodInvocation invocation, Method userMethod) { + Method originalMethod = invocation.getMethod(); + if( Modifier.isAbstract( originalMethod.getModifiers() ) ) { + return userMethod.getReturnType(); + } + + return originalMethod.getReturnType(); } /** diff --git a/spring-aop/src/test/java/org/springframework/aop/interceptor/AsyncExecutionInterceptorTests.java b/spring-aop/src/test/java/org/springframework/aop/interceptor/AsyncExecutionInterceptorTests.java new file mode 100644 index 0000000000..1bb59e4186 --- /dev/null +++ b/spring-aop/src/test/java/org/springframework/aop/interceptor/AsyncExecutionInterceptorTests.java @@ -0,0 +1,74 @@ +/* + * Copyright 2002-2024 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.interceptor; + +import java.util.concurrent.Callable; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.Future; + +import org.aopalliance.intercept.MethodInvocation; +import org.junit.jupiter.api.Test; +import org.mockito.ArgumentCaptor; + +import org.springframework.core.task.AsyncTaskExecutor; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.BDDMockito.given; +import static org.mockito.Mockito.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.verify; + + +/** + * Tests for {@link AsyncExecutionInterceptor}. + * + * @author Bao Ngo + * @since 7.0 + */ +class AsyncExecutionInterceptorTests { + + @Test + public void testInvokeOnInterface() throws Throwable { + AsyncExecutionInterceptor interceptor = spy( new AsyncExecutionInterceptor( null ) ); + Impl impl = new Impl(); + ArgumentCaptor> classArgumentCaptor = ArgumentCaptor.forClass( Class.class ); + MethodInvocation mi = mock(); + given( mi.getThis() ).willReturn( impl ); + given( mi.getMethod() ).willReturn( I.class.getMethod( "doSomeThing" ) ); + interceptor.invoke( mi ); + verify( interceptor ).doSubmit( + any( Callable.class ), + any( AsyncTaskExecutor.class ), + classArgumentCaptor.capture() + ); + assertThat( classArgumentCaptor.getValue() ).isEqualTo( Future.class ); + } + + + private interface I { + O doSomeThing(); + } + + private static final class Impl implements I> { + @Override + public Future doSomeThing() { + return CompletableFuture.runAsync( () -> { + } ); + } + } +} From 3923150dadead77eb14dbe44a005b81d79df0c02 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?St=C3=A9phane=20Nicoll?= Date: Tue, 4 Feb 2025 15:59:09 +0100 Subject: [PATCH 2/2] Polish "Use proper return type in AsyncExecutionInterceptor" See gh-33957 --- .../AsyncExecutionInterceptor.java | 15 +------ .../AsyncExecutionInterceptorTests.java | 39 +++++++++---------- 2 files changed, 21 insertions(+), 33 deletions(-) diff --git a/spring-aop/src/main/java/org/springframework/aop/interceptor/AsyncExecutionInterceptor.java b/spring-aop/src/main/java/org/springframework/aop/interceptor/AsyncExecutionInterceptor.java index a17ed63fe8..12e073db03 100644 --- a/spring-aop/src/main/java/org/springframework/aop/interceptor/AsyncExecutionInterceptor.java +++ b/spring-aop/src/main/java/org/springframework/aop/interceptor/AsyncExecutionInterceptor.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2024 the original author or authors. + * Copyright 2002-2025 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. @@ -17,7 +17,6 @@ package org.springframework.aop.interceptor; import java.lang.reflect.Method; -import java.lang.reflect.Modifier; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.Executor; @@ -61,7 +60,6 @@ import org.springframework.lang.Nullable; * @author Juergen Hoeller * @author Chris Beams * @author Stephane Nicoll - * @author Bao Ngo * @since 3.0 * @see org.springframework.scheduling.annotation.Async * @see org.springframework.scheduling.annotation.AsyncAnnotationAdvisor @@ -127,16 +125,7 @@ public class AsyncExecutionInterceptor extends AsyncExecutionAspectSupport imple return null; }; - return doSubmit( task, executor, determineReturnType( invocation, userMethod ) ); - } - - private static Class determineReturnType(MethodInvocation invocation, Method userMethod) { - Method originalMethod = invocation.getMethod(); - if( Modifier.isAbstract( originalMethod.getModifiers() ) ) { - return userMethod.getReturnType(); - } - - return originalMethod.getReturnType(); + return doSubmit(task, executor, userMethod.getReturnType()); } /** diff --git a/spring-aop/src/test/java/org/springframework/aop/interceptor/AsyncExecutionInterceptorTests.java b/spring-aop/src/test/java/org/springframework/aop/interceptor/AsyncExecutionInterceptorTests.java index 1bb59e4186..e18f4d24b8 100644 --- a/spring-aop/src/test/java/org/springframework/aop/interceptor/AsyncExecutionInterceptorTests.java +++ b/spring-aop/src/test/java/org/springframework/aop/interceptor/AsyncExecutionInterceptorTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2024 the original author or authors. + * Copyright 2002-2025 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. @@ -43,32 +43,31 @@ import static org.mockito.Mockito.verify; class AsyncExecutionInterceptorTests { @Test - public void testInvokeOnInterface() throws Throwable { - AsyncExecutionInterceptor interceptor = spy( new AsyncExecutionInterceptor( null ) ); - Impl impl = new Impl(); - ArgumentCaptor> classArgumentCaptor = ArgumentCaptor.forClass( Class.class ); + @SuppressWarnings("unchecked") + void invokeOnInterfaceWithGeneric() throws Throwable { + AsyncExecutionInterceptor interceptor = spy(new AsyncExecutionInterceptor(null)); + FutureRunner impl = new FutureRunner(); MethodInvocation mi = mock(); - given( mi.getThis() ).willReturn( impl ); - given( mi.getMethod() ).willReturn( I.class.getMethod( "doSomeThing" ) ); - interceptor.invoke( mi ); - verify( interceptor ).doSubmit( - any( Callable.class ), - any( AsyncTaskExecutor.class ), - classArgumentCaptor.capture() - ); - assertThat( classArgumentCaptor.getValue() ).isEqualTo( Future.class ); + given(mi.getThis()).willReturn(impl); + given(mi.getMethod()).willReturn(GenericRunner.class.getMethod("run")); + + interceptor.invoke(mi); + ArgumentCaptor> classArgumentCaptor = ArgumentCaptor.forClass(Class.class); + verify(interceptor).doSubmit(any(Callable.class), any(AsyncTaskExecutor.class), classArgumentCaptor.capture()); + assertThat(classArgumentCaptor.getValue()).isEqualTo(Future.class); } - private interface I { - O doSomeThing(); + interface GenericRunner { + + O run(); } - private static final class Impl implements I> { + static class FutureRunner implements GenericRunner> { @Override - public Future doSomeThing() { - return CompletableFuture.runAsync( () -> { - } ); + public Future run() { + return CompletableFuture.runAsync(() -> { + }); } } }