AOP源码解析：AspectJExpressionPointcutAdvisor类

　　先看看 AspectJExpressionPointcutAdvisor 的类图

　　再了解一下切点（Pointcut）表达式，它指定触发advice的方法，可以精确到返回参数，参数类型，方法名

package concert;

public interface Performance {
    void perform();
}

 

　　AspectJExpressionPointcutAdvisor 源码，官方文档解释说这是可以用于任何AspectJ切入点表达式的 Spring AOP Advisor。

@SuppressWarnings("serial")
public class AspectJExpressionPointcutAdvisor extends AbstractGenericPointcutAdvisor implements BeanFactoryAware {

    private final AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut(); // AspectJ表达式切点匹配器


    public void setExpression(@Nullable String expression) {
        this.pointcut.setExpression(expression);
    }

    @Nullable
    public String getExpression() {
        return this.pointcut.getExpression();
    }

    public void setLocation(@Nullable String location) {
        this.pointcut.setLocation(location);
    }

    @Nullable
    public String getLocation() {
        return this.pointcut.getLocation();
    }

    public void setParameterNames(String... names) {
        this.pointcut.setParameterNames(names);
    }

    public void setParameterTypes(Class<?>... types) {
        this.pointcut.setParameterTypes(types);
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) {
        this.pointcut.setBeanFactory(beanFactory);
    }

    @Override
    public Pointcut getPointcut() {
        return this.pointcut;
    }

}

　　再看看 AspectJExpressionPointcutAdvisor 的抽象父类 AbstractGenericPointcutAdvisor 的源码

@SuppressWarnings("serial")
public abstract class AbstractGenericPointcutAdvisor extends AbstractPointcutAdvisor {

    private Advice advice = EMPTY_ADVICE; // Advisor接口中定义的占位符


    /**
     * Specify the advice that this advisor should apply.
     */
    public void setAdvice(Advice advice) {
        this.advice = advice;
    }

    @Override
    public Advice getAdvice() {
        return this.advice;
    }


    @Override
    public String toString() {
        return getClass().getName() + ": advice [" + getAdvice() + "]";
    }

}

　　看完源码后，可以了解到一个 AspectJExpressionPointcutAdvisor 是用来处理对应 AspectJ 的 advice 和切点的，可以在代码中看见有advice的设置和获取、切点表达式的一些处理、设置切点的Bean工厂，还有获取该切点。该 AspectJExpressionPointcutAdvisor 创建了一个 AspectJExpressionPointcut，它们之间的关系是一对一的组合关系，如同字面意思，AspectJExpressionPointcut 与切点表达式有关。

　　下面是 AspectJExpressionPointcut 的类图

 　　AspectJExpressionPointcut 的源码（过长折叠起来了）

public class AspectJExpressionPointcut extends AbstractExpressionPointcut implements ClassFilter, IntroductionAwareMethodMatcher, BeanFactoryAware {
    private static final Set<PointcutPrimitive> SUPPORTED_PRIMITIVES = new HashSet();
    private static final Log logger;
    @Nullable
    private Class<?> pointcutDeclarationScope;
    private String[] pointcutParameterNames = new String[0];
    private Class<?>[] pointcutParameterTypes = new Class[0];
    @Nullable
    private BeanFactory beanFactory;
    @Nullable
    private transient ClassLoader pointcutClassLoader;
    @Nullable
    private transient PointcutExpression pointcutExpression;
    private transient Map<Method, ShadowMatch> shadowMatchCache = new ConcurrentHashMap(32);

    public AspectJExpressionPointcut() {
    }

    public AspectJExpressionPointcut(Class<?> declarationScope, String[] paramNames, Class<?>[] paramTypes) {
        this.pointcutDeclarationScope = declarationScope;
        if (paramNames.length != paramTypes.length) {
            throw new IllegalStateException("Number of pointcut parameter names must match number of pointcut parameter types");
        } else {
            this.pointcutParameterNames = paramNames;
            this.pointcutParameterTypes = paramTypes;
        }
    }

    public void setPointcutDeclarationScope(Class<?> pointcutDeclarationScope) {
        this.pointcutDeclarationScope = pointcutDeclarationScope;
    }

    public void setParameterNames(String... names) {
        this.pointcutParameterNames = names;
    }

    public void setParameterTypes(Class<?>... types) {
        this.pointcutParameterTypes = types;
    }

    public void setBeanFactory(BeanFactory beanFactory) {
        this.beanFactory = beanFactory;
    }

