org.aspectj.weaver.tools.ShadowMatch Java Examples

private ShadowMatch getTargetShadowMatch(Method method, Class<?> targetClass) {
	Method targetMethod = AopUtils.getMostSpecificMethod(method, targetClass);
	if (targetMethod.getDeclaringClass().isInterface()) {
		// Try to build the most specific interface possible for inherited methods to be
		// considered for sub-interface matches as well, in particular for proxy classes.
		// Note: AspectJ is only going to take Method.getDeclaringClass() into account.
		Set<Class<?>> ifcs = ClassUtils.getAllInterfacesForClassAsSet(targetClass);
		if (ifcs.size() > 1) {
			try {
				Class<?> compositeInterface = ClassUtils.createCompositeInterface(
						ClassUtils.toClassArray(ifcs), targetClass.getClassLoader());
				targetMethod = ClassUtils.getMostSpecificMethod(targetMethod, compositeInterface);
			}
			catch (IllegalArgumentException ex) {
				// Implemented interfaces probably expose conflicting method signatures...
				// Proceed with original target method.
			}
		}
	}
	return getShadowMatch(targetMethod, method);
}
 

private ShadowMatch getTargetShadowMatch(Method method, Class<?> targetClass) {
	Method targetMethod = AopUtils.getMostSpecificMethod(method, targetClass);
	if (targetMethod.getDeclaringClass().isInterface()) {
		// Try to build the most specific interface possible for inherited methods to be
		// considered for sub-interface matches as well, in particular for proxy classes.
		// Note: AspectJ is only going to take Method.getDeclaringClass() into account.
		Set<Class<?>> ifcs = ClassUtils.getAllInterfacesForClassAsSet(targetClass);
		if (ifcs.size() > 1) {
			try {
				Class<?> compositeInterface = ClassUtils.createCompositeInterface(
						ClassUtils.toClassArray(ifcs), targetClass.getClassLoader());
				targetMethod = ClassUtils.getMostSpecificMethod(targetMethod, compositeInterface);
			}
			catch (IllegalArgumentException ex) {
				// Implemented interfaces probably expose conflicting method signatures...
				// Proceed with original target method.
			}
		}
	}
	return getShadowMatch(targetMethod, method);
}
 

/**
 * 使用 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;
}
 

@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));
	}
}
 

@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;
}
 

@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;
}
 

@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;
}
 

public RuntimeTestWalker(ShadowMatch shadowMatch) {
	try {
		ReflectionUtils.makeAccessible(residualTestField);
		this.runtimeTest = (Test) residualTestField.get(shadowMatch);
	}
	catch (IllegalAccessException ex) {
		throw new IllegalStateException(ex);
	}
}
 

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);
}
 

@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));
	}
}
 

public RuntimeTestWalker(ShadowMatch shadowMatch) {
	try {
		ReflectionUtils.makeAccessible(residualTestField);
		this.runtimeTest = (Test) residualTestField.get(shadowMatch);
	}
	catch (IllegalAccessException ex) {
		throw new IllegalStateException(ex);
	}
}
 

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);
}
 

@Override
public boolean matches(Method method, Class<?> targetClass, boolean hasIntroductions) {
	obtainPointcutExpression();
	ShadowMatch shadowMatch = getTargetShadowMatch(method, targetClass);

	// 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 (hasIntroductions) {
			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));
	}
}
 

@Override
public boolean match(Caller caller, String pattern) {
	if(! pattern.startsWith("execution")) {
		pattern = "execution(" + pattern + ")";
	}
	
	PointcutExpression pe = cache.get(pattern);
	if(pe == null) {
		PointcutParser pp = PointcutParser.getPointcutParserSupportingAllPrimitivesAndUsingContextClassloaderForResolution();
		pe = pp.parsePointcutExpression(pattern);
		cache.set(pattern, pe);
	}
	ShadowMatch sm = pe.matchesMethodExecution(caller.getTargetMethod());
	return sm.alwaysMatches();
}
 

/**
 * Method是否匹配切点表达式
 *
 * @param method 目标方法
 * @return 是否匹配
 */
public boolean matches(Method method) {
    checkReadyToMatch();
    ShadowMatch shadowMatch = pointcutExpression.matchesMethodExecution(method);
    if (shadowMatch.alwaysMatches()) {
        return true;
    } else if (shadowMatch.neverMatches()) {
        return false;
    }
    return false;
}
 

public RuntimeTestWalker(ShadowMatch shadowMatch) {
	try {
		ReflectionUtils.makeAccessible(residualTestField);
		this.runtimeTest = (Test) residualTestField.get(shadowMatch);
	}
	catch (IllegalAccessException ex) {
		throw new IllegalStateException(ex);
	}
}
 

@Override
public boolean matches(Method method, Class<?> targetClass, boolean hasIntroductions) {
	obtainPointcutExpression();
	ShadowMatch shadowMatch = getTargetShadowMatch(method, targetClass);

	// 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 (hasIntroductions) {
			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));
	}
}
 

public RuntimeTestWalker(ShadowMatch shadowMatch) {
	try {
		ReflectionUtils.makeAccessible(residualTestField);
		this.runtimeTest = (Test) residualTestField.get(shadowMatch);
	}
	catch (IllegalAccessException ex) {
		throw new IllegalStateException(ex);
	}
}
 

private RuntimeTestWalker getRuntimeTestWalker(ShadowMatch shadowMatch) {
	if (shadowMatch instanceof DefensiveShadowMatch) {
		return new RuntimeTestWalker(((DefensiveShadowMatch) shadowMatch).primary);
	}
	return new RuntimeTestWalker(shadowMatch);
}
 

public DefensiveShadowMatch(ShadowMatch primary, ShadowMatch other) {
	this.primary = primary;
	this.other = other;
}
 

public DefensiveShadowMatch(ShadowMatch primary, ShadowMatch other) {
	this.primary = primary;
	this.other = other;
}
 

private RuntimeTestWalker getRuntimeTestWalker(ShadowMatch shadowMatch) {
	if (shadowMatch instanceof DefensiveShadowMatch) {
		return new RuntimeTestWalker(((DefensiveShadowMatch) shadowMatch).primary);
	}
	return new RuntimeTestWalker(shadowMatch);
}
 

private RuntimeTestWalker getRuntimeTestWalker(ShadowMatch shadowMatch) {
	if (shadowMatch instanceof DefensiveShadowMatch) {
		return new RuntimeTestWalker(((DefensiveShadowMatch) shadowMatch).primary);
	}
	return new RuntimeTestWalker(shadowMatch);
}
 

public DefensiveShadowMatch(ShadowMatch primary, ShadowMatch other) {
	this.primary = primary;
	this.other = other;
}
 

public DefensiveShadowMatch(ShadowMatch primary, ShadowMatch other) {
	this.primary = primary;
	this.other = other;
}
 

private RuntimeTestWalker getRuntimeTestWalker(ShadowMatch shadowMatch) {
	if (shadowMatch instanceof DefensiveShadowMatch) {
		return new RuntimeTestWalker(((DefensiveShadowMatch) shadowMatch).primary);
	}
	return new RuntimeTestWalker(shadowMatch);
}