Java AopUtils.getMostSpecificMethod方法代码示例

import org.springframework.aop.support.AopUtils; //导入方法依赖的package包/类
private void loadArgsAsVariables() {
	// shortcut if no args need to be loaded
	if (ObjectUtils.isEmpty(this.args)) {
		return;
	}

	MethodCacheKey methodKey = new MethodCacheKey(this.method, this.targetClass);
	Method targetMethod = this.methodCache.get(methodKey);
	if (targetMethod == null) {
		targetMethod = AopUtils.getMostSpecificMethod(this.method, this.targetClass);
		if (targetMethod == null) {
			targetMethod = this.method;
		}
		this.methodCache.put(methodKey, targetMethod);
	}

	// save arguments as indexed variables
	for (int i = 0; i < this.args.length; i++) {
		setVariable("a" + i, this.args[i]);
		setVariable("p" + i, this.args[i]);
	}

	String[] parameterNames = this.paramDiscoverer.getParameterNames(targetMethod);
	// save parameter names (if discovered)
	if (parameterNames != null) {
		for (int i = 0; i < parameterNames.length; i++) {
			setVariable(parameterNames[i], this.args[i]);
		}
	}
}
 

import org.springframework.aop.support.AopUtils; //导入方法依赖的package包/类
@Override
public boolean matches(Method method, Class<?> targetClass, boolean beanHasIntroductions) {
	checkReadyToMatch();
	Method targetMethod = AopUtils.getMostSpecificMethod(method, targetClass);
	ShadowMatch shadowMatch = getShadowMatch(targetMethod, method);

	// 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
		if (beanHasIntroductions) {
			return true;
		}
		// 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.
		RuntimeTestWalker walker = getRuntimeTestWalker(shadowMatch);
		return (!walker.testsSubtypeSensitiveVars() || walker.testTargetInstanceOfResidue(targetClass));
	}
}
 

import org.springframework.aop.support.AopUtils; //导入方法依赖的package包/类
@Override
public boolean matches(Method method, Class<?> targetClass) {
	if (method.isAnnotationPresent(this.annotationType)) {
		return true;
	}
	// The method may be on an interface, so let's check on the target class as well.
	Method specificMethod = AopUtils.getMostSpecificMethod(method, targetClass);
	return (specificMethod != method && specificMethod.isAnnotationPresent(this.annotationType));
}
 

import org.springframework.aop.support.AopUtils; //导入方法依赖的package包/类
private Method getTargetMethod(Class<?> targetClass, Method method) {
	AnnotatedElementKey methodKey = new AnnotatedElementKey(method, targetClass);
	Method targetMethod = this.targetMethodCache.get(methodKey);
	if (targetMethod == null) {
		targetMethod = AopUtils.getMostSpecificMethod(method, targetClass);
		if (targetMethod == null) {
			targetMethod = method;
		}
		this.targetMethodCache.put(methodKey, targetMethod);
	}
	return targetMethod;
}
 

import org.springframework.aop.support.AopUtils; //导入方法依赖的package包/类
public Method getMostSpecificMethod() {
	if (this.mostSpecificMethod != null) {
		return this.mostSpecificMethod;
	}
	else if (AopUtils.isAopProxy(this.bean)) {
		Class<?> target = AopProxyUtils.ultimateTargetClass(this.bean);
		return AopUtils.getMostSpecificMethod(getMethod(), target);
	}
	else {
		return getMethod();
	}
}