    public ClassFilter getClassFilter() {
        this.obtainPointcutExpression();
        return this;
    }

    public MethodMatcher getMethodMatcher() {
        this.obtainPointcutExpression();
        return this;
    }

    private PointcutExpression obtainPointcutExpression() {
        if (this.getExpression() == null) {
            throw new IllegalStateException("Must set property 'expression' before attempting to match");
        } else {
            if (this.pointcutExpression == null) {
                this.pointcutClassLoader = this.determinePointcutClassLoader();
                this.pointcutExpression = this.buildPointcutExpression(this.pointcutClassLoader);
            }

            return this.pointcutExpression;
        }
    }

    @Nullable
    private ClassLoader determinePointcutClassLoader() {
        if (this.beanFactory instanceof ConfigurableBeanFactory) {
            return ((ConfigurableBeanFactory)this.beanFactory).getBeanClassLoader();
        } else {
            return this.pointcutDeclarationScope != null ? this.pointcutDeclarationScope.getClassLoader() : ClassUtils.getDefaultClassLoader();
        }
    }

    private PointcutExpression buildPointcutExpression(@Nullable ClassLoader classLoader) {
        PointcutParser parser = this.initializePointcutParser(classLoader);
        PointcutParameter[] pointcutParameters = new PointcutParameter[this.pointcutParameterNames.length];

        for(int i = 0; i < pointcutParameters.length; ++i) {
            pointcutParameters[i] = parser.createPointcutParameter(this.pointcutParameterNames[i], this.pointcutParameterTypes[i]);
        }

        return parser.parsePointcutExpression(this.replaceBooleanOperators(this.resolveExpression()), this.pointcutDeclarationScope, pointcutParameters);
    }

    private String resolveExpression() {
        String expression = this.getExpression();
        Assert.state(expression != null, "No expression set");
        return expression;
    }

    private PointcutParser initializePointcutParser(@Nullable ClassLoader classLoader) {
        PointcutParser parser = PointcutParser.getPointcutParserSupportingSpecifiedPrimitivesAndUsingSpecifiedClassLoaderForResolution(SUPPORTED_PRIMITIVES, classLoader);
        parser.registerPointcutDesignatorHandler(new AspectJExpressionPointcut.BeanPointcutDesignatorHandler());
        return parser;
    }

    private String replaceBooleanOperators(String pcExpr) {
        String result = StringUtils.replace(pcExpr, " and ", " && ");
        result = StringUtils.replace(result, " or ", " || ");
        result = StringUtils.replace(result, " not ", " ! ");
        return result;
    }

    public PointcutExpression getPointcutExpression() {
        return this.obtainPointcutExpression();
    }

    public boolean matches(Class<?> targetClass) {
        PointcutExpression pointcutExpression = this.obtainPointcutExpression();

        try {
            try {
                return pointcutExpression.couldMatchJoinPointsInType(targetClass);
            } catch (ReflectionWorldException var5) {
                logger.debug("PointcutExpression matching rejected target class - trying fallback expression", var5);
                PointcutExpression fallbackExpression = this.getFallbackPointcutExpression(targetClass);
                if (fallbackExpression != null) {
                    return fallbackExpression.couldMatchJoinPointsInType(targetClass);
                }
            }
        } catch (Throwable var6) {
            logger.debug("PointcutExpression matching rejected target class", var6);
        }

        return false;
    }

    public boolean matches(Method method, Class<?> targetClass, boolean hasIntroductions) {
        this.obtainPointcutExpression();
        ShadowMatch shadowMatch = this.getTargetShadowMatch(method, targetClass);
        if (shadowMatch.alwaysMatches()) {
            return true;
        } else if (shadowMatch.neverMatches()) {
            return false;
        } else if (hasIntroductions) {
            return true;
        } else {
            RuntimeTestWalker walker = this.getRuntimeTestWalker(shadowMatch);
            return !walker.testsSubtypeSensitiveVars() || walker.testTargetInstanceOfResidue(targetClass);
        }
    }

    public boolean matches(Method method, Class<?> targetClass) {
        return this.matches(method, targetClass, false);
    }

    public boolean isRuntime() {
        return this.obtainPointcutExpression().mayNeedDynamicTest();
    }

