Rename modules {org.springframework.*=>spring-*}

This renaming more intuitively expresses the relationship between
subprojects and the JAR artifacts they produce.

Tracking history across these renames is possible, but it requires
use of the --follow flag to `git log`, for example

    $ git log spring-aop/src/main/java/org/springframework/aop/Advisor.java

will show history up until the renaming event, where

    $ git log --follow spring-aop/src/main/java/org/springframework/aop/Advisor.java

will show history for all changes to the file, before and after the
renaming.

See http://chrisbeams.com/git-diff-across-renamed-directories

spring-aspects/src/main/java/org/springframework/beans/factory/aspectj/AbstractBeanConfigurerAspect.aj

@@ -0,0 +1,85 @@
+/*
+ * 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.beans.factory.aspectj;
+
+import org.aspectj.lang.annotation.SuppressAjWarnings;
+import org.springframework.beans.factory.wiring.BeanConfigurerSupport;
+
+/**
+ * Abstract superaspect for AspectJ aspects that can perform Dependency
+ * Injection on objects, however they may be created. Define the beanCreation()
+ * pointcut in subaspects.
+ * 
+ * <p>Subaspects may also need a metadata resolution strategy, in the
+ * <code>BeanWiringInfoResolver</code> interface. The default implementation
+ * looks for a bean with the same name as the FQN. This is the default name
+ * of a bean in a Spring container if the id value is not supplied explicitly.
+ * 
+ * @author Rob Harrop
+ * @author Rod Johnson
+ * @author Adrian Colyer
+ * @author Ramnivas Laddad
+ * @since 2.0
+ * @deprecated as of Spring 2.5.2.
+ * Use AbstractDependencyInjectionAspect or its subaspects instead.
+ */
+public abstract aspect AbstractBeanConfigurerAspect extends BeanConfigurerSupport {
+
+	/**
+	 * Configured bean before initialization.
+	 */
+	@SuppressAjWarnings("adviceDidNotMatch")
+	before(Object beanInstance) : beanInitialization(beanInstance) {
+		if (preConstructionConfiguration(beanInstance)) {
+			configureBean(beanInstance);
+		}
+	}
+
+	/**
+	 * Configured bean after construction.
+	 */
+	@SuppressAjWarnings("adviceDidNotMatch")
+	after(Object beanInstance) returning : beanCreation(beanInstance) {
+		if (!preConstructionConfiguration(beanInstance)) {
+			configureBean(beanInstance);
+		}
+	}
+
+
+	/**
+	 * The initialization of a new object.
+	 * 
+	 * <p>WARNING: Although this pointcut is non-abstract for backwards
+	 * compatibility reasons, it is meant to be overridden to select
+	 * initialization of any configurable bean.
+	 */
+	protected pointcut beanInitialization(Object beanInstance);
+
+	/**
+	 * The creation of a new object.
+	 */
+	protected abstract pointcut beanCreation(Object beanInstance);
+
+
+	/**
+	 * Are dependencies to be injected prior to the construction of an object?
+	 */
+	protected boolean preConstructionConfiguration(Object beanInstance) {
+		return false; // matches the default in the @Configurable annotation
+	}
+
+}

spring-aspects/src/main/java/org/springframework/beans/factory/aspectj/AbstractDependencyInjectionAspect.aj

@@ -0,0 +1,101 @@
+/*
+ * 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.beans.factory.aspectj;
+
+import org.aspectj.lang.annotation.SuppressAjWarnings;
+
+/**
+ * Abstract base aspect that can perform Dependency
+ * Injection on objects, however they may be created.
+ * 
+ * @author Ramnivas Laddad
+ * @since 2.5.2
+ */
+public abstract aspect AbstractDependencyInjectionAspect {
+	/**
+	 * Select construction join points for objects to inject dependencies
+	 */
+	public abstract pointcut beanConstruction(Object bean); 
+
+	/**
+	 * Select deserialization join points for objects to inject dependencies
+	 */
+	public abstract pointcut beanDeserialization(Object bean);
+	
+	/**
+	 * Select join points in a configurable bean
+	 */
+	public abstract pointcut inConfigurableBean();
+	
+	/**
+	 * Select join points in beans to be configured prior to construction?
+	 * By default, use post-construction injection matching the default in the Configurable annotation.
+	 */
+	public pointcut preConstructionConfiguration() : if(false);
+	
+	/**
+	 * Select the most-specific initialization join point 
+	 * (most concrete class) for the initialization of an instance.
+	 */
+	public pointcut mostSpecificSubTypeConstruction() :
+		if(thisJoinPoint.getSignature().getDeclaringType() == thisJoinPoint.getThis().getClass());
+
+	/**
+	 * Select least specific super type that is marked for DI (so that injection occurs only once with pre-construction inejection
+	 */
+	public abstract pointcut leastSpecificSuperTypeConstruction();
+		
+	/**
+	 * Configure the bean
+	 */
+	public abstract void configureBean(Object bean);
+
+	
+	private pointcut preConstructionCondition() : 
+		leastSpecificSuperTypeConstruction() && preConstructionConfiguration();
+	
+	private pointcut postConstructionCondition() :
+		mostSpecificSubTypeConstruction() && !preConstructionConfiguration();
+	
+	/**
+	 * Pre-construction configuration.
+	 */
+	@SuppressAjWarnings("adviceDidNotMatch")
+	before(Object bean) : 
+		beanConstruction(bean) && preConstructionCondition() && inConfigurableBean()  { 
+		configureBean(bean);
+	}
+
+	/**
+	 * Post-construction configuration.
+	 */
+	@SuppressAjWarnings("adviceDidNotMatch")
+	after(Object bean) returning : 
+		beanConstruction(bean) && postConstructionCondition() && inConfigurableBean() {
+		configureBean(bean);
+	}
+	
+	/**
+	 * Post-deserialization configuration.
+	 */
+	@SuppressAjWarnings("adviceDidNotMatch")
+	after(Object bean) returning : 
+		beanDeserialization(bean) && inConfigurableBean() {
+		configureBean(bean);
+	}
+	
+}

