abstractaspectjadvice.java

struts+spring 源码 希望能给大家带来帮助

/*
 * 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.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.weaver.tools.JoinPointMatch;
import org.aspectj.weaver.tools.PointcutParameter;

import org.springframework.aop.framework.AopConfigException;
import org.springframework.aop.framework.ReflectiveMethodInvocation;
import org.springframework.aop.interceptor.ExposeInvocationInterceptor;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
import org.springframework.core.Ordered;
import org.springframework.core.PrioritizedParameterNameDiscoverer;
import org.springframework.util.ClassUtils;
import org.springframework.util.StringUtils;

/**
 * Superclass for Spring Advices wrapping an AspectJ aspect
 * or annotated advice method.
 *
 * @author Rod Johnson
 * @author Adrian Colyer
 * @since 2.0
 */
public abstract class AbstractAspectJAdvice implements AspectJPrecedenceInformation, InitializingBean {
	
	/**
	 * Key used in ReflectiveMethodInvocation userAtributes map for the current joinpoint.
	 */
	protected final static String JOIN_POINT_KEY = JoinPoint.class.getName();


	/**
	 * Lazily instantiate joinpoint for the current invocation.
	 * Requires MethodInvocation to be bound with ExposeInvocationInterceptor.
	 * <p>Do not use if access is available to the current ReflectiveMethodInvocation
	 * (in an around advice).
	 * @return current AspectJ joinpoint, or through an exception if we're not in a
	 * Spring AOP invocation.
	 */
	public static JoinPoint currentJoinPoint() {
		ReflectiveMethodInvocation rmi = (ReflectiveMethodInvocation) ExposeInvocationInterceptor.currentInvocation();
		JoinPoint jp = (JoinPoint) rmi.getUserAttribute(JOIN_POINT_KEY);
		if (jp == null) {
			jp = new MethodInvocationProceedingJoinPoint(rmi);
			rmi.setUserAttribute(JOIN_POINT_KEY, jp);
		}
		return jp;
	}


	protected final Method aspectJAdviceMethod;
	
	private final AspectJExpressionPointcut pointcutExpression;
	
	private final AspectInstanceFactory aif;

	/**
	 * The name of the aspect (ref bean) in which this advice was defined (used
	 * when determining advice precedence so that we can determine
	 * whether two pieces of advice come from the same aspect).
	 */
	private String aspectName;
	
	/**
	 * The bean that is the aspect (state + behaviour) backing this advice.
	 * If the bean has a non-singleton scope, this advice method may refer
	 * to a different instance of the bean to the one on which the advice is
	 * actually dispatched. This should not matter as we only use the bean
	 * for determining ordering (and all prototypes will be configured with
	 * the same order)
	 */
	private Object aspectBean;

	/**
	 * the order of declaration of this advice within the aspect
	 */
	private int declarationOrder;
	
	/**
	 * This will be non-null if the creator of this advice object knows the argument names
	 * and sets them explicitly
	 */
	private String[] argumentNames = null;
	
	/** non-null if after throwing advice binds the thrown value */
	private String throwingName = null;
	
	/** non-null if after returning advice binds the return value */
	private String returningName = null;
	
	private Class discoveredReturningType = Object.class;

	private Class discoveredThrowingType = Object.class;
	
	/** 
	 * the total number of arguments we have to populate on
	 * advice dispatch
	 */
	private final int numAdviceInvocationArguments;
	
	/**
	 * index for thisJoinPoint argument (currently only
	 * supported at index 0 if present at all)
	 */
	private int joinPointArgumentIndex = -1;

	/**
	 * index for thisJoinPointStaticPart argument (currently only
	 * supported at index 0 if present at all)
	 */
	private int joinPointStaticPartArgumentIndex = -1;
	
	private final Map/*<adviceArgumentName,argumentIndex>*/ argumentBindings = new HashMap();


	public AbstractAspectJAdvice(
			Method aspectJAdviceMethod, AspectJExpressionPointcut pointcutExpression, AspectInstanceFactory aif) {

		this.aspectJAdviceMethod = aspectJAdviceMethod;
		if (!aspectJAdviceMethod.isAccessible()) {
			aspectJAdviceMethod.setAccessible(true);
		}
		this.numAdviceInvocationArguments = this.aspectJAdviceMethod.getParameterTypes().length;
		this.pointcutExpression = pointcutExpression;
		this.aif = aif;
	}


