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;
+	}
+}

spring-aspects/src/main/java/overview.html

@@ -0,0 +1,7 @@
+<html>
+<body>
+<p>
+Spring's AspectJ-based aspects.
+</p>
+</body>
+</html>

spring-aspects/src/main/resources/META-INF/aop.xml

@@ -0,0 +1,19 @@
+<?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"/>
+		<aspect name="org.springframework.cache.aspectj.AnnotationCacheAspect"/>
+	</aspects>
+
+</aspectj>

spring-aspects/src/test/java/org/springframework/aop/aspectj/autoproxy/AutoProxyWithCodeStyleAspectsTests.java

@@ -0,0 +1,32 @@
+/*
+ * 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.aop.aspectj.autoproxy;
+
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+
+import junit.framework.TestCase;
+
+/**
+ * @author Adrian Colyer
+ */
+public class AutoProxyWithCodeStyleAspectsTests extends TestCase {
+
+	public void testNoAutoproxyingOfAjcCompiledAspects() {
+		new ClassPathXmlApplicationContext("org/springframework/aop/aspectj/autoproxy/ajcAutoproxyTests.xml");		
+	}
+	
+}

spring-aspects/src/test/java/org/springframework/aop/aspectj/autoproxy/CodeStyleAspect.aj

@@ -0,0 +1,36 @@
+/*
+ * 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.aop.aspectj.autoproxy;
+
+/**
+ * @author Adrian Colyer
+ */
+public aspect CodeStyleAspect {
+
+	private String foo;
+
+	pointcut somePC() : call(* someMethod());
+
+	before() : somePC() {
+		System.out.println("match");
+	}
+
+	public void setFoo(String foo) {
+		this.foo = foo;
+	}
+
+}

spring-aspects/src/test/java/org/springframework/aop/aspectj/autoproxy/ajcAutoproxyTests.xml

@@ -0,0 +1,17 @@
+<?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:aop="http://www.springframework.org/schema/aop"
+		xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
+				http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">
+
+	<aop:aspectj-autoproxy/>
+
+	<bean id="myAspect" class="org.springframework.aop.aspectj.autoproxy.CodeStyleAspect"
+			factory-method="aspectOf">
+		<property name="foo" value="bar"/>
+	</bean>
+
+	<bean id="otherBean" class="java.lang.Object"/>
+
+</beans>

spring-aspects/src/test/java/org/springframework/beans/Colour.java

@@ -0,0 +1,35 @@
+/*
+ * 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.beans;
+
+import org.springframework.core.enums.ShortCodedLabeledEnum;
+
+/**
+ * @author Rob Harrop
+ */
+public class Colour extends ShortCodedLabeledEnum {
+
+	public static final Colour RED = new Colour(0, "RED");
+	public static final Colour BLUE = new Colour(1, "BLUE");
+	public static final Colour GREEN = new Colour(2, "GREEN");
+	public static final Colour PURPLE = new Colour(3, "PURPLE");
+
+	private Colour(int code, String label) {
+		super(code, label);
+	}
+
+}

spring-aspects/src/test/java/org/springframework/beans/DerivedTestBean.java

@@ -0,0 +1,85 @@
+/*
+ * 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.beans;
+
+import java.io.Serializable;
+
+import org.springframework.beans.factory.BeanNameAware;
+import org.springframework.beans.factory.DisposableBean;
+
+/**
+ * @author Juergen Hoeller
+ * @since 21.08.2003
+ */
+public class DerivedTestBean extends TestBean implements Serializable, BeanNameAware, DisposableBean {
+
+	private String beanName;
+
+	private boolean initialized;
+
+	private boolean destroyed;
+
+
+	public DerivedTestBean() {
+	}
+
+	public DerivedTestBean(String[] names) {
+		if (names == null || names.length < 2) {
+			throw new IllegalArgumentException("Invalid names array");
+		}
+		setName(names[0]);
+		setBeanName(names[1]);
+	}
+
+	public static DerivedTestBean create(String[] names) {
+		return new DerivedTestBean(names);
+	}
+
+
+	public void setBeanName(String beanName) {
+		if (this.beanName == null || beanName == null) {
+			this.beanName = beanName;
+		}
+	}
+
+	public String getBeanName() {
+		return beanName;
+	}
+
+	public void setSpouseRef(String name) {
+		setSpouse(new TestBean(name));
+	}
+
+
+	public void initialize() {
+		this.initialized = true;
+	}
+
+	public boolean wasInitialized() {
+		return initialized;
+	}
+
+
+	public void destroy() {
+		this.destroyed = true;
+	}
+
+	public boolean wasDestroyed() {
+		return destroyed;
+	}
+
+}

spring-aspects/src/test/java/org/springframework/beans/INestedTestBean.java

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2002-2005 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;
+
+public interface INestedTestBean {
+
+	public String getCompany();
+
+}

spring-aspects/src/test/java/org/springframework/beans/IOther.java

@@ -0,0 +1,24 @@
+
+/*
+ * Copyright 2002-2005 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;
+
+public interface IOther {
+
+	void absquatulate();
+
+}

spring-aspects/src/test/java/org/springframework/beans/ITestBean.java

@@ -0,0 +1,71 @@
+/*
+ * 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.beans;
+
+import java.io.IOException;
+
+/**
+ * Interface used for {@link org.springframework.beans.TestBean}.
+ *
+ * <p>Two methods are the same as on Person, but if this
+ * extends person it breaks quite a few tests..
+ *
+ * @author Rod Johnson
+ * @author Juergen Hoeller
+ */
+public interface ITestBean {
+
+	int getAge();
+
+	void setAge(int age);
+
+	String getName();
+
+	void setName(String name);
+
+	ITestBean getSpouse();
+
+	void setSpouse(ITestBean spouse);
+
+	ITestBean[] getSpouses();
+
+	String[] getStringArray();
+
+	void setStringArray(String[] stringArray);
+
+	/**
+	 * Throws a given (non-null) exception.
+	 */
+	void exceptional(Throwable t) throws Throwable;
+
+	Object returnsThis();
+
+	INestedTestBean getDoctor();
+
+	INestedTestBean getLawyer();
+
+	IndexedTestBean getNestedIndexedBean();
+
+	/**
+	 * Increment the age by one.
+	 * @return the previous age
+	 */
+	int haveBirthday();
+
+	void unreliableFileOperation() throws IOException;
+
+}

spring-aspects/src/test/java/org/springframework/beans/IndexedTestBean.java

@@ -0,0 +1,145 @@
+/*
+ * Copyright 2002-2006 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;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.SortedMap;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+/**
+ * @author Juergen Hoeller
+ * @since 11.11.2003
+ */
+public class IndexedTestBean {
+
+	private TestBean[] array;
+
+	private Collection collection;
+
+	private List list;
+
+	private Set set;
+
+	private SortedSet sortedSet;
+
+	private Map map;
+
+	private SortedMap sortedMap;
+
+
+	public IndexedTestBean() {
+		this(true);
+	}
+
+	public IndexedTestBean(boolean populate) {
+		if (populate) {
+			populate();
+		}
+	}
+
+	public void populate() {
+		TestBean tb0 = new TestBean("name0", 0);
+		TestBean tb1 = new TestBean("name1", 0);
+		TestBean tb2 = new TestBean("name2", 0);
+		TestBean tb3 = new TestBean("name3", 0);
+		TestBean tb4 = new TestBean("name4", 0);
+		TestBean tb5 = new TestBean("name5", 0);
+		TestBean tb6 = new TestBean("name6", 0);
+		TestBean tb7 = new TestBean("name7", 0);
+		TestBean tbX = new TestBean("nameX", 0);
+		TestBean tbY = new TestBean("nameY", 0);
+		this.array = new TestBean[] {tb0, tb1};
+		this.list = new ArrayList();
+		this.list.add(tb2);
+		this.list.add(tb3);
+		this.set = new TreeSet();
+		this.set.add(tb6);
+		this.set.add(tb7);
+		this.map = new HashMap();
+		this.map.put("key1", tb4);
+		this.map.put("key2", tb5);
+		this.map.put("key.3", tb5);
+		List list = new ArrayList();
+		list.add(tbX);
+		list.add(tbY);
+		this.map.put("key4", list);
+	}
+
+
+	public TestBean[] getArray() {
+		return array;
+	}
+
+	public void setArray(TestBean[] array) {
+		this.array = array;
+	}
+
+	public Collection getCollection() {
+		return collection;
+	}
+
+	public void setCollection(Collection collection) {
+		this.collection = collection;
+	}
+
+	public List getList() {
+		return list;
+	}
+
+	public void setList(List list) {
+		this.list = list;
+	}
+
+	public Set getSet() {
+		return set;
+	}
+
+	public void setSet(Set set) {
+		this.set = set;
+	}
+
+	public SortedSet getSortedSet() {
+		return sortedSet;
+	}
+
+	public void setSortedSet(SortedSet sortedSet) {
+		this.sortedSet = sortedSet;
+	}
+
+	public Map getMap() {
+		return map;
+	}
+
+	public void setMap(Map map) {
+		this.map = map;
+	}
+
+	public SortedMap getSortedMap() {
+		return sortedMap;
+	}
+
+	public void setSortedMap(SortedMap sortedMap) {
+		this.sortedMap = sortedMap;
+	}
+
+}

spring-aspects/src/test/java/org/springframework/beans/NestedTestBean.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2002-2005 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;
+
+/**
+ * Simple nested test bean used for testing bean factories, AOP framework etc.
+ *
+ * @author Trevor D. Cook
+ * @since 30.09.2003
+ */
+public class NestedTestBean implements INestedTestBean {
+
+	private String company = "";
+
+	public NestedTestBean() {
+	}
+
+	public NestedTestBean(String company) {
+		setCompany(company);
+	}
+
+	public void setCompany(String company) {
+		this.company = (company != null ? company : "");
+	}
+
+	public String getCompany() {
+		return company;
+	}
+
+	public boolean equals(Object obj) {
+		if (!(obj instanceof NestedTestBean)) {
+			return false;
+		}
+		NestedTestBean ntb = (NestedTestBean) obj;
+		return this.company.equals(ntb.company);
+	}
+
+	public int hashCode() {
+		return this.company.hashCode();
+	}
+
+	public String toString() {
+		return "NestedTestBean: " + this.company;
+	}
+
+}

spring-aspects/src/test/java/org/springframework/beans/TestBean.java