spring-aspects/src/main/java/org/springframework/beans/factory/aspectj/AbstractInterfaceDrivenDependencyInjectionAspect.aj

@@ -0,0 +1,124 @@
+/*
+ * 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.beans.factory.aspectj;
+
+import java.io.ObjectStreamException;
+import java.io.Serializable;
+
+/**
+ * An aspect that injects dependency into any object whose type implements the {@link ConfigurableObject} interface.
+ * <p>
+ * This aspect supports injecting into domain objects when they are created for the first time as well as
+ * upon deserialization. Subaspects need to simply provide definition for the configureBean() method. This
+ * method may be implemented without relying on Spring container if so desired.
+ * </p>
+ * <p> 
+ * There are two cases that needs to be handled:
+ * <ol>
+ *   <li>Normal object creation via the '<code>new</code>' operator: this is
+ *       taken care of by advising <code>initialization()</code> join points.</li>
+ *   <li>Object creation through deserialization: since no constructor is
+ *       invoked during deserialization, the aspect needs to advise a method that a
+ *       deserialization mechanism is going to invoke. Ideally, we should not
+ *       require user classes to implement any specific method. This implies that
+ *       we need to <i>introduce</i> the chosen method. We should also handle the cases
+ *       where the chosen method is already implemented in classes (in which case,
+ *       the user's implementation for that method should take precedence over the 
+ *       introduced implementation). There are a few choices for the chosen method:
+ *       <ul>
+ *       <li>readObject(ObjectOutputStream): Java requires that the method must be
+ *           <code>private</p>. Since aspects cannot introduce a private member, 
+ *           while preserving its name, this option is ruled out.</li>
+ * 		 <li>readResolve(): Java doesn't pose any restriction on an access specifier. 
+ *           Problem solved! There is one (minor) limitation of this approach in 
+ *           that if a user class already has this method, that method must be 
+ *           <code>public</code>. However, this shouldn't be a big burden, since
+ *           use cases that need classes to implement readResolve() (custom enums, 
+ *           for example) are unlikely to be marked as &#64;Configurable, and
+ *           in any case asking to make that method <code>public</code> should not
+ *           pose any undue burden.</li>
+ *       </ul>
+ *       The minor collaboration needed by user classes (i.e., that the 
+ *       implementation of <code>readResolve()</code>, if any, must be 
+ *       <code>public</code>) can be lifted as well if we were to use an 
+ *       experimental feature in AspectJ - the <code>hasmethod()</code> PCD.</li>
+ * </ol>
+
+ * <p>
+ * While having type implement the {@link ConfigurableObject} interface is certainly a valid choice, an alternative
+ * is to use a 'declare parents' statement another aspect (a subaspect of this aspect would be a logical choice)
+ * that declares the classes that need to be configured by supplying the {@link ConfigurableObject} interface.
+ * </p>
+ * 
+ * @author Ramnivas Laddad
+ * @since 2.5.2
+ */
+public abstract aspect AbstractInterfaceDrivenDependencyInjectionAspect extends AbstractDependencyInjectionAspect {
+	/**
+	 * Select initialization join point as object construction
+	 */
+	public pointcut beanConstruction(Object bean) : 
+		initialization(ConfigurableObject+.new(..)) && this(bean); 
+
+	/**
+	 * Select deserialization join point made available through ITDs for ConfigurableDeserializationSupport
+	 */
+	public pointcut beanDeserialization(Object bean) :
+		execution(Object ConfigurableDeserializationSupport+.readResolve()) &&
+		this(bean);
+			
+	public pointcut leastSpecificSuperTypeConstruction() : initialization(ConfigurableObject.new(..));
+	
+	
+	
+	// Implementation to support re-injecting dependencies once an object is deserialized
+	/**
+	 * Declare any class implementing Serializable and ConfigurableObject as also implementing 
+	 * ConfigurableDeserializationSupport. This allows us to introduce the readResolve() 
+	 * method and select it with the beanDeserialization() pointcut.
+	 * 
+	 * <p>Here is an improved version that uses the hasmethod() pointcut and lifts
+	 * even the minor requirement on user classes:
+	 *
+	 * <pre class="code">declare parents: ConfigurableObject+ Serializable+
+	 *		            && !hasmethod(Object readResolve() throws ObjectStreamException) 
+	 *		            implements ConfigurableDeserializationSupport;
+	 * </pre>
+	 */
+	declare parents: 
+		ConfigurableObject+ && Serializable+	implements ConfigurableDeserializationSupport;
+	
+	/**
+	 * A marker interface to which the <code>readResolve()</code> is introduced.
+	 */
+	static interface ConfigurableDeserializationSupport extends Serializable {
+	}
+	
+	/**
+	 * Introduce the <code>readResolve()</code> method so that we can advise its
+	 * execution to configure the object.
+	 * 
+	 * <p>Note if a method with the same signature already exists in a
+	 * <code>Serializable</code> class of ConfigurableObject type,
+	 * that implementation will take precedence (a good thing, since we are
+	 * merely interested in an opportunity to detect deserialization.)
+	 */
+	public Object ConfigurableDeserializationSupport.readResolve() throws ObjectStreamException {
+		return this;
+	}
+
+}

