Examples of org.aspectj.weaver.tools.ShadowMatch

org.aspectj.weaver.tools.ShadowMatch
The result of asking a PointcutExpression to match at a shadow (method execution, handler, constructor call, and so on).

  }


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

View Full Code Here

  }


  public boolean matches(Method method, Class targetClass, boolean beanHasIntroductions) {
    checkReadyToMatch();
    Method targetMethod = AopUtils.getMostSpecificMethod(method, targetClass);
    ShadowMatch shadowMatch = null;
    try {
      shadowMatch = getShadowMatch(targetMethod, method);
    }
    catch (ReflectionWorld.ReflectionWorldException ex) {
      // Could neither introspect the target class nor the proxy class ->
      // let's simply consider this method as non-matching.
      return false;
    }


    // 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
      return (beanHasIntroductions || matchesIgnoringSubtypes(shadowMatch) || matchesTarget(shadowMatch, targetClass));

View Full Code Here

    return this.pointcutExpression.mayNeedDynamicTest();
  }


  public boolean matches(Method method, Class targetClass, Object[] args) {
    checkReadyToMatch();
    ShadowMatch shadowMatch = null;
    ShadowMatch originalShadowMatch = null;
    try {
      shadowMatch = getShadowMatch(AopUtils.getMostSpecificMethod(method, targetClass), method);
      originalShadowMatch = getShadowMatch(method, method);
    }
    catch (ReflectionWorld.ReflectionWorldException ex) {

View Full Code Here

    invocation.setUserAttribute(getExpression(), jpm);
  }


  private ShadowMatch getShadowMatch(Method targetMethod, Method originalMethod) {
    synchronized (this.shadowMapCache) {
      ShadowMatch shadowMatch = (ShadowMatch) this.shadowMapCache.get(targetMethod);
      if (shadowMatch == null) {
        try {
          shadowMatch = this.pointcutExpression.matchesMethodExecution(targetMethod);
        }
        catch (ReflectionWorld.ReflectionWorldException ex) {

View Full Code Here

  }


  public boolean matches(Method method, Class targetClass, boolean beanHasIntroductions) {
    checkReadyToMatch();
    Method targetMethod = AopUtils.getMostSpecificMethod(method, targetClass);
    ShadowMatch shadowMatch = null;
    try {
      shadowMatch = getShadowMatch(targetMethod, method);
    }
    catch (ReflectionWorld.ReflectionWorldException ex) {
      // Could neither introspect the target class nor the proxy class ->
      // let's simply consider this method as non-matching.
      return false;
    }


    // 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
      return (beanHasIntroductions || matchesIgnoringSubtypes(shadowMatch) || matchesTarget(shadowMatch, targetClass));

View Full Code Here

    return this.pointcutExpression.mayNeedDynamicTest();
  }


  public boolean matches(Method method, Class targetClass, Object[] args) {
    checkReadyToMatch();
    ShadowMatch shadowMatch = null;
    ShadowMatch originalShadowMatch = null;
    try {
      shadowMatch = getShadowMatch(AopUtils.getMostSpecificMethod(method, targetClass), method);
      originalShadowMatch = getShadowMatch(method, method);
    }
    catch (ReflectionWorld.ReflectionWorldException ex) {

View Full Code Here

    invocation.setUserAttribute(getExpression(), jpm);
  }


  private ShadowMatch getShadowMatch(Method targetMethod, Method originalMethod) {
    synchronized (this.shadowMapCache) {
      ShadowMatch shadowMatch = (ShadowMatch) this.shadowMapCache.get(targetMethod);
      if (shadowMatch == null) {
        try {
          shadowMatch = this.pointcutExpression.matchesMethodExecution(targetMethod);
        }
        catch (ReflectionWorld.ReflectionWorldException ex) {

View Full Code Here

    invocation.setUserAttribute(getExpression(), jpm);
  }


  private ShadowMatch getShadowMatch(Method targetMethod, Method originalMethod) {
    // Avoid lock contention for known Methods through concurrent access...
    ShadowMatch shadowMatch = this.shadowMatchCache.get(targetMethod);
    if (shadowMatch == null) {
      synchronized (this.shadowMatchCache) {
        // Not found - now check again with full lock...
        Method methodToMatch = targetMethod;
        PointcutExpression fallbackPointcutExpression = null;
        shadowMatch = this.shadowMatchCache.get(methodToMatch);
        if (shadowMatch == null) {
          try {
            shadowMatch = this.pointcutExpression.matchesMethodExecution(targetMethod);
          }
          catch (ReflectionWorld.ReflectionWorldException ex) {
            // Failed to introspect target method, probably because it has been loaded
            // in a special ClassLoader. Let's try the original method instead...
            try {
              fallbackPointcutExpression = getFallbackPointcutExpression(methodToMatch.getDeclaringClass());
              shadowMatch = fallbackPointcutExpression.matchesMethodExecution(methodToMatch);
            } catch (ReflectionWorld.ReflectionWorldException e) {
              if (targetMethod == originalMethod) {
                shadowMatch = new ShadowMatchImpl(org.aspectj.util.FuzzyBoolean.NO, null, null, null);
              }
              else {
                try {
                  shadowMatch = this.pointcutExpression.matchesMethodExecution(originalMethod);
                }
                catch (ReflectionWorld.ReflectionWorldException ex2) {
                  // Could neither introspect the target class nor the proxy class ->
                  // let's simply consider this method as non-matching.
                  methodToMatch = originalMethod;
                  fallbackPointcutExpression = getFallbackPointcutExpression(methodToMatch.getDeclaringClass());
                  try {
                    shadowMatch = fallbackPointcutExpression.matchesMethodExecution(methodToMatch);
                  } catch (ReflectionWorld.ReflectionWorldException e2) {
                    shadowMatch = new ShadowMatchImpl(org.aspectj.util.FuzzyBoolean.NO, null, null, null);
                  }
                }
              }
            }
          }
          if (shadowMatch.maybeMatches() && fallbackPointcutExpression!=null) {
            shadowMatch = new DefensiveShadowMatch(shadowMatch,
                fallbackPointcutExpression.matchesMethodExecution(methodToMatch));
          }
          this.shadowMatchCache.put(targetMethod, shadowMatch);
        }

View Full Code Here

  }


  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
      return (beanHasIntroductions || matchesIgnoringSubtypes(shadowMatch) || matchesTarget(shadowMatch, targetClass));

View Full Code Here

    return this.pointcutExpression.mayNeedDynamicTest();
  }


  public boolean matches(Method method, Class targetClass, Object[] args) {
    checkReadyToMatch();
    ShadowMatch shadowMatch = getShadowMatch(AopUtils.getMostSpecificMethod(method, targetClass), method);
    ShadowMatch originalShadowMatch = getShadowMatch(method, method);


    // Bind Spring AOP proxy to AspectJ "this" and Spring AOP target to AspectJ target,
    // consistent with return of MethodInvocationProceedingJoinPoint
    ProxyMethodInvocation pmi = null;
    Object targetObject = null;

View Full Code Here

0 1 2

TOP

Related Classes of org.aspectj.weaver.tools.ShadowMatch

com.gwtent.aop.matcher.AspectJExpress

org.aspectj.weaver.internal.tools.PointcutExpressionImpl

org.springframework.aop.aspectj.AspectJExpressionPointcut

us.codecraft.tinyioc.aop.AspectJExpressionPointcut

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.