Redistribute AOP Alliance interfaces in spring-aop again (as in Spring 2.x)

Issue: SPR-13984

build.gradle

@@ -202,7 +202,6 @@ configure(allprojects) { project ->
 		"http://portals.apache.org/pluto/portlet-2.0-apidocs/",
 		"http://tiles.apache.org/tiles-request/apidocs/",
 		"http://tiles.apache.org/framework/apidocs/",
-		"http://aopalliance.sourceforge.net/doc/",
 		"http://www.eclipse.org/aspectj/doc/released/aspectj5rt-api/",
 		"http://ehcache.org/apidocs/",
 		"http://quartz-scheduler.org/api/2.2.0/",
@@ -428,7 +427,6 @@ project("spring-aop") {
 		compile(project(":spring-core"))
 		compile(files(project(":spring-core").cglibRepackJar))
 		compile(files(project(":spring-core").objenesisRepackJar))
-		compile("aopalliance:aopalliance:1.0")
 		optional("org.aspectj:aspectjweaver:${aspectjVersion}")
 		optional("commons-pool:commons-pool:1.6")
 		optional("org.apache.commons:commons-pool2:2.4.2")
@@ -550,7 +548,6 @@ project("spring-tx") {
 		compile(project(":spring-core"))
 		optional(project(":spring-aop"))
 		optional(project(":spring-context"))  // for JCA, @EnableTransactionManagement
-		optional("aopalliance:aopalliance:1.0")
 		optional("javax.transaction:javax.transaction-api:${jtaVersion}")
 		optional("javax.resource:connector-api:1.5")
 		optional("javax.ejb:ejb-api:${ejbApiVersion}")
@@ -617,7 +614,6 @@ project("spring-jms") {
 		compile(project(":spring-tx"))
 		provided("javax.jms:jms-api:1.1-rev-1")
 		optional(project(":spring-oxm"))
-		optional("aopalliance:aopalliance:1.0")
 		optional("javax.transaction:javax.transaction-api:${jtaVersion}")
 		optional("javax.resource:connector-api:1.5")
 		optional("com.fasterxml.jackson.core:jackson-databind:${jackson2Version}")
@@ -710,7 +706,6 @@ project("spring-web") {
 		optional("javax.el:javax.el-api:2.2.5")
 		optional("javax.faces:javax.faces-api:2.2")
 		optional("javax.validation:validation-api:1.0.0.GA")
-		optional("aopalliance:aopalliance:1.0")
 		optional("org.codehaus.groovy:groovy-all:${groovyVersion}")
 		optional("com.caucho:hessian:4.0.38")
 		optional("commons-fileupload:commons-fileupload:${fileuploadVersion}")
@@ -801,7 +796,6 @@ project("spring-orm") {
 		optional(project(":spring-aop"))
 		optional(project(":spring-context"))
 		optional(project(":spring-web"))
-		optional("aopalliance:aopalliance:1.0")
 		optional("org.eclipse.persistence:javax.persistence:2.0.5")
 		optional("org.eclipse.persistence:org.eclipse.persistence.core:${eclipselinkVersion}")
 		optional("org.eclipse.persistence:org.eclipse.persistence.jpa:${eclipselinkVersion}") {
@@ -842,7 +836,6 @@ project("spring-orm-hibernate4") {
 		optional("org.hibernate:hibernate-core:${hibernate4Version}")
 		optional("org.hibernate:hibernate-entitymanager:${hibernate4Version}")
 		optional("javax.servlet:javax.servlet-api:3.0.1")
-        optional("aopalliance:aopalliance:1.0")
 		testCompile("javax.validation:validation-api:1.1.0.GA")
 		testCompile("org.hibernate:hibernate-validator:${hibval5Version}")
 		testCompile("javax.el:javax.el-api:2.2.5")
@@ -862,7 +855,6 @@ project("spring-orm-hibernate5") {
 		optional("org.hibernate:hibernate-entitymanager:${hibernate5Version}")
 		optional("javax.servlet:javax.servlet-api:3.0.1")
 		optional("javax.transaction:javax.transaction-api:${jtaVersion}")
-		optional("aopalliance:aopalliance:1.0")
 	}
 }
 

spring-aop/src/main/java/org/aopalliance/aop/Advice.java

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2002-2016 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.aopalliance.aop;
+
+/**
+ * Tag interface for Advice. Implementations can be any type
+ * of advice, such as Interceptors.
+ *
+ * @author Rod Johnson
+ * @version $Id: Advice.java,v 1.1 2004/03/19 17:02:16 johnsonr Exp $
+ */
+public interface Advice {
+
+}

spring-aop/src/main/java/org/aopalliance/aop/AspectException.java

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2002-2016 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.aopalliance.aop;
+
+/**
+ * Superclass for all AOP infrastructure exceptions.
+ * Unchecked, as such exceptions are fatal and end user
+ * code shouldn't be forced to catch them.
+ * 
+ * @author Rod Johnson
+ * @author Bob Lee
+ * @author Juergen Hoeller
+ */
+@SuppressWarnings("serial")
+public class AspectException extends RuntimeException {
+
+	/**
+	 * Constructor for AspectException.
+	 * @param message the exception message
+	 */
+	public AspectException(String message) {
+		super(message);
+	}
+
+	/**
+	 * Constructor for AspectException.
+	 * @param message the exception message
+	 * @param cause the root cause, if any
+	 */
+	public AspectException(String message, Throwable cause) {
+		super(message, cause);
+	}
+
+}

spring-aop/src/main/java/org/aopalliance/intercept/ConstructorInterceptor.java

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2002-2016 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.aopalliance.intercept;
+
+/**
+ * Intercepts the construction of a new object.
+ *
+ * <p>The user should implement the {@link
+ * #construct(ConstructorInvocation)} method to modify the original
+ * behavior. E.g. the following class implements a singleton
+ * interceptor (allows only one unique instance for the intercepted
+ * class):
+ *
+ * <pre class=code>
+ * class DebuggingInterceptor implements ConstructorInterceptor {
+ *   Object instance=null;
+ *
+ *   Object construct(ConstructorInvocation i) throws Throwable {
+ *     if(instance==null) {
+ *       return instance=i.proceed();
+ *     } else {
+ *       throw new Exception("singleton does not allow multiple instance");
+ *     }
+ *   }
+ * }
+ * </pre>
+ *
+ * @author Rod Johnson
+ */
+public interface ConstructorInterceptor extends Interceptor  {
+
+	/**
+	 * Implement this method to perform extra treatments before and
+	 * after the construction of a new object. Polite implementations
+	 * would certainly like to invoke {@link Joinpoint#proceed()}.
+	 * @param invocation the construction joinpoint
+	 * @return the newly created object, which is also the result of
+	 * the call to {@link Joinpoint#proceed()}; might be replaced by
+	 * the interceptor
+	 * @throws Throwable if the interceptors or the target object
+	 * throws an exception
+	 */
+	Object construct(ConstructorInvocation invocation) throws Throwable;
+
+}

spring-aop/src/main/java/org/aopalliance/intercept/ConstructorInvocation.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2002-2016 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.aopalliance.intercept;
+
+import java.lang.reflect.Constructor;
+
+/**
+ * Description of an invocation to a constuctor, given to an
+ * interceptor upon constructor-call.
+ *
+ * <p>A constructor invocation is a joinpoint and can be intercepted
+ * by a constructor interceptor.
+ *
+ * @author Rod Johnson
+ * @see ConstructorInterceptor
+ */
+public interface ConstructorInvocation extends Invocation {
+
+    /**
+     * Get the constructor being called.
+     * <p>This method is a friendly implementation of the
+     * {@link Joinpoint#getStaticPart()} method (same result).
+     * @return the constructor being called
+     */
+    Constructor<?> getConstructor();
+
+}

spring-aop/src/main/java/org/aopalliance/intercept/Interceptor.java

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2002-2016 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.aopalliance.intercept;
+
+import org.aopalliance.aop.Advice;
+
+/**
+ * This interface represents a generic interceptor.
+ *
+ * <p>A generic interceptor can intercept runtime events that occur
+ * within a base program. Those events are materialized by (reified
+ * in) joinpoints. Runtime joinpoints can be invocations, field
+ * access, exceptions... 
+ *
+ * <p>This interface is not used directly. Use the the sub-interfaces
+ * to intercept specific events. For instance, the following class
+ * implements some specific interceptors in order to implement a
+ * debugger:
+ *
+ * <pre class=code>
+ * class DebuggingInterceptor implements MethodInterceptor, 
+ *     ConstructorInterceptor, FieldInterceptor {
+ *
+ *   Object invoke(MethodInvocation i) throws Throwable {
+ *     debug(i.getMethod(), i.getThis(), i.getArgs());
+ *     return i.proceed();
+ *   }
+ *
+ *   Object construct(ConstructorInvocation i) throws Throwable {
+ *     debug(i.getConstructor(), i.getThis(), i.getArgs());
+ *     return i.proceed();
+ *   }
+ * 
+ *   Object get(FieldAccess fa) throws Throwable {
+ *     debug(fa.getField(), fa.getThis(), null);
+ *     return fa.proceed();
+ *   }
+ *
+ *   Object set(FieldAccess fa) throws Throwable {
+ *     debug(fa.getField(), fa.getThis(), fa.getValueToSet());
+ *     return fa.proceed();
+ *   }
+ *
+ *   void debug(AccessibleObject ao, Object this, Object value) {
+ *     ...
+ *   }
+ * }
+ * </pre>
+ *
+ * @author Rod Johnson
+ * @see Joinpoint
+ */
+public interface Interceptor extends Advice {
+
+}

spring-aop/src/main/java/org/aopalliance/intercept/Invocation.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2002-2016 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.aopalliance.intercept;
+
+/**
+ * This interface represents an invocation in the program.
+ *
+ * <p>An invocation is a joinpoint and can be intercepted by an
+ * interceptor.
+ *
+ * @author Rod Johnson
+ */
+public interface Invocation extends Joinpoint {
+
+	/**
+	 * Get the arguments as an array object.
+	 * It is possible to change element values within this
+	 * array to change the arguments.
+	 * @return the argument of the invocation
+	 */
+	Object[] getArguments();
+
+}

spring-aop/src/main/java/org/aopalliance/intercept/Joinpoint.java

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2002-2016 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.aopalliance.intercept;
+
+import java.lang.reflect.AccessibleObject;
+
+/**
+ * This interface represents a generic runtime joinpoint (in the AOP
+ * terminology).
+ *
+ * <p>A runtime joinpoint is an <i>event</i> that occurs on a static
+ * joinpoint (i.e. a location in a the program). For instance, an
+ * invocation is the runtime joinpoint on a method (static joinpoint).
+ * The static part of a given joinpoint can be generically retrieved
+ * using the {@link #getStaticPart()} method.
+ *
+ * <p>In the context of an interception framework, a runtime joinpoint
+ * is then the reification of an access to an accessible object (a
+ * method, a constructor, a field), i.e. the static part of the
+ * joinpoint. It is passed to the interceptors that are installed on
+ * the static joinpoint.
+ *
+ * @author Rod Johnson
+ * @see Interceptor
+ */
+public interface Joinpoint {
+
+	/**
+	 * Proceed to the next interceptor in the chain.
+	 * <p>The implementation and the semantics of this method depends
+	 * on the actual joinpoint type (see the children interfaces).
+	 * @return see the children interfaces' proceed definition
+	 * @throws Throwable if the joinpoint throws an exception
+	 */
+	Object proceed() throws Throwable;
+
+	/**
+	 * Return the object that holds the current joinpoint's static part.
+	 * <p>For instance, the target object for an invocation.
+	 * @return the object (can be null if the accessible object is static)
+	 */
+	Object getThis();
+
+	/**
+	 * Return the static part of this joinpoint.
+	 * <p>The static part is an accessible object on which a chain of
+	 * interceptors are installed.
+	 */
+	AccessibleObject getStaticPart();
+
+}

spring-aop/src/main/java/org/aopalliance/intercept/MethodInterceptor.java

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2002-2016 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.aopalliance.intercept;
+
+/**
+ * Intercepts calls on an interface on its way to the target. These
+ * are nested "on top" of the target.
+ *
+ * <p>The user should implement the {@link #invoke(MethodInvocation)}
+ * method to modify the original behavior. E.g. the following class
+ * implements a tracing interceptor (traces all the calls on the
+ * intercepted method(s)):
+ *
+ * <pre class=code>
+ * class TracingInterceptor implements MethodInterceptor {
+ *   Object invoke(MethodInvocation i) throws Throwable {
+ *     System.out.println("method "+i.getMethod()+" is called on "+
+ *                        i.getThis()+" with args "+i.getArguments());
+ *     Object ret=i.proceed();
+ *     System.out.println("method "+i.getMethod()+" returns "+ret);
+ *     return ret;
+ *   }
+ * }
+ * </pre>
+ *
+ * @author Rod Johnson
+ */
+public interface MethodInterceptor extends Interceptor {
+	
+	/**
+	 * Implement this method to perform extra treatments before and
+	 * after the invocation. Polite implementations would certainly
+	 * like to invoke {@link Joinpoint#proceed()}.
+	 * @param invocation the method invocation joinpoint
+	 * @return the result of the call to {@link Joinpoint#proceed();
+	 * might be intercepted by the interceptor
+	 * @throws Throwable if the interceptors or the target object
+	 * throws an exception
+	 */
+	Object invoke(MethodInvocation invocation) throws Throwable;
+
+}

spring-aop/src/main/java/org/aopalliance/intercept/MethodInvocation.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2002-2016 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.aopalliance.intercept;
+
+import java.lang.reflect.Method;
+
+/**
+ * Description of an invocation to a method, given to an interceptor
+ * upon method-call.
+ *
+ * <p>A method invocation is a joinpoint and can be intercepted by a
+ * method interceptor.
+ *
+ * @author Rod Johnson
+ * @see MethodInterceptor
+ */
+public interface MethodInvocation extends Invocation {
+
+	/**
+	 * Get the method being called.
+	 * <p>This method is a frienly implementation of the
+	 * {@link Joinpoint#getStaticPart()} method (same result).
+	 * @return the method being called
+	 */
+	Method getMethod();
+
+}