Moved over initial version of aop bundle

org.springframework.aop/ivy.xml

@@ -21,7 +21,14 @@
 	<dependencies>
 		<!-- compile dependencies -->
 		<dependency org="org.apache.commons" name="com.springsource.org.apache.commons.logging" rev="1.1.1" conf="compile->runtime" />
-
+		<dependency org="org.springframework" name="org.springframework.core" rev="latest.integration" conf="compile->compile" />
+		<dependency org="org.springframework" name="org.springframework.beans" rev="latest.integration" conf="compile->compile" />
+		<dependency org="org.aopalliance" name="com.springsource.org.aopalliance" rev="1.0.0" conf="compile->compile" />
+		<!-- optional dependencies -->
+		<dependency org="org.apache.commons" name="com.springsource.org.apache.commons.pool" rev="1.4.0" conf="optional->compile" />
+		<dependency org="org.aspectj" name="com.springsource.org.aspectj.weaver" rev="1.6.2.RELEASE" conf="optional->compile" />
+		<dependency org="com.jamonapi" name="com.springsource.com.jamonapi" rev="2.4.0" conf="optional->compile" />
+		<dependency org="net.sourceforge.cglib" name="com.springsource.net.sf.cglib" rev="2.1.3" conf="optional->compile" />
 		<!-- test dependencies -->
 		<dependency org="org.apache.log4j" name="com.springsource.org.apache.log4j" rev="1.2.15" conf="test->runtime"/>
 		<dependency org="org.junit" name="com.springsource.org.junit" rev="4.4.0" conf="test->runtime" />

org.springframework.aop/pom.xml

@@ -6,11 +6,41 @@
 	<packaging>jar</packaging>
 	<name>Spring Core Abstractions and Utilities</name>
 	<version>3.0.0.M1</version>
+	<repositories>
+		<repository>
+			<id>com.springsource.repository.bundles.external</id>
+			<name>SpringSource Enterprise Bundle Repository - External Bundle Releases</name>
+			<url>http://repository.springsource.com/maven/bundles/external</url>
+		</repository>		
+	</repositories>
+	<build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>1.5</source>
+                    <target>1.5</target>
+                </configuration>
+            </plugin>
+		</plugins>
+	</build>
 	<dependencies>
 		<dependency>
 			<groupId>commons-logging</groupId>
 			<artifactId>commons-logging</artifactId>
 			<version>1.1.1</version>
 		</dependency>
+		<dependency>
+		    <groupId>org.aopalliance</groupId>
+		    <artifactId>com.springsource.org.aopalliance</artifactId>
+		    <version>1.0.0</version>
+		</dependency>		
+		<dependency>
+		    <groupId>org.apache.commons</groupId>
+		    <artifactId>com.springsource.org.apache.commons.pool</artifactId>
+		    <version>1.4.0</version>
+			<optional>true</optional>
+		</dependency>
 	</dependencies>
 </project>
\ No newline at end of file

org.springframework.aop/src/main/java/org/springframework/aop/Advisor.java