spring-aspects/src/main/java/org/springframework/beans/factory/aspectj/AnnotationBeanConfigurerAspect.aj

@@ -0,0 +1,89 @@
+/*
+ * 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.beans.factory.aspectj;
+
+import java.io.Serializable;
+
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.BeanFactory;
+import org.springframework.beans.factory.BeanFactoryAware;
+import org.springframework.beans.factory.DisposableBean;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.beans.factory.annotation.AnnotationBeanWiringInfoResolver;
+import org.springframework.beans.factory.annotation.Configurable;
+import org.springframework.beans.factory.wiring.BeanConfigurerSupport;
+
+/**
+ * Concrete aspect that uses the {@link Configurable}
+ * annotation to identify which classes need autowiring.
+ *
+ * <p>The bean name to look up will be taken from the
+ * <code>&#64;Configurable</code> annotation if specified, otherwise the
+ * default bean name to look up will be the FQN of the class being configured.
+ *
+ * @author Rod Johnson
+ * @author Ramnivas Laddad
+ * @author Juergen Hoeller
+ * @author Adrian Colyer
+ * @since 2.0
+ * @see org.springframework.beans.factory.annotation.Configurable
+ * @see org.springframework.beans.factory.annotation.AnnotationBeanWiringInfoResolver
+ */
+public aspect AnnotationBeanConfigurerAspect 
+		extends AbstractInterfaceDrivenDependencyInjectionAspect
+		implements BeanFactoryAware, InitializingBean, DisposableBean {
+
+	private BeanConfigurerSupport beanConfigurerSupport = new BeanConfigurerSupport();
+
+	public pointcut inConfigurableBean() : @this(Configurable);
+
+	public pointcut preConstructionConfiguration() : preConstructionConfigurationSupport(*); 
+
+	declare parents: @Configurable * implements ConfigurableObject;
+
+	public void configureBean(Object bean) {
+		beanConfigurerSupport.configureBean(bean);
+	}
+
+
+	public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
+		beanConfigurerSupport.setBeanFactory(beanFactory);
+		beanConfigurerSupport.setBeanWiringInfoResolver(new AnnotationBeanWiringInfoResolver());
+	}
+
+	public void afterPropertiesSet() throws Exception {
+		beanConfigurerSupport.afterPropertiesSet();
+	}
+
+	public void destroy() throws Exception {
+		beanConfigurerSupport.destroy();
+	}
+
+
+	/*
+	 * An intermediary to match preConstructionConfiguration signature (that doesn't expose the annotation object)
+	 */
+	private pointcut preConstructionConfigurationSupport(Configurable c) : @this(c) && if(c.preConstruction());
+
+	/*
+	 * This declaration shouldn't be needed, 
+	 * except for an AspectJ bug (https://bugs.eclipse.org/bugs/show_bug.cgi?id=214559)
+	 */
+	declare parents: @Configurable Serializable+ 
+		implements ConfigurableDeserializationSupport;
+
+}

spring-aspects/src/main/java/org/springframework/beans/factory/aspectj/ConfigurableObject.java

@@ -0,0 +1,26 @@
+/*
+ * 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.beans.factory.aspectj;
+
+/**
+ * Marker interface for domain object that need DI through aspects.
+ * 
+ * @author Ramnivas Laddad
+ * @since 2.5
+ */
+public interface ConfigurableObject {
+
+}