    public boolean matches(Method method, Class<?> targetClass, Object... args) {
        this.obtainPointcutExpression();
        ShadowMatch shadowMatch = this.getTargetShadowMatch(method, targetClass);
        ProxyMethodInvocation pmi = null;
        Object targetObject = null;
        Object thisObject = null;

        try {
            MethodInvocation mi = ExposeInvocationInterceptor.currentInvocation();
            targetObject = mi.getThis();
            if (!(mi instanceof ProxyMethodInvocation)) {
                throw new IllegalStateException("MethodInvocation is not a Spring ProxyMethodInvocation: " + mi);
            }

            pmi = (ProxyMethodInvocation)mi;
            thisObject = pmi.getProxy();
        } catch (IllegalStateException var11) {
            if (logger.isDebugEnabled()) {
                logger.debug("Could not access current invocation - matching with limited context: " + var11);
            }
        }

        try {
            JoinPointMatch joinPointMatch = shadowMatch.matchesJoinPoint(thisObject, targetObject, args);
            if (pmi != null && thisObject != null) {
                RuntimeTestWalker originalMethodResidueTest = this.getRuntimeTestWalker(this.getShadowMatch(method, method));
                if (!originalMethodResidueTest.testThisInstanceOfResidue(thisObject.getClass())) {
                    return false;
                }

                if (joinPointMatch.matches()) {
                    this.bindParameters(pmi, joinPointMatch);
                }
            }

            return joinPointMatch.matches();
        } catch (Throwable var10) {
            if (logger.isDebugEnabled()) {
                logger.debug("Failed to evaluate join point for arguments " + Arrays.asList(args) + " - falling back to non-match", var10);
            }

            return false;
        }
    }

    @Nullable
    protected String getCurrentProxiedBeanName() {
        return ProxyCreationContext.getCurrentProxiedBeanName();
    }

    @Nullable
    private PointcutExpression getFallbackPointcutExpression(Class<?> targetClass) {
        try {
            ClassLoader classLoader = targetClass.getClassLoader();
            if (classLoader != null && classLoader != this.pointcutClassLoader) {
                return this.buildPointcutExpression(classLoader);
            }
        } catch (Throwable var3) {
            logger.debug("Failed to create fallback PointcutExpression", var3);
        }

        return null;
    }

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

    private void bindParameters(ProxyMethodInvocation invocation, JoinPointMatch jpm) {
        invocation.setUserAttribute(this.resolveExpression(), jpm);
    }

