diff --git a/org.springframework.aspects/src/main/java/org/springframework/scheduling/AbstractAsynchronousExecutionAspect.aj b/org.springframework.aspects/src/main/java/org/springframework/scheduling/AbstractAsynchronousExecutionAspect.aj
deleted file mode 100644
index 0701de71ca4c6e42f2ecb6033dd4563aedd65225..0000000000000000000000000000000000000000
--- a/org.springframework.aspects/src/main/java/org/springframework/scheduling/AbstractAsynchronousExecutionAspect.aj
+++ /dev/null
@@ -1,58 +0,0 @@
-package org.springframework.scheduling;
-
-import java.util.concurrent.Callable;
-import java.util.concurrent.Executor;
-import java.util.concurrent.Future;
-
-import org.aspectj.lang.reflect.MethodSignature;
-import org.springframework.core.task.AsyncTaskExecutor;
-import org.springframework.core.task.SimpleAsyncTaskExecutor;
-import org.springframework.core.task.support.TaskExecutorAdapter;
-
-/**
- * Abstract aspect that routes selected methods asynchronously.
- *
- * This aspect, by default, uses {@link SimpleAsyncTaskExecutor} to route method
- * execution. However, you may inject it with any implementation of
- * {@link Executor} to override the default.
- *
- * @author Ramnivas Laddad
- */
-public abstract aspect AbstractAsynchronousExecutionAspect {
- private AsyncTaskExecutor asyncExecutor;
-
- public AbstractAsynchronousExecutionAspect() {
- // Set default executor, which may be replaced by calling setExecutor(Executor)
- setExecutor(new SimpleAsyncTaskExecutor());
- }
-
- public abstract pointcut asyncMethod();
-
- Object around() : asyncMethod() {
- Callable callable = new Callable() {
- public Object call() throws Exception {
- Object result = proceed();
- if (result instanceof Future) {
- return ((Future>) result).get();
- }
- return null;
- }};
-
- Future> result = asyncExecutor.submit(callable);
-
- if (Future.class.isAssignableFrom(((MethodSignature)thisJoinPointStaticPart.getSignature()).getReturnType())) {
- return result;
- } else {
- return null;
- }
- }
-
- public void setExecutor(Executor executor) {
- if (executor instanceof AsyncTaskExecutor) {
- this.asyncExecutor = (AsyncTaskExecutor) executor;
- } else {
- this.asyncExecutor = new TaskExecutorAdapter(asyncExecutor);
- }
- }
-
-}
diff --git a/org.springframework.aspects/src/main/java/org/springframework/scheduling/aspectj/AbstractAsynchronousExecutionAspect.aj b/org.springframework.aspects/src/main/java/org/springframework/scheduling/aspectj/AbstractAsynchronousExecutionAspect.aj
new file mode 100644
index 0000000000000000000000000000000000000000..ba2db4aec330284099aad008ee8ae0d3a3b5070c
--- /dev/null
+++ b/org.springframework.aspects/src/main/java/org/springframework/scheduling/aspectj/AbstractAsynchronousExecutionAspect.aj
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2002-2010 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.scheduling.aspectj;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Future;
+
+import org.aspectj.lang.reflect.MethodSignature;
+import org.springframework.core.task.AsyncTaskExecutor;
+import org.springframework.core.task.SimpleAsyncTaskExecutor;
+import org.springframework.core.task.support.TaskExecutorAdapter;
+
+/**
+ * Abstract aspect that routes selected methods asynchronously.
+ *
+ * This aspect, by default, uses {@link SimpleAsyncTaskExecutor} to route
+ * method execution. However, you may inject it with any implementation of
+ * {@link Executor} to override the default.
+ *
+ * @author Ramnivas Laddad
+ * @since 3.0.5
+ */
+public abstract aspect AbstractAsynchronousExecutionAspect {
+
+ private AsyncTaskExecutor asyncExecutor;
+
+ public AbstractAsynchronousExecutionAspect() {
+ // Set default executor, which may be replaced by calling setExecutor.
+ setExecutor(new SimpleAsyncTaskExecutor());
+ }
+
+ public void setExecutor(Executor executor) {
+ if (executor instanceof AsyncTaskExecutor) {
+ this.asyncExecutor = (AsyncTaskExecutor) executor;
+ }
+ else {
+ this.asyncExecutor = new TaskExecutorAdapter(asyncExecutor);
+ }
+ }
+
+ Object around() : asyncMethod() {
+ Callable callable = new Callable() {
+ public Object call() throws Exception {
+ Object result = proceed();
+ if (result instanceof Future) {
+ return ((Future>) result).get();
+ }
+ return null;
+ }};
+ Future> result = asyncExecutor.submit(callable);
+ if (Future.class.isAssignableFrom(((MethodSignature) thisJoinPointStaticPart.getSignature()).getReturnType())) {
+ return result;
+ }
+ else {
+ return null;
+ }
+ }
+
+ public abstract pointcut asyncMethod();
+
+}
diff --git a/org.springframework.aspects/src/main/java/org/springframework/scheduling/AnnotationDrivenAsynchronousExecutionAspect.aj b/org.springframework.aspects/src/main/java/org/springframework/scheduling/aspectj/AnnotationDrivenAsynchronousExecutionAspect.aj
similarity index 53%
rename from org.springframework.aspects/src/main/java/org/springframework/scheduling/AnnotationDrivenAsynchronousExecutionAspect.aj
rename to org.springframework.aspects/src/main/java/org/springframework/scheduling/aspectj/AnnotationDrivenAsynchronousExecutionAspect.aj
index 4da2cd526eb2d8b575dce8207e542a303549425b..87e15b7e5245b3b53027f3776188c84ca017b00c 100644
--- a/org.springframework.aspects/src/main/java/org/springframework/scheduling/AnnotationDrivenAsynchronousExecutionAspect.aj
+++ b/org.springframework.aspects/src/main/java/org/springframework/scheduling/aspectj/AnnotationDrivenAsynchronousExecutionAspect.aj
@@ -1,35 +1,54 @@
-package org.springframework.scheduling;
-
-import java.util.concurrent.Future;
-import org.springframework.scheduling.annotation.Async;
-
-/**
- * Aspect to route methods based on the {@link Async} annotation.
- *
- * This aspect routes methods marked with the {@link Async} annotation
- * as well as methods in classes marked with the same. Any method expected
- * to be routed asynchronously must return either void, {@link Future},
- * or a subtype of {@link Future}. This aspect, therefore, will produce
- * a compile-time error for methods that violate this constraint on the return type.
- * If, however, a class marked with @Async
contains a method that
- * violates this constraint, it produces only a warning.
- *
- * @author Ramnivas Laddad
- *
- */
-public aspect AnnotationDrivenAsynchronousExecutionAspect extends AbstractAsynchronousExecutionAspect {
- private pointcut asyncMarkedMethod()
- : execution(@Async (void || Future+) *(..));
- private pointcut asyncTypeMarkedMethod()
- : execution((void || Future+) (@Async *).*(..));
-
- public pointcut asyncMethod() : asyncMarkedMethod() || asyncTypeMarkedMethod();
-
- declare error:
- execution(@Async !(void||Future) *(..)):
- "Only method that return void or Future may have @Async annotation";
-
- declare warning:
- execution(!(void||Future) (@Async *).*(..)):
- "Method in class marked with @Async that do not return void or Future will be routed synchronously";
-}
+/*
+ * Copyright 2002-2010 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.scheduling.aspectj;
+
+import java.util.concurrent.Future;
+import org.springframework.scheduling.annotation.Async;
+
+/**
+ * Aspect to route methods based on the {@link Async} annotation.
+ *
+ *
This aspect routes methods marked with the {@link Async} annotation
+ * as well as methods in classes marked with the same. Any method expected
+ * to be routed asynchronously must return either void, {@link Future},
+ * or a subtype of {@link Future}. This aspect, therefore, will produce
+ * a compile-time error for methods that violate this constraint on the return type.
+ * If, however, a class marked with @Async
contains a method that
+ * violates this constraint, it produces only a warning.
+ *
+ * @author Ramnivas Laddad
+ * @since 3.0.5
+ */
+public aspect AnnotationDrivenAsynchronousExecutionAspect extends AbstractAsynchronousExecutionAspect {
+
+ private pointcut asyncMarkedMethod()
+ : execution(@Async (void || Future+) *(..));
+
+ private pointcut asyncTypeMarkedMethod()
+ : execution((void || Future+) (@Async *).*(..));
+
+ public pointcut asyncMethod() : asyncMarkedMethod() || asyncTypeMarkedMethod();
+
+ declare error:
+ execution(@Async !(void||Future) *(..)):
+ "Only methods that return void or Future may have an @Async annotation";
+
+ declare warning:
+ execution(!(void||Future) (@Async *).*(..)):
+ "Methods in a class marked with @Async that do not return void or Future will be routed synchronously";
+
+}