spring-aspects/src/main/java/org/springframework/beans/factory/aspectj/EnableSpringConfigured.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2002-2011 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.beans.factory.aspectj;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.springframework.context.annotation.Import;
+
+/**
+ * Signals the current application context to apply dependency injection to non-managed
+ * classes that are instantiated outside of the Spring bean factory (typically classes
+ * annotated with the @{@link org.springframework.beans.factory.annotation.Configurable
+ * Configurable} annotation).
+ *
+ * <p>Similar to functionality found in Spring's {@code <context:spring-configured>} XML
+ * element. Often used in conjunction with {@link
+ * org.springframework.context.annotation.EnableLoadTimeWeaving @EnableLoadTimeWeaving}.
+ *
+ * @author Chris Beams
+ * @since 3.1
+ * @see org.springframework.context.annotation.EnableLoadTimeWeaving
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Import(SpringConfiguredConfiguration.class)
+public @interface EnableSpringConfigured {
+
+}

spring-aspects/src/main/java/org/springframework/beans/factory/aspectj/GenericInterfaceDrivenDependencyInjectionAspect.aj

@@ -0,0 +1,54 @@
+/*
+ * 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.beans.factory.aspectj;
+
+/**
+ * Generic-based dependency injection aspect.
+ * <p> 
+ * This aspect allows users to implement efficient, type-safe dependency injection without 
+ * the use of the &#64;Configurable annotation.
+ * 
+ * The subaspect of this aspect doesn't need to include any AOP constructs. 
+ * For example, here is a subaspect that configures the <code>PricingStrategyClient</code> objects.
+ * <pre>
+ * aspect PricingStrategyDependencyInjectionAspect 
+ *        extends GenericInterfaceDrivenDependencyInjectionAspect<PricingStrategyClient> {
+ *     private PricingStrategy pricingStrategy;
+ *     
+ *     public void configure(PricingStrategyClient bean) { 
+ *         bean.setPricingStrategy(pricingStrategy); 
+ *     }
+ *     
+ *     public void setPricingStrategy(PricingStrategy pricingStrategy) { 
+ *         this.pricingStrategy = pricingStrategy; 
+ *     } 
+ * }
+ * </pre>
+ * @author Ramnivas Laddad
+ * @since 3.0.0
+ */
+public abstract aspect GenericInterfaceDrivenDependencyInjectionAspect<I> extends AbstractInterfaceDrivenDependencyInjectionAspect {
+    declare parents: I implements ConfigurableObject;
+           
+	public pointcut inConfigurableBean() : within(I+);
+	
+	public final void configureBean(Object bean) {
+		configure((I)bean);
+	}
+	
+	// Unfortunately, erasure used with generics won't allow to use the same named method 
+	protected abstract void configure(I bean);
+}

spring-aspects/src/main/java/org/springframework/beans/factory/aspectj/SpringConfiguredConfiguration.java

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2002-2011 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.beans.factory.aspectj;
+
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Role;
+
+/**
+ * {@code @Configuration} class that registers an {@link AnnotationBeanConfigurerAspect}
+ * capable of performing dependency injection services for non-Spring managed objects
+ * annotated with @{@link org.springframework.beans.factory.annotation.Configurable
+ * Configurable}.
+ *
+ * <p>This configuration class is automatically imported when using the @{@link
+ * EnableSpringConfigured} annotation.  See {@code @EnableSpringConfigured} Javadoc for
+ * complete usage details.
+ *
+ * @author Chris Beams
+ * @since 3.1
+ * @see EnableSpringConfigured
+ */
+@Configuration
+public class SpringConfiguredConfiguration {
+
+	public static final String BEAN_CONFIGURER_ASPECT_BEAN_NAME =
+			"org.springframework.context.config.internalBeanConfigurerAspect";
+
+	@Bean(name=BEAN_CONFIGURER_ASPECT_BEAN_NAME)
+	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
+	public AnnotationBeanConfigurerAspect beanConfigurerAspect() {
+		return AnnotationBeanConfigurerAspect.aspectOf();
+	}
+}

spring-aspects/src/main/java/org/springframework/cache/aspectj/AbstractCacheAspect.aj

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2002-2011 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.cache.aspectj;
+
+import java.lang.reflect.Method;
+
+import org.aspectj.lang.annotation.SuppressAjWarnings;
+import org.aspectj.lang.reflect.MethodSignature;
+import org.springframework.cache.interceptor.CacheAspectSupport;
+import org.springframework.cache.interceptor.CacheOperationSource;
+
+/**
+ * Abstract superaspect for AspectJ cache aspects. Concrete subaspects will implement the
+ * {@link #cacheMethodExecution} pointcut using a strategy such as Java 5 annotations.
+ *
+ * <p>Suitable for use inside or outside the Spring IoC container. Set the
+ * {@link #setCacheManager cacheManager} property appropriately, allowing use of any cache
+ * implementation supported by Spring.
+ *
+ * <p><b>NB:</b> If a method implements an interface that is itself cache annotated, the
+ * relevant Spring cache definition will <i>not</i> be resolved.
+ *
+ * @author Costin Leau
+ * @since 3.1
+ */
+public abstract aspect AbstractCacheAspect extends CacheAspectSupport {
+
+	protected AbstractCacheAspect() {
+	}
+
+	/**
+	 * Construct object using the given caching metadata retrieval strategy.
+	 * @param cos {@link CacheOperationSource} implementation, retrieving Spring cache
+	 * metadata for each joinpoint.
+	 */
+	protected AbstractCacheAspect(CacheOperationSource... cos) {
+		setCacheOperationSources(cos);
+	}
+
+	@SuppressAjWarnings("adviceDidNotMatch")
+	Object around(final Object cachedObject) : cacheMethodExecution(cachedObject) {
+		MethodSignature methodSignature = (MethodSignature) thisJoinPoint.getSignature();
+		Method method = methodSignature.getMethod();
+
+		Invoker aspectJInvoker = new Invoker() {
+			public Object invoke() {
+				return proceed(cachedObject);
+			}
+		};
+
+		return execute(aspectJInvoker, thisJoinPoint.getTarget(), method, thisJoinPoint.getArgs());	
+	}
+
+	/**
+	 * Concrete subaspects must implement this pointcut, to identify cached methods.
+	 */
+	protected abstract pointcut cacheMethodExecution(Object cachedObject);
+
+}

