added mode="proxy"/"aspectj" and proxy-target-class options to task namespace; switched to concise names for async aspects

org.springframework.aspects/src/main/java/org/springframework/scheduling/aspectj/AbstractAsyncExecutionAspect.aj

@@ -28,22 +28,18 @@ import org.springframework.core.task.support.TaskExecutorAdapter;
 /**
  * Abstract aspect that routes selected methods asynchronously.
  *
- * <p>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.
+ * <p>This aspect needs to be injected with an implementation of 
+ * {@link Executor} to activate it for a specific thread pool.
+ * Otherwise it will simply delegate all calls synchronously.
  *
  * @author Ramnivas Laddad
+ * @author Juergen Hoeller
  * @since 3.0.5
  */
-public abstract aspect AbstractAsynchronousExecutionAspect {
+public abstract aspect AbstractAsyncExecutionAspect {
 
 	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;
@@ -54,6 +50,9 @@ public abstract aspect AbstractAsynchronousExecutionAspect {
 	}
 
 	Object around() : asyncMethod() {
+                if (this.asyncExecutor == null) {
+			return proceed();
+                }
 		Callable<Object> callable = new Callable<Object>() {
 			public Object call() throws Exception {
 				Object result = proceed();
@@ -62,7 +61,7 @@ public abstract aspect AbstractAsynchronousExecutionAspect {
 				}
 				return null;
 			}};
-		Future<?> result = asyncExecutor.submit(callable);
+		Future<?> result = this.asyncExecutor.submit(callable);
 		if (Future.class.isAssignableFrom(((MethodSignature) thisJoinPointStaticPart.getSignature()).getReturnType())) {
 			return result;
 		}

org.springframework.aspects/src/main/java/org/springframework/scheduling/aspectj/AnnotationAsyncExecutionAspect.aj

@@ -33,7 +33,7 @@ import org.springframework.scheduling.annotation.Async;
  * @author Ramnivas Laddad
  * @since 3.0.5
  */
-public aspect AnnotationDrivenAsynchronousExecutionAspect extends AbstractAsynchronousExecutionAspect {
+public aspect AnnotationAsyncExecutionAspect extends AbstractAsyncExecutionAspect {
 
 	private pointcut asyncMarkedMethod() 
 		: execution(@Async (void || Future+) *(..));

org.springframework.aspects/src/main/java/org/springframework/transaction/aspectj/AbstractTransactionAspect.aj

@@ -1,93 +1,93 @@
-/*
- * Copyright 2002-2007 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.transaction.aspectj;
-
-import java.lang.reflect.Method;
-
-import org.aspectj.lang.annotation.SuppressAjWarnings;
-import org.aspectj.lang.reflect.MethodSignature;
-import org.springframework.transaction.interceptor.TransactionAspectSupport;
-import org.springframework.transaction.interceptor.TransactionAttributeSource;
-
-/**
- * Abstract superaspect for AspectJ transaction aspects. Concrete
- * subaspects will implement the <code>transactionalMethodExecution()</code>
- * pointcut using a strategy such as Java 5 annotations.
- *
- * <p>Suitable for use inside or outside the Spring IoC container.
- * Set the "transactionManager" property appropriately, allowing
- * use of any transaction implementation supported by Spring.
- *
- * <p><b>NB:</b> If a method implements an interface that is itself
- * transactionally annotated, the relevant Spring transaction attribute
- * will <i>not</i> be resolved. This behavior will vary from that of Spring AOP
- * if proxying an interface (but not when proxying a class). We recommend that
- * transaction annotations should be added to classes, rather than business
- * interfaces, as they are an implementation detail rather than a contract
- * specification validation.
- *
- * @author Rod Johnson
- * @author Ramnivas Laddad
- * @since 2.0
- */
-public abstract aspect AbstractTransactionAspect extends TransactionAspectSupport {
-	
-	/**
-	 * Construct object using the given transaction metadata retrieval strategy.
-	 * @param tas TransactionAttributeSource implementation, retrieving Spring
-	 * transaction metadata for each joinpoint. Write the subclass to pass in null
-	 * if it's intended to be configured by Setter Injection.
-	 */
-	protected AbstractTransactionAspect(TransactionAttributeSource tas) {
-		setTransactionAttributeSource(tas);
-	}
-	
-	@SuppressAjWarnings("adviceDidNotMatch")
-	before(Object txObject) : transactionalMethodExecution(txObject) {
-		MethodSignature methodSignature = (MethodSignature) thisJoinPoint.getSignature();
-		Method method = methodSignature.getMethod();
-		TransactionInfo txInfo = createTransactionIfNecessary(method, txObject.getClass());
-	}
-	
-	@SuppressAjWarnings("adviceDidNotMatch")
-	after(Object txObject) throwing(Throwable t) : transactionalMethodExecution(txObject) {
-    try {
-      completeTransactionAfterThrowing(TransactionAspectSupport.currentTransactionInfo(), t);
-    }
-    catch (Throwable t2) {
-      logger.error("Failed to close transaction after throwing in a transactional method", t2);
-    }
-  }
-	
-	@SuppressAjWarnings("adviceDidNotMatch")
-	after(Object txObject) returning() : transactionalMethodExecution(txObject) {
-		commitTransactionAfterReturning(TransactionAspectSupport.currentTransactionInfo());
-	}
-	
-	@SuppressAjWarnings("adviceDidNotMatch")
-	after(Object txObject) : transactionalMethodExecution(txObject) {
-		cleanupTransactionInfo(TransactionAspectSupport.currentTransactionInfo());
-	}
-
-	/**
-	 * Concrete subaspects must implement this pointcut, to identify
-	 * transactional methods. For each selected joinpoint, TransactionMetadata
-	 * will be retrieved using Spring's TransactionAttributeSource interface.
-	 */
-	protected abstract pointcut transactionalMethodExecution(Object txObject);
-
-}
+/*
+ * 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.transaction.aspectj;
+
+import java.lang.reflect.Method;
+
+import org.aspectj.lang.annotation.SuppressAjWarnings;
+import org.aspectj.lang.reflect.MethodSignature;
+import org.springframework.transaction.interceptor.TransactionAspectSupport;
+import org.springframework.transaction.interceptor.TransactionAttributeSource;
+
+/**
+ * Abstract superaspect for AspectJ transaction aspects. Concrete
+ * subaspects will implement the <code>transactionalMethodExecution()</code>
+ * pointcut using a strategy such as Java 5 annotations.
+ *
+ * <p>Suitable for use inside or outside the Spring IoC container.
+ * Set the "transactionManager" property appropriately, allowing
+ * use of any transaction implementation supported by Spring.
+ *
+ * <p><b>NB:</b> If a method implements an interface that is itself
+ * transactionally annotated, the relevant Spring transaction attribute
+ * will <i>not</i> be resolved. This behavior will vary from that of Spring AOP
+ * if proxying an interface (but not when proxying a class). We recommend that
+ * transaction annotations should be added to classes, rather than business
+ * interfaces, as they are an implementation detail rather than a contract
+ * specification validation.
+ *
+ * @author Rod Johnson
+ * @author Ramnivas Laddad
+ * @since 2.0
+ */
+public abstract aspect AbstractTransactionAspect extends TransactionAspectSupport {
+
+	/**
+	 * Construct object using the given transaction metadata retrieval strategy.
+	 * @param tas TransactionAttributeSource implementation, retrieving Spring
+	 * transaction metadata for each joinpoint. Write the subclass to pass in null
+	 * if it's intended to be configured by Setter Injection.
+	 */
+	protected AbstractTransactionAspect(TransactionAttributeSource tas) {
+		setTransactionAttributeSource(tas);
+	}
+
+	@SuppressAjWarnings("adviceDidNotMatch")
+	before(Object txObject) : transactionalMethodExecution(txObject) {
+		MethodSignature methodSignature = (MethodSignature) thisJoinPoint.getSignature();
+		Method method = methodSignature.getMethod();
+		TransactionInfo txInfo = createTransactionIfNecessary(method, txObject.getClass());
+	}
+
+	@SuppressAjWarnings("adviceDidNotMatch")
+	after(Object txObject) throwing(Throwable t) : transactionalMethodExecution(txObject) {
+		try {
+      		completeTransactionAfterThrowing(TransactionAspectSupport.currentTransactionInfo(), t);
+		}
+		catch (Throwable t2) {
+			logger.error("Failed to close transaction after throwing in a transactional method", t2);
+		}
+	}
+
+	@SuppressAjWarnings("adviceDidNotMatch")
+	after(Object txObject) returning() : transactionalMethodExecution(txObject) {
+		commitTransactionAfterReturning(TransactionAspectSupport.currentTransactionInfo());
+	}
+
+	@SuppressAjWarnings("adviceDidNotMatch")
+	after(Object txObject) : transactionalMethodExecution(txObject) {
+		cleanupTransactionInfo(TransactionAspectSupport.currentTransactionInfo());
+	}
+
+	/**
+	 * Concrete subaspects must implement this pointcut, to identify
+	 * transactional methods. For each selected joinpoint, TransactionMetadata
+	 * will be retrieved using Spring's TransactionAttributeSource interface.
+	 */
+	protected abstract pointcut transactionalMethodExecution(Object txObject);
+
+}

org.springframework.aspects/src/main/java/org/springframework/transaction/aspectj/AnnotationTransactionAspect.aj

@@ -1,76 +1,75 @@
-/*
- * Copyright 2002-2008 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.transaction.aspectj;
-
-import org.springframework.transaction.annotation.AnnotationTransactionAttributeSource;
-import org.springframework.transaction.annotation.Transactional;
-
-/**
- * Concrete AspectJ transaction aspect using Spring Transactional annotation
- * for JDK 1.5+.
- * 
- * <p>When using this aspect, you <i>must</i> annotate the implementation class
- * (and/or methods within that class), <i>not</i> the interface (if any) that
- * the class implements. AspectJ follows Java's rule that annotations on 
- * interfaces are <i>not</i> inherited.
- *
- * <p>A @Transactional annotation on a class specifies the default transaction
- * semantics for the execution of any <b>public</b> operation in the class.
- *
- * <p>A @Transactional annotation on a method within the class overrides the
- * default transaction semantics given by the class annotation (if present). 
- * Any method may be annotated (regardless of visibility).
- * Annotating non-public methods directly is the only way
- * to get transaction demarcation for the execution of such operations.
- *
- * @author Rod Johnson
- * @author Ramnivas Laddad
- * @author Adrian Colyer
- * @since 2.0
- * @see org.springframework.transaction.annotation.Transactional
- */
-public aspect AnnotationTransactionAspect extends AbstractTransactionAspect {
-
-	public AnnotationTransactionAspect() {
-		super(new AnnotationTransactionAttributeSource(false));
-	}
-
-	/**
-	 * Matches the execution of any public method in a type with the
-	 * Transactional annotation, or any subtype of a type with the
-	 * Transactional annotation.
-	 */
-	private pointcut executionOfAnyPublicMethodInAtTransactionalType() :
-		execution(public * ((@Transactional *)+).*(..)) && @this(Transactional);
-
-	/**
-	 * Matches the execution of any method with the 
-	 * Transactional annotation.
-	 */
-	private pointcut executionOfTransactionalMethod() :
-		execution(* *(..)) && @annotation(Transactional);
-
-	/**
-	 * Definition of pointcut from super aspect - matched join points
-	 * will have Spring transaction management applied.
-	 */	
-	protected pointcut transactionalMethodExecution(Object txObject) :
-		(executionOfAnyPublicMethodInAtTransactionalType()
-		 || executionOfTransactionalMethod() )
-		 && this(txObject);
-
-}
+/*
+ * 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.transaction.aspectj;
+
+import org.springframework.transaction.annotation.AnnotationTransactionAttributeSource;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * Concrete AspectJ transaction aspect using Spring's @Transactional annotation.
+ * 
+ * <p>When using this aspect, you <i>must</i> annotate the implementation class
+ * (and/or methods within that class), <i>not</i> the interface (if any) that
+ * the class implements. AspectJ follows Java's rule that annotations on 
+ * interfaces are <i>not</i> inherited.
+ *
+ * <p>A @Transactional annotation on a class specifies the default transaction
+ * semantics for the execution of any <b>public</b> operation in the class.
+ *
+ * <p>A @Transactional annotation on a method within the class overrides the
+ * default transaction semantics given by the class annotation (if present). 
+ * Any method may be annotated (regardless of visibility).
+ * Annotating non-public methods directly is the only way
+ * to get transaction demarcation for the execution of such operations.
+ *
+ * @author Rod Johnson
+ * @author Ramnivas Laddad
+ * @author Adrian Colyer
+ * @since 2.0
+ * @see org.springframework.transaction.annotation.Transactional
+ */
+public aspect AnnotationTransactionAspect extends AbstractTransactionAspect {
+
+	public AnnotationTransactionAspect() {
+		super(new AnnotationTransactionAttributeSource(false));
+	}
+
+	/**
+	 * Matches the execution of any public method in a type with the
+	 * Transactional annotation, or any subtype of a type with the
+	 * Transactional annotation.
+	 */
+	private pointcut executionOfAnyPublicMethodInAtTransactionalType() :
+		execution(public * ((@Transactional *)+).*(..)) && @this(Transactional);
+
+	/**
+	 * Matches the execution of any method with the 
+	 * Transactional annotation.
+	 */
+	private pointcut executionOfTransactionalMethod() :
+		execution(* *(..)) && @annotation(Transactional);
+
+	/**
+	 * Definition of pointcut from super aspect - matched join points
+	 * will have Spring transaction management applied.
+	 */	
+	protected pointcut transactionalMethodExecution(Object txObject) :
+		(executionOfAnyPublicMethodInAtTransactionalType()
+		 || executionOfTransactionalMethod() )
+		 && this(txObject);
+
+}

org.springframework.aspects/src/main/resources/META-INF/aop.xml

@@ -1,17 +1,18 @@
-<?xml version="1.0"?>
-
-<!--
-	AspectJ load-time weaving config file to install common Spring aspects.
--->
-<aspectj>
-
-	<!--
-	<weaver options="-showWeaveInfo"/>
-	-->
-
-	<aspects>
-		<aspect name="org.springframework.beans.factory.aspectj.AnnotationBeanConfigurerAspect"/>
-		<aspect name="org.springframework.transaction.aspectj.AnnotationTransactionAspect"/>
-	</aspects>
-
-</aspectj>
+<?xml version="1.0"?>
+
+<!--
+	AspectJ load-time weaving config file to install common Spring aspects.
+-->
+<aspectj>
+
+	<!--
+	<weaver options="-showWeaveInfo"/>
+	-->
+
+	<aspects>
+		<aspect name="org.springframework.beans.factory.aspectj.AnnotationBeanConfigurerAspect"/>
+		<aspect name="org.springframework.scheduling.aspectj.AnnotationAsyncExecutionAspect"/>
+		<aspect name="org.springframework.transaction.aspectj.AnnotationTransactionAspect"/>
+	</aspects>
+
+</aspectj>

org.springframework.aspects/src/test/java/org/springframework/scheduling/aspectj/AnnotationAsyncExecutionAspectTests.java

@@ -33,7 +33,7 @@ import org.springframework.scheduling.annotation.AsyncResult;
 /**
  * @author Ramnivas Laddad
  */
-public class AnnotationDrivenAsynchronousExecutionAspectTests {
+public class AnnotationAsyncExecutionAspectTests {
 
 	private static final long WAIT_TIME = 1000; //milli seconds
 
@@ -42,7 +42,7 @@ public class AnnotationDrivenAsynchronousExecutionAspectTests {
 	@Before
 	public void setUp() {
 		executor = new CountingExecutor();
-		AnnotationDrivenAsynchronousExecutionAspect.aspectOf().setExecutor(executor);
+		AnnotationAsyncExecutionAspect.aspectOf().setExecutor(executor);
 	}
 	
 	@Test
@@ -150,7 +150,7 @@ public class AnnotationDrivenAsynchronousExecutionAspectTests {
 		// We need to keep this commented out, otherwise there will be a compile-time error. 
 		// Please uncomment and re-comment this periodically to check that the compiler 
 		// produces an error message due to the 'declare error' statement 
-		// in AnnotationDrivenAsynchronousExecutionAspect
+		// in AnnotationAsyncExecutionAspect
 //		@Async public int getInt() {
 //			return 0;
 //		}
@@ -164,7 +164,7 @@ public class AnnotationDrivenAsynchronousExecutionAspectTests {
 			counter++;
 		}
 		
-		// Manually check that there is a warning from the 'declare warning' statement in AnnotationDrivenAsynchronousExecutionAspect
+		// Manually check that there is a warning from the 'declare warning' statement in AnnotationAsynchExecutionAspect
 		public int return5() {
 			return 5;
 		}

org.springframework.context/src/main/java/org/springframework/scheduling/config/AnnotationDrivenBeanDefinitionParser.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2009 the original author or authors.
+ * 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.
@@ -18,6 +18,7 @@ package org.springframework.scheduling.config;
 
 import org.w3c.dom.Element;
 
+import org.springframework.aop.config.AopNamespaceUtils;
 import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.beans.factory.config.BeanDefinitionHolder;
 import org.springframework.beans.factory.parsing.BeanComponentDefinition;
@@ -32,16 +33,26 @@ import org.springframework.util.StringUtils;
  * Parser for the 'annotation-driven' element of the 'task' namespace.
  * 
  * @author Mark Fisher
+ * @author Juergen Hoeller
  * @since 3.0
  */
 public class AnnotationDrivenBeanDefinitionParser implements BeanDefinitionParser {
 
 	/**
-	 * The bean name of the internally managed async annotation processor.
+	 * The bean name of the internally managed async annotation processor (mode="proxy").
 	 */
 	public static final String ASYNC_ANNOTATION_PROCESSOR_BEAN_NAME =
 			"org.springframework.scheduling.annotation.internalAsyncAnnotationProcessor";
 
+	/**
+	 * The bean name of the internally managed transaction aspect (mode="aspectj").
+	 */
+	public static final String ASYNC_EXECUTION_ASPECT_BEAN_NAME =
+			"org.springframework.transaction.config.internalTransactionAspect";
+
+	private static final String ASYNC_EXECUTION_ASPECT_CLASS_NAME =
+			"org.springframework.scheduling.aspectj.AnnotationAsyncExecutionAspect";
+
 	/**
 	 * The bean name of the internally managed scheduled annotation processor.
 	 */
@@ -58,20 +69,33 @@ public class AnnotationDrivenBeanDefinitionParser implements BeanDefinitionParse
 
 		// Nest the concrete post-processor bean in the surrounding component.
 		BeanDefinitionRegistry registry = parserContext.getRegistry();
-		if (registry.containsBeanDefinition(ASYNC_ANNOTATION_PROCESSOR_BEAN_NAME)) {
-			parserContext.getReaderContext().error(
-					"Only one AsyncAnnotationBeanPostProcessor may exist within the context.", source);
+
+		String mode = element.getAttribute("mode");
+		if ("aspectj".equals(mode)) {
+			// mode="aspectj"
+			registerAsyncExecutionAspect(element, parserContext);
 		}
 		else {
-			BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(
-					"org.springframework.scheduling.annotation.AsyncAnnotationBeanPostProcessor");
-			builder.getRawBeanDefinition().setSource(source);
-			String executor = element.getAttribute("executor");
-			if (StringUtils.hasText(executor)) {
-				builder.addPropertyReference("executor", executor);
+			// mode="proxy"
+			if (registry.containsBeanDefinition(ASYNC_ANNOTATION_PROCESSOR_BEAN_NAME)) {
+				parserContext.getReaderContext().error(
+						"Only one AsyncAnnotationBeanPostProcessor may exist within the context.", source);
+			}
+			else {
+				BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(
+						"org.springframework.scheduling.annotation.AsyncAnnotationBeanPostProcessor");
+				builder.getRawBeanDefinition().setSource(source);
+				String executor = element.getAttribute("executor");
+				if (StringUtils.hasText(executor)) {
+					builder.addPropertyReference("executor", executor);
+				}
+				if (Boolean.valueOf(element.getAttribute(AopNamespaceUtils.PROXY_TARGET_CLASS_ATTRIBUTE))) {
+					builder.addPropertyValue("proxyTargetClass", true);
+				}
+				registerPostProcessor(parserContext, builder, ASYNC_ANNOTATION_PROCESSOR_BEAN_NAME);
 			}
-			registerPostProcessor(parserContext, builder, ASYNC_ANNOTATION_PROCESSOR_BEAN_NAME);
 		}
+
 		if (registry.containsBeanDefinition(SCHEDULED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
 			parserContext.getReaderContext().error(
 					"Only one ScheduledAnnotationBeanPostProcessor may exist within the context.", source);
@@ -93,6 +117,20 @@ public class AnnotationDrivenBeanDefinitionParser implements BeanDefinitionParse
 		return null;
 	}
 
+	private void registerAsyncExecutionAspect(Element element, ParserContext parserContext) {
+		if (!parserContext.getRegistry().containsBeanDefinition(ASYNC_EXECUTION_ASPECT_BEAN_NAME)) {
+			BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(
+					ASYNC_EXECUTION_ASPECT_CLASS_NAME);
+			builder.setFactoryMethod("aspectOf");
+			String executor = element.getAttribute("executor");
+			if (StringUtils.hasText(executor)) {
+				builder.addPropertyReference("executor", executor);
+			}
+			parserContext.registerBeanComponent(
+					new BeanComponentDefinition(builder.getBeanDefinition(), ASYNC_EXECUTION_ASPECT_BEAN_NAME));
+		}
+	}
+
 	private static void registerPostProcessor(
 			ParserContext parserContext, BeanDefinitionBuilder builder, String beanName) {
 

org.springframework.context/src/main/resources/org/springframework/scheduling/config/spring-task-3.0.xsd

@@ -44,6 +44,39 @@
 					]]></xsd:documentation>
 				</xsd:annotation>
 			</xsd:attribute>
+			<xsd:attribute name="mode" default="proxy">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Should annotated beans be proxied using Spring's AOP framework,
+	or should they rather be weaved with an AspectJ async execution aspect?
+
+	AspectJ weaving requires spring-aspects.jar on the classpath,
+	as well as load-time weaving (or compile-time weaving) enabled.
+
+	Note: The weaving-based aspect requires the @Async annotation to be
+	defined on the concrete class. Annotations in interfaces will not work
+	in that case (they will rather only work with interface-based proxies)!
+					]]></xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="proxy"/>
+						<xsd:enumeration value="aspectj"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:attribute>
+			<xsd:attribute name="proxy-target-class" type="xsd:boolean" default="false">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Are class-based (CGLIB) proxies to be created? By default, standard
+	Java interface-based proxies are created.
+
+	Note: Class-based proxies require the @Async annotation to be defined
+	on the concrete class. Annotations in interfaces will not work in
+	that case (they will rather only work with interface-based proxies)!
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
 		</xsd:complexType>
 	</xsd:element>
 

org.springframework.context/src/test/java/org/springframework/scheduling/annotation/AsyncAnnotationBeanPostProcessorTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2009 the original author or authors.
+ * 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.
@@ -16,22 +16,23 @@
 
 package org.springframework.scheduling.annotation;
 
-import static org.junit.Assert.assertNotSame;
-import static org.junit.Assert.assertTrue;
-
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 
+import static org.junit.Assert.*;
 import org.junit.Test;
 
 import org.springframework.aop.support.AopUtils;
 import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.beans.factory.support.RootBeanDefinition;
+import org.springframework.context.support.GenericXmlApplicationContext;
 import org.springframework.context.support.StaticApplicationContext;
+import org.springframework.core.io.ClassPathResource;
 import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
 
 /**
  * @author Mark Fisher
+ * @author Juergen Hoeller
  */
 public class AsyncAnnotationBeanPostProcessorTests {
 
@@ -85,6 +86,19 @@ public class AsyncAnnotationBeanPostProcessorTests {
 		context.close();
 	}
 
+	@Test
+	public void configuredThroughNamespace() {
+		GenericXmlApplicationContext context = new GenericXmlApplicationContext();
+		context.load(new ClassPathResource("taskNamespaceTests.xml", getClass()));
+		context.refresh();
+		ITestBean testBean = (ITestBean) context.getBean("target");
+		testBean.test();
+		testBean.await(3000);
+		Thread asyncThread = testBean.getThread();
+		assertTrue(asyncThread.getName().startsWith("testExecutor"));
+		context.close();
+	}
+
 
 	private static interface ITestBean {
 
@@ -96,7 +110,7 @@ public class AsyncAnnotationBeanPostProcessorTests {
 	}
 
 
-	private static class TestBean implements ITestBean {
+	public static class TestBean implements ITestBean {
 
 		private Thread thread;
 

org.springframework.context/src/test/java/org/springframework/scheduling/annotation/taskNamespaceTests.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xmlns:context="http://www.springframework.org/schema/context"
+		xmlns:task="http://www.springframework.org/schema/task"
+		xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
+				http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
+				http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd">
+
+	<!--
+	<context:load-time-weaver aspectj-weaving="on"/>
+	-->
+
+	<task:annotation-driven executor="executor"/>
+
+	<bean id="executor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
+		<property name="threadNamePrefix" value="testExecutor"/>
+	</bean>
+
+	<bean id="target" class="org.springframework.scheduling.annotation.AsyncAnnotationBeanPostProcessorTests$TestBean"/>
+
+</beans>