    private ShadowMatch getTargetShadowMatch(Method method, Class<?> targetClass) {
        Method targetMethod = AopUtils.getMostSpecificMethod(method, targetClass);
        if (targetMethod.getDeclaringClass().isInterface()) {
            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 var6) {
                }
            }
        }

        return this.getShadowMatch(targetMethod, method);
    }

    private ShadowMatch getShadowMatch(Method targetMethod, Method originalMethod) {
        ShadowMatch shadowMatch = (ShadowMatch)this.shadowMatchCache.get(targetMethod);
        if (shadowMatch == null) {
            synchronized(this.shadowMatchCache) {
                PointcutExpression fallbackExpression = null;
                shadowMatch = (ShadowMatch)this.shadowMatchCache.get(targetMethod);
                if (shadowMatch == null) {
                    Method methodToMatch = targetMethod;

                    try {
                        try {
                            shadowMatch = this.obtainPointcutExpression().matchesMethodExecution(methodToMatch);
                        } catch (ReflectionWorldException var13) {
                            try {
                                fallbackExpression = this.getFallbackPointcutExpression(methodToMatch.getDeclaringClass());
                                if (fallbackExpression != null) {
                                    shadowMatch = fallbackExpression.matchesMethodExecution(methodToMatch);
                                }
                            } catch (ReflectionWorldException var12) {
                                fallbackExpression = null;
                            }
                        }

                        if (targetMethod != originalMethod && (shadowMatch == null || ((ShadowMatch)shadowMatch).neverMatches() && Proxy.isProxyClass(targetMethod.getDeclaringClass()))) {
                            methodToMatch = originalMethod;

                            try {
                                shadowMatch = this.obtainPointcutExpression().matchesMethodExecution(methodToMatch);
                            } catch (ReflectionWorldException var11) {
                                try {
                                    fallbackExpression = this.getFallbackPointcutExpression(methodToMatch.getDeclaringClass());
                                    if (fallbackExpression != null) {
                                        shadowMatch = fallbackExpression.matchesMethodExecution(methodToMatch);
                                    }
                                } catch (ReflectionWorldException var10) {
                                    fallbackExpression = null;
                                }
                            }
                        }
                    } catch (Throwable var14) {
                        logger.debug("PointcutExpression matching rejected target method", var14);
                        fallbackExpression = null;
                    }

                    if (shadowMatch == null) {
                        shadowMatch = new ShadowMatchImpl(FuzzyBoolean.NO, (Test)null, (ExposedState)null, (PointcutParameter[])null);
                    } else if (((ShadowMatch)shadowMatch).maybeMatches() && fallbackExpression != null) {
                        shadowMatch = new AspectJExpressionPointcut.DefensiveShadowMatch((ShadowMatch)shadowMatch, fallbackExpression.matchesMethodExecution(methodToMatch));
                    }

                    this.shadowMatchCache.put(targetMethod, shadowMatch);
                }
            }
        }

        return (ShadowMatch)shadowMatch;
    }

    public boolean equals(Object other) {
        if (this == other) {
            return true;
        } else if (!(other instanceof AspectJExpressionPointcut)) {
            return false;
        } else {
            AspectJExpressionPointcut otherPc = (AspectJExpressionPointcut)other;
            return ObjectUtils.nullSafeEquals(this.getExpression(), otherPc.getExpression()) && ObjectUtils.nullSafeEquals(this.pointcutDeclarationScope, otherPc.pointcutDeclarationScope) && ObjectUtils.nullSafeEquals(this.pointcutParameterNames, otherPc.pointcutParameterNames) && ObjectUtils.nullSafeEquals(this.pointcutParameterTypes, otherPc.pointcutParameterTypes);
        }
    }

    public int hashCode() {
        int hashCode = ObjectUtils.nullSafeHashCode(this.getExpression());
        hashCode = 31 * hashCode + ObjectUtils.nullSafeHashCode(this.pointcutDeclarationScope);
        hashCode = 31 * hashCode + ObjectUtils.nullSafeHashCode(this.pointcutParameterNames);
        hashCode = 31 * hashCode + ObjectUtils.nullSafeHashCode(this.pointcutParameterTypes);
        return hashCode;
    }

    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("AspectJExpressionPointcut: ");
        sb.append("(");

        for(int i = 0; i < this.pointcutParameterTypes.length; ++i) {
            sb.append(this.pointcutParameterTypes[i].getName());
            sb.append(" ");
            sb.append(this.pointcutParameterNames[i]);
            if (i + 1 < this.pointcutParameterTypes.length) {
                sb.append(", ");
            }
        }

        sb.append(")");
        sb.append(" ");
        if (this.getExpression() != null) {
            sb.append(this.getExpression());
        } else {
            sb.append("<pointcut expression not set>");
        }

        return sb.toString();
    }

    private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
        ois.defaultReadObject();
        this.shadowMatchCache = new ConcurrentHashMap(32);
    }

    static {
        SUPPORTED_PRIMITIVES.add(PointcutPrimitive.EXECUTION);
        SUPPORTED_PRIMITIVES.add(PointcutPrimitive.ARGS);
        SUPPORTED_PRIMITIVES.add(PointcutPrimitive.REFERENCE);
        SUPPORTED_PRIMITIVES.add(PointcutPrimitive.THIS);
        SUPPORTED_PRIMITIVES.add(PointcutPrimitive.TARGET);
        SUPPORTED_PRIMITIVES.add(PointcutPrimitive.WITHIN);
        SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_ANNOTATION);
        SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_WITHIN);
        SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_ARGS);
        SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_TARGET);
        logger = LogFactory.getLog(AspectJExpressionPointcut.class);
    }

    private static class DefensiveShadowMatch implements ShadowMatch {
        private final ShadowMatch primary;
        private final ShadowMatch other;

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

        public boolean alwaysMatches() {
            return this.primary.alwaysMatches();
        }

        public boolean maybeMatches() {
            return this.primary.maybeMatches();
        }

        public boolean neverMatches() {
            return this.primary.neverMatches();
        }

        public JoinPointMatch matchesJoinPoint(Object thisObject, Object targetObject, Object[] args) {
            try {
                return this.primary.matchesJoinPoint(thisObject, targetObject, args);
            } catch (ReflectionWorldException var5) {
                return this.other.matchesJoinPoint(thisObject, targetObject, args);
            }
        }

        public void setMatchingContext(MatchingContext aMatchContext) {
            this.primary.setMatchingContext(aMatchContext);
            this.other.setMatchingContext(aMatchContext);
        }
    }

    private class BeanContextMatcher implements ContextBasedMatcher {
        private final NamePattern expressionPattern;

        public BeanContextMatcher(String expression) {
            this.expressionPattern = new NamePattern(expression);
        }

        /** @deprecated */
        @Deprecated
        public boolean couldMatchJoinPointsInType(Class someClass) {
            return this.contextMatch(someClass) == org.aspectj.weaver.tools.FuzzyBoolean.YES;
        }

        /** @deprecated */
        @Deprecated
        public boolean couldMatchJoinPointsInType(Class someClass, MatchingContext context) {
            return this.contextMatch(someClass) == org.aspectj.weaver.tools.FuzzyBoolean.YES;
        }

        public boolean matchesDynamically(MatchingContext context) {
            return true;
        }

        public org.aspectj.weaver.tools.FuzzyBoolean matchesStatically(MatchingContext context) {
            return this.contextMatch((Class)null);
        }

        public boolean mayNeedDynamicTest() {
            return false;
        }

        private org.aspectj.weaver.tools.FuzzyBoolean contextMatch(@Nullable Class<?> targetType) {
            String advisedBeanName = AspectJExpressionPointcut.this.getCurrentProxiedBeanName();
            if (advisedBeanName == null) {
                return org.aspectj.weaver.tools.FuzzyBoolean.MAYBE;
            } else if (BeanFactoryUtils.isGeneratedBeanName(advisedBeanName)) {
                return org.aspectj.weaver.tools.FuzzyBoolean.NO;
            } else if (targetType != null) {
                boolean isFactory = FactoryBean.class.isAssignableFrom(targetType);
                return org.aspectj.weaver.tools.FuzzyBoolean.fromBoolean(this.matchesBean(isFactory ? "&" + advisedBeanName : advisedBeanName));
            } else {
                return org.aspectj.weaver.tools.FuzzyBoolean.fromBoolean(this.matchesBean(advisedBeanName) || this.matchesBean("&" + advisedBeanName));
            }
        }

        private boolean matchesBean(String advisedBeanName) {
            return BeanFactoryAnnotationUtils.isQualifierMatch(this.expressionPattern::matches, advisedBeanName, AspectJExpressionPointcut.this.beanFactory);
        }
    }

    private class BeanPointcutDesignatorHandler implements PointcutDesignatorHandler {
        private static final String BEAN_DESIGNATOR_NAME = "bean";

        private BeanPointcutDesignatorHandler() {
        }

        public String getDesignatorName() {
            return "bean";
        }

        public ContextBasedMatcher parse(String expression) {
            return AspectJExpressionPointcut.this.new BeanContextMatcher(expression);
        }
    }
}