spring-aspects/src/main/java/org/springframework/cache/aspectj/AnnotationCacheAspect.aj

@@ -0,0 +1,116 @@
+/*
+ * Copyright 2002-2011 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.cache.aspectj;
+
+import org.springframework.cache.annotation.AnnotationCacheOperationSource;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.CachePut;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.cache.annotation.Caching;
+
+/**
+ * Concrete AspectJ cache aspect using Spring's @{@link Cacheable} 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 {@code @Cacheable} annotation on a class specifies the default caching semantics
+ * for the execution of any <b>public</b> operation in the class.
+ *
+ * <p>A {@code @Cacheable} annotation on a method within the class overrides the default
+ * caching 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 caching demarcation for the execution of such operations.
+ *
+ * @author Costin Leau
+ * @since 3.1
+ */
+public aspect AnnotationCacheAspect extends AbstractCacheAspect {
+
+	public AnnotationCacheAspect() {
+		super(new AnnotationCacheOperationSource(false));
+	}
+
+	/**
+	 * Matches the execution of any public method in a type with the @{@link Cacheable}
+	 * annotation, or any subtype of a type with the {@code @Cacheable} annotation.
+	 */
+	private pointcut executionOfAnyPublicMethodInAtCacheableType() :
+		execution(public * ((@Cacheable *)+).*(..)) && within(@Cacheable *);
+
+	/**
+	 * Matches the execution of any public method in a type with the @{@link CacheEvict}
+	 * annotation, or any subtype of a type with the {@code CacheEvict} annotation.
+	 */
+	private pointcut executionOfAnyPublicMethodInAtCacheEvictType() :
+		execution(public * ((@CacheEvict *)+).*(..)) && within(@CacheEvict *);
+
+	/**
+	 * Matches the execution of any public method in a type with the @{@link CachePut}
+	 * annotation, or any subtype of a type with the {@code CachePut} annotation.
+	 */
+	private pointcut executionOfAnyPublicMethodInAtCachePutType() :
+		execution(public * ((@CachePut *)+).*(..)) && within(@CachePut *);
+
+	/**
+	 * Matches the execution of any public method in a type with the @{@link Caching}
+	 * annotation, or any subtype of a type with the {@code Caching} annotation.
+	 */
+	private pointcut executionOfAnyPublicMethodInAtCachingType() :
+		execution(public * ((@Caching *)+).*(..)) && within(@Caching *);
+
+	/**
+	 * Matches the execution of any method with the @{@link Cacheable} annotation.
+	 */
+	private pointcut executionOfCacheableMethod() :
+		execution(@Cacheable * *(..));
+
+	/**
+	 * Matches the execution of any method with the @{@link CacheEvict} annotation.
+	 */
+	private pointcut executionOfCacheEvictMethod() :
+		execution(@CacheEvict * *(..));
+
+	/**
+	 * Matches the execution of any method with the @{@link CachePut} annotation.
+	 */
+	private pointcut executionOfCachePutMethod() :
+		execution(@CachePut * *(..));
+
+	/**
+	 * Matches the execution of any method with the @{@link Caching} annotation.
+	 */
+	private pointcut executionOfCachingMethod() :
+		execution(@Caching * *(..));
+
+	/**
+	 * Definition of pointcut from super aspect - matched join points will have Spring
+	 * cache management applied.
+	 */
+	protected pointcut cacheMethodExecution(Object cachedObject) :
+		(executionOfAnyPublicMethodInAtCacheableType()
+				|| executionOfAnyPublicMethodInAtCacheEvictType()
+				|| executionOfAnyPublicMethodInAtCachePutType()
+				|| executionOfAnyPublicMethodInAtCachingType()
+				|| executionOfCacheableMethod()
+				|| executionOfCacheEvictMethod()
+				|| executionOfCachePutMethod()
+				|| executionOfCachingMethod())
+			&& this(cachedObject);
+}