@@ -0,0 +1,437 @@
+/*
+ * 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;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+
+import org.springframework.beans.factory.BeanFactory;
+import org.springframework.beans.factory.BeanFactoryAware;
+import org.springframework.beans.factory.BeanNameAware;
+import org.springframework.util.ObjectUtils;
+
+/**
+ * Simple test bean used for testing bean factories, the AOP framework etc.
+ *
+ * @author Rod Johnson
+ * @author Juergen Hoeller
+ * @since 15 April 2001
+ */
+public class TestBean implements BeanNameAware, BeanFactoryAware, ITestBean, IOther, Comparable {
+
+	private String beanName;
+
+	private String country;
+
+	private BeanFactory beanFactory;
+
+	private boolean postProcessed;
+
+	private String name;
+
+	private String sex;
+
+	private int age;
+
+	private boolean jedi;
+
+	private ITestBean[] spouses;
+
+	private String touchy;
+
+	private String[] stringArray;
+
+	private Integer[] someIntegerArray;
+
+	private Date date = new Date();
+
+	private Float myFloat = new Float(0.0);
+
+	private Collection friends = new LinkedList();
+
+	private Set someSet = new HashSet();
+
+	private Map someMap = new HashMap();
+
+	private List someList = new ArrayList();
+
+	private Properties someProperties = new Properties();
+
+	private INestedTestBean doctor = new NestedTestBean();
+
+	private INestedTestBean lawyer = new NestedTestBean();
+
+	private IndexedTestBean nestedIndexedBean;
+
+	private boolean destroyed;
+
+	private Number someNumber;
+
+	private Colour favouriteColour;
+
+	private Boolean someBoolean;
+
+	private List otherColours;
+
+	private List pets;
+
+
+	public TestBean() {
+	}
+
+	public TestBean(String name) {
+		this.name = name;
+	}
+
+	public TestBean(ITestBean spouse) {
+		this.spouses = new ITestBean[] {spouse};
+	}
+
+	public TestBean(String name, int age) {
+		this.name = name;
+		this.age = age;
+	}
+
+	public TestBean(ITestBean spouse, Properties someProperties) {
+		this.spouses = new ITestBean[] {spouse};
+		this.someProperties = someProperties;
+	}
+
+	public TestBean(List someList) {
+		this.someList = someList;
+	}
+
+	public TestBean(Set someSet) {
+		this.someSet = someSet;
+	}
+
+	public TestBean(Map someMap) {
+		this.someMap = someMap;
+	}
+
+	public TestBean(Properties someProperties) {
+		this.someProperties = someProperties;
+	}
+
+
+	public void setBeanName(String beanName) {
+		this.beanName = beanName;
+	}
+
+	public String getBeanName() {
+		return beanName;
+	}
+
+	public void setBeanFactory(BeanFactory beanFactory) {
+		this.beanFactory = beanFactory;
+	}
+
+	public BeanFactory getBeanFactory() {
+		return beanFactory;
+	}
+
+	public void setPostProcessed(boolean postProcessed) {
+		this.postProcessed = postProcessed;
+	}
+
+	public boolean isPostProcessed() {
+		return postProcessed;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	public String getSex() {
+		return sex;
+	}
+
+	public void setSex(String sex) {
+		this.sex = sex;
+		if (this.name == null) {
+			this.name = sex;
+		}
+	}
+
+	public int getAge() {
+		return age;
+	}
+
+	public void setAge(int age) {
+		this.age = age;
+	}
+
+	public boolean isJedi() {
+		return jedi;
+	}
+
+	public void setJedi(boolean jedi) {
+		this.jedi = jedi;
+	}
+
+	public ITestBean getSpouse() {
+		return (spouses != null ? spouses[0] : null);
+	}
+
+	public void setSpouse(ITestBean spouse) {
+		this.spouses = new ITestBean[] {spouse};
+	}
+
+	public ITestBean[] getSpouses() {
+		return spouses;
+	}
+
+	public String getTouchy() {
+		return touchy;
+	}
+
+	public void setTouchy(String touchy) throws Exception {
+		if (touchy.indexOf('.') != -1) {
+			throw new Exception("Can't contain a .");
+		}
+		if (touchy.indexOf(',') != -1) {
+			throw new NumberFormatException("Number format exception: contains a ,");
+		}
+		this.touchy = touchy;
+	}
+
+	public String getCountry() {
+		return country;
+	}
+
+	public void setCountry(String country) {
+		this.country = country;
+	}
+
+	public String[] getStringArray() {
+		return stringArray;
+	}
+
+	public void setStringArray(String[] stringArray) {
+		this.stringArray = stringArray;
+	}
+
+	public Integer[] getSomeIntegerArray() {
+		return someIntegerArray;
+	}
+
+	public void setSomeIntegerArray(Integer[] someIntegerArray) {
+		this.someIntegerArray = someIntegerArray;
+	}
+
+	public Date getDate() {
+		return date;
+	}
+
+	public void setDate(Date date) {
+		this.date = date;
+	}
+
+	public Float getMyFloat() {
+		return myFloat;
+	}
+
+	public void setMyFloat(Float myFloat) {
+		this.myFloat = myFloat;
+	}
+
+	public Collection getFriends() {
+		return friends;
+	}
+
+	public void setFriends(Collection friends) {
+		this.friends = friends;
+	}
+
+	public Set getSomeSet() {
+		return someSet;
+	}
+
+	public void setSomeSet(Set someSet) {
+		this.someSet = someSet;
+	}
+
+	public Map getSomeMap() {
+		return someMap;
+	}
+
+	public void setSomeMap(Map someMap) {
+		this.someMap = someMap;
+	}
+
+	public List getSomeList() {
+		return someList;
+	}
+
+	public void setSomeList(List someList) {
+		this.someList = someList;
+	}
+
+	public Properties getSomeProperties() {
+		return someProperties;
+	}
+
+	public void setSomeProperties(Properties someProperties) {
+		this.someProperties = someProperties;
+	}
+
+	public INestedTestBean getDoctor() {
+		return doctor;
+	}
+
+	public void setDoctor(INestedTestBean doctor) {
+		this.doctor = doctor;
+	}
+
+	public INestedTestBean getLawyer() {
+		return lawyer;
+	}
+
+	public void setLawyer(INestedTestBean lawyer) {
+		this.lawyer = lawyer;
+	}
+
+	public Number getSomeNumber() {
+		return someNumber;
+	}
+
+	public void setSomeNumber(Number someNumber) {
+		this.someNumber = someNumber;
+	}
+
+	public Colour getFavouriteColour() {
+		return favouriteColour;
+	}
+
+	public void setFavouriteColour(Colour favouriteColour) {
+		this.favouriteColour = favouriteColour;
+	}
+
+	public Boolean getSomeBoolean() {
+		return someBoolean;
+	}
+
+	public void setSomeBoolean(Boolean someBoolean) {
+		this.someBoolean = someBoolean;
+	}
+
+	public IndexedTestBean getNestedIndexedBean() {
+		return nestedIndexedBean;
+	}
+
+	public void setNestedIndexedBean(IndexedTestBean nestedIndexedBean) {
+		this.nestedIndexedBean = nestedIndexedBean;
+	}
+
+	public List getOtherColours() {
+		return otherColours;
+	}
+
+	public void setOtherColours(List otherColours) {
+		this.otherColours = otherColours;
+	}
+
+	public List getPets() {
+		return pets;
+	}
+
+	public void setPets(List pets) {
+		this.pets = pets;
+	}
+
+
+	/**
+	 * @see org.springframework.beans.ITestBean#exceptional(Throwable)
+	 */
+	public void exceptional(Throwable t) throws Throwable {
+		if (t != null) {
+			throw t;
+		}
+	}
+
+	public void unreliableFileOperation() throws IOException {
+		throw new IOException();
+	}
+	/**
+	 * @see org.springframework.beans.ITestBean#returnsThis()
+	 */
+	public Object returnsThis() {
+		return this;
+	}
+
+	/**
+	 * @see org.springframework.beans.IOther#absquatulate()
+	 */
+	public void absquatulate() {
+	}
+
+	public int haveBirthday() {
+		return age++;
+	}
+
+
+	public void destroy() {
+		this.destroyed = true;
+	}
+
+	public boolean wasDestroyed() {
+		return destroyed;
+	}
+
+
+	public boolean equals(Object other) {
+		if (this == other) {
+			return true;
+		}
+		if (other == null || !(other instanceof TestBean)) {
+			return false;
+		}
+		TestBean tb2 = (TestBean) other;
+		return (ObjectUtils.nullSafeEquals(this.name, tb2.name) && this.age == tb2.age);
+	}
+
+	public int hashCode() {
+		return this.age;
+	}
+
+	public int compareTo(Object other) {
+		if (this.name != null && other instanceof TestBean) {
+			return this.name.compareTo(((TestBean) other).getName());
+		}
+		else {
+			return 1;
+		}
+	}
+
+	public String toString() {
+		return this.name;
+	}
+
+}

spring-aspects/src/test/java/org/springframework/beans/factory/aspectj/AbstractBeanConfigurerTests.java

@@ -0,0 +1,652 @@
+/*
+ * 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.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.ObjectStreamException;
+import java.io.Serializable;
+
+import junit.framework.TestCase;
+
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Pointcut;
+import org.springframework.beans.TestBean;
+import org.springframework.beans.factory.FactoryBean;
+import org.springframework.beans.factory.UnsatisfiedDependencyException;
+import org.springframework.beans.factory.annotation.Autowire;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Configurable;
+import org.springframework.context.ConfigurableApplicationContext;
+import org.springframework.mail.MailSender;
+import org.springframework.mail.javamail.JavaMailSenderImpl;
+
+/**
+ * @author Adrian Colyer
+ * @author Rod Johnson
+ * @author Ramnivas Laddad
+ * @author Juergen Hoeller
+ * @author Chris Beams
+ */
+public abstract class AbstractBeanConfigurerTests extends TestCase {
+
+	protected ConfigurableApplicationContext context;
+
+	@Override
+	protected void setUp() throws Exception {
+		this.context = createContext();
+	}
+
+	protected abstract ConfigurableApplicationContext createContext();
+
+	public void testConfigurableWithExplicitBeanName() {
+		ShouldBeConfiguredBySpring myObject = new ShouldBeConfiguredBySpring();
+		assertEquals("Rod", myObject.getName());
+	}
+
+	public void testWithoutAnnotation() {
+		ShouldNotBeConfiguredBySpring myObject = new ShouldNotBeConfiguredBySpring();
+		assertNull("Name should not have been set", myObject.getName());
+	}
+
+	public void testConfigurableWithImplicitBeanName() {
+		ShouldBeConfiguredBySpringUsingTypeNameAsBeanName myObject =
+				new ShouldBeConfiguredBySpringUsingTypeNameAsBeanName();
+		assertEquals("Rob", myObject.getName());
+	}
+
+	public void testConfigurableUsingAutowireByType() {
+		ShouldBeConfiguredBySpringUsingAutowireByType myObject =
+				new ShouldBeConfiguredBySpringUsingAutowireByType();
+		assertNotNull(myObject.getFriend());
+		assertEquals("Ramnivas", myObject.getFriend().getName());
+	}
+
+	public void testConfigurableUsingAutowireByName() {
+		ValidAutowireByName myObject = new ValidAutowireByName();
+		assertNotNull(myObject.getRamnivas());
+		assertEquals("Ramnivas", myObject.getRamnivas().getName());
+	}
+
+	public void testInvalidAutowireByName() {
+		try {
+			new InvalidAutowireByName();
+			fail("Autowire by name cannot work");
+		}
+		catch (UnsatisfiedDependencyException ex) {
+			// Ok
+		}
+	}
+
+	public void testNewAspectAppliesToArbitraryNonAnnotatedPojo() {
+		ArbitraryExistingPojo aep = new ArbitraryExistingPojo();
+		assertNotNull(aep.friend);
+		assertEquals("Ramnivas", aep.friend.getName());
+	}
+
+	public void testNewAspectThatWasNotAddedToSpringContainer() {
+		try{
+			new ClassThatWillNotActuallyBeWired();
+		}
+		catch (IllegalStateException ex) {
+			assertTrue(ex.getMessage().indexOf("BeanFactory") != -1);
+		}
+	}
+
+	public void testInjectionOnDeserialization() throws Exception {
+		ShouldBeConfiguredBySpring domainObject = new ShouldBeConfiguredBySpring();
+		domainObject.setName("Anonymous");
+		ShouldBeConfiguredBySpring deserializedDomainObject =
+				serializeAndDeserialize(domainObject);
+		assertEquals("Dependency injected on deserialization","Rod",deserializedDomainObject.getName());
+	}
+
+	public void testInjectionOnDeserializationForClassesThatContainsPublicReadResolve() throws Exception {
+		ShouldBeConfiguredBySpringContainsPublicReadResolve domainObject = new ShouldBeConfiguredBySpringContainsPublicReadResolve();
+		domainObject.setName("Anonymous");
+		ShouldBeConfiguredBySpringContainsPublicReadResolve deserializedDomainObject =
+				serializeAndDeserialize(domainObject);
+		assertEquals("Dependency injected on deserialization","Rod",deserializedDomainObject.getName());
+		assertEquals("User readResolve should take precedence", 1, deserializedDomainObject.readResolveInvocationCount);
+	}
+
+	// See ShouldBeConfiguredBySpringContainsPrivateReadResolve
+//	public void testInjectionOnDeserializationForClassesThatContainsPrivateReadResolve() throws Exception {
+//		ShouldBeConfiguredBySpringContainsPrivateReadResolve domainObject = new ShouldBeConfiguredBySpringContainsPrivateReadResolve();
+//		domainObject.setName("Anonymous");
+//		ShouldBeConfiguredBySpringContainsPrivateReadResolve deserializedDomainObject =
+//				serializeAndDeserialize(domainObject);
+//		assertEquals("Dependency injected on deserialization","Rod",deserializedDomainObject.getName());
+//	}
+
+	public void testNonInjectionOnDeserializationForSerializedButNotConfigured() throws Exception {
+		SerializableThatShouldNotBeConfiguredBySpring domainObject = new SerializableThatShouldNotBeConfiguredBySpring();
+		domainObject.setName("Anonymous");
+		SerializableThatShouldNotBeConfiguredBySpring deserializedDomainObject =
+				serializeAndDeserialize(domainObject);
+		assertEquals("Dependency injected on deserialization","Anonymous",deserializedDomainObject.getName());
+	}
+
+	public void testSubBeanConfiguredOnlyOnce() throws Exception {
+		SubBean subBean = new SubBean();
+		assertEquals("Property injected more than once", 1, subBean.setterCount);
+	}
+
+	public void testSubBeanConfiguredOnlyOnceForPreConstruction() throws Exception {
+		SubBeanPreConstruction subBean = new SubBeanPreConstruction();
+		assertEquals("Property injected more than once", 1, subBean.setterCount);
+	}
+
+	public void testSubSerializableBeanConfiguredOnlyOnce() throws Exception {
+		SubSerializableBean subBean = new SubSerializableBean();
+		assertEquals("Property injected more than once", 1, subBean.setterCount);
+		subBean.setterCount = 0;
+
+		SubSerializableBean deserializedSubBean = serializeAndDeserialize(subBean);
+		assertEquals("Property injected more than once", 1, deserializedSubBean.setterCount);
+	}
+
+	public void testPreConstructionConfiguredBean() {
+		PreConstructionConfiguredBean bean = new PreConstructionConfiguredBean();
+		assertTrue("Injection didn't occur before construction", bean.preConstructionConfigured);
+	}
+
+	public void testPreConstructionConfiguredBeanDeserializationReinjection() throws Exception {
+		PreConstructionConfiguredBean bean = new PreConstructionConfiguredBean();
+		PreConstructionConfiguredBean deserialized = serializeAndDeserialize(bean);
+		assertEquals("Injection didn't occur upon deserialization", "ramnivas", deserialized.getName());
+	}
+
+	public void testPostConstructionConfiguredBean() {
+		PostConstructionConfiguredBean bean = new PostConstructionConfiguredBean();
+		assertFalse("Injection occurred before construction", bean.preConstructionConfigured);
+	}
+
+	public void testPostConstructionConfiguredBeanDeserializationReinjection() throws Exception {
+		PostConstructionConfiguredBean bean = new PostConstructionConfiguredBean();
+		PostConstructionConfiguredBean deserialized = serializeAndDeserialize(bean);
+		assertEquals("Injection didn't occur upon deserialization", "ramnivas", deserialized.getName());
+	}
+
+	public void testInterfaceDrivenDependencyInjection() {
+		MailClientDependencyInjectionAspect.aspectOf().setMailSender(new JavaMailSenderImpl());
+		Order testOrder = new Order();
+		assertNotNull("Interface driven injection didn't occur for direct construction", testOrder.mailSender);
+	}
+
+	public void testGenericInterfaceDrivenDependencyInjection() {
+		PricingStrategy injectedPricingStrategy = new PricingStrategy();
+		PricingStrategyDependencyInjectionAspect.aspectOf().setPricingStrategy(injectedPricingStrategy);
+		LineItem testLineItem = new LineItem();
+		assertSame("Generic interface driven injection didn't occur for direct construction", injectedPricingStrategy, testLineItem.pricingStrategy);
+	}
+
+	public void testInterfaceDrivenDependencyInjectionMultipleInterfaces() {
+		MailClientDependencyInjectionAspect.aspectOf().setMailSender(new JavaMailSenderImpl());
+		PaymentProcessorDependencyInjectionAspect.aspectOf().setPaymentProcessor(new PaymentProcessor());
+
+		ShoppingCart testCart = new ShoppingCart();
+
+		assertNotNull("Interface driven injection didn't occur for direct construction", testCart.mailSender);
+		assertNotNull("Interface driven injection didn't occur for direct construction", testCart.paymentProcessor);
+	}
+
+	public void testInterfaceDrivenDependencyInjectionUponDeserialization() throws Exception {
+		MailClientDependencyInjectionAspect.aspectOf().setMailSender(new JavaMailSenderImpl());
+		Order testOrder = new Order();
+		Order deserializedOrder = serializeAndDeserialize(testOrder);
+		assertNotNull("Interface driven injection didn't occur for deserialization", testOrder.mailSender);
+	}
+
+	public void testFieldAutoWiredAnnotationInjection() {
+		FieldAutoWiredServiceBean bean = new FieldAutoWiredServiceBean();
+		assertNotNull(bean.testService);
+	}
+
+	public void testMethodAutoWiredAnnotationInjection() {
+		MethodAutoWiredServiceBean bean = new MethodAutoWiredServiceBean();
+		assertNotNull(bean.testService);
+	}
+
+	public void testMultiArgumentMethodAutoWiredAnnotationInjection() {
+		MultiArgumentMethodAutoWiredServiceBean bean = new MultiArgumentMethodAutoWiredServiceBean();
+		assertNotNull(bean.testService);
+		assertNotNull(bean.paymentService);
+	}
+
+	public void testGenericParameterConfigurableBean() {
+		GenericParameterConfigurableBean bean = new GenericParameterConfigurableBean();
+		assertNotNull(bean.testService);
+	}
+
+	@SuppressWarnings("unchecked")
+	private <T> T serializeAndDeserialize(T serializable) throws Exception {
+		ByteArrayOutputStream baos = new ByteArrayOutputStream();
+		ObjectOutputStream oos = new ObjectOutputStream(baos);
+		oos.writeObject(serializable);
+		oos.close();
+		ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
+		ObjectInputStream ois = new ObjectInputStream(bais);
+		return (T)ois.readObject();
+	}
+
+
+	@Configurable("beanOne")
+	protected static class ShouldBeConfiguredBySpring implements Serializable {
+
+		private String name;
+
+		public void setName(String name) {
+			this.name = name;
+		}
+
+		public String getName() {
+			return this.name;
+		}
+	}
+
+
+	@Configurable("beanOne")
+	private static class ShouldBeConfiguredBySpringContainsPublicReadResolve implements Serializable {
+
+		private String name;
+
+		private int readResolveInvocationCount = 0;
+
+		public void setName(String name) {
+			this.name = name;
+		}
+
+		public String getName() {
+			return this.name;
+		}
+
+		public Object readResolve() throws ObjectStreamException {
+			readResolveInvocationCount++;
+			return this;
+		}
+	}
+
+// 	Won't work until we use hasmethod() experimental pointcut in AspectJ.
+//	@Configurable("beanOne")
+//	private static class ShouldBeConfiguredBySpringContainsPrivateReadResolve implements Serializable {
+//
+//		private String name;
+//
+//		public void setName(String name) {
+//			this.name = name;
+//		}
+//
+//		public String getName() {
+//			return this.name;
+//		}
+//
+//		private Object readResolve() throws ObjectStreamException {
+//			return this;
+//		}
+//	}
+
+
+	private static class ShouldNotBeConfiguredBySpring {
+
+		private String name;
+
+		public void setName(String name) {
+			this.name = name;
+		}
+
+		public String getName() {
+			return this.name;
+		}
+	}
+
+
+	private static class SerializableThatShouldNotBeConfiguredBySpring implements Serializable {
+
+		private String name;
+
+		public void setName(String name) {
+			this.name = name;
+		}
+
+		public String getName() {
+			return this.name;
+		}
+	}
+
+
+	@Configurable
+	private static class ShouldBeConfiguredBySpringUsingTypeNameAsBeanName {
+
+		private String name;
+
+		public void setName(String name) {
+			this.name = name;
+		}
+
+		public String getName() {
+			return this.name;
+		}
+	}
+
+
+	@Configurable(autowire=Autowire.BY_TYPE)
+	private static class ShouldBeConfiguredBySpringUsingAutowireByType {
+
+		private TestBean friend = null;
+
+		public TestBean getFriend() {
+			return friend;
+		}
+
+		public void setFriend(TestBean friend) {
+			this.friend = friend;
+		}
+	}
+
+
+	@Configurable(autowire=Autowire.BY_NAME)
+	private static class ValidAutowireByName {
+
+		private TestBean friend = null;
+
+		public TestBean getRamnivas() {
+			return friend;
+		}
+
+		public void setRamnivas(TestBean friend) {
+			this.friend = friend;
+		}
+	}
+
+
+	@Configurable(autowire=Autowire.BY_NAME, dependencyCheck=true)
+	private static class InvalidAutowireByName {
+
+		private TestBean friend;
+
+		public TestBean getFriend() {
+			return friend;
+		}
+
+		public void setFriend(TestBean friend) {
+			this.friend = friend;
+		}
+	}
+
+
+	private static class ArbitraryExistingPojo {
+
+		private TestBean friend;
+
+		public void setFriend(TestBean f) {
+			this.friend = f;
+		}
+	}
+
+
+	public static class CircularFactoryBean implements FactoryBean{
+
+		public CircularFactoryBean() {
+			ValidAutowireByName autowired = new ValidAutowireByName();
+			assertNull(autowired.getRamnivas());
+		}
+
+		public Object getObject() throws Exception {
+			return new TestBean();
+		}
+
+		public Class getObjectType() {
+			return TestBean.class;
+		}
+
+		public boolean isSingleton() {
+			return false;
+		}
+	}
+
+
+	@Configurable
+	private static class BaseBean {
+
+		public int setterCount;
+
+		private String name;
+
+		public void setName(String name) {
+			this.name = name;
+			setterCount++;
+		}
+	}
+
+
+	private static class SubBean extends BaseBean {
+	}
+
+	@Configurable(preConstruction=true)
+	private static class SubBeanPreConstruction extends BaseBean {
+	}
+
+	@Configurable
+	private static class BaseSerializableBean implements Serializable {
+
+		public int setterCount;
+
+		private String name;
+
+		public void setName(String name) {
+			this.name = name;
+			setterCount++;
+		}
+	}
+
+
+	private static class SubSerializableBean extends BaseSerializableBean {
+	}
+
+
+	@Aspect
+	private static class WireArbitraryExistingPojo extends AbstractBeanConfigurerAspect {
+
+		@Pointcut("initialization(ArbitraryExistingPojo.new(..)) && this(beanInstance)")
+		protected void beanCreation(Object beanInstance){
+
+		}
+	}
+
+
+	@Aspect
+	private static class AspectThatWillNotBeUsed extends AbstractBeanConfigurerAspect {
+
+		@Pointcut("initialization(ClassThatWillNotActuallyBeWired.new(..)) && this(beanInstance)")
+		protected void beanCreation(Object beanInstance){
+		}
+	}
+
+	private static aspect MailClientDependencyInjectionAspect extends AbstractInterfaceDrivenDependencyInjectionAspect {
+		private MailSender mailSender;
+
+		public pointcut inConfigurableBean() : within(MailSenderClient+);
+
+		public void configureBean(Object bean) {
+			((MailSenderClient)bean).setMailSender(this.mailSender);
+		}
+
+		declare parents: MailSenderClient implements ConfigurableObject;
+
+		public void setMailSender(MailSender mailSender) {
+			this.mailSender = mailSender;
+		}
+	}
+
+	private static aspect PaymentProcessorDependencyInjectionAspect extends AbstractInterfaceDrivenDependencyInjectionAspect {
+		private PaymentProcessor paymentProcessor;
+
+		public pointcut inConfigurableBean() : within(PaymentProcessorClient+);
+
+		public void configureBean(Object bean) {
+			((PaymentProcessorClient)bean).setPaymentProcessor(this.paymentProcessor);
+		}
+
+		declare parents: PaymentProcessorClient implements ConfigurableObject;
+
+		public void setPaymentProcessor(PaymentProcessor paymentProcessor) {
+			this.paymentProcessor = paymentProcessor;
+		}
+	}
+
+	private static aspect PricingStrategyDependencyInjectionAspect extends GenericInterfaceDrivenDependencyInjectionAspect<PricingStrategyClient> {
+		private PricingStrategy pricingStrategy;
+
+		public void configure(PricingStrategyClient bean) {
+			bean.setPricingStrategy(pricingStrategy);
+		}
+
+		public void setPricingStrategy(PricingStrategy pricingStrategy) {
+			this.pricingStrategy = pricingStrategy;
+		}
+	}
+
+	public static interface MailSenderClient {
+		public void setMailSender(MailSender mailSender);
+	}
+
+	public static interface PaymentProcessorClient {
+		public void setPaymentProcessor(PaymentProcessor paymentProcessor);
+	}
+
+	public static class PaymentProcessor {
+
+	}
+
+	public static interface PricingStrategyClient {
+		public void setPricingStrategy(PricingStrategy pricingStrategy);
+	}
+
+	public static class PricingStrategy {
+
+	}
+
+	public static class LineItem implements PricingStrategyClient {
+		private PricingStrategy pricingStrategy;
+
+		public void setPricingStrategy(PricingStrategy pricingStrategy) {
+			this.pricingStrategy = pricingStrategy;
+		}
+	}
+
+	public static class Order implements MailSenderClient, Serializable {
+		private transient MailSender mailSender;
+
+		public void setMailSender(MailSender mailSender) {
+			this.mailSender = mailSender;
+		}
+	}
+
+	public static class ShoppingCart implements MailSenderClient, PaymentProcessorClient {
+		private transient MailSender mailSender;
+		private transient PaymentProcessor paymentProcessor;
+
+		public void setMailSender(MailSender mailSender) {
+			this.mailSender = mailSender;
+		}
+
+		public void setPaymentProcessor(PaymentProcessor paymentProcessor) {
+			this.paymentProcessor = paymentProcessor;
+		}
+	}
+
+	private static class ClassThatWillNotActuallyBeWired {
+
+	}
+
+	@Configurable
+	private static class PreOrPostConstructionConfiguredBean implements Serializable {
+		private transient String name;
+		protected transient boolean preConstructionConfigured;
+		transient int count;
+
+		public PreOrPostConstructionConfiguredBean() {
+			preConstructionConfigured = (this.name != null);
+		}
+
+		public void setName(String name) {
+			this.name = name;
+		}
+
+		public String getName() {
+			return this.name;
+		}
+	}
+
+
+	@Configurable(preConstruction=true)
+	public static class PreConstructionConfiguredBean extends PreOrPostConstructionConfiguredBean {
+	}
+
+
+	@Configurable(preConstruction=false)
+	private static class PostConstructionConfiguredBean extends PreOrPostConstructionConfiguredBean {
+	}
+
+	@Configurable
+	public static class FieldAutoWiredServiceBean {
+		@Autowired transient private TestService testService;
+	}
+
+	@Configurable
+	public static class MethodAutoWiredServiceBean {
+		transient private TestService testService;
+
+		@Autowired
+		public void setTestService(TestService testService) {
+			this.testService = testService;
+		}
+	}
+
+	@Configurable
+	public static class MultiArgumentMethodAutoWiredServiceBean {
+		transient private TestService testService;
+		transient private PaymentService paymentService;
+
+		@Autowired
+		public void setDependencies(TestService testService, PaymentService paymentService) {
+			this.testService = testService;
+			this.paymentService = paymentService;
+		}
+	}
+
+	@Configurable
+	public static class GenericParameterConfigurableBean {
+		private TestService testService;
+
+		public void setTestService(TestService testService) {
+			this.testService = testService;
+		}
+	}
+
+	public static class TestService {
+
+	}
+
+	public static class PaymentService {
+
+	}
+
+}

spring-aspects/src/test/java/org/springframework/beans/factory/aspectj/AnnotationBeanConfigurerTests.java

@@ -0,0 +1,43 @@
+/*
+ * 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.context.ConfigurableApplicationContext;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.ImportResource;
+
+/**
+ * Tests that @EnableSpringConfigured properly registers an
+ * {@link AnnotationBeanConfigurerAspect}, just as does {@code <context:spring-configured>}
+ *
+ * @author Chris Beams
+ * @since 3.1
+ */
+public class AnnotationBeanConfigurerTests extends AbstractBeanConfigurerTests {
+
+	@Override
+	protected ConfigurableApplicationContext createContext() {
+		return new AnnotationConfigApplicationContext(Config.class);
+	}
+
+	@Configuration
+	@ImportResource("org/springframework/beans/factory/aspectj/beanConfigurerTests-beans.xml")
+	@EnableSpringConfigured
+	static class Config {
+	}
+}

spring-aspects/src/test/java/org/springframework/beans/factory/aspectj/SpringConfiguredWithAutoProxyingTests.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2002-2006 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.context.support.ClassPathXmlApplicationContext;
+
+import junit.framework.TestCase;
+
+public class SpringConfiguredWithAutoProxyingTests extends TestCase {
+
+	@Override
+	protected void setUp() throws Exception {
+		new ClassPathXmlApplicationContext("org/springframework/beans/factory/aspectj/springConfigured.xml");
+	}
+
+	public void testSpringConfiguredAndAutoProxyUsedTogether() {
+		; // set up is sufficient to trigger failure if this is going to fail...
+	}
+}

spring-aspects/src/test/java/org/springframework/beans/factory/aspectj/XmlBeanConfigurerTests.java

@@ -0,0 +1,38 @@
+/*
+ * 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.context.ConfigurableApplicationContext;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+
+/**
+ * @author Chris Beams
+ */
+public class XmlBeanConfigurerTests extends AbstractBeanConfigurerTests {
+
+	@Override
+	protected ConfigurableApplicationContext createContext() {
+		return new ClassPathXmlApplicationContext("org/springframework/beans/factory/aspectj/beanConfigurerTests.xml");
+	}
+
+	public void testInjectionAfterRefresh() {
+		context.refresh();
+		ShouldBeConfiguredBySpring myObject = new ShouldBeConfiguredBySpring();
+		assertEquals("Rod", myObject.getName());
+	}
+
+}

spring-aspects/src/test/java/org/springframework/beans/factory/aspectj/beanConfigurerTests-beans.xml

@@ -0,0 +1,64 @@
+<?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"
+		xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
+				http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
+
+	<bean class="org.springframework.beans.factory.aspectj.AbstractBeanConfigurerTests$WireArbitraryExistingPojo"
+			factory-method="aspectOf"/>
+
+	<bean id="beanOne" class="org.springframework.beans.factory.aspectj.AbstractBeanConfigurerTests$ShouldBeConfiguredBySpring"
+			lazy-init="true">
+		<property name="name" value="Rod"/>
+	</bean>
+
+	<bean class="org.springframework.beans.factory.aspectj.AbstractBeanConfigurerTests$ShouldBeConfiguredBySpringUsingTypeNameAsBeanName"
+			lazy-init="true">
+		<property name="name" value="Rob"/>
+	</bean>
+
+	<bean class="org.springframework.beans.factory.aspectj.AbstractBeanConfigurerTests$SubBean"
+			lazy-init="true">
+		<property name="name" value="Ramnivas"/>
+	</bean>
+
+	<bean class="org.springframework.beans.factory.aspectj.AbstractBeanConfigurerTests$SubBeanPreConstruction"
+			lazy-init="true">
+		<property name="name" value="Ramnivas"/>
+	</bean>
+
+	<bean class="org.springframework.beans.factory.aspectj.AbstractBeanConfigurerTests$SubSerializableBean"
+			lazy-init="true">
+		<property name="name" value="Ramnivas"/>
+	</bean>
+
+	<bean id="circular" class="org.springframework.beans.factory.aspectj.AbstractBeanConfigurerTests$CircularFactoryBean"
+			autowire-candidate="false"/>
+
+	<!-- Used as a target for autowiring by type -->
+	<bean id="ramnivas" class="org.springframework.beans.TestBean" depends-on="circular">
+		<property name="name" value="Ramnivas"/>
+		<property name="spouse" ref="circular"/>
+	</bean>
+
+	<bean class="org.springframework.beans.factory.aspectj.AbstractBeanConfigurerTests$ArbitraryExistingPojo">
+		<property name="friend" ref="ramnivas"/>
+	</bean>
+
+	<bean class="org.springframework.beans.factory.aspectj.AbstractBeanConfigurerTests$PreConstructionConfiguredBean">
+		<property name="name" value="ramnivas"/>
+	</bean>
+
+	<bean class="org.springframework.beans.factory.aspectj.AbstractBeanConfigurerTests$PostConstructionConfiguredBean">
+		<property name="name" value="ramnivas"/>
+	</bean>
+
+	<bean class="org.springframework.beans.factory.aspectj.AbstractBeanConfigurerTests$GenericParameterConfigurableBean" scope="prototype">
+		<property name="testService" ref="testService"/>
+	</bean>
+
+	<bean id="testService" class="org.springframework.beans.factory.aspectj.AbstractBeanConfigurerTests$TestService"/>
+	<bean id="paymentService" class="org.springframework.beans.factory.aspectj.AbstractBeanConfigurerTests$PaymentService"/>
+
+</beans>

spring-aspects/src/test/java/org/springframework/beans/factory/aspectj/beanConfigurerTests.xml

@@ -0,0 +1,14 @@
+<?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"
+		xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
+				http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
+
+	<context:spring-configured/>
+
+	<context:annotation-config/>
+
+	<import resource="beanConfigurerTests-beans.xml"/>
+
+</beans>

spring-aspects/src/test/java/org/springframework/beans/factory/aspectj/springConfigured.xml

@@ -0,0 +1,14 @@
+<?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:aop="http://www.springframework.org/schema/aop"
+		xmlns:context="http://www.springframework.org/schema/context"
+		xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
+				http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
+				http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
+
+	<context:spring-configured/>
+
+	<aop:aspectj-autoproxy/>
+
+</beans>

spring-aspects/src/test/java/org/springframework/cache/aspectj/AbstractAnnotationTest.java

@@ -0,0 +1,596 @@
+/*
+ * Copyright 2010-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 static org.junit.Assert.*;
+
+import java.util.Collection;
+import java.util.UUID;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.cache.Cache;
+import org.springframework.cache.CacheManager;
+import org.springframework.cache.config.AnnotatedClassCacheableService;
+import org.springframework.cache.config.CacheableService;
+import org.springframework.context.ApplicationContext;
+
+/**
+ * Abstract annotation test (containing several reusable methods).
+ *
+ * @author Costin Leau
+ * @author Chris Beams
+ */
+public abstract class AbstractAnnotationTest {
+
+	protected ApplicationContext ctx;
+
+	protected CacheableService<?> cs;
+
+	protected CacheableService<?> ccs;
+
+	protected CacheManager cm;
+
+	/** @return a refreshed application context */
+	protected abstract ApplicationContext getApplicationContext();
+
+	@Before
+	public void setup() {
+		ctx = getApplicationContext();
+		cs = ctx.getBean("service", CacheableService.class);
+		ccs = ctx.getBean("classService", CacheableService.class);
+		cm = ctx.getBean(CacheManager.class);
+		Collection<String> cn = cm.getCacheNames();
+		assertTrue(cn.contains("default"));
+	}
+
+	public void testCacheable(CacheableService<?> service) throws Exception {
+		Object o1 = new Object();
+
+		Object r1 = service.cache(o1);
+		Object r2 = service.cache(o1);
+		Object r3 = service.cache(o1);
+
+		assertSame(r1, r2);
+		assertSame(r1, r3);
+	}
+
+	public void testEvict(CacheableService<?> service) throws Exception {
+		Object o1 = new Object();
+
+		Object r1 = service.cache(o1);
+		Object r2 = service.cache(o1);
+
+		assertSame(r1, r2);
+		service.invalidate(o1);
+		Object r3 = service.cache(o1);
+		Object r4 = service.cache(o1);
+		assertNotSame(r1, r3);
+		assertSame(r3, r4);
+	}
+
+	public void testEvictEarly(CacheableService<?> service) throws Exception {
+		Object o1 = new Object();
+
+		Object r1 = service.cache(o1);
+		Object r2 = service.cache(o1);
+
+		assertSame(r1, r2);
+		try {
+			service.evictEarly(o1);
+		} catch (RuntimeException ex) {
+			// expected
+		}
+
+		Object r3 = service.cache(o1);
+		Object r4 = service.cache(o1);
+		assertNotSame(r1, r3);
+		assertSame(r3, r4);
+	}
+
+	public void testEvictException(CacheableService<?> service) throws Exception {
+		Object o1 = new Object();
+
+		Object r1 = service.cache(o1);
+		Object r2 = service.cache(o1);
+
+		assertSame(r1, r2);
+		try {
+			service.evictWithException(o1);
+		} catch (RuntimeException ex) {
+			// expected
+		}
+		// exception occurred, eviction skipped, data should still be in the cache
+		Object r3 = service.cache(o1);
+		assertSame(r1, r3);
+	}
+
+	public void testEvictWKey(CacheableService<?> service) throws Exception {
+		Object o1 = new Object();
+
+		Object r1 = service.cache(o1);
+		Object r2 = service.cache(o1);
+
+		assertSame(r1, r2);
+		service.evict(o1, null);
+		Object r3 = service.cache(o1);
+		Object r4 = service.cache(o1);
+		assertNotSame(r1, r3);
+		assertSame(r3, r4);
+	}
+
+	public void testEvictWKeyEarly(CacheableService<?> service) throws Exception {
+		Object o1 = new Object();
+
+		Object r1 = service.cache(o1);
+		Object r2 = service.cache(o1);
+
+		assertSame(r1, r2);
+
+		try {
+			service.invalidateEarly(o1, null);
+		} catch (Exception ex) {
+			// expected
+		}
+		Object r3 = service.cache(o1);
+		Object r4 = service.cache(o1);
+		assertNotSame(r1, r3);
+		assertSame(r3, r4);
+	}
+
+	public void testEvictAll(CacheableService<?> service) throws Exception {
+		Object o1 = new Object();
+
+		Object r1 = service.cache(o1);
+		Object r2 = service.cache(o1);
+
+		Object o2 = new Object();
+		Object r10 = service.cache(o2);
+
+		assertSame(r1, r2);
+		assertNotSame(r1, r10);
+		service.evictAll(new Object());
+		Cache cache = cm.getCache("default");
+		assertNull(cache.get(o1));
+		assertNull(cache.get(o2));
+
+		Object r3 = service.cache(o1);
+		Object r4 = service.cache(o1);
+		assertNotSame(r1, r3);
+		assertSame(r3, r4);
+	}
+
+	public void testConditionalExpression(CacheableService<?> service) throws Exception {
+		Object r1 = service.conditional(4);
+		Object r2 = service.conditional(4);
+
+		assertNotSame(r1, r2);
+
+		Object r3 = service.conditional(3);
+		Object r4 = service.conditional(3);
+
+		assertSame(r3, r4);
+	}
+
+	public void testKeyExpression(CacheableService<?> service) throws Exception {
+		Object r1 = service.key(5, 1);
+		Object r2 = service.key(5, 2);
+
+		assertSame(r1, r2);
+
+		Object r3 = service.key(1, 5);
+		Object r4 = service.key(2, 5);
+
+		assertNotSame(r3, r4);
+	}
+
+	public void testNullValue(CacheableService<?> service) throws Exception {
+		Object key = new Object();
+		assertNull(service.nullValue(key));
+		int nr = service.nullInvocations().intValue();
+		assertNull(service.nullValue(key));
+		assertEquals(nr, service.nullInvocations().intValue());
+		assertNull(service.nullValue(new Object()));
+		assertEquals(nr + 1, service.nullInvocations().intValue());
+	}
+
+	public void testMethodName(CacheableService<?> service, String keyName) throws Exception {
+		Object key = new Object();
+		Object r1 = service.name(key);
+		assertSame(r1, service.name(key));
+		Cache cache = cm.getCache("default");
+		// assert the method name is used
+		assertNotNull(cache.get(keyName));
+	}
+
+	public void testCheckedThrowable(CacheableService<?> service) throws Exception {
+		String arg = UUID.randomUUID().toString();
+		try {
+			service.throwChecked(arg);
+			fail("Excepted exception");
+		} catch (Exception ex) {
+			assertEquals(arg, ex.getMessage());
+		}
+	}
+
+	public void testUncheckedThrowable(CacheableService<?> service) throws Exception {
+		try {
+			service.throwUnchecked(Long.valueOf(1));
+			fail("Excepted exception");
+		} catch (RuntimeException ex) {
+			assertTrue("Excepted different exception type and got " + ex.getClass(),
+					ex instanceof UnsupportedOperationException);
+			// expected
+		}
+	}
+
+	public void testNullArg(CacheableService<?> service) {
+		Object r1 = service.cache(null);
+		assertSame(r1, service.cache(null));
+	}
+
+	public void testCacheUpdate(CacheableService<?> service) {
+		Object o = new Object();
+		Cache cache = cm.getCache("default");
+		assertNull(cache.get(o));
+		Object r1 = service.update(o);
+		assertSame(r1, cache.get(o).get());
+
+		o = new Object();
+		assertNull(cache.get(o));
+		Object r2 = service.update(o);
+		assertSame(r2, cache.get(o).get());
+	}
+
+	public void testConditionalCacheUpdate(CacheableService<?> service) {
+		Integer one = Integer.valueOf(1);
+		Integer three = Integer.valueOf(3);
+
+		Cache cache = cm.getCache("default");
+		assertEquals(one, Integer.valueOf(service.conditionalUpdate(one).toString()));
+		assertNull(cache.get(one));
+
+		assertEquals(three, Integer.valueOf(service.conditionalUpdate(three).toString()));
+		assertEquals(three, Integer.valueOf(cache.get(three).get().toString()));
+	}
+
+	public void testMultiCache(CacheableService<?> service) {
+		Object o1 = new Object();
+		Object o2 = new Object();
+
+		Cache primary = cm.getCache("primary");
+		Cache secondary = cm.getCache("secondary");
+
+		assertNull(primary.get(o1));
+		assertNull(secondary.get(o1));
+		Object r1 = service.multiCache(o1);
+		assertSame(r1, primary.get(o1).get());
+		assertSame(r1, secondary.get(o1).get());
+
+		Object r2 = service.multiCache(o1);
+		Object r3 = service.multiCache(o1);
+
+		assertSame(r1, r2);
+		assertSame(r1, r3);
+
+		assertNull(primary.get(o2));
+		assertNull(secondary.get(o2));
+		Object r4 = service.multiCache(o2);
+		assertSame(r4, primary.get(o2).get());
+		assertSame(r4, secondary.get(o2).get());
+	}
+
+	public void testMultiEvict(CacheableService<?> service) {
+		Object o1 = new Object();
+
+		Object r1 = service.multiCache(o1);
+		Object r2 = service.multiCache(o1);
+
+		Cache primary = cm.getCache("primary");
+		Cache secondary = cm.getCache("secondary");
+
+		assertSame(r1, r2);
+		assertSame(r1, primary.get(o1).get());
+		assertSame(r1, secondary.get(o1).get());
+
+		service.multiEvict(o1);
+		assertNull(primary.get(o1));
+		assertNull(secondary.get(o1));
+
+		Object r3 = service.multiCache(o1);
+		Object r4 = service.multiCache(o1);
+		assertNotSame(r1, r3);
+		assertSame(r3, r4);
+
+		assertSame(r3, primary.get(o1).get());
+		assertSame(r4, secondary.get(o1).get());
+	}
+
+	public void testMultiPut(CacheableService<?> service) {
+		Object o = Integer.valueOf(1);
+
+		Cache primary = cm.getCache("primary");
+		Cache secondary = cm.getCache("secondary");
+
+		assertNull(primary.get(o));
+		assertNull(secondary.get(o));
+		Object r1 = service.multiUpdate(o);
+		assertSame(r1, primary.get(o).get());
+		assertSame(r1, secondary.get(o).get());
+
+		o = Integer.valueOf(2);
+		assertNull(primary.get(o));
+		assertNull(secondary.get(o));
+		Object r2 = service.multiUpdate(o);
+		assertSame(r2, primary.get(o).get());
+		assertSame(r2, secondary.get(o).get());
+	}
+
+	public void testMultiCacheAndEvict(CacheableService<?> service) {
+		String methodName = "multiCacheAndEvict";
+
+		Cache primary = cm.getCache("primary");
+		Cache secondary = cm.getCache("secondary");
+		Object key = Integer.valueOf(1);
+
+		secondary.put(key, key);
+
+		assertNull(secondary.get(methodName));
+		assertSame(key, secondary.get(key).get());
+
+		Object r1 = service.multiCacheAndEvict(key);
+		assertSame(r1, service.multiCacheAndEvict(key));
+
+		// assert the method name is used
+		assertSame(r1, primary.get(methodName).get());
+		assertNull(secondary.get(methodName));
+		assertNull(secondary.get(key));
+	}
+
+	public void testMultiConditionalCacheAndEvict(CacheableService<?> service) {
+		Cache primary = cm.getCache("primary");
+		Cache secondary = cm.getCache("secondary");
+		Object key = Integer.valueOf(1);
+
+		secondary.put(key, key);
+
+		assertNull(primary.get(key));
+		assertSame(key, secondary.get(key).get());
+
+		Object r1 = service.multiConditionalCacheAndEvict(key);
+		Object r3 = service.multiConditionalCacheAndEvict(key);
+
+		assertTrue(!r1.equals(r3));
+		assertNull(primary.get(key));
+
+		Object key2 = Integer.valueOf(3);
+		Object r2 = service.multiConditionalCacheAndEvict(key2);
+		assertSame(r2, service.multiConditionalCacheAndEvict(key2));
+
+		// assert the method name is used
+		assertSame(r2, primary.get(key2).get());
+		assertNull(secondary.get(key2));
+	}
+
+	@Test
+	public void testCacheable() throws Exception {
+		testCacheable(cs);
+	}
+
+	@Test
+	public void testInvalidate() throws Exception {
+		testEvict(cs);
+	}
+
+	@Test
+	public void testEarlyInvalidate() throws Exception {
+		testEvictEarly(cs);
+	}
+
+	@Test
+	public void testEvictWithException() throws Exception {
+		testEvictException(cs);
+	}
+
+	@Test
+	public void testEvictAll() throws Exception {
+		testEvictAll(cs);
+	}
+
+	@Test
+	public void testInvalidateWithKey() throws Exception {
+		testEvictWKey(cs);
+	}
+
+	@Test
+	public void testEarlyInvalidateWithKey() throws Exception {
+		testEvictWKeyEarly(cs);
+	}
+
+	@Test
+	public void testConditionalExpression() throws Exception {
+		testConditionalExpression(cs);
+	}
+
+	@Test
+	public void testKeyExpression() throws Exception {
+		testKeyExpression(cs);
+	}
+
+	@Test
+	public void testClassCacheCacheable() throws Exception {
+		testCacheable(ccs);
+	}
+
+	@Test
+	public void testClassCacheInvalidate() throws Exception {
+		testEvict(ccs);
+	}
+
+	@Test
+	public void testClassEarlyInvalidate() throws Exception {
+		testEvictEarly(ccs);
+	}
+
+	@Test
+	public void testClassEvictAll() throws Exception {
+		testEvictAll(ccs);
+	}
+
+	@Test
+	public void testClassEvictWithException() throws Exception {
+		testEvictException(ccs);
+	}
+
+	@Test
+	public void testClassCacheInvalidateWKey() throws Exception {
+		testEvictWKey(ccs);
+	}
+
+	@Test
+	public void testClassEarlyInvalidateWithKey() throws Exception {
+		testEvictWKeyEarly(ccs);
+	}
+
+	@Test
+	public void testNullValue() throws Exception {
+		testNullValue(cs);
+	}
+
+	@Test
+	public void testClassNullValue() throws Exception {
+		Object key = new Object();
+		assertNull(ccs.nullValue(key));
+		int nr = ccs.nullInvocations().intValue();
+		assertNull(ccs.nullValue(key));
+		assertEquals(nr, ccs.nullInvocations().intValue());
+		assertNull(ccs.nullValue(new Object()));
+		// the check method is also cached
+		assertEquals(nr, ccs.nullInvocations().intValue());
+		assertEquals(nr + 1, AnnotatedClassCacheableService.nullInvocations.intValue());
+	}
+
+	@Test
+	public void testMethodName() throws Exception {
+		testMethodName(cs, "name");
+	}
+
+	@Test
+	public void testClassMethodName() throws Exception {
+		testMethodName(ccs, "namedefault");
+	}
+
+	@Test
+	public void testNullArg() throws Exception {
+		testNullArg(cs);
+	}
+
+	@Test
+	public void testClassNullArg() throws Exception {
+		testNullArg(ccs);
+	}
+
+	@Test
+	public void testCheckedException() throws Exception {
+		testCheckedThrowable(cs);
+	}
+
+	@Test
+	public void testClassCheckedException() throws Exception {
+		testCheckedThrowable(ccs);
+	}
+
+	@Test
+	public void testUncheckedException() throws Exception {
+		testUncheckedThrowable(cs);
+	}
+
+	@Test
+	public void testClassUncheckedException() throws Exception {
+		testUncheckedThrowable(ccs);
+	}
+
+	@Test
+	public void testUpdate() {
+		testCacheUpdate(cs);
+	}
+
+	@Test
+	public void testClassUpdate() {
+		testCacheUpdate(ccs);
+	}
+
+	@Test
+	public void testConditionalUpdate() {
+		testConditionalCacheUpdate(cs);
+	}
+
+	@Test
+	public void testClassConditionalUpdate() {
+		testConditionalCacheUpdate(ccs);
+	}
+
+	@Test
+	public void testMultiCache() {
+		testMultiCache(cs);
+	}
+
+	@Test
+	public void testClassMultiCache() {
+		testMultiCache(ccs);
+	}
+
+	@Test
+	public void testMultiEvict() {
+		testMultiEvict(cs);
+	}
+
+	@Test
+	public void testClassMultiEvict() {
+		testMultiEvict(ccs);
+	}
+
+	@Test
+	public void testMultiPut() {
+		testMultiPut(cs);
+	}
+
+	@Test
+	public void testClassMultiPut() {
+		testMultiPut(ccs);
+	}
+
+	@Test
+	public void testMultiCacheAndEvict() {
+		testMultiCacheAndEvict(cs);
+	}
+
+	@Test
+	public void testClassMultiCacheAndEvict() {
+		testMultiCacheAndEvict(ccs);
+	}
+
+	@Test
+	public void testMultiConditionalCacheAndEvict() {
+		testMultiConditionalCacheAndEvict(cs);
+	}
+
+	@Test
+	public void testClassMultiConditionalCacheAndEvict() {
+		testMultiConditionalCacheAndEvict(ccs);
+	}
+}

spring-aspects/src/test/java/org/springframework/cache/aspectj/AspectJAnnotationTest.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright 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.cache.aspectj;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.support.GenericXmlApplicationContext;
+
+
+/**
+ * @author Costin Leau
+ */
+public class AspectJAnnotationTest extends AbstractAnnotationTest {
+
+
+	@Override
+	protected ApplicationContext getApplicationContext() {
+		return new GenericXmlApplicationContext("/org/springframework/cache/config/annotation-cache-aspectj.xml");
+	}
+
+	@Test
+	public void testKeyStrategy() throws Exception {
+		AnnotationCacheAspect aspect = ctx.getBean("org.springframework.cache.config.internalCacheAspect", AnnotationCacheAspect.class);
+		Assert.assertSame(ctx.getBean("keyGenerator"), aspect.getKeyGenerator());
+	}
+}

spring-aspects/src/test/java/org/springframework/cache/config/AnnotatedClassCacheableService.java

@@ -0,0 +1,138 @@
+/*
+ * Copyright 2010-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.config;
+
+import java.util.concurrent.atomic.AtomicLong;
+
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.CachePut;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.cache.annotation.Caching;
+
+/**
+ * @author Costin Leau
+ */
+@Cacheable("default")
+public class AnnotatedClassCacheableService implements CacheableService<Object> {
+
+	private final AtomicLong counter = new AtomicLong();
+	public static final AtomicLong nullInvocations = new AtomicLong();
+
+	public Object cache(Object arg1) {
+		return counter.getAndIncrement();
+	}
+
+	public Object conditional(int field) {
+		return null;
+	}
+
+	@CacheEvict("default")
+	public void invalidate(Object arg1) {
+	}
+
+	@CacheEvict("default")
+	public void evictWithException(Object arg1) {
+		throw new RuntimeException("exception thrown - evict should NOT occur");
+	}
+
+	@CacheEvict(value = "default", allEntries = true)
+	public void evictAll(Object arg1) {
+	}
+
+	@CacheEvict(value = "default", beforeInvocation = true)
+	public void evictEarly(Object arg1) {
+		throw new RuntimeException("exception thrown - evict should still occur");
+	}
+
+	@CacheEvict(value = "default", key = "#p0")
+	public void evict(Object arg1, Object arg2) {
+	}
+
+	@CacheEvict(value = "default", key = "#p0", beforeInvocation = true)
+	public void invalidateEarly(Object arg1, Object arg2) {
+		throw new RuntimeException("exception thrown - evict should still occur");
+	}
+
+	@Cacheable(value = "default", key = "#p0")
+	public Object key(Object arg1, Object arg2) {
+		return counter.getAndIncrement();
+	}
+
+	@Cacheable(value = "default", key = "#root.methodName + #root.caches[0].name")
+	public Object name(Object arg1) {
+		return counter.getAndIncrement();
+	}
+
+	@Cacheable(value = "default", key = "#root.methodName + #root.method.name + #root.targetClass + #root.target")
+	public Object rootVars(Object arg1) {
+		return counter.getAndIncrement();
+	}
+
+	@CachePut("default")
+	public Object update(Object arg1) {
+		return counter.getAndIncrement();
+	}
+
+	@CachePut(value = "default", condition = "#arg.equals(3)")
+	public Object conditionalUpdate(Object arg) {
+		return arg;
+	}
+
+	public Object nullValue(Object arg1) {
+		nullInvocations.incrementAndGet();
+		return null;
+	}
+
+	public Number nullInvocations() {
+		return nullInvocations.get();
+	}
+
+	public Long throwChecked(Object arg1) throws Exception {
+		throw new UnsupportedOperationException(arg1.toString());
+	}
+
+	public Long throwUnchecked(Object arg1) {
+		throw new UnsupportedOperationException();
+	}
+
+	// multi annotations
+
+	@Caching(cacheable = { @Cacheable("primary"), @Cacheable("secondary") })
+	public Object multiCache(Object arg1) {
+		return counter.getAndIncrement();
+	}
+
+	@Caching(evict = { @CacheEvict("primary"), @CacheEvict(value = "secondary", key = "#p0") })
+	public Object multiEvict(Object arg1) {
+		return counter.getAndIncrement();
+	}
+
+	@Caching(cacheable = { @Cacheable(value = "primary", key = "#root.methodName") }, evict = { @CacheEvict("secondary") })
+	public Object multiCacheAndEvict(Object arg1) {
+		return counter.getAndIncrement();
+	}
+
+	@Caching(cacheable = { @Cacheable(value = "primary", condition = "#p0 == 3") }, evict = { @CacheEvict("secondary") })
+	public Object multiConditionalCacheAndEvict(Object arg1) {
+		return counter.getAndIncrement();
+	}
+
+	@Caching(put = { @CachePut("primary"), @CachePut("secondary") })
+	public Object multiUpdate(Object arg1) {
+		return arg1;
+	}
+}

spring-aspects/src/test/java/org/springframework/cache/config/CacheableService.java

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2010-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.config;
+
+/**
+ * Basic service interface.
+ * 
+ * @author Costin Leau
+ */
+public interface CacheableService<T> {
+
+	T cache(Object arg1);
+
+	void invalidate(Object arg1);
+
+	void evictEarly(Object arg1);
+
+	void evictAll(Object arg1);
+
+	void evictWithException(Object arg1);
+
+	void evict(Object arg1, Object arg2);
+
+	void invalidateEarly(Object arg1, Object arg2);
+
+	T conditional(int field);
+
+	T key(Object arg1, Object arg2);
+
+	T name(Object arg1);
+
+	T nullValue(Object arg1);
+
+	T update(Object arg1);
+
+	T conditionalUpdate(Object arg2);
+
+	Number nullInvocations();
+
+	T rootVars(Object arg1);
+
+	T throwChecked(Object arg1) throws Exception;
+
+	T throwUnchecked(Object arg1);
+
+	// multi annotations
+	T multiCache(Object arg1);
+
+	T multiEvict(Object arg1);
+
+	T multiCacheAndEvict(Object arg1);
+
+	T multiConditionalCacheAndEvict(Object arg1);
+
+	T multiUpdate(Object arg1);
+}

spring-aspects/src/test/java/org/springframework/cache/config/DefaultCacheableService.java

@@ -0,0 +1,144 @@
+/*
+ * Copyright 2010-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.config;
+
+import java.util.concurrent.atomic.AtomicLong;
+
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.CachePut;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.cache.annotation.Caching;
+
+/**
+ * Simple cacheable service
+ * 
+ * @author Costin Leau
+ */
+public class DefaultCacheableService implements CacheableService<Long> {
+
+	private final AtomicLong counter = new AtomicLong();
+	private final AtomicLong nullInvocations = new AtomicLong();
+
+	@Cacheable("default")
+	public Long cache(Object arg1) {
+		return counter.getAndIncrement();
+	}
+
+	@CacheEvict("default")
+	public void invalidate(Object arg1) {
+	}
+
+	@CacheEvict("default")
+	public void evictWithException(Object arg1) {
+		throw new RuntimeException("exception thrown - evict should NOT occur");
+	}
+
+	@CacheEvict(value = "default", allEntries = true)
+	public void evictAll(Object arg1) {
+	}
+
+	@CacheEvict(value = "default", beforeInvocation = true)
+	public void evictEarly(Object arg1) {
+		throw new RuntimeException("exception thrown - evict should still occur");
+	}
+
+	@CacheEvict(value = "default", key = "#p0")
+	public void evict(Object arg1, Object arg2) {
+	}
+
+	@CacheEvict(value = "default", key = "#p0", beforeInvocation = true)
+	public void invalidateEarly(Object arg1, Object arg2) {
+		throw new RuntimeException("exception thrown - evict should still occur");
+	}
+
+	@Cacheable(value = "default", condition = "#classField == 3")
+	public Long conditional(int classField) {
+		return counter.getAndIncrement();
+	}
+
+	@Cacheable(value = "default", key = "#p0")
+	public Long key(Object arg1, Object arg2) {
+		return counter.getAndIncrement();
+	}
+
+	@Cacheable(value = "default", key = "#root.methodName")
+	public Long name(Object arg1) {
+		return counter.getAndIncrement();
+	}
+
+	@Cacheable(value = "default", key = "#root.methodName + #root.method.name + #root.targetClass + #root.target")
+	public Long rootVars(Object arg1) {
+		return counter.getAndIncrement();
+	}
+
+	@CachePut("default")
+	public Long update(Object arg1) {
+		return counter.getAndIncrement();
+	}
+
+	@CachePut(value = "default", condition = "#arg.equals(3)")
+	public Long conditionalUpdate(Object arg) {
+		return Long.valueOf(arg.toString());
+	}
+
+	@Cacheable("default")
+	public Long nullValue(Object arg1) {
+		nullInvocations.incrementAndGet();
+		return null;
+	}
+
+	public Number nullInvocations() {
+		return nullInvocations.get();
+	}
+
+	@Cacheable("default")
+	public Long throwChecked(Object arg1) throws Exception {
+		throw new Exception(arg1.toString());
+	}
+
+	@Cacheable("default")
+	public Long throwUnchecked(Object arg1) {
+		throw new UnsupportedOperationException(arg1.toString());
+	}
+
+	// multi annotations
+
+	@Caching(cacheable = { @Cacheable("primary"), @Cacheable("secondary") })
+	public Long multiCache(Object arg1) {
+		return counter.getAndIncrement();
+	}
+
+	@Caching(evict = { @CacheEvict("primary"), @CacheEvict(value = "secondary", key = "#p0") })
+	public Long multiEvict(Object arg1) {
+		return counter.getAndIncrement();
+	}
+
+	@Caching(cacheable = { @Cacheable(value = "primary", key = "#root.methodName") }, evict = { @CacheEvict("secondary") })
+	public Long multiCacheAndEvict(Object arg1) {
+		return counter.getAndIncrement();
+	}
+
+	@Caching(cacheable = { @Cacheable(value = "primary", condition = "#p0 == 3") }, evict = { @CacheEvict("secondary") })
+	public Long multiConditionalCacheAndEvict(Object arg1) {
+		return counter.getAndIncrement();
+	}
+
+	@Caching(put = { @CachePut("primary"), @CachePut("secondary") })
+	public Long multiUpdate(Object arg1) {
+		return Long.valueOf(arg1.toString());
+	}
+}

spring-aspects/src/test/java/org/springframework/cache/config/SomeKeyGenerator.java

@@ -0,0 +1,23 @@
+/*
+ * 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.config;
+
+import org.springframework.cache.interceptor.DefaultKeyGenerator;
+
+public class SomeKeyGenerator extends DefaultKeyGenerator {
+
+}

spring-aspects/src/test/java/org/springframework/cache/config/annotation-cache-aspectj.xml

@@ -0,0 +1,45 @@
+<?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:aop="http://www.springframework.org/schema/aop"
+       xmlns:p="http://www.springframework.org/schema/p"
+       xmlns:cache="http://www.springframework.org/schema/cache"
+       xmlns:context="http://www.springframework.org/schema/context"
+       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
+       		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
+       		http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd
+       		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
+
+
+	<!--
+	<aop:config>
+		<aop:advisor advice-ref="debugInterceptor" pointcut="execution(* *..CacheableService.*(..))" order="1"/>
+	</aop:config>
+
+	<bean id="cacheAspect" class="org.springframework.cache.aspectj.AnnotationCacheAspect" factory-method="aspectOf">
+		<property name="cacheManager" ref="cacheManager"/>
+		<property name="cacheOperationSources" ref="annotationSource"/>
+	</bean>
+
+	<bean id="annotationSource" class="org.springframework.cache.annotation.AnnotationCacheOperationSource"/>
+	-->
+
+	<cache:annotation-driven mode="aspectj" key-generator="keyGenerator"/>
+
+	<bean id="keyGenerator" class="org.springframework.cache.config.SomeKeyGenerator" />
+
+	<bean id="cacheManager" class="org.springframework.cache.support.SimpleCacheManager">
+		<property name="caches">
+			<set>
+				<bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean" p:name="default"/>
+				<bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean" p:name="primary"/>
+				<bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean" p:name="secondary"/>
+			</set>
+		</property>
+	</bean>
+
+	<bean id="debugInterceptor" class="org.springframework.aop.interceptor.DebugInterceptor"/>
+
+	<bean id="service" class="org.springframework.cache.config.DefaultCacheableService"/>
+	<bean id="classService" class="org.springframework.cache.config.AnnotatedClassCacheableService"/>
+
+</beans>

spring-aspects/src/test/java/org/springframework/mock/staticmock/AnnotationDrivenStaticEntityMockingControlTest.java

@@ -0,0 +1,146 @@
+/*
+ * 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 javax.persistence.PersistenceException;
+
+import junit.framework.Assert;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import static org.springframework.mock.staticmock.AnnotationDrivenStaticEntityMockingControl.*;
+
+
+/**
+ * Test for static entity mocking framework.
+ * @author Rod Johnson
+ * @author Ramnivas Laddad
+ *
+ */
+@MockStaticEntityMethods
+@RunWith(JUnit4.class)
+public class AnnotationDrivenStaticEntityMockingControlTest {
+
+	@Test
+	public void testNoArgIntReturn() {
+		int expectedCount = 13;
+		Person.countPeople();
+		expectReturn(expectedCount);
+		playback();
+		Assert.assertEquals(expectedCount, Person.countPeople());
+	}
+	
+	@Test(expected=PersistenceException.class)
+	public void testNoArgThrows() {
+		Person.countPeople();
+		expectThrow(new PersistenceException());
+		playback();
+		Person.countPeople();
+	}
+
+	@Test
+	public void testArgMethodMatches() {
+		long id = 13;
+		Person found = new Person();
+		Person.findPerson(id);
+		expectReturn(found);
+		playback();
+		Assert.assertEquals(found, Person.findPerson(id));
+	}
+
+	
+	@Test
+	public void testLongSeriesOfCalls() {
+		long id1 = 13;
+		long id2 = 24;
+		Person found1 = new Person();
+		Person.findPerson(id1);
+		expectReturn(found1);
+		Person found2 = new Person();
+		Person.findPerson(id2);
+		expectReturn(found2);
+		Person.findPerson(id1);
+		expectReturn(found1);
+		Person.countPeople();
+		expectReturn(0);
+		playback();
+		
+		Assert.assertEquals(found1, Person.findPerson(id1));
+		Assert.assertEquals(found2, Person.findPerson(id2));
+		Assert.assertEquals(found1, Person.findPerson(id1));
+		Assert.assertEquals(0, Person.countPeople());
+	}
+
+	// Note delegation is used when tests are invalid and should fail, as otherwise
+	// the failure will occur on the verify() method in the aspect after
+	// this method returns, failing the test case
+	@Test
+	public void testArgMethodNoMatchExpectReturn() {
+		try {
+			new Delegate().testArgMethodNoMatchExpectReturn();
+			Assert.fail();
+		} catch (IllegalArgumentException expected) {
+		}
+	}
+
+	@Test(expected=IllegalArgumentException.class)
+	public void testArgMethodNoMatchExpectThrow() {
+		new Delegate().testArgMethodNoMatchExpectThrow();
+	}
+
+	private void called(Person found, long id) {
+		Assert.assertEquals(found, Person.findPerson(id));
+	}
+
+	@Test
+	public void testReentrant() {
+		long id = 13;
+		Person found = new Person();
+		Person.findPerson(id);
+		expectReturn(found);
+		playback();
+		called(found, id);
+	}
+
+	@Test(expected=IllegalStateException.class)
+	public void testRejectUnexpectedCall() {
+		new Delegate().rejectUnexpectedCall();
+	}
+	
+	@Test(expected=IllegalStateException.class)
+	public void testFailTooFewCalls() {
+		new Delegate().failTooFewCalls();
+	}
+	
+	@Test
+	public void testEmpty() {
+		// Test that verification check doesn't blow up if no replay() call happened
+	}
+	
+	@Test(expected=IllegalStateException.class)
+	public void testDoesntEverReplay() {
+		new Delegate().doesntEverReplay();
+	}
+	
+	@Test(expected=IllegalStateException.class)
+	public void testDoesntEverSetReturn() {
+		new Delegate().doesntEverSetReturn();
+	}
+}
+

spring-aspects/src/test/java/org/springframework/mock/staticmock/Delegate.java

@@ -0,0 +1,92 @@
+/*
+ * 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.rmi.RemoteException;
+
+import javax.persistence.PersistenceException;
+
+import junit.framework.Assert;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import org.springframework.mock.staticmock.AnnotationDrivenStaticEntityMockingControl;
+import org.springframework.mock.staticmock.MockStaticEntityMethods;
+
+//Used because verification failures occur after method returns,
+//so we can't test for them in the test case itself
+@MockStaticEntityMethods
+@Ignore // This isn't meant for direct testing; rather it is driven from AnnotationDrivenStaticEntityMockingControl
+public class Delegate {
+
+	@Test
+	public void testArgMethodNoMatchExpectReturn() {
+		long id = 13;
+		Person found = new Person();
+		Person.findPerson(id);
+		AnnotationDrivenStaticEntityMockingControl.expectReturn(found);
+		AnnotationDrivenStaticEntityMockingControl.playback();
+		Assert.assertEquals(found, Person.findPerson(id + 1));
+	}
+
+	@Test
+	public void testArgMethodNoMatchExpectThrow() {
+		long id = 13;
+		Person found = new Person();
+		Person.findPerson(id);
+		AnnotationDrivenStaticEntityMockingControl.expectThrow(new PersistenceException());
+		AnnotationDrivenStaticEntityMockingControl.playback();
+		Assert.assertEquals(found, Person.findPerson(id + 1));
+	}
+	
+	@Test
+	public void failTooFewCalls() {
+		long id = 13;
+		Person found = new Person();
+		Person.findPerson(id);
+		AnnotationDrivenStaticEntityMockingControl.expectReturn(found);
+		Person.countPeople();
+		AnnotationDrivenStaticEntityMockingControl.expectReturn(25);
+		AnnotationDrivenStaticEntityMockingControl.playback();
+		Assert.assertEquals(found, Person.findPerson(id));
+	}
+
+	@Test
+	public void doesntEverReplay() {
+		Person.countPeople();
+	}
+	
+	@Test
+	public void doesntEverSetReturn() {
+		Person.countPeople();
+		AnnotationDrivenStaticEntityMockingControl.playback();
+	}
+
+	@Test
+	public void rejectUnexpectedCall() {
+		AnnotationDrivenStaticEntityMockingControl.playback();
+		Person.countPeople();
+	}
+	
+	@Test(expected=RemoteException.class)
+	public void testVerificationFailsEvenWhenTestFailsInExpectedManner() throws RemoteException {
+		Person.countPeople();
+		AnnotationDrivenStaticEntityMockingControl.playback();
+		// No calls to allow verification failure
+		throw new RemoteException();
+	}
+}

spring-aspects/src/test/java/org/springframework/mock/staticmock/Person.java

@@ -0,0 +1,24 @@
+/*
+ * 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 javax.persistence.Entity;
+
+@Entity
+public class Person {
+}
+

spring-aspects/src/test/java/org/springframework/mock/staticmock/Person_Roo_Entity.aj

@@ -0,0 +1,100 @@
+/*
+ * 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;
+
+privileged aspect Person_Roo_Entity {
+    
+    @javax.persistence.PersistenceContext    
+    transient javax.persistence.EntityManager Person.entityManager;    
+    
+    @javax.persistence.Id    
+    @javax.persistence.GeneratedValue(strategy = javax.persistence.GenerationType.AUTO)    
+    @javax.persistence.Column(name = "id")    
+    private java.lang.Long Person.id;    
+    
+    @javax.persistence.Version    
+    @javax.persistence.Column(name = "version")    
+    private java.lang.Integer Person.version;    
+    
+    public java.lang.Long Person.getId() {    
+        return this.id;        
+    }    
+    
+    public void Person.setId(java.lang.Long id) {    
+        this.id = id;        
+    }    
+    
+    public java.lang.Integer Person.getVersion() {    
+        return this.version;        
+    }    
+    
+    public void Person.setVersion(java.lang.Integer version) {    
+        this.version = version;        
+    }    
+    
+    @org.springframework.transaction.annotation.Transactional    
+    public void Person.persist() {    
+        if (this.entityManager == null) throw new IllegalStateException("Entity manager has not been injected (is the Spring Aspects JAR configured as an AJC/AJDT aspects library?)");        
+        this.entityManager.persist(this);        
+    }    
+    
+    @org.springframework.transaction.annotation.Transactional    
+    public void Person.remove() {    
+        if (this.entityManager == null) throw new IllegalStateException("Entity manager has not been injected (is the Spring Aspects JAR configured as an AJC/AJDT aspects library?)");        
+        this.entityManager.remove(this);        
+    }    
+    
+    @org.springframework.transaction.annotation.Transactional    
+    public void Person.flush() {    
+        if (this.entityManager == null) throw new IllegalStateException("Entity manager has not been injected (is the Spring Aspects JAR configured as an AJC/AJDT aspects library?)");        
+        this.entityManager.flush();        
+    }    
+    
+    @org.springframework.transaction.annotation.Transactional    
+    public void Person.merge() {    
+        if (this.entityManager == null) throw new IllegalStateException("Entity manager has not been injected (is the Spring Aspects JAR configured as an AJC/AJDT aspects library?)");        
+        Person merged = this.entityManager.merge(this);        
+        this.entityManager.flush();        
+        this.id = merged.getId();        
+    }    
+    
+    public static long Person.countPeople() {    
+        javax.persistence.EntityManager em = new Person().entityManager;        
+        if (em == null) throw new IllegalStateException("Entity manager has not been injected (is the Spring Aspects JAR configured as an AJC/AJDT aspects library?)");        
+        return (Long) em.createQuery("select count(o) from Person o").getSingleResult();        
+    }    
+    
+    public static java.util.List<Person> Person.findAllPeople() {    
+        javax.persistence.EntityManager em = new Person().entityManager;        
+        if (em == null) throw new IllegalStateException("Entity manager has not been injected (is the Spring Aspects JAR configured as an AJC/AJDT aspects library?)");        
+        return em.createQuery("select o from Person o").getResultList();        
+    }    
+    
+    public static Person Person.findPerson(java.lang.Long id) {    
+        if (id == null) throw new IllegalArgumentException("An identifier is required to retrieve an instance of Person");        
+        javax.persistence.EntityManager em = new Person().entityManager;        
+        if (em == null) throw new IllegalStateException("Entity manager has not been injected (is the Spring Aspects JAR configured as an AJC/AJDT aspects library?)");        
+        return em.find(Person.class, id);        
+    }    
+    
+    public static java.util.List<Person> Person.findPersonEntries(int firstResult, int maxResults) {    
+        javax.persistence.EntityManager em = new Person().entityManager;        
+        if (em == null) throw new IllegalStateException("Entity manager has not been injected (is the Spring Aspects JAR configured as an AJC/AJDT aspects library?)");        
+        return em.createQuery("select o from Person o").setFirstResult(firstResult).setMaxResults(maxResults).getResultList();        
+    }    
+    
+}

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

@@ -0,0 +1,178 @@
+/*
+ * 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.ExecutionException;
+import java.util.concurrent.Future;
+
+import junit.framework.Assert;
+
+import static junit.framework.Assert.*;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.core.task.SimpleAsyncTaskExecutor;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.scheduling.annotation.AsyncResult;
+
+/**
+ * @author Ramnivas Laddad
+ */
+public class AnnotationAsyncExecutionAspectTests {
+
+	private static final long WAIT_TIME = 1000; //milli seconds
+
+	private CountingExecutor executor;
+	
+	@Before
+	public void setUp() {
+		executor = new CountingExecutor();
+		AnnotationAsyncExecutionAspect.aspectOf().setExecutor(executor);
+	}
+	
+	@Test
+	public void asyncMethodGetsRoutedAsynchronously() {
+		ClassWithoutAsyncAnnotation obj = new ClassWithoutAsyncAnnotation();
+		obj.incrementAsync();
+		executor.waitForCompletion();
+		assertEquals(1, obj.counter);
+		assertEquals(1, executor.submitStartCounter);
+		assertEquals(1, executor.submitCompleteCounter);
+	}
+	
+	@Test
+	public void asyncMethodReturningFutureGetsRoutedAsynchronouslyAndReturnsAFuture() throws InterruptedException, ExecutionException {
+		ClassWithoutAsyncAnnotation obj = new ClassWithoutAsyncAnnotation();
+		Future<Integer> future = obj.incrementReturningAFuture();
+		// No need to executor.waitForCompletion() as future.get() will have the same effect
+		assertEquals(5, future.get().intValue());
+		assertEquals(1, obj.counter);
+		assertEquals(1, executor.submitStartCounter);
+		assertEquals(1, executor.submitCompleteCounter);
+	}
+
+	@Test
+	public void syncMethodGetsRoutedSynchronously() {
+		ClassWithoutAsyncAnnotation obj = new ClassWithoutAsyncAnnotation();
+		obj.increment();
+		assertEquals(1, obj.counter);
+		assertEquals(0, executor.submitStartCounter);
+		assertEquals(0, executor.submitCompleteCounter);
+	}	
+	
+	@Test
+	public void voidMethodInAsyncClassGetsRoutedAsynchronously() {
+		ClassWithAsyncAnnotation obj = new ClassWithAsyncAnnotation();
+		obj.increment();
+		executor.waitForCompletion();
+		assertEquals(1, obj.counter);
+		assertEquals(1, executor.submitStartCounter);
+		assertEquals(1, executor.submitCompleteCounter);
+	}
+
+	@Test
+	public void methodReturningFutureInAsyncClassGetsRoutedAsynchronouslyAndReturnsAFuture() throws InterruptedException, ExecutionException {
+		ClassWithAsyncAnnotation obj = new ClassWithAsyncAnnotation();
+		Future<Integer> future = obj.incrementReturningAFuture();
+		assertEquals(5, future.get().intValue());
+		assertEquals(1, obj.counter);
+		assertEquals(1, executor.submitStartCounter);
+		assertEquals(1, executor.submitCompleteCounter);
+	}
+
+	@Test
+	public void methodReturningNonVoidNonFutureInAsyncClassGetsRoutedSynchronously() {
+		ClassWithAsyncAnnotation obj = new ClassWithAsyncAnnotation();
+		int returnValue = obj.return5();
+		assertEquals(5, returnValue);
+		assertEquals(0, executor.submitStartCounter);
+		assertEquals(0, executor.submitCompleteCounter);
+	}	
+
+	@SuppressWarnings("serial")
+	private static class CountingExecutor extends SimpleAsyncTaskExecutor {
+		int submitStartCounter;
+		int submitCompleteCounter;
+		
+		@Override
+		public <T> Future<T> submit(Callable<T> task) {
+			submitStartCounter++;
+			Future<T> future = super.submit(task);
+			submitCompleteCounter++;
+			synchronized (this) {
+				notifyAll();
+			}
+			return future;
+		}
+		
+		public synchronized void waitForCompletion() {
+			try {
+				wait(WAIT_TIME);
+			} catch (InterruptedException e) {
+				Assert.fail("Didn't finish the async job in " + WAIT_TIME + " milliseconds");
+			}
+		}
+	}
+	
+	static class ClassWithoutAsyncAnnotation {
+		int counter;
+		
+		@Async public void incrementAsync() {
+			counter++;
+		}
+		
+		public void increment() {
+			counter++;
+		}
+		
+		@Async public Future<Integer> incrementReturningAFuture() {
+			counter++;
+			return new AsyncResult<Integer>(5);
+		}
+		
+		// It should be an error to attach @Async to a method that returns a non-void
+		// or non-Future.
+		// 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 AnnotationAsyncExecutionAspect
+//		@Async public int getInt() {
+//			return 0;
+//		}
+	}
+	
+	@Async
+	static class ClassWithAsyncAnnotation {
+		int counter;
+		
+		public void increment() {
+			counter++;
+		}
+		
+		// Manually check that there is a warning from the 'declare warning' statement in AnnotationAsynchExecutionAspect
+		public int return5() {
+			return 5;
+		}
+
+		public Future<Integer> incrementReturningAFuture() {
+			counter++;
+			return new AsyncResult<Integer>(5);
+		}
+	}
+
+}

spring-aspects/src/test/java/org/springframework/transaction/CallCountingTransactionManager.java

@@ -0,0 +1,58 @@
+/*
+ * 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;
+
+import org.springframework.transaction.support.AbstractPlatformTransactionManager;
+import org.springframework.transaction.support.DefaultTransactionStatus;
+
+/**
+ * @author Rod Johnson
+ * @author Juergen Hoeller
+ */
+public class CallCountingTransactionManager extends AbstractPlatformTransactionManager {
+
+	public TransactionDefinition lastDefinition;
+	public int begun;
+	public int commits;
+	public int rollbacks;
+	public int inflight;
+
+	protected Object doGetTransaction() {
+		return new Object();
+	}
+
+	protected void doBegin(Object transaction, TransactionDefinition definition) {
+		this.lastDefinition = definition;
+		++begun;
+		++inflight;
+	}
+
+	protected void doCommit(DefaultTransactionStatus status) {
+		++commits;
+		--inflight;
+	}
+
+	protected void doRollback(DefaultTransactionStatus status) {
+		++rollbacks;
+		--inflight;
+	}
+	
+	public void clear() {
+		begun = commits = rollbacks = inflight = 0;
+	}
+
+}

spring-aspects/src/test/java/org/springframework/transaction/aspectj/ClassWithPrivateAnnotatedMember.java

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2002-2006 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.
+ *
+ * Created on 11 Sep 2006 by Adrian Colyer
+ */
+package org.springframework.transaction.aspectj;
+
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * @author Adrian Colyer
+ * @since 2.0
+ */
+public class ClassWithPrivateAnnotatedMember {
+
+	public void doSomething() {
+		doInTransaction();
+	}
+	
+	@Transactional
+	private void doInTransaction() {}
+}

spring-aspects/src/test/java/org/springframework/transaction/aspectj/ClassWithProtectedAnnotatedMember.java

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2002-2006 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.
+ *
+ * Created on 11 Sep 2006 by Adrian Colyer
+ */
+package org.springframework.transaction.aspectj;
+
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * @author Adrian Colyer
+ * @since 2.0
+ */
+public class ClassWithProtectedAnnotatedMember {
+
+	public void doSomething() {
+		doInTransaction();
+	}
+	
+	@Transactional
+	protected void doInTransaction() {}
+}

spring-aspects/src/test/java/org/springframework/transaction/aspectj/ITransactional.java

@@ -0,0 +1,10 @@
+package org.springframework.transaction.aspectj;
+
+import org.springframework.transaction.annotation.Transactional;
+
+@Transactional
+public interface ITransactional {
+	
+	Object echo(Throwable t) throws Throwable;
+
+}

spring-aspects/src/test/java/org/springframework/transaction/aspectj/MethodAnnotationOnClassWithNoInterface.java

@@ -0,0 +1,19 @@
+package org.springframework.transaction.aspectj;
+
+import org.springframework.transaction.annotation.Transactional;
+
+public class MethodAnnotationOnClassWithNoInterface {
+	
+	@Transactional(rollbackFor=InterruptedException.class)
+	public Object echo(Throwable t) throws Throwable {
+		if (t != null) {
+			throw t;
+		}
+		return t;
+	}
+	
+	public void noTransactionAttribute() {
+		
+	}
+
+}

spring-aspects/src/test/java/org/springframework/transaction/aspectj/TransactionAspectTests-context.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd">
+
+<beans>
+
+	<bean id="transactionManager" class="org.springframework.transaction.CallCountingTransactionManager"/>
+
+	<bean class="org.springframework.transaction.aspectj.AnnotationTransactionAspect" factory-method="aspectOf">
+		<property name="transactionManager" ref="transactionManager"/>
+	</bean>
+
+	<bean class="org.springframework.transaction.aspectj.TransactionalAnnotationOnlyOnClassWithNoInterface"/>
+
+	<bean class="org.springframework.transaction.aspectj.ClassWithProtectedAnnotatedMember"/>
+
+	<bean class="org.springframework.transaction.aspectj.ClassWithPrivateAnnotatedMember"/>
+
+</beans>

spring-aspects/src/test/java/org/springframework/transaction/aspectj/TransactionAspectTests.java

@@ -0,0 +1,261 @@
+/*
+ * 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 junit.framework.AssertionFailedError;
+
+import org.springframework.test.AbstractDependencyInjectionSpringContextTests;
+import org.springframework.transaction.CallCountingTransactionManager;
+import org.springframework.transaction.annotation.AnnotationTransactionAttributeSource;
+import org.springframework.transaction.interceptor.TransactionAspectSupport;
+import org.springframework.transaction.interceptor.TransactionAttribute;
+
+/**
+ * @author Rod Johnson
+ * @author Ramnivas Laddad
+ */
+public class TransactionAspectTests extends AbstractDependencyInjectionSpringContextTests {
+	
+	private TransactionAspectSupport transactionAspect;
+	
+	private CallCountingTransactionManager txManager;
+	
+	private TransactionalAnnotationOnlyOnClassWithNoInterface annotationOnlyOnClassWithNoInterface;
+	
+	private ClassWithProtectedAnnotatedMember beanWithAnnotatedProtectedMethod;
+
+	private ClassWithPrivateAnnotatedMember beanWithAnnotatedPrivateMethod;
+	
+	private MethodAnnotationOnClassWithNoInterface methodAnnotationOnly = new MethodAnnotationOnClassWithNoInterface();
+
+
+	public void setAnnotationOnlyOnClassWithNoInterface(
+			TransactionalAnnotationOnlyOnClassWithNoInterface annotationOnlyOnClassWithNoInterface) {
+		this.annotationOnlyOnClassWithNoInterface = annotationOnlyOnClassWithNoInterface;
+	}
+	
+	public void setClassWithAnnotatedProtectedMethod(ClassWithProtectedAnnotatedMember aBean) {
+		this.beanWithAnnotatedProtectedMethod = aBean;
+	}
+
+	public void setClassWithAnnotatedPrivateMethod(ClassWithPrivateAnnotatedMember aBean) {
+		this.beanWithAnnotatedPrivateMethod = aBean;
+	}
+
+	public void setTransactionAspect(TransactionAspectSupport transactionAspect) {
+		this.transactionAspect = transactionAspect;
+		this.txManager = (CallCountingTransactionManager) transactionAspect.getTransactionManager();
+	}
+
+	public TransactionAspectSupport getTransactionAspect() {
+		return this.transactionAspect;
+	}
+
+	@Override
+	protected String getConfigPath() {
+		return "TransactionAspectTests-context.xml";
+	}
+
+
+	public void testCommitOnAnnotatedClass() throws Throwable {
+		txManager.clear();
+		assertEquals(0, txManager.begun);
+		annotationOnlyOnClassWithNoInterface.echo(null);
+		assertEquals(1, txManager.commits);
+	}
+
+	public void testCommitOnAnnotatedProtectedMethod() throws Throwable {
+		txManager.clear();
+		assertEquals(0, txManager.begun);
+		beanWithAnnotatedProtectedMethod.doInTransaction();
+		assertEquals(1, txManager.commits);		
+	}
+
+	public void testCommitOnAnnotatedPrivateMethod() throws Throwable {
+		txManager.clear();
+		assertEquals(0, txManager.begun);
+		beanWithAnnotatedPrivateMethod.doSomething();
+		assertEquals(1, txManager.commits);		
+	}
+
+	public void testNoCommitOnNonAnnotatedNonPublicMethodInTransactionalType() throws Throwable {
+		txManager.clear();
+		assertEquals(0,txManager.begun);
+		annotationOnlyOnClassWithNoInterface.nonTransactionalMethod();
+		assertEquals(0,txManager.begun);
+	}
+	
+	public void testCommitOnAnnotatedMethod() throws Throwable {
+		txManager.clear();
+		assertEquals(0, txManager.begun);
+		methodAnnotationOnly.echo(null);
+		assertEquals(1, txManager.commits);
+	}
+	
+	
+	public static class NotTransactional {
+		public void noop() {
+		}
+	}
+	
+	public void testNotTransactional() throws Throwable {
+		txManager.clear();
+		assertEquals(0, txManager.begun);
+		new NotTransactional().noop();
+		assertEquals(0, txManager.begun);
+	}
+	
+	
+	public void testDefaultCommitOnAnnotatedClass() throws Throwable {
+		testRollback(new TransactionOperationCallback() {
+			public Object performTransactionalOperation() throws Throwable {
+				return annotationOnlyOnClassWithNoInterface.echo(new Exception());
+			}
+		}, false);
+	}
+	
+	public void testDefaultRollbackOnAnnotatedClass() throws Throwable {
+		testRollback(new TransactionOperationCallback() {
+			public Object performTransactionalOperation() throws Throwable {
+				return annotationOnlyOnClassWithNoInterface.echo(new RuntimeException());
+			}
+		}, true);
+	}
+	
+	
+	public static class SubclassOfClassWithTransactionalAnnotation extends TransactionalAnnotationOnlyOnClassWithNoInterface {
+	}
+	
+	public void testDefaultCommitOnSubclassOfAnnotatedClass() throws Throwable {
+		testRollback(new TransactionOperationCallback() {
+			public Object performTransactionalOperation() throws Throwable {
+				return new SubclassOfClassWithTransactionalAnnotation().echo(new Exception());
+			}
+		}, false);
+	}
+	
+	public static class SubclassOfClassWithTransactionalMethodAnnotation extends MethodAnnotationOnClassWithNoInterface {
+	}
+	
+	public void testDefaultCommitOnSubclassOfClassWithTransactionalMethodAnnotated() throws Throwable {
+		testRollback(new TransactionOperationCallback() {
+			public Object performTransactionalOperation() throws Throwable {
+				return new SubclassOfClassWithTransactionalMethodAnnotation().echo(new Exception());
+			}
+		}, false);
+	}
+	
+	public static class ImplementsAnnotatedInterface implements ITransactional {
+		public Object echo(Throwable t) throws Throwable {
+			if (t != null) {
+				throw t;
+			}
+			return t;
+		}
+	}
+	
+	public void testDefaultCommitOnImplementationOfAnnotatedInterface() throws Throwable {
+//		testRollback(new TransactionOperationCallback() {
+//			public Object performTransactionalOperation() throws Throwable {
+//				return new ImplementsAnnotatedInterface().echo(new Exception());
+//			}
+//		}, false);
+		
+		final Exception ex = new Exception();
+		testNotTransactional(new TransactionOperationCallback() {
+			public Object performTransactionalOperation() throws Throwable {
+				return new ImplementsAnnotatedInterface().echo(ex);
+			}
+		}, ex);
+	}
+	
+	/**
+	 * Note: resolution does not occur. Thus we can't make a class transactional if
+	 * it implements a transactionally annotated interface. This behaviour could only
+	 * be changed in AbstractFallbackTransactionAttributeSource in Spring proper.
+	 * @throws SecurityException
+	 * @throws NoSuchMethodException
+	 */
+	public void testDoesNotResolveTxAnnotationOnMethodFromClassImplementingAnnotatedInterface() throws SecurityException, NoSuchMethodException {
+		AnnotationTransactionAttributeSource atas = new AnnotationTransactionAttributeSource();
+		Method m = ImplementsAnnotatedInterface.class.getMethod("echo", Throwable.class);
+		TransactionAttribute ta = atas.getTransactionAttribute(m, ImplementsAnnotatedInterface.class);
+		assertNull(ta);
+	}
+	
+	
+	public void testDefaultRollbackOnImplementationOfAnnotatedInterface() throws Throwable {
+//		testRollback(new TransactionOperationCallback() {
+//			public Object performTransactionalOperation() throws Throwable {
+//				return new ImplementsAnnotatedInterface().echo(new RuntimeException());
+//			}
+//		}, true);
+		
+		final Exception rollbackProvokingException = new RuntimeException();
+		testNotTransactional(new TransactionOperationCallback() {
+			public Object performTransactionalOperation() throws Throwable {
+				return new ImplementsAnnotatedInterface().echo(rollbackProvokingException);
+			}
+		}, rollbackProvokingException);
+	}
+
+	
+	protected void testRollback(TransactionOperationCallback toc, boolean rollback) throws Throwable {
+		txManager.clear();
+		assertEquals(0, txManager.begun);
+		try {
+			toc.performTransactionalOperation();
+			assertEquals(1, txManager.commits);
+		}
+		catch (Throwable caught) {
+			if (caught instanceof AssertionFailedError) {
+				return;
+			}
+		}
+		
+		if (rollback) {
+			assertEquals(1, txManager.rollbacks);
+		}
+		assertEquals(1, txManager.begun);
+	}
+	
+	protected void testNotTransactional(TransactionOperationCallback toc, Throwable expected) throws Throwable {
+		txManager.clear();
+		assertEquals(0, txManager.begun);
+		try {
+			toc.performTransactionalOperation();
+		}
+		catch (Throwable t) {
+			if (expected == null) {
+				fail("Expected " + expected);
+			}
+			assertSame(expected, t);
+		}
+		finally {
+			assertEquals(0, txManager.begun);
+		}
+	}
+	
+
+	private interface TransactionOperationCallback {
+
+		Object performTransactionalOperation() throws Throwable;
+	}
+
+}

spring-aspects/src/test/java/org/springframework/transaction/aspectj/TransactionalAnnotationOnlyOnClassWithNoInterface.java

@@ -0,0 +1,20 @@
+package org.springframework.transaction.aspectj;
+
+import org.springframework.transaction.annotation.Transactional;
+
+@Transactional
+public class TransactionalAnnotationOnlyOnClassWithNoInterface {
+	
+	public Object echo(Throwable t) throws Throwable {
+		if (t != null) {
+			throw t;
+		}
+		return t;
+	}
+	
+	void nonTransactionalMethod() {
+		// no-op
+	}
+
+}
+

spring-aspects/src/test/resources/log4j.xml

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
+
+<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
+
+	<!-- Appenders -->
+	<appender name="console" class="org.apache.log4j.ConsoleAppender">
+		<param name="Target" value="System.out" />
+		<layout class="org.apache.log4j.PatternLayout">
+			<param name="ConversionPattern" value="%-5p: %c - %m%n" />
+		</layout>
+	</appender>
+
+	<logger name="org.springframework.beans">
+		<level value="warn" />
+	</logger>
+
+	<logger name="org.springframework.binding">
+		<level value="debug" />
+	</logger>
+
+	<!-- Root Logger -->
+	<root>
+		<priority value="warn" />
+		<appender-ref ref="console" />
+	</root>
+	
+</log4j:configuration>