　　那下面就挑一部分代码来看，首先看静态代码块，里面的Set放的是切面表达式所支持的类型

    private static final Set<PointcutPrimitive> SUPPORTED_PRIMITIVES = new HashSet<>();

    static {
        SUPPORTED_PRIMITIVES.add(PointcutPrimitive.EXECUTION);
        SUPPORTED_PRIMITIVES.add(PointcutPrimitive.ARGS);
        SUPPORTED_PRIMITIVES.add(PointcutPrimitive.REFERENCE);
        SUPPORTED_PRIMITIVES.add(PointcutPrimitive.THIS);
        SUPPORTED_PRIMITIVES.add(PointcutPrimitive.TARGET);
        SUPPORTED_PRIMITIVES.add(PointcutPrimitive.WITHIN);
        SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_ANNOTATION);
        SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_WITHIN);
        SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_ARGS);
        SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_TARGET);
    }

　　切点表达式类型：

1. execution表达式：能在运行指定方法时拦截指定方法，用的最多。

2. args：匹配参数，当执行的方法的参数是指定类型时生效。

3. reference：表示引用其他命名切入点，只有@ApectJ风格支持，Schema风格不支持

4. this：Spring Aop是基于代理的，生成的bean也是一个代理对象，this就是这个代理对象，当这个对象可以转换为指定的类型时，对应的切入点就是它了，Spring Aop将生效。

5. target：当被代理的对象可以转换为指定的类型时，对应的切入点就是它了，Spring Aop将生效。

6. within：指定某些类型的全部方法执行，也可用来指定一个包。

7. @target：当代理的目标对象上拥有指定的注解时生效。

8. @args：当执行的方法参数类型上拥有指定的注解时生效。

9. @within：与@target类似，看官方文档和网上的说法都是@within只需要目标对象的类或者父类上有指定的注解，则@within会生效，而@target则是必须是目标对象的类上有指定的注解。而根据笔者的测试这两者都是只要目标类或父类上有指定的注解即可。