spring-aspects/src/main/java/org/springframework/cache/aspectj/AspectJCachingConfiguration.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2002-2011 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.cache.aspectj;
+
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.cache.annotation.AbstractCachingConfiguration;
+import org.springframework.context.annotation.AnnotationConfigUtils;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Role;
+
+/**
+ * {@code @Configuration} class that registers the Spring infrastructure beans necessary
+ * to enable AspectJ-based annotation-driven cache management.
+ *
+ * @author Chris Beams
+ * @since 3.1
+ * @see org.springframework.cache.annotation.EnableCaching
+ * @see org.springframework.cache.annotation.CachingConfigurationSelector
+ */
+@Configuration
+public class AspectJCachingConfiguration extends AbstractCachingConfiguration {
+
+	@Bean(name=AnnotationConfigUtils.CACHE_ASPECT_BEAN_NAME)
+	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
+	public AnnotationCacheAspect cacheAspect() {
+		AnnotationCacheAspect cacheAspect = AnnotationCacheAspect.aspectOf();
+		if (this.cacheManager != null) {
+			cacheAspect.setCacheManager(this.cacheManager);
+		}
+		if (this.keyGenerator != null) {
+			cacheAspect.setKeyGenerator(this.keyGenerator);
+		}
+		return cacheAspect;
+	}
+}

spring-aspects/src/main/java/org/springframework/mock/staticmock/AbstractMethodMockingControl.aj

@@ -0,0 +1,197 @@
+/*
+ * 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.mock.staticmock;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * Abstract aspect to enable mocking of methods picked out by a pointcut.
+ * Sub-aspects must define the mockStaticsTestMethod() pointcut to
+ * indicate call stacks when mocking should be triggered, and the 
+ * methodToMock() pointcut to pick out a method invocations to mock.
+ * 
+ * @author Rod Johnson
+ * @author Ramnivas Laddad
+ */
+public abstract aspect AbstractMethodMockingControl percflow(mockStaticsTestMethod()) {
+
+	protected abstract pointcut mockStaticsTestMethod();
+
+	protected abstract pointcut methodToMock();
+
+	private boolean recording = true;
+
+	static enum CallResponse { nothing, return_, throw_ };
+
+	// Represents a list of expected calls to static entity methods
+	// Public to allow inserted code to access: is this normal??
+	public class Expectations {
+		
+		// Represents an expected call to a static entity method
+		private class Call {
+			private final String signature;
+			private final Object[] args;
+
+			private Object responseObject; // return value or throwable
+			private CallResponse responseType = CallResponse.nothing;
+			
+			public Call(String name, Object[] args) {
+				this.signature = name;
+				this.args = args;
+			}
+			
+			public boolean hasResponseSpecified() {
+				return responseType != CallResponse.nothing;
+			}
+			
+			public void setReturnVal(Object retVal) {
+				this.responseObject = retVal;
+				responseType = CallResponse.return_;
+			}
+			
+			public void setThrow(Throwable throwable) {
+				this.responseObject = throwable;
+				responseType = CallResponse.throw_;
+			}
+
+			public Object returnValue(String lastSig, Object[] args) {
+				checkSignature(lastSig, args);
+				return responseObject;
+			}
+
+			public Object throwException(String lastSig, Object[] args) {
+				checkSignature(lastSig, args);
+				throw (RuntimeException)responseObject;
+			}
+
+			private void checkSignature(String lastSig, Object[] args) {
+				if (!signature.equals(lastSig)) {
+					throw new IllegalArgumentException("Signature doesn't match");
+				}
+				if (!Arrays.equals(this.args, args)) {
+					throw new IllegalArgumentException("Arguments don't match");
+				}
+			}
+		}
+		
+		private List<Call> calls = new LinkedList<Call>();
+
+		// Calls already verified
+		private int verified;
+
+		public void verify() {
+			if (verified != calls.size()) {
+				throw new IllegalStateException("Expected " + calls.size()
+						+ " calls, received " + verified);
+			}
+		}
+		
+		/**
+		 * Validate the call and provide the expected return value
+		 * @param lastSig
+		 * @param args
+		 * @return
+		 */
+		public Object respond(String lastSig, Object[] args) {
+			Call call = nextCall();
+			CallResponse responseType = call.responseType;
+			if (responseType == CallResponse.return_) {
+				return call.returnValue(lastSig, args);
+			} else if(responseType == CallResponse.throw_) {
+				return (RuntimeException)call.throwException(lastSig, args);
+			} else if(responseType == CallResponse.nothing) {
+				// do nothing
+			}
+			throw new IllegalStateException("Behavior of " + call + " not specified");
+		}
+
+		private Call nextCall() {
+			if (verified > calls.size() - 1) {
+				throw new IllegalStateException("Expected " + calls.size()
+						+ " calls, received " + verified);
+			}
+			return calls.get(verified++);
+		}
+
+		public void expectCall(String lastSig, Object lastArgs[]) {
+			Call call = new Call(lastSig, lastArgs);
+			calls.add(call);
+		}
+
+		public boolean hasCalls() {
+			return !calls.isEmpty();
+		}
+
+		public void expectReturn(Object retVal) {
+			Call call = calls.get(calls.size() - 1);
+			if (call.hasResponseSpecified()) {
+				throw new IllegalStateException("No static method invoked before setting return value");
+			}
+			call.setReturnVal(retVal);
+		}
+
+		public void expectThrow(Throwable throwable) {
+			Call call = calls.get(calls.size() - 1);
+			if (call.hasResponseSpecified()) {
+				throw new IllegalStateException("No static method invoked before setting throwable");
+			}
+			call.setThrow(throwable);
+		}
+	}
+
+	private Expectations expectations = new Expectations();
+
+	after() returning : mockStaticsTestMethod() {
+		if (recording && (expectations.hasCalls())) {
+			throw new IllegalStateException(
+					"Calls recorded, yet playback state never reached: Create expectations then call "
+							+ this.getClass().getSimpleName() + ".playback()");
+		}
+		expectations.verify();
+	}
+
+	Object around() : methodToMock() && cflowbelow(mockStaticsTestMethod()) {
+		if (recording) {
+			expectations.expectCall(thisJoinPointStaticPart.toLongString(), thisJoinPoint.getArgs());
+			// Return value doesn't matter
+			return null;
+		} else {
+			return expectations.respond(thisJoinPointStaticPart.toLongString(), thisJoinPoint.getArgs());
+		}
+	}
+	
+	public void expectReturnInternal(Object retVal) {
+		if (!recording) {
+			throw new IllegalStateException("Not recording: Cannot set return value");
+		}
+		expectations.expectReturn(retVal);
+	}
+
+	public void expectThrowInternal(Throwable throwable) {
+		if (!recording) {
+			throw new IllegalStateException("Not recording: Cannot set throwable value");
+		}
+		expectations.expectThrow(throwable);
+	}
+
+	public void playbackInternal() {
+		recording = false;
+	}
+
+}