+/*
+ * 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;
+
+import org.aopalliance.aop.Advice;
+
+/** 
+ * Base interface holding AOP <b>advice</b> (action to take at a joinpoint)
+ * and a filter determining the applicability of the advice (such as 
+ * a pointcut). <i>This interface is not for use by Spring users, but to
+ * allow for commonality in support for different types of advice.</i>
+ *
+ * <p>Spring AOP is based around <b>around advice</b> delivered via method
+ * <b>interception</b>, compliant with the AOP Alliance interception API. 
+ * The Advisor interface allows support for different types of advice,
+ * such as <b>before</b> and <b>after</b> advice, which need not be
+ * implemented using interception.
+ *
+ * @author Rod Johnson
+ */
+public interface Advisor {
+
+	/**
+	 * Return the advice part of this aspect. An advice may be an
+	 * interceptor, a before advice, a throws advice, etc.
+	 * @return the advice that should apply if the pointcut matches
+	 * @see org.aopalliance.intercept.MethodInterceptor
+	 * @see BeforeAdvice
+	 * @see ThrowsAdvice
+	 * @see AfterReturningAdvice
+	 */
+	Advice getAdvice();
+
+	/**
+	 * Return whether this advice is associated with a particular instance
+	 * (for example, creating a mixin) or shared with all instances of
+	 * the advised class obtained from the same Spring bean factory.
+	 * <p><b>Note that this method is not currently used by the framework.</b>
+	 * Typical Advisor implementations always return <code>true</code>.
+	 * Use singleton/prototype bean definitions or appropriate programmatic
+	 * proxy creation to ensure that Advisors have the correct lifecycle model.
+	 * @return whether this advice is associated with a particular target instance
+	 */
+	boolean isPerInstance();
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/AfterAdvice.java

+/*
+ * 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;
+
+import org.aopalliance.aop.Advice;
+
+/**
+ * Common marker interface for after advice,
+ * such as {@link AfterReturningAdvice} and {@link ThrowsAdvice}.
+ *
+ * @author Juergen Hoeller
+ * @since 2.0.3
+ * @see BeforeAdvice
+ */
+public interface AfterAdvice extends Advice {
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/AfterReturningAdvice.java

+/*
+ * 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;
+
+import java.lang.reflect.Method;
+
+/**
+ * After returning advice is invoked only on normal method return, not if an
+ * exception is thrown. Such advice can see the return value, but cannot change it.
+ *
+ * @author Rod Johnson
+ * @see MethodBeforeAdvice
+ * @see ThrowsAdvice
+ */
+public interface AfterReturningAdvice extends AfterAdvice {
+
+	/**
+	 * Callback after a given method successfully returned.
+	 * @param returnValue the value returned by the method, if any
+	 * @param method method being invoked
+	 * @param args arguments to the method
+	 * @param target target of the method invocation. May be <code>null</code>.
+	 * @throws Throwable if this object wishes to abort the call.
+	 * Any exception thrown will be returned to the caller if it's
+	 * allowed by the method signature. Otherwise the exception
+	 * will be wrapped as a runtime exception.
+	 */
+	void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable;
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/AopInvocationException.java

+/*
+ * 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.aop;
+
+import org.springframework.core.NestedRuntimeException;
+
+/**
+ * Exception that gets thrown when an AOP invocation failed
+ * because of misconfiguration or unexpected runtime issues.
+ *
+ * @author Juergen Hoeller
+ * @since 2.0
+ */
+public class AopInvocationException extends NestedRuntimeException {
+
+	/**
+	 * Constructor for AopInvocationException.
+	 * @param msg the detail message
+	 */
+	public AopInvocationException(String msg) {
+		super(msg);
+	}
+
+	/**
+	 * Constructor for AopInvocationException.
+	 * @param msg the detail message
+	 * @param cause the root cause
+	 */
+	public AopInvocationException(String msg, Throwable cause) {
+		super(msg, cause);
+	}
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/BeforeAdvice.java

+/*
+ * 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;
+
+import org.aopalliance.aop.Advice;
+
+/**
+ * Common marker interface for before advice, such as {@link MethodBeforeAdvice}.
+ *
+ * <p>Spring supports only method before advice. Although this is unlikely to change,
+ * this API is designed to allow field advice in future if desired.
+ *
+ * @author Rod Johnson
+ * @see AfterAdvice
+ */
+public interface BeforeAdvice extends Advice {
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/ClassFilter.java

+/*
+ * 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;
+
+/**
+ * Filter that restricts matching of a pointcut or introduction to
+ * a given set of target classes.
+ *
+ * <p>Can be used as part of a {@link Pointcut} or for the entire
+ * targeting of an {@link IntroductionAdvisor}.
+ *
+ * @author Rod Johnson
+ * @see Pointcut
+ * @see MethodMatcher
+ */
+public interface ClassFilter {
+
+	/**
+	 * Should the pointcut apply to the given interface or target class?
+	 * @param clazz the candidate target class
+	 * @return whether the advice should apply to the given target class
+	 */
+	boolean matches(Class clazz);
+
+
+	/**
+	 * Canonical instance of a ClassFilter that matches all classes.
+	 */
+	ClassFilter TRUE = TrueClassFilter.INSTANCE;
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/DynamicIntroductionAdvice.java

+/*
+ * 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;
+
+import org.aopalliance.aop.Advice;
+
+/** 
+ * Subinterface of AOP Alliance Advice that allows additional interfaces
+ * to be implemented by an Advice, and available via a proxy using that
+ * interceptor. This is a fundamental AOP concept called <b>introduction</b>.
+ *
+ * <p>Introductions are often <b>mixins</b>, enabling the building of composite
+ * objects that can achieve many of the goals of multiple inheritance in Java.
+ *
+ * <p>Compared to {qlink IntroductionInfo}, this interface allows an advice to
+ * implement a range of interfaces that is not necessarily known in advance.
+ * Thus an {@link IntroductionAdvisor} can be used to specify which interfaces
+ * will be exposed in an advised object.
+ *
+ * @author Rod Johnson
+ * @since 1.1.1
+ * @see IntroductionInfo
+ * @see IntroductionAdvisor
+ */
+public interface DynamicIntroductionAdvice extends Advice {
+	
+	/**
+	 * Does this introduction advice implement the given interface?
+	 * @param intf the interface to check
+	 * @return whether the advice implements the specified interface
+	 */
+	boolean implementsInterface(Class intf);
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/IntroductionAdvisor.java

+/*
+ * 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;
+
+/**
+ * Superinterface for advisors that perform one or more AOP <b>introductions</b>.
+ *
+ * <p>This interface cannot be implemented directly; subinterfaces must
+ * provide the advice type implementing the introduction.
+ *
+ * <p>Introduction is the implementation of additional interfaces
+ * (not implemented by a target) via AOP advice.
+ *
+ * @author Rod Johnson
+ * @since 04.04.2003
+ * @see IntroductionInterceptor
+ */
+public interface IntroductionAdvisor extends Advisor, IntroductionInfo {
+	
+	/**
+	 * Return the filter determining which target classes this introduction
+	 * should apply to.
+	 * <p>This represents the class part of a pointcut. Note that method
+	 * matching doesn't make sense to introductions.
+	 * @return the class filter
+	 */
+	ClassFilter getClassFilter();
+	
+	/**
+	 * Can the advised interfaces be implemented by the introduction advice?
+	 * Invoked before adding an IntroductionAdvisor.
+	 * @throws IllegalArgumentException if the advised interfaces can't be
+	 * implemented by the introduction advice
+	 */
+	void validateInterfaces() throws IllegalArgumentException;
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/IntroductionAwareMethodMatcher.java

+/*
+ * 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;
+
+import java.lang.reflect.Method;
+
+/**
+ * A specialized type of MethodMatcher that takes into account introductions when
+ * matching methods. If there are no introductions on the target class, a method
+ * matcher may be able to optimize matching more effectively for example.
+ *
+ * @author Adrian Colyer
+ * @since 2.0
+ */
+public interface IntroductionAwareMethodMatcher extends MethodMatcher {
+
+	/**
+	 * Perform static checking whether the given method matches. This may be invoked
+	 * instead of the 2-arg {@link #matches(java.lang.reflect.Method, Class)} method
+	 * if the caller supports the extended IntroductionAwareMethodMatcher interface.
+	 * @param method the candidate method
+	 * @param targetClass the target class (may be <code>null</code>, in which case
+	 * the candidate class must be taken to be the method's declaring class)
+	 * @param hasIntroductions <code>true</code> if the object on whose behalf we are
+	 * asking is the subject on one or more introductions; <code>false</code> otherwise
+	 * @return whether or not this method matches statically
+	 */
+	boolean matches(Method method, Class targetClass, boolean hasIntroductions);
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/IntroductionInfo.java

+/*
+ * 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;
+
+/**
+ * Interface supplying the information necessary to describe an introduction.
+ *
+ * <p>{@link IntroductionAdvisor IntroductionAdvisors} must implement this
+ * interface. If an {@link org.aopalliance.aop.Advice} implements this,
+ * it may be used as an introduction without an {@link IntroductionAdvisor}.
+ * In this case, the advice is self-describing, providing not only the
+ * necessary behavior, but describing the interfaces it introduces.
+ *
+ * @author Rod Johnson
+ * @since 1.1.1
+ */
+public interface IntroductionInfo {
+	
+	/**
+	 * Return the additional interfaces introduced by this Advisor or Advice.
+	 * @return the introduced interfaces
+	 */
+	Class[] getInterfaces();
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/IntroductionInterceptor.java

+/*
+ * 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;
+
+import org.aopalliance.intercept.MethodInterceptor;
+
+/**
+ * Subinterface of AOP Alliance MethodInterceptor that allows additional interfaces
+ * to be implemented by the interceptor, and available via a proxy using that
+ * interceptor. This is a fundamental AOP concept called <b>introduction</b>.
+ *
+ * <p>Introductions are often <b>mixins</b>, enabling the building of composite
+ * objects that can achieve many of the goals of multiple inheritance in Java.
+ *
+ * @author Rod Johnson
+ * @see DynamicIntroductionAdvice
+ */
+public interface IntroductionInterceptor extends MethodInterceptor, DynamicIntroductionAdvice {
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/MethodBeforeAdvice.java

+/*
+ * 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.aop;
+
+import java.lang.reflect.Method;
+
+/**
+ * Advice invoked before a method is invoked. Such advices cannot
+ * prevent the method call proceeding, unless they throw a Throwable.
+ *
+ * @see AfterReturningAdvice
+ * @see ThrowsAdvice
+ *
+ * @author Rod Johnson
+ */
+public interface MethodBeforeAdvice extends BeforeAdvice {
+	
+	/**
+	 * Callback before a given method is invoked.
+	 * @param method method being invoked
+	 * @param args arguments to the method
+	 * @param target target of the method invocation. May be <code>null</code>.
+	 * @throws Throwable if this object wishes to abort the call.
+	 * Any exception thrown will be returned to the caller if it's
+	 * allowed by the method signature. Otherwise the exception
+	 * will be wrapped as a runtime exception.
+	 */
+	void before(Method method, Object[] args, Object target) throws Throwable;
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/MethodMatcher.java

+/*
+ * 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;
+
+import java.lang.reflect.Method;
+
+/**
+ * Part of a {@link Pointcut}: Checks whether the target method is eligible for advice.
+ *
+ * <p>A MethodMatcher may be evaluated <b>statically</b> or at <b>runtime</b> (dynamically).
+ * Static matching involves method and (possibly) method attributes. Dynamic matching
+ * also makes arguments for a particular call available, and any effects of running
+ * previous advice applying to the joinpoint.
+ *
+ * <p>If an implementation returns <code>false</code> from its {@link #isRuntime()}
+ * method, evaluation can be performed statically, and the result will be the same
+ * for all invocations of this method, whatever their arguments. This means that
+ * if the {@link #isRuntime()} method returns <code>false</code>, the 3-arg
+ * {@link #matches(java.lang.reflect.Method, Class, Object[])} method will never be invoked.
+ *
+ * <p>If an implementation returns <code>true</code> from its 2-arg
+ * {@link #matches(java.lang.reflect.Method, Class)} method and its {@link #isRuntime()} method
+ * returns <code>true</code>, the 3-arg {@link #matches(java.lang.reflect.Method, Class, Object[])}
+ * method will be invoked <i>immediately before each potential execution of the related advice</i>,
+ * to decide whether the advice should run. All previous advice, such as earlier interceptors
+ * in an interceptor chain, will have run, so any state changes they have produced in
+ * parameters or ThreadLocal state will be available at the time of evaluation.
+ *
+ * @author Rod Johnson
+ * @since 11.11.2003
+ * @see Pointcut
+ * @see ClassFilter
+ */
+public interface MethodMatcher {
+
+	/**
+	 * Perform static checking whether the given method matches. If this
+	 * returns <code>false</code> or if the {@link #isRuntime()} method
+	 * returns <code>false</code>, no runtime check (i.e. no.
+	 * {@link #matches(java.lang.reflect.Method, Class, Object[])} call) will be made.
+	 * @param method the candidate method
+	 * @param targetClass the target class (may be <code>null</code>, in which case
+	 * the candidate class must be taken to be the method's declaring class)
+	 * @return whether or not this method matches statically
+	 */
+	boolean matches(Method method, Class targetClass);
+
+	/**
+	 * Is this MethodMatcher dynamic, that is, must a final call be made on the
+	 * {@link #matches(java.lang.reflect.Method, Class, Object[])} method at
+	 * runtime even if the 2-arg matches method returns <code>true</code>?
+	 * <p>Can be invoked when an AOP proxy is created, and need not be invoked
+	 * again before each method invocation,
+	 * @return whether or not a runtime match via the 3-arg
+	 * {@link #matches(java.lang.reflect.Method, Class, Object[])} method
+	 * is required if static matching passed
+	 */
+	boolean isRuntime();
+
+	/**
+	 * Check whether there a runtime (dynamic) match for this method,
+	 * which must have matched statically.
+	 * <p>This method is invoked only if the 2-arg matches method returns
+	 * <code>true</code> for the given method and target class, and if the
+	 * {@link #isRuntime()} method returns <code>true</code>. Invoked
+	 * immediately before potential running of the advice, after any
+	 * advice earlier in the advice chain has run.
+	 * @param method the candidate method
+	 * @param targetClass the target class (may be <code>null</code>, in which case
+	 * the candidate class must be taken to be the method's declaring class)
+	 * @param args arguments to the method
+	 * @return whether there's a runtime match
+	 * @see MethodMatcher#matches(Method, Class)
+	 */
+	boolean matches(Method method, Class targetClass, Object[] args);
+
+
+	/**
+	 * Canonical instance that matches all methods.
+	 */
+	MethodMatcher TRUE = TrueMethodMatcher.INSTANCE;
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/Pointcut.java

+/*
+ * 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;
+
+/**
+ * Core Spring pointcut abstraction.
+ *
+ * <p>A pointcut is composed of a {@link ClassFilter} and a {@link MethodMatcher}.
+ * Both these basic terms and a Pointcut itself can be combined to build up combinations
+ * (e.g. through {@link org.springframework.aop.support.ComposablePointcut}).
+ *
+ * @author Rod Johnson
+ * @see ClassFilter
+ * @see MethodMatcher
+ * @see org.springframework.aop.support.Pointcuts
+ * @see org.springframework.aop.support.ClassFilters
+ * @see org.springframework.aop.support.MethodMatchers
+ */
+public interface Pointcut {
+
+	/**
+	 * Return the ClassFilter for this pointcut.
+	 * @return the ClassFilter (never <code>null</code>)
+	 */
+	ClassFilter getClassFilter();
+
+	/**
+	 * Return the MethodMatcher for this pointcut.
+	 * @return the MethodMatcher (never <code>null</code>)
+	 */
+	MethodMatcher getMethodMatcher();
+
+
+	/**
+	 * Canonical Pointcut instance that always matches.
+	 */
+	Pointcut TRUE = TruePointcut.INSTANCE;
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/PointcutAdvisor.java

+/*
+ * 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.aop;
+
+/**
+ * Superinterface for all Advisors that are driven by a pointcut.
+ * This covers nearly all advisors except introduction advisors,
+ * for which method-level matching doesn't apply.
+ *
+ * @author Rod Johnson
+ */
+public interface PointcutAdvisor extends Advisor {
+
+	/**
+	 * Get the Pointcut that drives this advisor.
+	 */
+	Pointcut getPointcut();
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/ProxyMethodInvocation.java

+/*
+ * 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;
+
+import org.aopalliance.intercept.MethodInvocation;
+
+/**
+ * Extension of the AOP Alliance {@link org.aopalliance.intercept.MethodInvocation}
+ * interface, allowing access to the proxy that the method invocation was made through.
+ *
+ * <p>Useful to be able to substitute return values with the proxy,
+ * if necessary, for example if the invocation target returned itself.
+ *
+ * @author Juergen Hoeller
+ * @author Adrian Colyer
+ * @since 1.1.3
+ * @see org.springframework.aop.framework.ReflectiveMethodInvocation
+ * @see org.springframework.aop.support.DelegatingIntroductionInterceptor
+ */
+public interface ProxyMethodInvocation extends MethodInvocation {
+
+	/**
+	 * Return the proxy that this method invocation was made through.
+	 * @return the original proxy object
+	 */
+	Object getProxy();
+
+	/**
+	 * Create a clone of this object. If cloning is done before <code>proceed()</code>
+	 * is invoked on this object, <code>proceed()</code> can be invoked once per clone
+	 * to invoke the joinpoint (and the rest of the advice chain) more than once.
+	 * @return an invocable clone of this invocation.
+	 * <code>proceed()</code> can be called once per clone.
+	 */
+	MethodInvocation invocableClone();
+
+	/**
+	 * Create a clone of this object. If cloning is done before <code>proceed()</code>
+	 * is invoked on this object, <code>proceed()</code> can be invoked once per clone
+	 * to invoke the joinpoint (and the rest of the advice chain) more than once.
+	 * @param arguments the arguments that the cloned invocation is supposed to use,
+	 * overriding the original arguments
+	 * @return an invocable clone of this invocation.
+	 * <code>proceed()</code> can be called once per clone.
+	 */
+	MethodInvocation invocableClone(Object[] arguments);
+
+	/**
+	 * Set the arguments to be used on subsequent invocations in the any advice
+	 * in this chain.
+	 * @param arguments the argument array
+	 */
+	void setArguments(Object[] arguments);
+
+	/**
+	 * Add the specified user attribute with the given value to this invocation.
+	 * <p>Such attributes are not used within the AOP framework itself. They are
+	 * just kept as part of the invocation object, for use in special interceptors.
+	 * @param key the name of the attribute
+	 * @param value the value of the attribute, or <code>null</code> to reset it
+	 */
+	void setUserAttribute(String key, Object value);
+
+	/**
+	 * Return the value of the specified user attribute.
+	 * @param key the name of the attribute
+	 * @return the value of the attribute, or <code>null</code> if not set
+	 * @see #setUserAttribute
+	 */
+	Object getUserAttribute(String key);
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/RawTargetAccess.java

+/*
+ * 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;
+
+/**
+ * Marker for AOP proxy interfaces (in particular: introduction interfaces)
+ * that explicitly intend to return the raw target object (which would normally
+ * get replaced with the proxy object when returned from a method invocation).
+ *
+ * <p>Note that this is a marker interface in the style of {@link java.io.Serializable},
+ * semantically applying to a declared interface rather than to the full class
+ * of a concrete object. In other words, this marker applies to a particular
+ * interface only (typically an introduction interface that does not serve
+ * as the primary interface of an AOP proxy), and hence does not affect
+ * other interfaces that a concrete AOP proxy may implement.
+ *
+ * @author Juergen Hoeller
+ * @since 2.0.5
+ * @see org.springframework.aop.scope.ScopedObject
+ */
+public interface RawTargetAccess {
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/SpringProxy.java

+/*
+ * 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;
+
+/**
+ * Marker interface implemented by all AOP proxies. Used to detect
+ * whether or not objects are Spring-generated proxies.
+ *
+ * @author Rob Harrop
+ * @since 2.0.1
+ * @see org.springframework.aop.support.AopUtils#isAopProxy(Object)
+ */
+public interface SpringProxy {
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/TargetClassAware.java

+/*
+ * 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;
+
+/**
+ * Minimal interface for exposing the target class behind a proxy.
+ *
+ * <p>Implemented by AOP proxy objects and proxy factories
+ * (via {@link org.springframework.aop.framework.Advised}}
+ * as well as by {@link TargetSource TargetSources}.
+ *
+ * @author Juergen Hoeller
+ * @since 2.0.3
+ * @see org.springframework.aop.support.AopUtils#getTargetClass(Object)
+ */
+public interface TargetClassAware {
+
+	/**
+	 * Return the target class behind the implementing object
+	 * (typically a proxy configuration or an actual proxy).
+	 * @return the target Class, or <code>null</code> if not known
+	 */
+	Class getTargetClass();
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/TargetSource.java

+/*<
+ * 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;
+
+/**
+ * A <code>TargetSource</code> is used to obtain the current "target" of
+ * an AOP invocation, which will be invoked via reflection if no around
+ * advice chooses to end the interceptor chain itself.
+ *
+ * <p>If a <code>TargetSource</code> is "static", it will always return
+ * the same target, allowing optimizations in the AOP framework. Dynamic
+ * target sources can support pooling, hot swapping, etc.
+ *
+ * <p>Application developers don't usually need to work with
+ * <code>TargetSources</code> directly: this is an AOP framework interface.
+ *
+ * @author Rod Johnson
+ */
+public interface TargetSource extends TargetClassAware {
+
+	/**
+	 * Return the type of targets returned by this {@link TargetSource}.
+	 * <p>Can return <code>null</code>, although certain usages of a
+	 * <code>TargetSource</code> might just work with a predetermined
+	 * target class.
+	 * @return the type of targets returned by this {@link TargetSource}
+	 */
+	Class getTargetClass();
+
+	/**
+	 * Will all calls to {@link #getTarget()} return the same object?
+	 * <p>In that case, there will be no need to invoke
+	 * {@link #releaseTarget(Object)}, and the AOP framework can cache
+	 * the return value of {@link #getTarget()}.
+	 * @return <code>true</code> if the target is immutable
+	 * @see #getTarget
+	 */
+	boolean isStatic();
+
+	/**
+	 * Return a target instance. Invoked immediately before the
+	 * AOP framework calls the "target" of an AOP method invocation.
+	 * @return the target object, which contains the joinpoint
+	 * @throws Exception if the target object can't be resolved
+	 */
+	Object getTarget() throws Exception;
+
+	/**
+	 * Release the given target object obtained from the
+	 * {@link #getTarget()} method.
+	 * @param target object obtained from a call to {@link #getTarget()}
+	 * @throws Exception if the object can't be released
+	 */
+	void releaseTarget(Object target) throws Exception;
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/ThrowsAdvice.java

+/*
+ * 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.aop;
+
+/**
+ * Tag interface for throws advice.
+ *
+ * <p>There are not any methods on this interface, as methods are invoked by
+ * reflection. Implementing classes must implement methods of the form:
+ *
+ * <pre class="code">void afterThrowing([Method, args, target], ThrowableSubclass);</pre>
+ *
+ * <p>Some examples of valid methods would be:
+ *
+ * <pre class="code">public void afterThrowing(Exception ex)</pre>
+ * <pre class="code">public void afterThrowing(RemoteException)</pre>
+ * <pre class="code">public void afterThrowing(Method method, Object[] args, Object target, Exception ex)</pre>
+ * <pre class="code">public void afterThrowing(Method method, Object[] args, Object target, ServletException ex)</pre>
+ *
+ * The first three arguments are optional, and only useful if we want further
+ * information about the joinpoint, as in AspectJ <b>after-throwing</b> advice.
+ *
+ * <p><b>Note:</b> If a throws-advice method throws an exception itself, it will
+ * override the original exception (i.e. change the exception thrown to the user).
+ * The overriding exception will typically be a RuntimeException; this is compatible
+ * with any method signature. However, if a throws-advice method throws a checked
+ * exception, it will have to match the declared exceptions of the target method
+ * and is hence to some degree coupled to specific target method signatures.
+ * <b>Do not throw an undeclared checked exception that is incompatible with
+ * the target method's signature!</b>
+ *
+ * @author Rod Johnson
+ * @author Juergen Hoeller
+ * @see AfterReturningAdvice
+ * @see MethodBeforeAdvice
+ */
+public interface ThrowsAdvice extends AfterAdvice {
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/TrueClassFilter.java

+/*
+ * 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.aop;
+
+import java.io.Serializable;
+
+/**
+ * Canonical ClassFilter instance that matches all classes.
+ *
+ * @author Rod Johnson
+ */
+class TrueClassFilter implements ClassFilter, Serializable {
+	
+	public static final TrueClassFilter INSTANCE = new TrueClassFilter();
+	
+	/**
+	 * Enforce Singleton pattern.
+	 */
+	private TrueClassFilter() {
+	}
+
+	public boolean matches(Class clazz) {
+		return true;
+	}
+	
+	/**
+	 * Required to support serialization. Replaces with canonical
+	 * instance on deserialization, protecting Singleton pattern.
+	 * Alternative to overriding <code>equals()</code>.
+	 */
+	private Object readResolve() {
+		return INSTANCE;
+	}
+
+	public String toString() {
+		return "ClassFilter.TRUE";
+	}
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/TrueMethodMatcher.java

+/*
+ * 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.aop;
+
+import java.io.Serializable;
+import java.lang.reflect.Method;
+
+/**
+ * Canonical MethodMatcher instance that matches all methods.
+ *
+ * @author Rod Johnson
+ */
+class TrueMethodMatcher implements MethodMatcher, Serializable {
+	
+	public static final TrueMethodMatcher INSTANCE = new TrueMethodMatcher();
+	
+	/**
+	 * Enforce Singleton pattern.
+	 */
+	private TrueMethodMatcher() {
+	}
+
+	public boolean isRuntime() {
+		return false;
+	}
+
+	public boolean matches(Method method, Class targetClass) {
+		return true;
+	}
+
+	public boolean matches(Method method, Class targetClass, Object[] args) {
+		// Should never be invoked as isRuntime returns false.
+		throw new UnsupportedOperationException();
+	}
+	
+	/**
+	 * Required to support serialization. Replaces with canonical
+	 * instance on deserialization, protecting Singleton pattern.
+	 * Alternative to overriding <code>equals()</code>.
+	 */
+	private Object readResolve() {
+		return INSTANCE;
+	}
+	
+	public String toString() {
+		return "MethodMatcher.TRUE";
+	}
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/TruePointcut.java

+/*
+ * 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.aop;
+
+import java.io.Serializable;
+
+/**
+ * Canonical Pointcut instance that always matches.
+ *
+ * @author Rod Johnson
+ */
+class TruePointcut implements Pointcut, Serializable {
+	
+	public static final TruePointcut INSTANCE = new TruePointcut();
+	
+	/**
+	 * Enforce Singleton pattern.
+	 */
+	private TruePointcut() {
+	}
+
+	public ClassFilter getClassFilter() {
+		return ClassFilter.TRUE;
+	}
+
+	public MethodMatcher getMethodMatcher() {
+		return MethodMatcher.TRUE;
+	}
+	
+	/**
+	 * Required to support serialization. Replaces with canonical
+	 * instance on deserialization, protecting Singleton pattern.
+	 * Alternative to overriding <code>equals()</code>.
+	 */
+	private Object readResolve() {
+		return INSTANCE;
+	}
+
+	public String toString() {
+		return "Pointcut.TRUE";
+	}
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/AspectInstanceFactory.java

+/*
+ * 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;
+
+import org.springframework.core.Ordered;
+
+/**
+ * Interface implemented to provide an instance of an AspectJ aspect.
+ * Decouples from Spring's bean factory.
+ *
+ * <p>Extends the {@link org.springframework.core.Ordered} interface
+ * to express an order value for the underlying aspect in a chain.
+ *
+ * @author Rod Johnson
+ * @author Juergen Hoeller
+ * @since 2.0
+ * @see org.springframework.beans.factory.BeanFactory#getBean
+ */
+public interface AspectInstanceFactory extends Ordered {
+
+	/**
+	 * Create an instance of this factory's aspect.
+	 * @return the aspect instance (never <code>null</code>)
+	 */
+	Object getAspectInstance();
+
+	/**
+	 * Expose the aspect class loader that this factory uses.
+	 * @return the aspect class loader (never <code>null</code>)
+	 */
+	ClassLoader getAspectClassLoader();
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/AspectJAfterAdvice.java

+/*
+ * 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;
+
+import java.lang.reflect.Method;
+
+import org.aopalliance.intercept.MethodInterceptor;
+import org.aopalliance.intercept.MethodInvocation;
+
+import org.springframework.aop.AfterAdvice;
+
+/**
+ * Spring AOP advice wrapping an AspectJ after advice method.
+ *
+ * @author Rod Johnson
+ * @since 2.0
+ */
+public class AspectJAfterAdvice extends AbstractAspectJAdvice implements MethodInterceptor, AfterAdvice {
+
+	public AspectJAfterAdvice(
+			Method aspectJBeforeAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aif) {
+
+		super(aspectJBeforeAdviceMethod, pointcut, aif);
+	}
+	
+	public Object invoke(MethodInvocation mi) throws Throwable {
+		try {
+			return mi.proceed();
+		}
+		finally {
+			invokeAdviceMethod(getJoinPointMatch(), null, null);
+		}
+	}
+
+	public boolean isBeforeAdvice() {
+		return false;
+	}
+
+	public boolean isAfterAdvice() {
+		return true;
+	}
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/AspectJAfterReturningAdvice.java

+/*
+ * 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;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+
+import org.springframework.aop.AfterAdvice;
+import org.springframework.aop.AfterReturningAdvice;
+import org.springframework.util.ClassUtils;
+import org.springframework.util.TypeUtils;
+
+/**
+ * Spring AOP advice wrapping an AspectJ after-returning advice method.
+ *
+ * @author Rod Johnson
+ * @author Juergen Hoeller
+ * @author Ramnivas Laddad
+ * @since 2.0
+ */
+public class AspectJAfterReturningAdvice extends AbstractAspectJAdvice implements AfterReturningAdvice, AfterAdvice {
+
+	public AspectJAfterReturningAdvice(
+			Method aspectJBeforeAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aif) {
+
+		super(aspectJBeforeAdviceMethod, pointcut, aif);
+	}
+
+	public boolean isBeforeAdvice() {
+		return false;
+	}
+
+	public boolean isAfterAdvice() {
+		return true;
+	}
+
+	public void setReturningName(String name) {
+		setReturningNameNoCheck(name);
+	}
+
+	public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
+		if (shouldInvokeOnReturnValueOf(method, returnValue)) {
+			invokeAdviceMethod(getJoinPointMatch(), returnValue, null);
+		}
+	}
+
+	/**
+	 * Following AspectJ semantics, if a returning clause was specified, then the
+	 * advice is only invoked if the returned value is an instance of the given
+	 * returning type and generic type parameters, if any, match the assignment
+	 * rules. If the returning type is Object, the advice is *always* invoked.
+	 * @param returnValue the return value of the target method
+	 * @return whether to invoke the advice method for the given return value
+	 */
+	private boolean shouldInvokeOnReturnValueOf(Method method, Object returnValue) {
+		Class type = getDiscoveredReturningType();
+		Object genericType = getDiscoveredReturningGenericType();
+		// If we aren't dealing with a raw type, check if  generic parameters are assignable.
+		return (ClassUtils.isAssignableValue(type, returnValue) &&
+				(genericType == null || genericType == type || GenericTypeMatcher.isAssignable(genericType, method)));
+	}
+
+
+	/**
+	 * Inner class to avoid a static JDK 1.5 dependency for generic type matching.
+	 */
+	private static class GenericTypeMatcher {
+
+		public static boolean isAssignable(Object genericType, Method method) {
+			return TypeUtils.isAssignable((Type) genericType, method.getGenericReturnType());
+		}
+	}
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/AspectJAfterThrowingAdvice.java

+/*
+ * 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;
+
+import java.lang.reflect.Method;
+
+import org.aopalliance.intercept.MethodInterceptor;
+import org.aopalliance.intercept.MethodInvocation;
+
+import org.springframework.aop.AfterAdvice;
+
+/**
+ * Spring AOP advice wrapping an AspectJ after-throwing advice method.
+ *
+ * @author Rod Johnson
+ * @since 2.0
+ */
+public class AspectJAfterThrowingAdvice extends AbstractAspectJAdvice implements MethodInterceptor, AfterAdvice {
+
+	public AspectJAfterThrowingAdvice(
+			Method aspectJBeforeAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aif) {
+
+		super(aspectJBeforeAdviceMethod, pointcut, aif);
+	}
+
+	public boolean isBeforeAdvice() {
+		return false;
+	}
+
+	public boolean isAfterAdvice() {
+		return true;
+	}
+
+	public void setThrowingName(String name) {
+		setThrowingNameNoCheck(name);
+	}
+
+	public Object invoke(MethodInvocation mi) throws Throwable {
+		try {
+			return mi.proceed();
+		}
+		catch (Throwable t) {
+			if (shouldInvokeOnThrowing(t)) {
+				invokeAdviceMethod(getJoinPointMatch(), null, t);
+			}
+			throw t;
+		}
+	}
+
+	/**
+	 * In AspectJ semantics, after throwing advice that specifies a throwing clause
+	 * is only invoked if the thrown exception is a subtype of the given throwing type.
+	 */
+	private boolean shouldInvokeOnThrowing(Throwable t) {
+		Class throwingType = getDiscoveredThrowingType();
+		return throwingType.isAssignableFrom(t.getClass());
+	}
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/AspectJAopUtils.java

+/*
+ * 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;
+
+import org.aopalliance.aop.Advice;
+
+import org.springframework.aop.Advisor;
+import org.springframework.aop.AfterAdvice;
+import org.springframework.aop.BeforeAdvice;
+
+/**
+ * Utility methods for dealing with AspectJ advisors.
+ *
+ * @author Adrian Colyer
+ * @author Juergen Hoeller
+ * @since 2.0
+ */
+public abstract class AspectJAopUtils {
+
+	/**
+	 * Return <code>true</code> if the advisor is a form of before advice.
+	 */
+	public static boolean isBeforeAdvice(Advisor anAdvisor) {
+		AspectJPrecedenceInformation precedenceInfo = getAspectJPrecedenceInformationFor(anAdvisor);
+		if (precedenceInfo != null) {
+			return precedenceInfo.isBeforeAdvice();
+		}
+		return (anAdvisor.getAdvice() instanceof BeforeAdvice);
+	}
+
+	/**
+	 * Return <code>true</code> if the advisor is a form of after advice.
+	 */
+	public static boolean isAfterAdvice(Advisor anAdvisor) {
+		AspectJPrecedenceInformation precedenceInfo = getAspectJPrecedenceInformationFor(anAdvisor);
+		if (precedenceInfo != null) {
+			return precedenceInfo.isAfterAdvice();
+		}
+		return (anAdvisor.getAdvice() instanceof AfterAdvice);
+	}
+
+	/**
+	 * Return the AspectJPrecedenceInformation provided by this advisor or its advice.
+	 * If neither the advisor nor the advice have precedence information, this method
+	 * will return <code>null</code>.
+	 */
+	public static AspectJPrecedenceInformation getAspectJPrecedenceInformationFor(Advisor anAdvisor) {
+		if (anAdvisor instanceof AspectJPrecedenceInformation) {
+			return (AspectJPrecedenceInformation) anAdvisor;
+		}
+		Advice advice = anAdvisor.getAdvice();
+		if (advice instanceof AspectJPrecedenceInformation) {
+			return (AspectJPrecedenceInformation) advice;
+		}
+		return null;
+	}
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/AspectJAroundAdvice.java

+/*
+ * 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;
+
+import java.lang.reflect.Method;
+
+import org.aopalliance.intercept.MethodInterceptor;
+import org.aopalliance.intercept.MethodInvocation;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.weaver.tools.JoinPointMatch;
+
+import org.springframework.aop.ProxyMethodInvocation;
+
+/**
+ * Spring AOP around advice (MethodInterceptor) that wraps
+ * an AspectJ advice method. Exposes ProceedingJoinPoint.
+ *
+ * @author Rod Johnson
+ * @author Juergen Hoeller
+ * @since 2.0
+ */
+public class AspectJAroundAdvice extends AbstractAspectJAdvice implements MethodInterceptor {
+
+	public AspectJAroundAdvice(
+			Method aspectJAroundAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aif) {
+
+		super(aspectJAroundAdviceMethod, pointcut, aif);
+	}
+
+	public boolean isBeforeAdvice() {
+		return false;
+	}
+
+	public boolean isAfterAdvice() {
+		return false;
+	}
+
+	protected boolean supportsProceedingJoinPoint() {
+		return true;
+	}
+
+
+	public Object invoke(MethodInvocation mi) throws Throwable {
+		if (!(mi instanceof ProxyMethodInvocation)) {
+			throw new IllegalStateException("MethodInvocation is not a Spring ProxyMethodInvocation: " + mi);
+		}
+		ProxyMethodInvocation pmi = (ProxyMethodInvocation) mi;
+		ProceedingJoinPoint pjp = lazyGetProceedingJoinPoint(pmi);
+		JoinPointMatch jpm = getJoinPointMatch(pmi);
+		return invokeAdviceMethod(pjp, jpm, null, null);
+	}
+
+	/**
+	 * Return the ProceedingJoinPoint for the current invocation,
+	 * instantiating it lazily if it hasn't been bound to the thread already.
+	 * @param rmi the current Spring AOP ReflectiveMethodInvocation,
+	 * which we'll use for attribute binding
+	 * @return the ProceedingJoinPoint to make available to advice methods
+	 */
+	protected ProceedingJoinPoint lazyGetProceedingJoinPoint(ProxyMethodInvocation rmi) {
+		return new MethodInvocationProceedingJoinPoint(rmi);
+	}
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/AspectJExpressionPointcut.java

+/*
+ * 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.aop.aspectj;
+
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import org.aopalliance.intercept.MethodInvocation;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.aspectj.weaver.BCException;
+import org.aspectj.weaver.patterns.NamePattern;
+import org.aspectj.weaver.reflect.ReflectionWorld;
+import org.aspectj.weaver.tools.ContextBasedMatcher;
+import org.aspectj.weaver.tools.FuzzyBoolean;
+import org.aspectj.weaver.tools.JoinPointMatch;
+import org.aspectj.weaver.tools.MatchingContext;
+import org.aspectj.weaver.tools.PointcutDesignatorHandler;
+import org.aspectj.weaver.tools.PointcutExpression;
+import org.aspectj.weaver.tools.PointcutParameter;
+import org.aspectj.weaver.tools.PointcutParser;
+import org.aspectj.weaver.tools.PointcutPrimitive;
+import org.aspectj.weaver.tools.ShadowMatch;
+
+import org.springframework.aop.ClassFilter;
+import org.springframework.aop.IntroductionAwareMethodMatcher;
+import org.springframework.aop.MethodMatcher;
+import org.springframework.aop.ProxyMethodInvocation;
+import org.springframework.aop.framework.autoproxy.ProxyCreationContext;
+import org.springframework.aop.interceptor.ExposeInvocationInterceptor;
+import org.springframework.aop.support.AbstractExpressionPointcut;
+import org.springframework.aop.support.AopUtils;
+import org.springframework.beans.factory.BeanFactory;
+import org.springframework.beans.factory.BeanFactoryAware;
+import org.springframework.beans.factory.BeanFactoryUtils;
+import org.springframework.beans.factory.FactoryBean;
+import org.springframework.util.ObjectUtils;
+import org.springframework.util.StringUtils;
+
+/**
+ * Spring {@link org.springframework.aop.Pointcut} implementation
+ * that uses the AspectJ weaver to evaluate a pointcut expression.
+ *
+ * <p>The pointcut expression value is an AspectJ expression. This can
+ * reference other pointcuts and use composition and other operations.
+ *
+ * <p>Naturally, as this is to be processed by Spring AOP's proxy-based model,
+ * only method execution pointcuts are supported.
+ *
+ * @author Rob Harrop
+ * @author Adrian Colyer
+ * @author Rod Johnson
+ * @author Juergen Hoeller
+ * @author Ramnivas Laddad
+ * @since 2.0
+ */
+public class AspectJExpressionPointcut extends AbstractExpressionPointcut
+		implements ClassFilter, IntroductionAwareMethodMatcher, BeanFactoryAware {
+
+	private static final Set DEFAULT_SUPPORTED_PRIMITIVES = new HashSet();
+
+	static {
+		DEFAULT_SUPPORTED_PRIMITIVES.add(PointcutPrimitive.EXECUTION);
+		DEFAULT_SUPPORTED_PRIMITIVES.add(PointcutPrimitive.ARGS);
+		DEFAULT_SUPPORTED_PRIMITIVES.add(PointcutPrimitive.REFERENCE);
+		DEFAULT_SUPPORTED_PRIMITIVES.add(PointcutPrimitive.THIS);
+		DEFAULT_SUPPORTED_PRIMITIVES.add(PointcutPrimitive.TARGET);
+		DEFAULT_SUPPORTED_PRIMITIVES.add(PointcutPrimitive.WITHIN);
+		DEFAULT_SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_ANNOTATION);
+		DEFAULT_SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_WITHIN);
+		DEFAULT_SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_ARGS);
+		DEFAULT_SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_TARGET);
+	}
+
+
+	private static final Log logger = LogFactory.getLog(AspectJExpressionPointcut.class);
+
+	private final Map shadowMapCache = new HashMap();
+
+	private PointcutParser pointcutParser;
+
+	private Class pointcutDeclarationScope;
+
+	private String[] pointcutParameterNames = new String[0];
+
+	private Class[] pointcutParameterTypes = new Class[0];
+
+	private BeanFactory beanFactory;
+
+	private PointcutExpression pointcutExpression;
+
+
+	/**
+	 * Create a new default AspectJExpressionPointcut.
+	 */
+	public AspectJExpressionPointcut() {
+		this(DEFAULT_SUPPORTED_PRIMITIVES);
+	}
+
+	/**
+	 * Create a new AspectJExpressionPointcut with the given supported primitives.
+	 * @param supportedPrimitives Set of {@link org.aspectj.weaver.tools.PointcutPrimitive}
+	 * instances
+	 */
+	public AspectJExpressionPointcut(Set supportedPrimitives) {
+		this.pointcutParser =
+				PointcutParser.getPointcutParserSupportingSpecifiedPrimitivesAndUsingContextClassloaderForResolution(
+						supportedPrimitives);
+		this.pointcutParser.registerPointcutDesignatorHandler(new BeanNamePointcutDesignatorHandler());
+	}
+
+	/**
+	 * Create a new AspectJExpressionPointcut with the given settings.
+	 * @param declarationScope the declaration scope for the pointcut
+	 * @param paramNames the parameter names for the pointcut
+	 * @param paramTypes the parameter types for the pointcut
+	 */
+	public AspectJExpressionPointcut(Class declarationScope, String[] paramNames, Class[] paramTypes) {
+		this(DEFAULT_SUPPORTED_PRIMITIVES);
+		this.pointcutDeclarationScope = declarationScope;
+		if (paramNames.length != paramTypes.length) {
+			throw new IllegalStateException(
+					"Number of pointcut parameter names must match number of pointcut parameter types");
+		}
+		this.pointcutParameterNames = paramNames;
+		this.pointcutParameterTypes = paramTypes;
+	}
+
+
+	/**
+	 * Set the declaration scope for the pointcut.
+	 */
+	public void setPointcutDeclarationScope(Class pointcutDeclarationScope) {
+		this.pointcutDeclarationScope = pointcutDeclarationScope;
+	}
+
+	/**
+	 * Set the parameter names for the pointcut.
+	 */
+	public void setParameterNames(String[] names) {
+		this.pointcutParameterNames = names;
+	}
+
+	/**
+	 * Set the parameter types for the pointcut.
+	 */
+	public void setParameterTypes(Class[] types) {
+		this.pointcutParameterTypes = types;
+	}
+
+	public void setBeanFactory(BeanFactory beanFactory) {
+		this.beanFactory = beanFactory;
+	}
+
+
+	public ClassFilter getClassFilter() {
+		checkReadyToMatch();
+		return this;
+	}
+
+	public MethodMatcher getMethodMatcher() {
+		checkReadyToMatch();
+		return this;
+	}
+
+
+	/**
+	 * Check whether this pointcut is ready to match,
+	 * lazily building the underlying AspectJ pointcut expression.
+	 */
+	private void checkReadyToMatch() {
+		if (getExpression() == null) {
+			throw new IllegalStateException("Must set property 'expression' before attempting to match");
+		}
+		if (this.pointcutExpression == null) {
+			this.pointcutExpression = buildPointcutExpression();
+		}
+	}
+
+	/**
+	 * Build the underlying AspectJ pointcut expression.
+	 */
+	private PointcutExpression buildPointcutExpression() {
+		PointcutParameter[] pointcutParameters = new PointcutParameter[this.pointcutParameterNames.length];
+		for (int i = 0; i < pointcutParameters.length; i++) {
+			pointcutParameters[i] = this.pointcutParser.createPointcutParameter(
+					this.pointcutParameterNames[i], this.pointcutParameterTypes[i]);
+		}
+		return this.pointcutParser.parsePointcutExpression(
+				replaceBooleanOperators(getExpression()), this.pointcutDeclarationScope, pointcutParameters);
+	}
+
+	/**
+	 * If a pointcut expression has been specified in XML, the user cannot
+	 * write <code>and</code> as "&&" (though &amp;&amp; will work).
+	 * We also allow <code>and</code> between two pointcut sub-expressions.
+	 * <p>This method converts back to <code>&&</code> for the AspectJ pointcut parser.
+	 */
+	private String replaceBooleanOperators(String pcExpr) {
+		pcExpr = StringUtils.replace(pcExpr," and "," && ");
+		pcExpr = StringUtils.replace(pcExpr, " or ", " || ");
+		pcExpr = StringUtils.replace(pcExpr, " not ", " ! ");
+		return pcExpr;
+	}
+
+	/**
+	 * Return the underlying AspectJ pointcut expression.
+	 */
+	public PointcutExpression getPointcutExpression() {
+		checkReadyToMatch();
+		return this.pointcutExpression;
+	}
+
+
+	public boolean matches(Class targetClass) {
+		checkReadyToMatch();
+		try {
+			return this.pointcutExpression.couldMatchJoinPointsInType(targetClass);
+		}
+		catch (BCException ex) {
+			logger.debug("PointcutExpression matching rejected target class", ex);
+			return false;
+		}
+	}
+
+	public boolean matches(Method method, Class targetClass, boolean beanHasIntroductions) {
+		checkReadyToMatch();
+		Method targetMethod = AopUtils.getMostSpecificMethod(method, targetClass);
+		ShadowMatch shadowMatch = null;
+		try {
+			shadowMatch = getShadowMatch(targetMethod, method);
+		}
+		catch (ReflectionWorld.ReflectionWorldException ex) {
+			// Could neither introspect the target class nor the proxy class ->
+			// let's simply consider this method as non-matching.
+			return false;
+		}
+
+		// Special handling for this, target, @this, @target, @annotation
+		// in Spring - we can optimize since we know we have exactly this class,
+		// and there will never be matching subclass at runtime.
+		if (shadowMatch.alwaysMatches()) {
+			return true;
+		}
+		else if (shadowMatch.neverMatches()) {
+			return false;
+		}
+		else {
+		  // the maybe case
+		  return (beanHasIntroductions || matchesIgnoringSubtypes(shadowMatch) || matchesTarget(shadowMatch, targetClass));
+		}
+	}
+
+	public boolean matches(Method method, Class targetClass) {
+		return matches(method, targetClass, false);
+	}
+
+	public boolean isRuntime() {
+		checkReadyToMatch();
+		return this.pointcutExpression.mayNeedDynamicTest();
+	}
+
+	public boolean matches(Method method, Class targetClass, Object[] args) {
+		checkReadyToMatch();
+		ShadowMatch shadowMatch = null;
+		ShadowMatch originalShadowMatch = null;
+		try {
+			shadowMatch = getShadowMatch(AopUtils.getMostSpecificMethod(method, targetClass), method);
+			originalShadowMatch = getShadowMatch(method, method);
+		}
+		catch (ReflectionWorld.ReflectionWorldException ex) {
+			// Could neither introspect the target class nor the proxy class ->
+			// let's simply consider this method as non-matching.
+			return false;
+		}
+
+		// Bind Spring AOP proxy to AspectJ "this" and Spring AOP target to AspectJ target,
+		// consistent with return of MethodInvocationProceedingJoinPoint
+		ProxyMethodInvocation pmi = null;
+		Object targetObject = null;
+		Object thisObject = null;
+		try {
+			MethodInvocation mi = ExposeInvocationInterceptor.currentInvocation();
+			targetObject = mi.getThis();
+			if (!(mi instanceof ProxyMethodInvocation)) {
+				throw new IllegalStateException("MethodInvocation is not a Spring ProxyMethodInvocation: " + mi);
+			}
+			pmi = (ProxyMethodInvocation) mi;
+			thisObject = pmi.getProxy();
+		}
+		catch (IllegalStateException ex) {
+			// No current invocation...
+			// TODO: Should we really proceed here?
+			logger.debug("Couldn't access current invocation - matching with limited context: " + ex);
+		}
+
+		JoinPointMatch joinPointMatch = shadowMatch.matchesJoinPoint(thisObject, targetObject, args);
+
+		/*
+		 * Do a final check to see if any this(TYPE) kind of residue match. For
+		 * this purpose, we use the original method's (proxy method's) shadow to
+		 * ensure that 'this' is correctly checked against. Without this check,
+		 * we get incorrect match on this(TYPE) where TYPE matches the target
+		 * type but not 'this' (as would be the case of JDK dynamic proxies).
+		 * <p>See SPR-2979 for the original bug.
+		 */
+		if (pmi != null) {  // there is a current invocation
+			RuntimeTestWalker originalMethodResidueTest = new RuntimeTestWalker(originalShadowMatch);
+			if (!originalMethodResidueTest.testThisInstanceOfResidue(thisObject.getClass())) {
+				return false;
+			}
+		}
+		if (joinPointMatch.matches() && pmi != null) {
+			bindParameters(pmi, joinPointMatch);
+		}
+		return joinPointMatch.matches();
+	}
+
+
+	protected String getCurrentProxiedBeanName() {
+		return ProxyCreationContext.getCurrentProxiedBeanName();
+	}
+
+
+	/**
+	 * A match test returned maybe - if there are any subtype sensitive variables
+	 * involved in the test (this, target, at_this, at_target, at_annotation) then
+	 * we say this is not a match as in Spring there will never be a different
+	 * runtime subtype.
+	 */
+	private boolean matchesIgnoringSubtypes(ShadowMatch shadowMatch) {
+		return !(new RuntimeTestWalker(shadowMatch).testsSubtypeSensitiveVars());
+	}
+
+	private boolean matchesTarget(ShadowMatch shadowMatch, Class targetClass) {
+		return new RuntimeTestWalker(shadowMatch).testTargetInstanceOfResidue(targetClass);
+	}
+
+	private void bindParameters(ProxyMethodInvocation invocation, JoinPointMatch jpm) {
+		// Note: Can't use JoinPointMatch.getClass().getName() as the key, since
+		// Spring AOP does all the matching at a join point, and then all the invocations
+		// under this scenario, if we just use JoinPointMatch as the key, then
+		// 'last man wins' which is not what we want at all.
+		// Using the expression is guaranteed to be safe, since 2 identical expressions
+		// are guaranteed to bind in exactly the same way.
+		invocation.setUserAttribute(getExpression(), jpm);
+	}
+
+	private ShadowMatch getShadowMatch(Method targetMethod, Method originalMethod) {
+		synchronized (this.shadowMapCache) {
+			ShadowMatch shadowMatch = (ShadowMatch) this.shadowMapCache.get(targetMethod);
+			if (shadowMatch == null) {
+				try {
+					shadowMatch = this.pointcutExpression.matchesMethodExecution(targetMethod);
+				}
+				catch (ReflectionWorld.ReflectionWorldException ex) {
+					// Failed to introspect target method, probably because it has been loaded
+					// in a special ClassLoader. Let's try the original method instead...
+					if (targetMethod == originalMethod) {
+						throw ex;
+					}
+					shadowMatch = this.pointcutExpression.matchesMethodExecution(originalMethod);
+				}
+				this.shadowMapCache.put(targetMethod, shadowMatch);
+			}
+			return shadowMatch;
+		}
+	}
+
+
+	public boolean equals(Object other) {
+		if (this == other) {
+			return true;
+		}
+		if (!(other instanceof AspectJExpressionPointcut)) {
+			return false;
+		}
+		AspectJExpressionPointcut otherPc = (AspectJExpressionPointcut) other;
+		return ObjectUtils.nullSafeEquals(this.getExpression(), otherPc.getExpression()) &&
+				ObjectUtils.nullSafeEquals(this.pointcutDeclarationScope, otherPc.pointcutDeclarationScope) &&
+				ObjectUtils.nullSafeEquals(this.pointcutParameterNames, otherPc.pointcutParameterNames) &&
+				ObjectUtils.nullSafeEquals(this.pointcutParameterTypes, otherPc.pointcutParameterTypes);
+	}
+
+	public int hashCode() {
+		int hashCode = ObjectUtils.nullSafeHashCode(this.getExpression());
+		hashCode = 31 * hashCode + ObjectUtils.nullSafeHashCode(this.pointcutDeclarationScope);
+		hashCode = 31 * hashCode + ObjectUtils.nullSafeHashCode(this.pointcutParameterNames);
+		hashCode = 31 * hashCode + ObjectUtils.nullSafeHashCode(this.pointcutParameterTypes);
+		return hashCode;
+	}
+
+	public String toString() {
+		StringBuffer sb = new StringBuffer();
+		sb.append("AspectJExpressionPointcut: ");
+		if (this.pointcutParameterNames != null && this.pointcutParameterTypes != null) {
+			sb.append("(");
+			for (int i = 0; i < this.pointcutParameterTypes.length; i++) {
+				sb.append(this.pointcutParameterTypes[i].getName());
+				sb.append(" ");
+				sb.append(this.pointcutParameterNames[i]);
+				if ((i+1) < this.pointcutParameterTypes.length) {
+					sb.append(", ");
+				}
+			}
+			sb.append(")");
+		}
+		sb.append(" ");
+		if (getExpression() != null) {
+			sb.append(getExpression());
+		}
+		else {
+			sb.append("<pointcut expression not set>");
+		}
+		return sb.toString();
+	}
+
+
+	/**
+	 * Handler for the Spring-specific <code>bean()</code> pointcut designator
+	 * extension to AspectJ.
+	 * <p>This handler must be added to each pointcut object that needs to
+	 * handle the <code>bean()</code> PCD. Matching context is obtained
+	 * automatically by examining a thread local variable and therefore a matching
+	 * context need not be set on the pointcut.
+	 */
+	private class BeanNamePointcutDesignatorHandler implements PointcutDesignatorHandler {
+
+		private static final String BEAN_DESIGNATOR_NAME = "bean";
+
+		public String getDesignatorName() {
+			return BEAN_DESIGNATOR_NAME;
+		}
+
+		public ContextBasedMatcher parse(String expression) {
+			return new BeanNameContextMatcher(expression);
+		}
+	}
+
+
+	/**
+	 * Matcher class for the BeanNamePointcutDesignatorHandler.
+	 *
+	 * <p>Dynamic match tests for this matcher always return true,
+	 * since the matching decision is made at the proxy creation time.
+	 * For static match tests, this matcher abstains to allow the overall
+	 * pointcut to match even when negation is used with the bean() poitncut.
+	 */
+	private class BeanNameContextMatcher implements ContextBasedMatcher {
+
+		private final NamePattern expressionPattern;
+
+		public BeanNameContextMatcher(String expression) {
+			this.expressionPattern = new NamePattern(expression);
+		}
+
+		public boolean couldMatchJoinPointsInType(Class someClass) {
+			return (contextMatch(someClass) == FuzzyBoolean.YES);
+		}
+
+		public boolean couldMatchJoinPointsInType(Class someClass, MatchingContext context) {
+			return (contextMatch(someClass) == FuzzyBoolean.YES);
+		}
+
+		public boolean matchesDynamically(MatchingContext context) {
+			return true;
+		}
+
+		public FuzzyBoolean matchesStatically(MatchingContext context) {
+			return contextMatch(null);
+		}
+
+		public boolean mayNeedDynamicTest() {
+			return false;
+		}
+
+		private FuzzyBoolean contextMatch(Class targetType) {
+			String advisedBeanName = getCurrentProxiedBeanName();
+			if (advisedBeanName == null) {  // no proxy creation in progress
+				// abstain; can't return YES, since that will make pointcut with negation fail
+				return FuzzyBoolean.MAYBE; 
+			}
+			if (BeanFactoryUtils.isGeneratedBeanName(advisedBeanName)) {
+				return FuzzyBoolean.NO;
+			}
+			if (targetType != null) {
+				boolean isFactory = FactoryBean.class.isAssignableFrom(targetType);
+				return FuzzyBoolean.fromBoolean(
+						matchesBeanName(isFactory ? BeanFactory.FACTORY_BEAN_PREFIX + advisedBeanName : advisedBeanName));
+			}
+			else {
+				return FuzzyBoolean.fromBoolean(matchesBeanName(advisedBeanName) ||
+						matchesBeanName(BeanFactory.FACTORY_BEAN_PREFIX + advisedBeanName));
+			}
+		}
+
+		private boolean matchesBeanName(String advisedBeanName) {
+			if (this.expressionPattern.matches(advisedBeanName)) {
+				return true;
+			}
+			if (beanFactory != null) {
+				String[] aliases = beanFactory.getAliases(advisedBeanName);
+				for (int i = 0; i < aliases.length; i++) {
+					if (this.expressionPattern.matches(aliases[i])) {
+						return true;
+					}
+				}
+			}
+			return false;
+		}
+	}
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/AspectJExpressionPointcutAdvisor.java

+/*
+ * 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.aop.aspectj;
+
+import org.springframework.aop.Pointcut;
+import org.springframework.aop.support.AbstractGenericPointcutAdvisor;
+
+/**
+ * Spring AOP Advisor that can be used for any AspectJ pointcut expression.
+ * 
+ * @author Rob Harrop
+ * @since 2.0
+ */
+public class AspectJExpressionPointcutAdvisor extends AbstractGenericPointcutAdvisor {
+
+	private final AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
+
+
+	public Pointcut getPointcut() {
+		return this.pointcut;
+	}
+
+	public void setExpression(String expression) {
+		this.pointcut.setExpression(expression);
+	}
+
+	public void setLocation(String location) {
+		this.pointcut.setLocation(location);
+	}
+
+	public void setParameterTypes(Class[] types) {
+		this.pointcut.setParameterTypes(types);
+	}
+
+	public void setParameterNames(String[] names) {
+		this.pointcut.setParameterNames(names);
+	}
+
+	public String getLocation() {
+		return this.pointcut.getLocation();
+	}
+
+	public String getExpression() {
+		return this.pointcut.getExpression();
+	}
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/AspectJMethodBeforeAdvice.java

+/*
+ * 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.aop.aspectj;
+
+import java.lang.reflect.Method;
+
+import org.springframework.aop.MethodBeforeAdvice;
+
+/**
+ * Spring AOP advice that wraps an AspectJ before method.
+ *
+ * @author Rod Johnson
+ * @author Adrian Colyer
+ * @since 2.0
+ */
+public class AspectJMethodBeforeAdvice extends AbstractAspectJAdvice implements MethodBeforeAdvice {
+
+	public AspectJMethodBeforeAdvice(
+			Method aspectJBeforeAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aif) {
+
+		super(aspectJBeforeAdviceMethod, pointcut, aif);
+	}
+
+	public void before(Method method, Object[] args, Object target) throws Throwable {
+		invokeAdviceMethod(getJoinPointMatch(), null, null);
+	}
+
+	public boolean isBeforeAdvice() {
+		return true;
+	}
+
+	public boolean isAfterAdvice() {
+		return false;
+	}
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/AspectJPointcutAdvisor.java

+/*
+ * 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;
+
+import org.aopalliance.aop.Advice;
+
+import org.springframework.aop.Pointcut;
+import org.springframework.aop.PointcutAdvisor;
+import org.springframework.core.Ordered;
+import org.springframework.util.Assert;
+import org.springframework.util.ObjectUtils;
+
+/**
+ * AspectJPointcutAdvisor that adapts an {@link AbstractAspectJAdvice}
+ * to the {@link org.springframework.aop.PointcutAdvisor} interface.
+ *
+ * @author Adrian Colyer
+ * @author Juergen Hoeller
+ * @since 2.0
+ */
+public class AspectJPointcutAdvisor implements PointcutAdvisor, Ordered {
+
+	private final AbstractAspectJAdvice advice;
+
+	private final Pointcut pointcut;
+
+	private Integer order;
+
+
+	/**
+	 * Create a new AspectJPointcutAdvisor for the given advice
+	 * @param advice the AbstractAspectJAdvice to wrap
+	 */
+	public AspectJPointcutAdvisor(AbstractAspectJAdvice advice) {
+		Assert.notNull(advice, "Advice must not be null");
+		this.advice = advice;
+		this.pointcut = advice.buildSafePointcut();
+	}
+
+	public void setOrder(int order) {
+		this.order = new Integer(order);
+	}
+
+
+	public boolean isPerInstance() {
+		return true;
+	}
+
+	public Advice getAdvice() {
+		return this.advice;
+	}
+
+	public Pointcut getPointcut() {
+		return this.pointcut;
+	}
+
+	public int getOrder() {
+		if (this.order != null) {
+			return this.order.intValue();
+		}
+		else {
+			return this.advice.getOrder();
+		}
+	}
+
+
+	public boolean equals(Object other) {
+		if (this == other) {
+			return true;
+		}
+		if (!(other instanceof AspectJPointcutAdvisor)) {
+			return false;
+		}
+		AspectJPointcutAdvisor otherAdvisor = (AspectJPointcutAdvisor) other;
+		return (ObjectUtils.nullSafeEquals(this.advice, otherAdvisor.advice));
+	}
+
+	public int hashCode() {
+		return AspectJPointcutAdvisor.class.hashCode();
+	}
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/AspectJPrecedenceInformation.java

+/*
+ * 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.aop.aspectj;
+
+import org.springframework.core.Ordered;
+
+/**
+ * Interface to be implemented by types that can supply the information
+ * needed to sort advice/advisors by AspectJ's precedence rules.
+ *
+ * @author Adrian Colyer
+ * @since 2.0
+ * @see org.springframework.aop.aspectj.autoproxy.AspectJPrecedenceComparator
+ */
+public interface AspectJPrecedenceInformation extends Ordered {
+
+	// Implementation note:
+	// We need the level of indirection this interface provides as otherwise the
+	// AspectJPrecedenceComparator must ask an Advisor for its Advice in all cases
+	// in order to sort advisors. This causes problems with the
+	// InstantiationModelAwarePointcutAdvisor which needs to delay creating
+	// its advice for aspects with non-singleton instantiation models.
+
+	/**
+	 * The name of the aspect (bean) in which the advice was declared.
+	 */
+	String getAspectName();
+
+	/**
+	 * The declaration order of the advice member within the aspect.
+	 */
+	int getDeclarationOrder();
+
+	/**
+	 * Return whether this is a before advice.
+	 */
+	boolean isBeforeAdvice();
+
+	/**
+	 * Return whether this is an after advice.
+	 */
+	boolean isAfterAdvice();
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/AspectJProxyUtils.java

+/*
+ * 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;
+
+import java.util.Iterator;
+import java.util.List;
+
+import org.springframework.aop.Advisor;
+import org.springframework.aop.PointcutAdvisor;
+import org.springframework.aop.interceptor.ExposeInvocationInterceptor;
+
+/**
+ * Utility methods for working with AspectJ proxies.
+ *
+ * @author Rod Johnson
+ * @author Ramnivas Laddad
+ * @since 2.0
+ */
+public abstract class AspectJProxyUtils {
+	
+	/**
+	 * Add special advisors if necessary to work with a proxy chain that contains AspectJ advisors.
+	 * This will expose the current Spring AOP invocation (necessary for some AspectJ pointcut matching)
+	 * and make available the current AspectJ JoinPoint. The call will have no effect if there are no
+	 * AspectJ advisors in the advisor chain.
+	 * @param advisors Advisors available
+	 * @return <code>true</code> if any special {@link Advisor Advisors} were added, otherwise <code>false</code>.
+	 */
+	public static boolean makeAdvisorChainAspectJCapableIfNecessary(List advisors) {
+		// Don't add advisors to an empty list; may indicate that proxying is just not required
+		if (!advisors.isEmpty()) {
+			boolean foundAspectJAdvice = false;
+			for (Iterator it = advisors.iterator(); it.hasNext() && !foundAspectJAdvice; ) {
+				Advisor advisor = (Advisor) it.next();
+				// Be careful not to get the Advice without a guard, as
+				// this might eagerly instantiate a non-singleton AspectJ aspect
+				if (isAspectJAdvice(advisor)) {
+					foundAspectJAdvice = true;
+				}
+			}
+			if (foundAspectJAdvice && !advisors.contains(ExposeInvocationInterceptor.ADVISOR)) {
+				advisors.add(0, ExposeInvocationInterceptor.ADVISOR);
+				return true;
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * Determine whether the given Advisor contains an AspectJ advice.
+	 * @param advisor the Advisor to check
+	 */
+	private static boolean isAspectJAdvice(Advisor advisor) {
+		return (advisor instanceof InstantiationModelAwarePointcutAdvisor ||
+			   advisor.getAdvice() instanceof AbstractAspectJAdvice ||
+			   (advisor instanceof PointcutAdvisor &&
+						 ((PointcutAdvisor) advisor).getPointcut() instanceof AspectJExpressionPointcut));
+	}
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/AspectJWeaverMessageHandler.java

+/*
+ * 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;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.aspectj.bridge.AbortException;
+import org.aspectj.bridge.IMessage;
+import org.aspectj.bridge.IMessage.Kind;
+import org.aspectj.bridge.IMessageHandler;
+
+/**
+ * Implementation of AspectJ's {@link IMessageHandler} interface that
+ * routes AspectJ weaving messages through the same logging system as the
+ * regular Spring messages.
+ * 
+ * <p>Pass the option...
+ *
+ * <p><code class="code">-XmessageHandlerClass:org.springframework.aop.aspectj.AspectJWeaverMessageHandler</code>
+ *
+ * <p>to the weaver; for example, specifying the following in a
+ * "<code>META-INF/aop.xml</code> file:
+ *
+ * <p><code class="code">&lt;weaver options="..."/&gt;</code>
+ *
+ * @author Adrian Colyer
+ * @author Juergen Hoeller
+ * @since 2.0
+ */
+public class AspectJWeaverMessageHandler implements IMessageHandler {
+
+	private static final String AJ_ID = "[AspectJ] ";
+	
+	private static final Log LOGGER = LogFactory.getLog("AspectJ Weaver");
+	
+
+	public boolean handleMessage(IMessage message) throws AbortException {
+		Kind messageKind = message.getKind();
+
+		if (LOGGER.isDebugEnabled() || LOGGER.isTraceEnabled()) {
+			if (messageKind == IMessage.DEBUG) {
+				LOGGER.debug(makeMessageFor(message));
+				return true;
+			}
+		} 
+		
+		if (LOGGER.isInfoEnabled()) {
+			if ((messageKind == IMessage.INFO) || (messageKind == IMessage.WEAVEINFO)) {
+				LOGGER.info(makeMessageFor(message));
+				return true;
+			}
+		} 
+		
+		if (LOGGER.isWarnEnabled()) {
+			if (messageKind == IMessage.WARNING) {
+				LOGGER.warn(makeMessageFor(message));
+				return true;
+			}
+		}
+		
+		if (LOGGER.isErrorEnabled()) {
+			if (messageKind == IMessage.ERROR) {
+				LOGGER.error(makeMessageFor(message));
+				return true;
+			}
+		}
+		
+		if (LOGGER.isFatalEnabled()) {
+			if (messageKind == IMessage.ABORT) {
+				LOGGER.fatal(makeMessageFor(message));
+				return true;
+			}
+		}
+		
+		return false;
+	}
+	
+	private String makeMessageFor(IMessage aMessage) {
+		return AJ_ID + aMessage.getMessage();
+	}
+
+	public boolean isIgnoring(Kind messageKind) {
+		// We want to see everything, and allow configuration of log levels dynamically.
+		return false;
+	}
+
+	public void dontIgnore(Kind messageKind) {
+		// We weren't ignoring anything anyway...
+	}
+
+	public void ignore(Kind kind) {
+		// We weren't ignoring anything anyway...
+	}
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/DeclareParentsAdvisor.java

+/*
+ * 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;
+
+import org.aopalliance.aop.Advice;
+
+import org.springframework.aop.ClassFilter;
+import org.springframework.aop.IntroductionAdvisor;
+import org.springframework.aop.support.ClassFilters;
+import org.springframework.aop.support.DelegatePerTargetObjectIntroductionInterceptor;
+import org.springframework.aop.support.DelegatingIntroductionInterceptor;
+
+/**
+ * Introduction advisor delegating to the given object.
+ * Implements AspectJ annotation-style behavior for the DeclareParents annotation.
+ *
+ * @author Rod Johnson
+ * @author Ramnivas Laddad
+ * @since 2.0
+ */
+public class DeclareParentsAdvisor implements IntroductionAdvisor {
+
+	private final Class introducedInterface;
+
+	private final ClassFilter typePatternClassFilter;
+
+	private final Advice advice;
+
+
+	/**
+	 * Create a new advisor for this DeclareParents field.
+	 * @param interfaceType static field defining the introduction
+	 * @param typePattern type pattern the introduction is restricted to
+	 * @param defaultImpl the default implementation class
+	 */
+	public DeclareParentsAdvisor(Class interfaceType, String typePattern, Class defaultImpl) {
+		this(interfaceType, typePattern, defaultImpl, 
+			 new DelegatePerTargetObjectIntroductionInterceptor(defaultImpl, interfaceType));
+	}
+
+	/**
+	 * Create a new advisor for this DeclareParents field.
+	 * @param interfaceType static field defining the introduction
+	 * @param typePattern type pattern the introduction is restricted to
+	 * @param delegateRef the delegate implementation object
+	 */
+	public DeclareParentsAdvisor(Class interfaceType, String typePattern, Object delegateRef) {
+		this(interfaceType, typePattern, delegateRef.getClass(), 
+			 new DelegatingIntroductionInterceptor(delegateRef));
+	}
+
+	/**
+	 * Private constructor to share common code between impl-based delegate and reference-based delegate
+	 * (cannot use method such as init() to share common code, due the the use of final fields)
+	 * @param interfaceType static field defining the introduction
+	 * @param typePattern type pattern the introduction is restricted to
+	 * @param implementationClass implementation class
+	 * @param advice delegation advice
+	 */
+	private DeclareParentsAdvisor(Class interfaceType, String typePattern, Class implementationClass, Advice advice) {
+		this.introducedInterface = interfaceType;
+		ClassFilter typePatternFilter = new TypePatternClassFilter(typePattern);
+
+		// Excludes methods implemented.
+		ClassFilter exclusion = new ClassFilter() {
+			public boolean matches(Class clazz) {
+				return !(introducedInterface.isAssignableFrom(clazz));
+			}
+		};
+
+		this.typePatternClassFilter = ClassFilters.intersection(typePatternFilter, exclusion);
+		this.advice = advice;
+	}
+
+
+	public ClassFilter getClassFilter() {
+		return this.typePatternClassFilter;
+	}
+
+	public void validateInterfaces() throws IllegalArgumentException {
+		// Do nothing
+	}
+
+	public boolean isPerInstance() {
+		return true;
+	}
+
+	public Advice getAdvice() {
+		return this.advice;
+	}
+
+	public Class[] getInterfaces() {
+		return new Class[] {this.introducedInterface};
+	}
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/InstantiationModelAwarePointcutAdvisor.java

+/*
+ * 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.aop.aspectj;
+
+import org.springframework.aop.PointcutAdvisor;
+
+/**
+ * Interface to be implemented by Spring AOP Advisors wrapping AspectJ
+ * aspects that may have a lazy initialization strategy. For example,
+ * a perThis instantiation model would mean lazy initialization of the advice.
+ *
+ * @author Rod Johnson
+ * @author Juergen Hoeller
+ * @since 2.0
+ */
+public interface InstantiationModelAwarePointcutAdvisor extends PointcutAdvisor {
+
+	/**
+	 * Return whether this advisor is lazily initializing its underlying advice.
+	 */
+	boolean isLazy();
+
+	/**
+	 * Return whether this advisor has already instantiated its advice.
+	 */
+	boolean isAdviceInstantiated();
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/MethodInvocationProceedingJoinPoint.java

+/*
+ * 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;
+
+import java.lang.reflect.Method;
+
+import org.aspectj.lang.JoinPoint;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.Signature;
+import org.aspectj.lang.reflect.MethodSignature;
+import org.aspectj.lang.reflect.SourceLocation;
+import org.aspectj.runtime.internal.AroundClosure;
+
+import org.springframework.aop.ProxyMethodInvocation;
+import org.springframework.util.Assert;
+
+/**
+ * Implementation of AspectJ ProceedingJoinPoint interface
+ * wrapping an AOP Alliance MethodInvocation.
+ *
+ * <p><b>Note</b>: the <code>getThis()</code> method returns the current Spring AOP proxy.
+ * The <code>getTarget()</code> method returns the current Spring AOP target (which may be
+ * <code>null</code> if there is no target), and is a plain POJO without any advice.
+ * <b>If you want to call the object and have the advice take effect, use
+ * <code>getThis()</code>.</b> A common example is casting the object to an
+ * introduced interface in the implementation of an introduction.
+ *
+ * <p>Of course there is no such distinction between target and proxy in AspectJ.
+ *
+ * @author Rod Johnson
+ * @author Juergen Hoeller
+ * @author Adrian Colyer
+ * @since 2.0
+ */
+public class MethodInvocationProceedingJoinPoint implements ProceedingJoinPoint, JoinPoint.StaticPart {
+	
+	private final ProxyMethodInvocation methodInvocation;
+
+	private Object[] defensiveCopyOfArgs;
+
+	/** Lazily initialized signature object */
+	private Signature signature;
+
+	/** Lazily initialized source location object */
+	private SourceLocation sourceLocation;
+
+
+	/**
+	 * Create a new MethodInvocationProceedingJoinPoint, wrapping the given
+	 * Spring ProxyMethodInvocation object.
+	 * @param methodInvocation the Spring ProxyMethodInvocation object
+	 */
+	public MethodInvocationProceedingJoinPoint(ProxyMethodInvocation methodInvocation) {
+		Assert.notNull(methodInvocation, "MethodInvocation must not be null");
+		this.methodInvocation = methodInvocation;
+	}
+
+	public void set$AroundClosure(AroundClosure aroundClosure) {
+		throw new UnsupportedOperationException();
+	}
+
+	public Object proceed() throws Throwable {
+		return this.methodInvocation.invocableClone().proceed();
+	}
+
+	public Object proceed(Object[] arguments) throws Throwable {
+		Assert.notNull(arguments, "Argument array passed to proceed cannot be null");
+		if (arguments.length != this.methodInvocation.getArguments().length) {
+			throw new IllegalArgumentException("Expecting " +
+					this.methodInvocation.getArguments().length + " arguments to proceed, " +
+					"but was passed " + arguments.length + " arguments");
+		}
+		this.methodInvocation.setArguments(arguments);
+		return this.methodInvocation.invocableClone(arguments).proceed();
+	}
+
+	/**
+	 * Returns the Spring AOP proxy. Cannot be <code>null</code>.
+	 */
+	public Object getThis() {
+		return this.methodInvocation.getProxy();
+	}
+
+	/**
+	 * Returns the Spring AOP target. May be <code>null</code> if there is no target.
+	 */
+	public Object getTarget() {
+		return this.methodInvocation.getThis();
+	}
+
+	public Object[] getArgs() {
+		if (this.defensiveCopyOfArgs == null) {
+			Object[] argsSource = this.methodInvocation.getArguments();
+			this.defensiveCopyOfArgs = new Object[argsSource.length];
+			System.arraycopy(argsSource, 0, this.defensiveCopyOfArgs, 0, argsSource.length);
+		}
+		return this.defensiveCopyOfArgs;
+	}
+
+	public Signature getSignature() {
+		if (this.signature == null) {
+			this.signature = new MethodSignatureImpl();
+		}
+		return signature;
+	}
+
+	public SourceLocation getSourceLocation() {
+		if (this.sourceLocation == null) {
+			this.sourceLocation = new SourceLocationImpl();
+		}
+		return this.sourceLocation;
+	}
+
+	public String getKind() {
+		return ProceedingJoinPoint.METHOD_EXECUTION;
+	}
+
+	public JoinPoint.StaticPart getStaticPart() {
+		return this;
+	}
+	
+
+	public String toShortString() {
+		return "execution(" + this.methodInvocation.getMethod().getName() + ")";
+	}
+
+	public String toLongString() {
+		return getClass().getName() + ": execution: [" + this.methodInvocation + "]";
+	}
+
+	public String toString() {
+		return getClass().getName() + ": " + toShortString();
+	}
+
+
+	/**
+	 * Lazily initialized MethodSignature.
+	 */
+	private class MethodSignatureImpl implements Signature, MethodSignature {
+
+		public String toShortString() {
+			return methodInvocation.getMethod().getName();
+		}
+
+		public String toLongString() {
+			return methodInvocation.getMethod().toString();
+		}
+
+		public String getName() {
+			return methodInvocation.getMethod().getName();
+		}
+
+		public int getModifiers() {
+			return methodInvocation.getMethod().getModifiers();
+		}
+
+		public Class getDeclaringType() {
+			return methodInvocation.getMethod().getDeclaringClass();
+		}
+
+		public String getDeclaringTypeName() {
+			return methodInvocation.getMethod().getDeclaringClass().getName();
+		}
+
+		public Class getReturnType() {
+			return methodInvocation.getMethod().getReturnType();
+		}
+
+		public Method getMethod() {
+			return methodInvocation.getMethod();
+		}
+
+		public Class[] getParameterTypes() {
+			return methodInvocation.getMethod().getParameterTypes();
+		}
+
+		public String[] getParameterNames() {
+			// TODO consider allowing use of ParameterNameDiscoverer, or tying into
+			// parameter names exposed for argument binding...
+			throw new UnsupportedOperationException(
+					"Parameter names cannot be determined unless compiled by AspectJ compiler");
+		}
+
+		public Class[] getExceptionTypes() {
+			return methodInvocation.getMethod().getExceptionTypes();
+		}
+	}
+
+
+	/**
+	 * Lazily initialized SourceLocation.
+	 */
+	private class SourceLocationImpl implements SourceLocation {
+
+		public Class getWithinType() {
+			if (methodInvocation.getThis() == null) {
+				throw new UnsupportedOperationException("No source location joinpoint available: target is null");
+			}
+			return methodInvocation.getThis().getClass();
+		}
+
+		public String getFileName() {
+			throw new UnsupportedOperationException();
+		}
+
+		public int getLine() {
+			throw new UnsupportedOperationException();
+		}
+
+		public int getColumn() {
+			throw new UnsupportedOperationException();
+		}
+	}
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/RuntimeTestWalker.java

+/*
+ * 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.aop.aspectj;
+
+import java.lang.reflect.Field;
+
+import org.aspectj.weaver.ResolvedType;
+import org.aspectj.weaver.ast.And;
+import org.aspectj.weaver.ast.Call;
+import org.aspectj.weaver.ast.FieldGetCall;
+import org.aspectj.weaver.ast.HasAnnotation;
+import org.aspectj.weaver.ast.ITestVisitor;
+import org.aspectj.weaver.ast.Instanceof;
+import org.aspectj.weaver.ast.Literal;
+import org.aspectj.weaver.ast.Not;
+import org.aspectj.weaver.ast.Or;
+import org.aspectj.weaver.ast.Test;
+import org.aspectj.weaver.internal.tools.MatchingContextBasedTest;
+import org.aspectj.weaver.reflect.ReflectionVar;
+import org.aspectj.weaver.reflect.ShadowMatchImpl;
+import org.aspectj.weaver.tools.ShadowMatch;
+
+import org.springframework.util.ClassUtils;
+import org.springframework.util.ReflectionUtils;
+
+/**
+ * This class encapsulates some AspectJ internal knowledge that should be
+ * pushed back into the AspectJ project in a future release. 
+ *
+ * <p>It relies on implementation specific knowledge in AspectJ to break
+ * encapsulation and do something AspectJ was not designed to do: query
+ * the types of runtime tests that will be performed. The code here should
+ * migrate to <code>ShadowMatch.getVariablesInvolvedInRuntimeTest()</code>
+ * or some similar operation.
+ *
+ * <p>See <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=151593"/>.
+ *
+ * @author Adrian Colyer
+ * @author Ramnivas Laddad
+ * @since 2.0
+ */
+class RuntimeTestWalker {
+
+	private final Test runtimeTest;
+
+
+	public RuntimeTestWalker(ShadowMatch shadowMatch) {
+		ShadowMatchImpl shadowMatchImplementation = (ShadowMatchImpl) shadowMatch;
+		try {
+			Field testField = shadowMatchImplementation.getClass().getDeclaredField("residualTest");
+			ReflectionUtils.makeAccessible(testField);
+			this.runtimeTest = (Test) testField.get(shadowMatch);
+		}
+		catch (NoSuchFieldException noSuchFieldEx) {
+			throw new IllegalStateException("The version of aspectjtools.jar / aspectjweaver.jar " +
+					"on the classpath is incompatible with this version of Spring: Expected field " +
+					"'runtimeTest' is not present on ShadowMatchImpl class.");
+		}
+		catch (IllegalAccessException illegalAccessEx) {
+			// Famous last words... but I don't see how this can happen given the
+			// makeAccessible call above
+			throw new IllegalStateException("Unable to access ShadowMatchImpl.runtimeTest field.");
+		}
+	}
+
+
+	/**
+	 * If the test uses any of the this, target, at_this, at_target, and at_annotation vars,
+	 * then it tests subtype sensitive vars.
+	 */
+	public boolean testsSubtypeSensitiveVars() {
+		return new SubtypeSensitiveVarTypeTestVisitor().testsSubtypeSensitiveVars(this.runtimeTest);
+	}
+
+	public boolean testThisInstanceOfResidue(Class thisClass) {
+		return new ThisInstanceOfResidueTestVisitor(thisClass).thisInstanceOfMatches(this.runtimeTest);
+	}
+
+	public boolean testTargetInstanceOfResidue(Class targetClass) {
+		return new TargetInstanceOfResidueTestVisitor(targetClass).targetInstanceOfMatches(this.runtimeTest);
+	}
+
+
+	private static class TestVisitorAdapter implements ITestVisitor {
+
+		protected static final int THIS_VAR = 0;
+		protected static final int TARGET_VAR = 1;
+		protected static final int AT_THIS_VAR = 3;
+		protected static final int AT_TARGET_VAR = 4;
+		protected static final int AT_ANNOTATION_VAR = 8;
+
+		public void visit(And e) {
+			e.getLeft().accept(this);
+			e.getRight().accept(this);
+		}
+
+		public void visit(Or e) {
+			e.getLeft().accept(this);
+			e.getRight().accept(this);
+		}
+
+		public void visit(Not e) {
+			e.getBody().accept(this);
+		}
+
+		public void visit(Instanceof i) {
+		}
+
+		public void visit(Literal literal) {
+		}
+
+		public void visit(Call call) {
+		}
+
+		public void visit(FieldGetCall fieldGetCall) {
+		}
+
+		public void visit(HasAnnotation hasAnnotation) {
+		}
+
+		public void visit(MatchingContextBasedTest matchingContextTest) {
+		}
+		
+		protected int getVarType(ReflectionVar v) {
+			try {
+				Field varTypeField = ReflectionVar.class.getDeclaredField("varType");
+				ReflectionUtils.makeAccessible(varTypeField);
+				Integer varTypeValue = (Integer) varTypeField.get(v);
+				return varTypeValue.intValue();
+			}
+			catch (NoSuchFieldException noSuchFieldEx) {
+				throw new IllegalStateException("the version of aspectjtools.jar / aspectjweaver.jar " +
+						"on the classpath is incompatible with this version of Spring:- expected field " +
+						"'varType' is not present on ReflectionVar class");
+			}
+			catch (IllegalAccessException illegalAccessEx) {
+				// Famous last words... but I don't see how this can happen given the
+				// makeAccessible call above
+				throw new IllegalStateException("Unable to access ReflectionVar.varType field.");
+			}
+		}
+	}
+
+
+	private static abstract class InstanceOfResidueTestVisitor extends TestVisitorAdapter {
+
+		private Class matchClass;
+		private boolean matches;
+		private int matchVarType;
+
+		public InstanceOfResidueTestVisitor(Class matchClass, boolean defaultMatches, int matchVarType) {
+			this.matchClass = matchClass;
+			this.matches = defaultMatches;
+			this.matchVarType = matchVarType;
+		}
+		
+		public boolean instanceOfMatches(Test test) {
+			test.accept(this);
+			return matches;
+		}
+
+		public void visit(Instanceof i) {
+			ResolvedType type = (ResolvedType) i.getType();
+			int varType = getVarType((ReflectionVar) i.getVar());
+			if (varType != this.matchVarType) {
+				return;
+			}
+			try {
+				Class typeClass = ClassUtils.forName(type.getName(), this.matchClass.getClassLoader());
+				// Don't use ReflectionType.isAssignableFrom() as it won't be aware of (Spring) mixins
+				this.matches = typeClass.isAssignableFrom(this.matchClass);
+			}
+			catch (ClassNotFoundException ex) {
+				this.matches = false;
+			}
+		}
+	}
+
+
+	/**
+	 * Check if residue of target(TYPE) kind. See SPR-3783 for more details.
+	 */
+	private static class TargetInstanceOfResidueTestVisitor extends InstanceOfResidueTestVisitor {
+
+		public TargetInstanceOfResidueTestVisitor(Class targetClass) {
+			super(targetClass, false, TARGET_VAR);
+		}
+
+		public boolean targetInstanceOfMatches(Test test) {
+			return instanceOfMatches(test);
+		}
+	}
+
+
+	/**
+	 * Check if residue of this(TYPE) kind. See SPR-2979 for more details.
+	 */
+	private static class ThisInstanceOfResidueTestVisitor extends InstanceOfResidueTestVisitor {
+
+		public ThisInstanceOfResidueTestVisitor(Class thisClass) {
+			super(thisClass, true, THIS_VAR);
+		}
+
+		// TODO: Optimization: Process only if this() specifies a type and not an identifier.
+		public boolean thisInstanceOfMatches(Test test) {
+			return instanceOfMatches(test);
+		}
+	}
+
+
+	private static class SubtypeSensitiveVarTypeTestVisitor extends TestVisitorAdapter {
+
+		private final Object thisObj = new Object();
+		private final Object targetObj = new Object();
+		private final Object[] argsObjs = new Object[0];
+		private boolean testsSubtypeSensitiveVars = false;
+
+		public boolean testsSubtypeSensitiveVars(Test aTest) {
+			aTest.accept(this);
+			return this.testsSubtypeSensitiveVars;
+		}
+		
+		public void visit(Instanceof i) {
+			ReflectionVar v = (ReflectionVar) i.getVar();
+			Object varUnderTest = v.getBindingAtJoinPoint(thisObj,targetObj,argsObjs);
+			if ((varUnderTest == thisObj) || (varUnderTest == targetObj)) {
+				this.testsSubtypeSensitiveVars = true;
+			}
+		}
+
+		public void visit(HasAnnotation hasAnn) {
+			// If you thought things were bad before, now we sink to new levels of horror...
+			ReflectionVar v = (ReflectionVar) hasAnn.getVar();
+			int varType = getVarType(v);
+				if ((varType == AT_THIS_VAR) || (varType == AT_TARGET_VAR) || (varType == AT_ANNOTATION_VAR)) {
+				this.testsSubtypeSensitiveVars = true;
+			}
+		}
+	}
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/SimpleAspectInstanceFactory.java

+/*
+ * 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;
+
+import org.springframework.aop.framework.AopConfigException;
+import org.springframework.core.Ordered;
+import org.springframework.util.Assert;
+
+/**
+ * Implementation of {@link AspectInstanceFactory} that creates a new instance
+ * of the specified aspect class for every {@link #getAspectInstance()} call.
+ *
+ * @author Juergen Hoeller
+ * @since 2.0.4
+ */
+public class SimpleAspectInstanceFactory implements AspectInstanceFactory {
+
+	private final Class aspectClass;
+
+
+	/**
+	 * Create a new SimpleAspectInstanceFactory for the given aspect class.
+	 * @param aspectClass the aspect class
+	 */
+	public SimpleAspectInstanceFactory(Class aspectClass) {
+		Assert.notNull(aspectClass, "Aspect class must not be null");
+		this.aspectClass = aspectClass;
+	}
+
+	/**
+	 * Return the specified aspect class (never <code>null</code>).
+	 */
+	public final Class getAspectClass() {
+		return this.aspectClass;
+	}
+
+
+	public final Object getAspectInstance() {
+		try {
+			return this.aspectClass.newInstance();
+		}
+		catch (InstantiationException ex) {
+			throw new AopConfigException("Unable to instantiate aspect class [" + this.aspectClass.getName() + "]", ex);
+		}
+		catch (IllegalAccessException ex) {
+			throw new AopConfigException("Cannot access element class [" + this.aspectClass.getName() + "]", ex);
+		}
+	}
+
+	public ClassLoader getAspectClassLoader() {
+		return this.aspectClass.getClassLoader();
+	}
+
+	/**
+	 * Determine the order for this factory's aspect instance,
+	 * either an instance-specific order expressed through implementing
+	 * the {@link org.springframework.core.Ordered} interface,
+	 * or a fallback order.
+	 * @see org.springframework.core.Ordered
+	 * @see #getOrderForAspectClass
+	 */
+	public int getOrder() {
+		return getOrderForAspectClass(this.aspectClass);
+	}
+
+	/**
+	 * Determine a fallback order for the case that the aspect instance
+	 * does not express an instance-specific order through implementing
+	 * the {@link org.springframework.core.Ordered} interface.
+	 * <p>The default implementation simply returns <code>Ordered.LOWEST_PRECEDENCE</code>.
+	 * @param aspectClass the aspect class
+	 */
+	protected int getOrderForAspectClass(Class aspectClass) {
+		return Ordered.LOWEST_PRECEDENCE;
+	}
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/SingletonAspectInstanceFactory.java

+/*
+ * 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;
+
+import org.springframework.core.Ordered;
+import org.springframework.util.Assert;
+
+/**
+ * Implementation of {@link AspectInstanceFactory} that is backed by a
+ * specified singleton object, returning the same instance for every
+ * {@link #getAspectInstance()} call.
+ *
+ * @author Rod Johnson
+ * @author Juergen Hoeller
+ * @since 2.0
+ * @see SimpleAspectInstanceFactory
+ */
+public class SingletonAspectInstanceFactory implements AspectInstanceFactory {
+	
+	private final Object aspectInstance;
+
+
+	/**
+	 * Create a new SingletonAspectInstanceFactory for the given aspect instance.
+	 * @param aspectInstance the singleton aspect instance
+	 */
+	public SingletonAspectInstanceFactory(Object aspectInstance) {
+		Assert.notNull(aspectInstance, "Aspect instance must not be null");
+		this.aspectInstance = aspectInstance;
+	}
+
+
+	public final Object getAspectInstance() {
+		return this.aspectInstance;
+	}
+
+	public ClassLoader getAspectClassLoader() {
+		return this.aspectInstance.getClass().getClassLoader();
+	}
+
+	/**
+	 * Determine the order for this factory's aspect instance,
+	 * either an instance-specific order expressed through implementing
+	 * the {@link org.springframework.core.Ordered} interface,
+	 * or a fallback order.
+	 * @see org.springframework.core.Ordered
+	 * @see #getOrderForAspectClass
+	 */
+	public int getOrder() {
+		if (this.aspectInstance instanceof Ordered) {
+			return ((Ordered) this.aspectInstance).getOrder();
+		}
+		return getOrderForAspectClass(this.aspectInstance.getClass());
+	}
+
+	/**
+	 * Determine a fallback order for the case that the aspect instance
+	 * does not express an instance-specific order through implementing
+	 * the {@link org.springframework.core.Ordered} interface.
+	 * <p>The default implementation simply returns <code>Ordered.LOWEST_PRECEDENCE</code>.
+	 * @param aspectClass the aspect class
+	 */
+	protected int getOrderForAspectClass(Class aspectClass) {
+		return Ordered.LOWEST_PRECEDENCE;
+	}
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/annotation/package.html

+<html>
+<body>
+
+Classes enabling AspectJ 5 @Annotated classes to be used in Spring AOP.
+
+<p>Normally to be used through an AspectJAutoProxyCreator rather than directly.
+
+</body>
+</html>

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/autoproxy/package.html

+<html>
+<body>
+
+Base classes enabling auto-proxying based on AspectJ.
+Support for AspectJ annotation aspects resides in the "aspectj.annotation" package.
+
+</body>
+</html>

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/package.html

+<html>
+<body>
+
+AspectJ integration package. Includes Spring AOP advice implementations for AspectJ 5
+annotation-style methods, and an AspectJExpressionPointcut: a Spring AOP Pointcut
+implementation that allows use of the AspectJ pointcut expression language with the Spring AOP
+runtime framework.
+
+<p>Note that use of this package does <i>not</i> require the use of the <code>ajc</code> compiler
+or AspectJ load-time weaver. It is intended to enable the use of a valuable subset of AspectJ
+functionality, with consistent semantics, with the proxy-based Spring AOP framework.
+
+</body>
+</html>