10. @annotation：当执行的方法上拥有指定的注解时生效。

　　还有一种是Spring Aop扩展的类型 bean：当调用的方法是指定的bean的方法时生效。

　　AspectJExpressionPointcut 的属性里面还有 PointcutExpression，是org.aspectj.weaver.tools.PointcutExpression 中的类 ，经过一系列操作后由org.aspectj.weaver.tools.PointcutParser#parsePointcutExpression 从字符串表达式解析出来。

    @Nullable
    private transient PointcutExpression pointcutExpression;

　　这个是ClassFilter 接口的实现方法，借助的 PointcutExpression#couldMatchJoinPointsInType 去匹配，其参数为一个代表被检测类Class的实例，如果切入点适合该类，则返回true

    @Override
    public boolean matches(Class<?> targetClass) {
        PointcutExpression pointcutExpression = obtainPointcutExpression();
        try {
            try {
                return pointcutExpression.couldMatchJoinPointsInType(targetClass);
            }
            catch (ReflectionWorldException ex) {
                logger.debug("PointcutExpression matching rejected target class - trying fallback expression", ex);
                // Actually this is still a "maybe" - treat the pointcut as dynamic if we don't know enough yet
                PointcutExpression fallbackExpression = getFallbackPointcutExpression(targetClass);
                if (fallbackExpression != null) {
                    return fallbackExpression.couldMatchJoinPointsInType(targetClass);
                }
            }
        }
        catch (Throwable ex) {
            logger.debug("PointcutExpression matching rejected target class", ex);
        }
        return false;
    }

　　下面这个是 MethodMatcher 接口中的 match 方法，作为Spring支持静态和动态的MethodMatcher。执行静态检查给定的方法是否匹配。

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

        // 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;
        Object thisObject = null;
        try {
            MethodInvocation mi = ExposeInvocationInterceptor.currentInvocation();
            targetObject = mi.getThis();
            if (!(mi instanceof ProxyMethodInvocation)) {
                throw new IllegalStateException("MethodInvocation is not a Spring ProxyMethodInvocation: " + mi);
            }
            pmi = (ProxyMethodInvocation) mi;
            thisObject = pmi.getProxy();
        }
        catch (IllegalStateException ex) {
            // No current invocation...
            if (logger.isDebugEnabled()) {
                logger.debug("Could not access current invocation - matching with limited context: " + ex);
            }
        }

        try {
            JoinPointMatch joinPointMatch = shadowMatch.matchesJoinPoint(thisObject, targetObject, args);

            /*
             * Do a final check to see if any this(TYPE) kind of residue match. For
             * this purpose, we use the original method's (proxy method's) shadow to
             * ensure that 'this' is correctly checked against. Without this check,
             * we get incorrect match on this(TYPE) where TYPE matches the target
             * type but not 'this' (as would be the case of JDK dynamic proxies).
             * <p>See SPR-2979 for the original bug.
             */
            if (pmi != null && thisObject != null) {  // there is a current invocation
                RuntimeTestWalker originalMethodResidueTest = getRuntimeTestWalker(getShadowMatch(method, method));
                if (!originalMethodResidueTest.testThisInstanceOfResidue(thisObject.getClass())) {
                    return false;
                }
                if (joinPointMatch.matches()) {
                    bindParameters(pmi, joinPointMatch);
                }
            }

            return joinPointMatch.matches();
        }
        catch (Throwable ex) {
            if (logger.isDebugEnabled()) {
                logger.debug("Failed to evaluate join point for arguments " + Arrays.asList(args) +
                        " - falling back to non-match", ex);
            }
            return false;
        }
    }

　　初始化一个基础的AspectJ切入点解析器，BeanPointcutDesignatorHandler 这个是Spring实现真正解析的内部类。

    /**
     * Initialize the underlying AspectJ pointcut parser.
     */
    private PointcutParser initializePointcutParser(@Nullable ClassLoader classLoader) {
        PointcutParser parser = PointcutParser
                .getPointcutParserSupportingSpecifiedPrimitivesAndUsingSpecifiedClassLoaderForResolution(
                        SUPPORTED_PRIMITIVES, classLoader);
        parser.registerPointcutDesignatorHandler(new BeanPointcutDesignatorHandler()); // 注册了一个BeanPointcutDesignatorHandler它是处理Spring自己支持的bean()的切点表达式的
        return parser;
    }

 总结