spring-aspects/src/main/java/org/springframework/mock/staticmock/AnnotationDrivenStaticEntityMockingControl.aj

@@ -0,0 +1,68 @@
+/*
+ * 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.mock.staticmock;
+
+/**
+ * Annotation-based aspect to use in test build to enable mocking static methods
+ * on JPA-annotated <code>@Entity</code> classes, as used by Roo for finders.
+ *
+ * <p>Mocking will occur in the call stack of any method in a class (typically a test class) 
+ * that is annotated with the @MockStaticEntityMethods annotation. 
+ *
+ * <p>Also provides static methods to simplify the programming model for
+ * entering playback mode and setting expected return values.
+ *
+ * <p>Usage:
+ * <ol> 
+ * <li>Annotate a test class with @MockStaticEntityMethods.
+ * <li>In each test method, AnnotationDrivenStaticEntityMockingControl will begin in recording mode.
+ * Invoke static methods on Entity classes, with each recording-mode invocation
+ * being followed by an invocation to the static expectReturn() or expectThrow()
+ * method on AnnotationDrivenStaticEntityMockingControl.
+ * <li>Invoke the static AnnotationDrivenStaticEntityMockingControl() method.
+ * <li>Call the code you wish to test that uses the static methods. Verification will
+ * occur automatically.
+ * </ol>
+ * 
+ * @author Rod Johnson
+ * @author Ramnivas Laddad
+ * @see MockStaticEntityMethods
+ */
+public aspect AnnotationDrivenStaticEntityMockingControl extends AbstractMethodMockingControl {
+	
+	/**
+	 * Stop recording mock calls and enter playback state
+	 */
+	public static void playback() {
+		AnnotationDrivenStaticEntityMockingControl.aspectOf().playbackInternal();
+	}
+	
+	public static void expectReturn(Object retVal) {
+		AnnotationDrivenStaticEntityMockingControl.aspectOf().expectReturnInternal(retVal);
+	}
+
+	public static void expectThrow(Throwable throwable) {
+		AnnotationDrivenStaticEntityMockingControl.aspectOf().expectThrowInternal(throwable);
+	}
+
+	// Only matches directly annotated @Test methods, to allow methods in
+	// @MockStatics classes to invoke each other without resetting the mocking environment
+	protected pointcut mockStaticsTestMethod() : execution(public * (@MockStaticEntityMethods *).*(..));
+
+	protected pointcut methodToMock() : execution(public static * (@javax.persistence.Entity *).*(..));
+
+}

spring-aspects/src/main/java/org/springframework/mock/staticmock/MockStaticEntityMethods.java