	public Method getAspectJAdviceMethod() {
		return this.aspectJAdviceMethod;
	}

	public AspectJExpressionPointcut getPointcut() {
		return this.pointcutExpression;
	}
	
	public void setAspectName(String name) {
		this.aspectName = name;
	}
	
	public String getAspectName() {
		return this.aspectName;
	}

	public void setAspectBean(Object bean) {
		this.aspectBean = bean;
	}
	
	/**
	 * Get the precedence (order) associated with the aspect declaring this advice.
	 */
	public int getOrder() {
		if (this.aspectBean != null && (this.aspectBean instanceof Ordered)) {
			return ((Ordered) this.aspectBean).getOrder();
		}
		return Ordered.LOWEST_PRECEDENCE;
	}
	
	/**
	 * Sets the <b>declaration order</b> of this advice within the aspect
	 */
	public void setDeclarationOrder(int order) {
		this.declarationOrder = order;
	}

	public int getDeclarationOrder() {
		return this.declarationOrder;
	}

	/**
	 * Set by creator of this advice object if the argument names are known.
	 * This could be for example because they have been explicitly specified in XML,
	 * or in an advice annotation.
	 * @param argNames comma delimited list of arg names
	 */
	public void setArgumentNames(String argNames) {
		String[] tokens = StringUtils.commaDelimitedListToStringArray(argNames);
		setArgumentNamesFromStringArray(tokens);
	}

	public void setArgumentNamesFromStringArray(String[] args) {
		this.argumentNames = new String[args.length];
		for (int i = 0; i < args.length; i++) {
			this.argumentNames[i] = StringUtils.trimWhitespace(args[i]);
			if (!isVariableName(this.argumentNames[i])) {
				throw new IllegalArgumentException(
						"argumentNames property of AbstractAspectJAdvice " + 
						"contains an argument name '" +
						this.argumentNames[i] + "' that is not a valid Java identifier");
			}
		}		
	}

	public void setReturningName(String name) {
		throw new UnsupportedOperationException("Only afterReturning advice can be used to bind a return value");
	}

	/** 
	 * We need to hold the returning name at this level for argument binding calculations,
	 * this method allows the afterReturning advice subclass to set the name.
	 */
	protected void setReturningNameNoCheck(String name) {
		// name could be a variable or a type...
		if (isVariableName(name)) {
			this.returningName = name;
		}
		else {
			// assume a type
			try {
				this.discoveredReturningType = ClassUtils.forName(name);
			}
			catch (Throwable ex) {
				throw new IllegalArgumentException("Returning name '" + name  +
						"' is neither a valid argument name nor the fully-qualified name of a Java type on the classpath. " +
						"Root cause: " + ex);
			}
		}
	}
	
	protected Class getDiscoveredReturningType() {
		return this.discoveredReturningType;
	}
	
	public void setThrowingName(String name) {
		throw new UnsupportedOperationException("Only afterThrowing advice can be used to bind a thrown exception");
	}
	
	/** 
	 * We need to hold the throwing name at this level for argument binding calculations,
	 * this method allows the afterThrowing advice subclass to set the name.
	 */
	protected void setThrowingNameNoCheck(String name) {
		// name could be a variable or a type...
		if (isVariableName(name)) {
			this.throwingName = name;
		}
		else {
			// assume a type
			try {
				this.discoveredThrowingType = ClassUtils.forName(name);
			}
			catch (Throwable ex) {
				throw new IllegalArgumentException("Throwing name '" + name  +
						"' is neither a valid argument name nor the fully-qualified name of a Java type on the classpath. " +
						"Root cause: " + ex);
			}
		}
	}

	protected Class getDiscoveredThrowingType() {
		return this.discoveredThrowingType;
	}
	
	private boolean isVariableName(String name) {
		char[] chars = name.toCharArray();
		if (!Character.isJavaIdentifierStart(chars[0])) {
			return false;
		}
		for (int i = 1; i < chars.length; i++) {
			if (!Character.isJavaIdentifierPart(chars[i])) {
				return false;
			}
		}
		return true;
	}


	/**
	 * Argument names have to be discovered and set on the associated pointcut expression,