import org.aspectj.weaver.tools.ShadowMatch; //导入依赖的package包/类
/**
 * 使用 AspectJ Expression 匹配方法
 * @param method
 * @param targetClass
 * @return 成功匹配返回 true，否则返回 false
 */
@Override
public Boolean matchers(Method method, Class targetClass) {
    checkReadyToMatche();
    ShadowMatch shadowMatch = pointcutExpression.matchesMethodExecution(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.
    // https://github.com/spring-projects/spring-framework/blob/master/spring-aop/src/main/java/org/springframework/aop/aspectj/AspectJExpressionPointcut.java
    if (shadowMatch.alwaysMatches()) {
        return true;
    }
    else if (shadowMatch.neverMatches()) {
        return false;
    }

    return false;
}
 

import org.aspectj.weaver.tools.ShadowMatch; //导入依赖的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.aspectj.weaver.tools.ShadowMatch; //导入依赖的package包/类
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
	// Rely on default serialization, just initialize state after deserialization.
	ois.defaultReadObject();

	// Initialize transient fields.
	// pointcutExpression will be initialized lazily by checkReadyToMatch()
	this.shadowMatchCache = new ConcurrentHashMap<Method, ShadowMatch>(32);
}
 

import org.aspectj.weaver.tools.ShadowMatch; //导入依赖的package包/类
public RuntimeTestWalker(ShadowMatch shadowMatch) {
	try {
		ReflectionUtils.makeAccessible(residualTestField);
		this.runtimeTest = (Test) residualTestField.get(shadowMatch);
	}
	catch (IllegalAccessException ex) {
		throw new IllegalStateException(ex);
	}
}
 

import org.aspectj.weaver.tools.ShadowMatch; //导入依赖的package包/类
@Override
public boolean matches(Method method, Class targetClass) {
	checkReadyToMatch();
	ShadowMatch shadowMatch = pointcutExpression.matchesMethodExecution(method);
	if (shadowMatch.alwaysMatches()) {
		return true;
	} else if (shadowMatch.neverMatches()) {
		return false;
	}
	// TODO:其他情况不判断了！见org.springframework.aop.aspectj.RuntimeTestWalker
	return false;
}
 

import org.aspectj.weaver.tools.ShadowMatch; //导入依赖的package包/类
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.aspectj.weaver.tools.ShadowMatch; //导入依赖的package包/类
private RuntimeTestWalker getRuntimeTestWalker(ShadowMatch shadowMatch) {
	if (shadowMatch instanceof DefensiveShadowMatch) {
		return new RuntimeTestWalker(((DefensiveShadowMatch) shadowMatch).primary);
	}
	return new RuntimeTestWalker(shadowMatch);
}
 

import org.aspectj.weaver.tools.ShadowMatch; //导入依赖的package包/类
public DefensiveShadowMatch(ShadowMatch primary, ShadowMatch other) {
	this.primary = primary;
	this.other = other;
}