@@ -0,0 +1,34 @@
+/*
+ * 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.mock.staticmock;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotation to indicate a test class for whose @Test methods
+ * static methods on Entity classes should be mocked.
+ *
+ * @author Rod Johnson
+ * @see AbstractMethodMockingControl
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface MockStaticEntityMethods {
+
+}

spring-aspects/src/main/java/org/springframework/orm/jpa/aspectj/JpaExceptionTranslatorAspect.aj

@@ -0,0 +1,22 @@
+package org.springframework.orm.jpa.aspectj;
+
+import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.EntityTransaction;
+import javax.persistence.Query;
+
+import org.springframework.dao.DataAccessException;
+import org.springframework.orm.jpa.EntityManagerFactoryUtils;
+
+public aspect JpaExceptionTranslatorAspect {
+    pointcut entityManagerCall(): call(* EntityManager.*(..)) || call(* EntityManagerFactory.*(..)) || call(* EntityTransaction.*(..)) || call(* Query.*(..));
+    
+    after() throwing(RuntimeException re): entityManagerCall() {     
+    	DataAccessException dex = EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(re);
+    	if (dex != null) {
+    		throw dex;
+    	} else {
+    		throw re;
+    	}        
+    }	
+}

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

@@ -0,0 +1,75 @@
+/*
+ * 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.
+ *
+ * <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 AbstractAsyncExecutionAspect {
+
+	private AsyncTaskExecutor asyncExecutor;
+
+	public void setExecutor(Executor executor) {
+		if (executor instanceof AsyncTaskExecutor) {
+			this.asyncExecutor = (AsyncTaskExecutor) executor;
+		}
+		else {
+			this.asyncExecutor = new TaskExecutorAdapter(executor);
+		}
+	}
+
+	Object around() : asyncMethod() {
+                if (this.asyncExecutor == null) {
+			return proceed();
+                }
+		Callable<Object> callable = new Callable<Object>() {
+			public Object call() throws Exception {
+				Object result = proceed();
+				if (result instanceof Future) {
+					return ((Future<?>) result).get();
+				}
+				return null;
+			}};
+		Future<?> result = this.asyncExecutor.submit(callable);
+		if (Future.class.isAssignableFrom(((MethodSignature) thisJoinPointStaticPart.getSignature()).getReturnType())) {
+			return result;
+		}
+		else {
+			return null;
+		}
+	}
+
+	public abstract pointcut asyncMethod();
+
+}

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

@@ -0,0 +1,54 @@
+/*
+ * 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.
+ *
+ * <p>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 <code>&#64;Async</code> contains a method that 
+ * violates this constraint, it produces only a warning.
+ * 
+ * @author Ramnivas Laddad
+ * @since 3.0.5
+ */
+public aspect AnnotationAsyncExecutionAspect extends AbstractAsyncExecutionAspect {
+
+	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";
+
+}

spring-aspects/src/main/java/org/springframework/scheduling/aspectj/AspectJAsyncConfiguration.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2002-2011 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 org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.context.annotation.AnnotationConfigUtils;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Role;
+import org.springframework.scheduling.annotation.AbstractAsyncConfiguration;
+import org.springframework.scheduling.annotation.EnableAsync;
+
+/**
+ * {@code @Configuration} class that registers the Spring infrastructure beans necessary
+ * to enable AspectJ-based asynchronous method execution.
+ *
+ * @author Chris Beams
+ * @since 3.1
+ * @see EnableAsync
+ * @see AsyncConfigurationSelector
+ */
+@Configuration
+public class AspectJAsyncConfiguration extends AbstractAsyncConfiguration {
+
+	@Override
+	@Bean(name=AnnotationConfigUtils.ASYNC_EXECUTION_ASPECT_BEAN_NAME)
+	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
+	public AnnotationAsyncExecutionAspect asyncAdvisor() {
+		AnnotationAsyncExecutionAspect asyncAspect = AnnotationAsyncExecutionAspect.aspectOf();
+		if (this.executor != null) {
+			asyncAspect.setExecutor(this.executor);
+		}
+		return asyncAspect;
+	}
+
+}

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

@@ -0,0 +1,93 @@
+/*
+ * 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);
+
+}

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

@@ -0,0 +1,75 @@
+/*
+ * 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>An @Transactional annotation on a class specifies the default transaction
+ * semantics for the execution of any <b>public</b> operation in the class.
+ *
+ * <p>An @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 *)+).*(..)) && within(@Transactional *);
+
+	/**
+	 * Matches the execution of any method with the 
+	 * Transactional annotation.
+	 */
+	private pointcut executionOfTransactionalMethod() :
+		execution(@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);
+
+}

spring-aspects/src/main/java/org/springframework/transaction/aspectj/AspectJTransactionManagementConfiguration.java

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2002-2011 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.beans.factory.config.BeanDefinition;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Role;
+import org.springframework.transaction.annotation.AbstractTransactionManagementConfiguration;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+import org.springframework.transaction.annotation.TransactionManagementConfigurationSelector;
+import org.springframework.transaction.config.TransactionManagementConfigUtils;
+
+/**
+ * {@code @Configuration} class that registers the Spring infrastructure beans necessary
+ * to enable AspectJ-based annotation-driven transaction management.
+ *
+ * @author Chris Beams
+ * @since 3.1
+ * @see EnableTransactionManagement
+ * @see TransactionManagementConfigurationSelector
+ */
+@Configuration
+public class AspectJTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {
+
+	@Bean(name=TransactionManagementConfigUtils.TRANSACTION_ASPECT_BEAN_NAME)
+	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
+	public AnnotationTransactionAspect transactionAspect() {
+		AnnotationTransactionAspect txAspect = AnnotationTransactionAspect.aspectOf();
+		if (this.txManager != null) {
+			txAspect.setTransactionManager(this.txManager);
+		}
+		return txAspect;
+	}
+}