spring aop 动态代理

最近在做代码的性能优化，用arthas的trace命令来查看方法调用链及各个方法的耗时，发现一个加了事务注解（@Transactional(rollbackFor = Exception.class, propagation = Propagation.NOT_SUPPORTED)）的方法执行速度有点慢，调用此方法（代理）的执行时间几乎和内部方法的执行时间一样了，去掉方法上的事务注解，耗时就很少了，虽然后续还不知道如何处理这个方法（方法上的事务是后来加上去的，应该是不会去掉了，很有可能要改方法外的逻辑），但是对这点挺好奇的，于是查了下spring aop动态代理的文章，这里做个记录。

原文链接:https://yaoyuanyy.github.io/categories/spring/

01 AnnotationAwareAspectJAutoProxyCreator

直接看EnableAspectJAutoProxy接口注解（注释还是有点东西的），关键点在于@Import的类上。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
  /**
  Enables support for handling components marked with AspectJ's @Aspect annotation, similar to functionality found in Spring's <aop:aspectj-autoproxy> XML element. To be used on @Configuration classes as follows:
    @Configuration
    @EnableAspectJAutoProxy
    public class AppConfig {
    
        @Bean
        public FooService fooService() {
            return new FooService();
        }
    
        @Bean
        public MyAspect myAspect() {
            return new MyAspect();
        }
    }
  Where FooService is a typical POJO component and MyAspect is an @Aspect-style aspect:
    public class FooService {
    
        // various methods
    }
    @Aspect
    public class MyAspect {
    
        @Before("execution(* FooService+.*(..))")
        public void advice() {
            // advise FooService methods as appropriate
        }
    }
  In the scenario above, @EnableAspectJAutoProxy ensures that MyAspect will be properly processed and that FooService will be proxied mixing in the advice that it contributes.
  Users can control the type of proxy that gets created for FooService using the proxyTargetClass() attribute. The following enables CGLIB-style 'subclass' proxies as opposed to the default interface-based JDK proxy approach.
    @Configuration
    @EnableAspectJAutoProxy(proxyTargetClass=true)
    public class AppConfig {
        // ...
    }
  Note that @Aspect beans may be component-scanned like any other. Simply mark the aspect with both @Aspect and @Component:
    package com.foo;
    
    @Component
    public class FooService { ... }
    
    @Aspect
    @Component
    public class MyAspect { ... }
  Then use the @ComponentScan annotation to pick both up:
    @Configuration
    @ComponentScan("com.foo")
    @EnableAspectJAutoProxy
    public class AppConfig {
    
        // no explicit @Bean definitions required
    }
  Note: @EnableAspectJAutoProxy applies to its local application context only, allowing for selective proxying of beans at different levels. Please redeclare @EnableAspectJAutoProxy in each individual context, e.g. the common root web application context and any separate DispatcherServlet application contexts, if you need to apply its behavior at multiple levels.
  This feature requires the presence of aspectjweaver on the classpath. While that dependency is optional for spring-aop in general, it is required for @EnableAspectJAutoProxy and its underlying facilities.
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {

	boolean proxyTargetClass() default false;

	boolean exposeProxy() default false;

}

下面看下AspectJAutoProxyRegistrar这个类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/**
 * 根据所给的 @EnableAspectJAutoProxy 注释和属性值，注册一个 AnnotationAwareAspectJAutoProxyCreator 给当前的 BeanDefinitionRegistry
 */
class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {

	/**
	 * 根据@Configuration class import的属性EnableAspectJAutoProxy#proxyTargetClass()的值去注册、配置AspectJ auto proxy creator based on the value
	 */
	public void registerBeanDefinitions(
			AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

		//注册一个AnnotationAwareAspectJAutoProxyCreator到BeanFactory容器中。
		AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);

		AnnotationAttributes enableAspectJAutoProxy =
				AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
		if (enableAspectJAutoProxy != null) {
			if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
				//根据proxyTargetClass的值判断是否使用cglib的代理方式(这就是我们日常工作中要想使用cglib代理方式时声明proxyTargetClass=true的原因)。
				AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
			}
			if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
				//是否可以通过AopContext.currentProxy()取到代理对象。
				AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
			}
		}
	}
}

最终，AnnotationAwareAspectJAutoProxyCreator bean被创建后放入beanFactory。后面当其他类bean instance时会用到它，为什么会用到它呢？核心关键点：因为AnnotationAwareAspectJAutoProxyCreator
是一个InstantiationAwareBeanPostProcessor和BeanPostProcessor，所以beanFactory容器中所有的类被创建都会经过他的的实例化前后置处理和初始化前后置处理。而AnnotationAwareAspectJAutoProxyCreator从父类AbstractAutoProxyCreator继承来的postProcessBeforeInstantiation(Class<?> beanClass, String beanName)方法和postProcessAfterInitialization(Object bean, String beanName)方法都是生成代理类的功能。
具体调用流程是在org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object[])中调用的

1
2
3
4
5
6
7
try {
  // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
  Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
  if (bean != null) {
    return bean;
  }
}

两个方法生成代理类的时机不同，过滤条件也不一样，下面详细说下

postProcessBeforeInstantiation实例化前置方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
  // 后面数据map存储Key使用。如果beanName长度大于0，返回beanName,否则返回beanClass
  Object cacheKey = getCacheKey(beanClass, beanName);
  // 判断targetSourcedBeans是否包含当前beanName,如果不包含；
  // 接着判断是否这个beanName已经生成过代理类，如果没有生成过；
  // 接着判断beanClass是否为advice,advisor,PointCut,AopInfrastructureBean子类或者beanClass有Aspect注解，不产生代理类，如果是，不生成代理
  // 防止重复走(1)处逻辑，提供性能
  if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
    if (this.advisedBeans.containsKey(cacheKey)) {
      return null;
    }
    // 如果beanClass是advice,advisor,PointCut,AopInfrastructureBean子类或者beanClass有Aspect注解，不产生代理类
    if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {//(1)
      this.advisedBeans.put(cacheKey, Boolean.FALSE);
      return null;
    }
  }

  // Create proxy here if we have a custom TargetSource.
  // Suppresses unnecessary default instantiation of the target bean:
  // The TargetSource will handle target instances in a custom fashion.
  TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
  if (targetSource != null) {
    if (StringUtils.hasLength(beanName)) {
      this.targetSourcedBeans.add(beanName);
    }
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
    Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
    this.proxyTypes.put(cacheKey, proxy.getClass());
    return proxy;
  }

  return null;
}

postProcessAfterInitialization初始化后置方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
/**
  * 这个方法生成代理类的过滤条件沿用了postProcessBeforeInstantiation()的过滤逻辑，在这个基础上又增加了两个过滤条件：
  * earlyProxyReferences不包含这个bean
  * 根据beanName、beanClass获取到的interceptors有值。这些条件满足后生成代理类
  */
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) throws BeansException {
  if (bean != null) {
    Object cacheKey = getCacheKey(bean.getClass(), beanName);
    if (!this.earlyProxyReferences.contains(cacheKey)) {
      return wrapIfNecessary(bean, beanName, cacheKey);
    }
  }
  return bean;
}

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
  if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
    return bean;
  }
  if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
    return bean;
  }
  if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
    this.advisedBeans.put(cacheKey, Boolean.FALSE);
    return bean;
  }

  // Create proxy if we have advice.
  Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
  if (specificInterceptors != DO_NOT_PROXY) {
    this.advisedBeans.put(cacheKey, Boolean.TRUE);
    Object proxy = createProxy(
        bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
    this.proxyTypes.put(cacheKey, proxy.getClass());
    return proxy;
  }

  this.advisedBeans.put(cacheKey, Boolean.FALSE);
  return bean;
}

02 判断beanName或beanClass是否生成Proxy代理类

首先需要创建两个类，然后启动项目debug进行分析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

/**
 * Bean实例化之后做的增强
 * 分析这个类的加载流程
 */
@Component
public class MyInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter {

	@Override
	public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
		System.out.println(this.getClass().getName() + ".postProcessBeforeInstantiation()被调用 了...");
		return super.postProcessBeforeInstantiation(beanClass, beanName);
	}

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		System.out.println(this.getClass().getName() + ".postProcessAfterInitialization()被调用 了...");
		return super.postProcessAfterInitialization(bean, beanName);
	}

	@Override
	public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean,
													String beanName) throws BeansException {
		System.out.println(this.getClass().getName() + ".postProcessPropertyValues()被调用 了...");
		return super.postProcessPropertyValues(pvs, pds, bean, beanName);
	}
}

下面这个是一个切面类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Aspect
@Component
@EnableAspectJAutoProxy
public class TimeFeeAspect {

	@Pointcut("execution(* com.xuekg.constructor..*(..))")
	public void cut(){}

	@Before("cut()")
	public void doTimeFeeIntercepter(JoinPoint joinPoint) throws Throwable {
		System.out.println("args: " + joinPoint.getArgs());
		System.out.println("target: " + joinPoint.getTarget().toString());
	}
}

断点走到postProcessBeforeInstantiation()中，进入到shouldSkip(beanClass, beanName)方法

1
2
3
4
5
6
7
8
9
10
11
12
protected boolean shouldSkip(Class<?> beanClass, String beanName) {
  // TODO: Consider optimization by caching the list of the aspect names
  //advisor候选者
  List<Advisor> candidateAdvisors = findCandidateAdvisors();
  for (Advisor advisor : candidateAdvisors) {
    if (advisor instanceof AspectJPointcutAdvisor &&
        ((AspectJPointcutAdvisor) advisor).getAspectName().equals(beanName)) {
      return true;
    }
  }
  return super.shouldSkip(beanClass, beanName);
}

首先获取advisor候选者列表，然后遍历，如果有AspectName等于beanName，说明这个beanName是Aspect，不用生成代理，方法返回true，否则走父类逻辑(返回false)。查看获取advisor候选者方法findCandidateAdvisors()

1
2
3
4
5
6
7
8
9
protected List<Advisor> findCandidateAdvisors() {
  // Add all the Spring advisors found according to superclass rules.
  List<Advisor> advisors = super.findCandidateAdvisors();
  // Build Advisors for all AspectJ aspects in the bean factory.
  if (this.aspectJAdvisorsBuilder != null) {
    advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
  }
  return advisors;
}

方法内部逻辑很简单，但是意义重大，从两个角度获取Advisor。角度一是从beanFactory容器中获取Advisor类；角度二是从beanFactory容器中获取Aspect类。先看其一

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
public List<Advisor> findAdvisorBeans() {
  // Determine list of advisor bean names, if not cached already.
  String[] advisorNames = null;
  synchronized (this) {
    advisorNames = this.cachedAdvisorBeanNames;
    if (advisorNames == null) {
      // Do not initialize FactoryBeans here: We need to leave all regular beans
      // uninitialized to let the auto-proxy creator apply to them!
      advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
          this.beanFactory, Advisor.class, true, false);
      this.cachedAdvisorBeanNames = advisorNames;
    }
  }
  if (advisorNames.length == 0) {
    return new LinkedList<>();
  }

  List<Advisor> advisors = new LinkedList<>();
  for (String name : advisorNames) {
    if (isEligibleBean(name)) {
      if (this.beanFactory.isCurrentlyInCreation(name)) {
        if (logger.isDebugEnabled()) {
          logger.debug("Skipping currently created advisor '" + name + "'");
        }
      }
      else {
        try {
          advisors.add(this.beanFactory.getBean(name, Advisor.class));
        }
        catch (BeanCreationException ex) {
          Throwable rootCause = ex.getMostSpecificCause();
          if (rootCause instanceof BeanCurrentlyInCreationException) {
            BeanCreationException bce = (BeanCreationException) rootCause;
            String bceBeanName = bce.getBeanName();
            if (bceBeanName != null && this.beanFactory.isCurrentlyInCreation(bceBeanName)) {
              if (logger.isDebugEnabled()) {
                logger.debug("Skipping advisor '" + name +
                    "' with dependency on currently created bean: " + ex.getMessage());
              }
              // Ignore: indicates a reference back to the bean we're trying to advise.
              // We want to find advisors other than the currently created bean itself.
              continue;
            }
          }
          throw ex;
        }
      }
    }
  }
  return advisors;
}

这里只列出了关键代码，可以看到，从beanFactory容器中获取Advisor的子类name集合，然后验证下name是否合格，合格后获取name对应的bean。但是实际debug代码时，这步却没有获取到Advisor的子类，所以返回的是空list。
回到findCandidateAdvisors()方法,看其二

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
public List<Advisor> buildAspectJAdvisors() {
  List<String> aspectNames = this.aspectBeanNames;

  if (aspectNames == null) {
    synchronized (this) {
      aspectNames = this.aspectBeanNames;
      if (aspectNames == null) {
        List<Advisor> advisors = new LinkedList<>();
        aspectNames = new LinkedList<>();
        // 从beanFactory中获取所有的beanName
        String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
            this.beanFactory, Object.class, true, false);
        // 遍历beanName集合对beanName进行合格性验证
        for (String beanName : beanNames) {
          // 默认true,除非有aop:include使用
          if (!isEligibleBean(beanName)) {//(1)
            continue;
          }
          // We must be careful not to instantiate beans eagerly as in this case they
          // would be cached by the Spring container but would not have been weaved.
          Class<?> beanType = this.beanFactory.getType(beanName);
          if (beanType == null) {
            continue;
          }
          if (this.advisorFactory.isAspect(beanType)) {//(2)
            aspectNames.add(beanName);
            AspectMetadata amd = new AspectMetadata(beanType, beanName);
            //singleton
            if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
              MetadataAwareAspectInstanceFactory factory =
                  new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);//(3)
              List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);//(4)
              if (this.beanFactory.isSingleton(beanName)) {
                this.advisorsCache.put(beanName, classAdvisors);
              }
              else {
                this.aspectFactoryCache.put(beanName, factory);
              }
              advisors.addAll(classAdvisors);
            }
            else {
              // Per target or per this.
              if (this.beanFactory.isSingleton(beanName)) {
                throw new IllegalArgumentException("Bean with name '" + beanName +
                    "' is a singleton, but aspect instantiation model is not singleton");
              }
              MetadataAwareAspectInstanceFactory factory =
                  new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
              this.aspectFactoryCache.put(beanName, factory);
              advisors.addAll(this.advisorFactory.getAdvisors(factory));
            }
          }
        }
        this.aspectBeanNames = aspectNames;
        return advisors;
      }
    }
  }

  if (aspectNames.isEmpty()) {
    return Collections.emptyList();
  }
  List<Advisor> advisors = new LinkedList<>();
  for (String aspectName : aspectNames) {
    List<Advisor> cachedAdvisors = this.advisorsCache.get(aspectName);
    if (cachedAdvisors != null) {
      advisors.addAll(cachedAdvisors);
    }
    else {
      MetadataAwareAspectInstanceFactory factory = this.aspectFactoryCache.get(aspectName);
      advisors.addAll(this.advisorFactory.getAdvisors(factory));
    }
  }
  return advisors;
}

代码(2)处，判断beanType是否为Aspect，实现逻辑为AnnotationUtils.findAnnotation(clazz, Aspect.class) != null，开头我定义了一个TimeFeeAspect切面类，所以这里只有TimeFeeAspect符合条件，进入if块里面
代码(3)处，构造一个带有Aspect metadata和beanFactory的BeanFactoryAspectInstanceFactory实例，传给关键代码(4)块，看代码(4)内部逻辑

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
  Class<?> aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
  String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName();
  validate(aspectClass);

  // We need to wrap the MetadataAwareAspectInstanceFactory with a decorator
  // so that it will only instantiate once.
  MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory =
      new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);

  List<Advisor> advisors = new LinkedList<>();
  //获取aspectClass的方法集合
  for (Method method : getAdvisorMethods(aspectClass)) {
    Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName);
    if (advisor != null) {
      advisors.add(advisor);
    }
  }

  // If it's a per target aspect, emit the dummy instantiating aspect.
  if (!advisors.isEmpty() && lazySingletonAspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
    Advisor instantiationAdvisor = new SyntheticInstantiationAdvisor(lazySingletonAspectInstanceFactory);
    advisors.add(0, instantiationAdvisor);
  }

  // Find introduction fields.
  for (Field field : aspectClass.getDeclaredFields()) {
    Advisor advisor = getDeclareParentsAdvisor(field);
    if (advisor != null) {
      advisors.add(advisor);
    }
  }

  return advisors;
}

这个方法的目的很明确：获取advisor。方法解析出入参aspectClass的methods，遍历methods从而获取advisor集合，advisor包含advice和pointcut。
根据method获取advisor的getAdvisor(..)方法就是核心逻辑了，看其内部

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory,
    int declarationOrderInAspect, String aspectName) {

  // 验证aspectClass是否有@Aspect注解，其父类是否没有Aspect注解
  validate(aspectInstanceFactory.getAspectMetadata().getAspectClass());

  // 核心：生成PointCut
  AspectJExpressionPointcut expressionPointcut = getPointcut(
      candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());
  if (expressionPointcut == null) {
    return null;
  }

  return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,
      this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
}

方法首先验证后，根据adviceMethod和aspectClass生成PointCut，然后构造成InstantiationModelAwarePointcutAdvisorImpl实例。首先看生成PointCut的逻辑

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
private AspectJExpressionPointcut getPointcut(Method candidateAdviceMethod, Class<?> candidateAspectClass) {
  // 获取method的Advice,即Before.class, Around.class, After.class, AfterReturning.class, AfterThrowing.class
  // AspectJAnnotation包括具体类型的Advice和PointCut的expression
  AspectJAnnotation<?> aspectJAnnotation =
      AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
  if (aspectJAnnotation == null) {
    return null;
  }

  //构造pointCut
  AspectJExpressionPointcut ajexp =
      new AspectJExpressionPointcut(candidateAspectClass, new String[0], new Class<?>[0]);
  ajexp.setExpression(aspectJAnnotation.getPointcutExpression());
  if (this.beanFactory != null) {
    ajexp.setBeanFactory(this.beanFactory);
  }
  return ajexp;
}

protected static AspectJAnnotation<?> findAspectJAnnotationOnMethod(Method method) {
  Class<?>[] classesToLookFor = new Class<?>[] {
      Before.class, Around.class, After.class, AfterReturning.class, AfterThrowing.class, Pointcut.class};
  // 匹配方法的Advice类型：Before.class, Around.class, After.class, AfterReturning.class, AfterThrowing.class, Pointcut.class
  // 匹配即返回
  for (Class<?> c : classesToLookFor) {
    AspectJAnnotation<?> foundAnnotation = findAnnotation(method, (Class<Annotation>) c);
    if (foundAnnotation != null) {
      return foundAnnotation;
    }
  }
  return null;
}

生成PointCut后，代码回到ReflectiveAspectJAdvisorFactory.getAdvisor()方法的构造InstantiationModelAwarePointcutAdvisorImpl实例部分，查看其构造方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public InstantiationModelAwarePointcutAdvisorImpl(AspectJExpressionPointcut declaredPointcut,
    Method aspectJAdviceMethod, AspectJAdvisorFactory aspectJAdvisorFactory,
    MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {

  this.declaredPointcut = declaredPointcut;
  this.declaringClass = aspectJAdviceMethod.getDeclaringClass();
  this.methodName = aspectJAdviceMethod.getName();
  this.parameterTypes = aspectJAdviceMethod.getParameterTypes();
  this.aspectJAdviceMethod = aspectJAdviceMethod;
  this.aspectJAdvisorFactory = aspectJAdvisorFactory;
  this.aspectInstanceFactory = aspectInstanceFactory;
  this.declarationOrder = declarationOrder;
  this.aspectName = aspectName;

  if (aspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
    // Static part of the pointcut is a lazy type.
    Pointcut preInstantiationPointcut = Pointcuts.union(
        aspectInstanceFactory.getAspectMetadata().getPerClausePointcut(), this.declaredPointcut);

    // Make it dynamic: must mutate from pre-instantiation to post-instantiation state.
    // If it's not a dynamic pointcut, it may be optimized out
    // by the Spring AOP infrastructure after the first evaluation.
    this.pointcut = new PerTargetInstantiationModelPointcut(
        this.declaredPointcut, preInstantiationPointcut, aspectInstanceFactory);
    this.lazy = true;
  }
  else {
    // A singleton aspect.
    this.pointcut = this.declaredPointcut;
    this.lazy = false;
    this.instantiatedAdvice = instantiateAdvice(this.declaredPointcut);
  }
}

可以看到，InstantiationModelAwarePointcutAdvisorImpl类包含AspectJExpressionPointcut类型的pointcut名属性，adviceName，aspectJAdviceMethod切面方法等属性。同时也会根据advice的type生成对应的xxxAdvice对象。看最后一行instantiatedAdvice的解析代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
private Advice instantiateAdvice(AspectJExpressionPointcut pointcut) {
  Advice advice = this.aspectJAdvisorFactory.getAdvice(this.aspectJAdviceMethod, pointcut,
      this.aspectInstanceFactory, this.declarationOrder, this.aspectName);
  return (advice != null ? advice : EMPTY_ADVICE);
}

public Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut expressionPointcut,
    MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {

  Class<?> candidateAspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
  validate(candidateAspectClass);

  AspectJAnnotation<?> aspectJAnnotation =
      AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
  if (aspectJAnnotation == null) {
    return null;
  }

  // If we get here, we know we have an AspectJ method.
  // Check that it's an AspectJ-annotated class
  if (!isAspect(candidateAspectClass)) {
    throw new AopConfigException("Advice must be declared inside an aspect type: " +
        "Offending method '" + candidateAdviceMethod + "' in class [" +
        candidateAspectClass.getName() + "]");
  }

  if (logger.isDebugEnabled()) {
    logger.debug("Found AspectJ method: " + candidateAdviceMethod);
  }

  AbstractAspectJAdvice springAdvice;

  switch (aspectJAnnotation.getAnnotationType()) {
    case AtBefore:
      springAdvice = new AspectJMethodBeforeAdvice(
          candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
      break;
    case AtAfter:
      springAdvice = new AspectJAfterAdvice(
          candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
      break;
    case AtAfterReturning:
      springAdvice = new AspectJAfterReturningAdvice(
          candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
      AfterReturning afterReturningAnnotation = (AfterReturning) aspectJAnnotation.getAnnotation();
      if (StringUtils.hasText(afterReturningAnnotation.returning())) {
        springAdvice.setReturningName(afterReturningAnnotation.returning());
      }
      break;
    case AtAfterThrowing:
      springAdvice = new AspectJAfterThrowingAdvice(
          candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
      AfterThrowing afterThrowingAnnotation = (AfterThrowing) aspectJAnnotation.getAnnotation();
      if (StringUtils.hasText(afterThrowingAnnotation.throwing())) {
        springAdvice.setThrowingName(afterThrowingAnnotation.throwing());
      }
      break;
    case AtAround:
      springAdvice = new AspectJAroundAdvice(
          candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
      break;
    case AtPointcut:
      if (logger.isDebugEnabled()) {
        logger.debug("Processing pointcut '" + candidateAdviceMethod.getName() + "'");
      }
      return null;
    default:
      throw new UnsupportedOperationException(
          "Unsupported advice type on method: " + candidateAdviceMethod);
  }

  // Now to configure the advice...
  springAdvice.setAspectName(aspectName);
  springAdvice.setDeclarationOrder(declarationOrder);
  String[] argNames = this.parameterNameDiscoverer.getParameterNames(candidateAdviceMethod);
  if (argNames != null) {
    springAdvice.setArgumentNamesFromStringArray(argNames);
  }
  springAdvice.calculateArgumentBindings();

  return springAdvice;
}

整个方法就是为了获取Advice，根据切面方法(即TimeFeeAspect.doTimeFeeIntercepter)上的advice注解type返回对应的xxxxAdvice实例。这里doTimeFeeIntercepter方法上注解了@Before advice，所以我们得到是AspectJMethodBeforeAdvice对象。AspectJMethodBeforeAdvice包含advice method, pointcut, aspect class name。AspectJMethodBeforeAdvice相当于interceptor。当生成proxy代理类时，AspectJMethodBeforeAdvice就是proxy代理类的interceptor，proxy的切入的方法就是AspectJMethodBeforeAdvice的advice method，即TimeFeeAspect.doTimeFeeIntercepter方法。这样，就把目标类的被切入方法和aspect的想切入的方法关联起来了。所以每次程序走到目标类的被切入方法时，都会先走aspect的切入的方法。
所以，对外暴露的advisor其实就是InstantiationModelAwarePointcutAdvisorImpl对象，当生成proxy代理类的时候传进去的advisor也就是InstantiationModelAwarePointcutAdvisorImpl对象了。

到这,Advice class获取到了，Advice的PointCut也拿到了，但是PointCut自身的表达式(Expression)值还没有拿到。接着走代码
回到postProcessBeforeInstantiation()方法，由于我们找到了Advisor，所以shouldSkip(beanClass, beanName)返回false，逻辑往下走。又由于getCustomTargetSource(beanClass, beanName)返回null，所以这步没有生成入参beanName或beanClass的代理
这样，postProcessBeforeInstantiatioin()方法的逻辑就走完了。但是beanName或beanClass还有一次生成代理类的机会，就是postProcessAfterInitialization()方法提供的,可以看到：wrapIfNecessary方法是核心，查看其内部代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
  if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
    return bean;
  }
  if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
    return bean;
  }
  if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
    this.advisedBeans.put(cacheKey, Boolean.FALSE);
    return bean;
  }

  // Create proxy if we have advice.
  Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
  if (specificInterceptors != DO_NOT_PROXY) {
    this.advisedBeans.put(cacheKey, Boolean.TRUE);
    Object proxy = createProxy(
        bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
    this.proxyTypes.put(cacheKey, proxy.getClass());
    return proxy;
  }

  this.advisedBeans.put(cacheKey, Boolean.FALSE);
  return bean;
}

可以看到，方法上半部分与postProcessBeforeInstantiation()方法相同，刚才的分析就是shouldSkip(bean.getClass(), beanName)方法，所以我们直接看getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null)。这个方法获取Advisor，看其内部逻辑

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
protected Object[] getAdvicesAndAdvisorsForBean(
    Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {

  List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
  if (advisors.isEmpty()) {
    return DO_NOT_PROXY;
  }
  return advisors.toArray();
}
protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
  List<Advisor> candidateAdvisors = findCandidateAdvisors();
  List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
  extendAdvisors(eligibleAdvisors);
  if (!eligibleAdvisors.isEmpty()) {
    eligibleAdvisors = sortAdvisors(eligibleAdvisors);
  }
  return eligibleAdvisors;
}

findEligibleAdvisors()方法首先获取Advisor候选者(findCandidateAdvisors()的逻辑在postProcessBeforeInstantiation()方法分析时已经说过)，然后通过findAdvisorsThatCanApply()方法检验这些Advisor候选者对beanClass来说是否是合格的Advisor。这里就很关键了，我们看其内部代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
protected List<Advisor> findAdvisorsThatCanApply(
    List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) {

  ProxyCreationContext.setCurrentProxiedBeanName(beanName);
  try {
    return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
  }
  finally {
    ProxyCreationContext.setCurrentProxiedBeanName(null);
  }
}

public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
  if (candidateAdvisors.isEmpty()) {
    return candidateAdvisors;
  }
  List<Advisor> eligibleAdvisors = new LinkedList<>();
  for (Advisor candidate : candidateAdvisors) {
    if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
      eligibleAdvisors.add(candidate);
    }
  }
  boolean hasIntroductions = !eligibleAdvisors.isEmpty();
  for (Advisor candidate : candidateAdvisors) {
    if (candidate instanceof IntroductionAdvisor) {
      // already processed
      continue;
    }
    if (canApply(candidate, clazz, hasIntroductions)) {
      eligibleAdvisors.add(candidate);
    }
  }
  return eligibleAdvisors;
}

方法重点是条件判断。这里只列出部分代码，其实方法将候选者Advisor分为两拨，一拨是IntroductionAdvisor，然后条件判断canApply(candidate, clazz)；另一拨是其他Advisor，然后条件判断canApply(candidate, clazz, hasIntroductions)，我们debug时走的后一个条件判断方法逻辑，看其内部代码逻辑

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
  if (advisor instanceof IntroductionAdvisor) {
    return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
  }
  else if (advisor instanceof PointcutAdvisor) {
    PointcutAdvisor pca = (PointcutAdvisor) advisor;
    return canApply(pca.getPointcut(), targetClass, hasIntroductions);
  }
  else {
    // It doesn't have a pointcut so we assume it applies.
    return true;
  }
}

public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
  Assert.notNull(pc, "Pointcut must not be null");
  // 使用Pointcut匹配targetClass,此时的Pointcut.pointcutExpression赋值就隐藏在pc.getClassFilter()中
  if (!pc.getClassFilter().matches(targetClass)) {//(0)
    return false;
  }

  MethodMatcher methodMatcher = pc.getMethodMatcher();
  if (methodMatcher == MethodMatcher.TRUE) {
    // No need to iterate the methods if we're matching any method anyway...
    return true;
  }

  IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
  if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
    introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
  }
  //(1)
  Set<Class<?>> classes = new LinkedHashSet<>();
  if (!Proxy.isProxyClass(targetClass)) {
    classes.add(ClassUtils.getUserClass(targetClass));
  }
  classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetClass));

  for (Class<?> clazz : classes) {
    Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
    for (Method method : methods) {
      if (introductionAwareMethodMatcher != null ?
          introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :
          methodMatcher.matches(method, targetClass)) {//(2)
        return true;
      }
    }
  }

  return false;
}

整个方法都在判断targerClass是否匹配这个pointcut，由于此时的pointcut.pointcutExpression还没有赋值呢，所以在判断匹配之前，需要pointcut.pointcutExpression赋值，所以整个AopUtis.canApply分为两部分：
1.给pointcut.pointcutExpression赋值
2.targerClass匹配pointcut检验
而第一部分的赋值在pc.getClassFilter()里，看方法代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
public ClassFilter getClassFilter() {
  obtainPointcutExpression();
  return this;
}

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

private PointcutExpression buildPointcutExpression(@Nullable ClassLoader classLoader) {
  PointcutParser parser = 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(replaceBooleanOperators(resolveExpression()),
      this.pointcutDeclarationScope, pointcutParameters);
}

public PointcutExpression parsePointcutExpression(String expression, Class<?> inScope, PointcutParameter[] formalParameters)
    throws UnsupportedPointcutPrimitiveException, IllegalArgumentException {
  PointcutExpressionImpl pcExpr = null;
  try {
    Pointcut pc = resolvePointcutExpression(expression, inScope, formalParameters);
    pc = concretizePointcutExpression(pc, inScope, formalParameters);
    validateAgainstSupportedPrimitives(pc, expression); // again, because we have now followed any ref'd pcuts
    pcExpr = new PointcutExpressionImpl(pc, expression, formalParameters, getWorld());
  } catch (ParserException pEx) {
    throw new IllegalArgumentException(buildUserMessageFromParserException(expression, pEx));
  } catch (ReflectionWorld.ReflectionWorldException rwEx) {
    throw new IllegalArgumentException(rwEx.getMessage());
  }
  return pcExpr;
}

protected Pointcut resolvePointcutExpression(String expression, Class<?> inScope, PointcutParameter[] formalParameters) {
  try {
    PatternParser parser = new PatternParser(expression);
    parser.setPointcutDesignatorHandlers(pointcutDesignators, world);
    Pointcut pc = parser.parsePointcut();
    validateAgainstSupportedPrimitives(pc, expression);
    IScope resolutionScope = buildResolutionScope((inScope == null ? Object.class : inScope), formalParameters);
    pc = pc.resolve(resolutionScope);
    return pc;
  } catch (ParserException pEx) {
    throw new IllegalArgumentException(buildUserMessageFromParserException(expression, pEx));
  }
}

以上代码的核心逻辑就是给AspectJExpressionPointcut.PointcutExpression赋值，这个就是开篇时的例子代码：@Pointcut(“execution( * com.xuekg.constructor..(..))”)。赋值操作是通过PointcutParser、PatternParser和Pointcut来完成的。具体的赋值过程入口为pc = pc.resolve(resolutionScope)。resolve方法调用栈：
Pointcut.resolve()
-this.resolveBindings()
–searchType.findPointcut(name)
searchType就是TimeFeeAspect，name就是cut方法名
… 经过getPointcuts().iterator循环 …
—Java15ReflectionBasedReferenceTypeDelegate.getDeclaredPointcuts()
—-AjType.getDeclaredPointcuts()
—–Method[] methods = clazz.getDeclaredMethods()

clazz就是TimeFeeAspect,循环methods，判断method是否有@Pointcut注解：Pointcut pcAnn = method.getAnnotation(Pointcut.class);
拿到pcAnn.value()。构造成一个Pointcut，再构造成一个PointcutExpressionImpl，再构造成一个PointcutImpl。最后AspectJExpressionPointcut.PointcutExpression被赋值了。切入点的表达式已经有了，接下来要做的自然是使用表达式来验证目标了。这部分即是AopUtils.canApply()方法的第二部分的逻辑。
下面看AopUtils.canApply()方法的第二部分：targerClass匹配pointcut检验，首先看pc.getClassFilter().matches(targetClass)如果匹配，代码往下走；如果不匹配，直接返回false。接着走(2)处代码，即获取targerClass的所有接口和父类，遍历每个类的每个方法，使用Pointcut的expression去match每个方法，一旦有匹配上，返回true，退出遍历。所以匹配的逻辑就是重点了。这里列下关键的代码段

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
// 可以看到这个方法中使用了双重检查机制(double check)，double check结合synchronized可以有效的
// 避免锁的竞争，这个组合我们可以在很多地方使用，想想在你的项目中使用它，很棒，面试也是高频知识点
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...
      PointcutExpression fallbackExpression = null;
      shadowMatch = this.shadowMatchCache.get(targetMethod);
      if (shadowMatch == null) {
        Method methodToMatch = targetMethod;
        try {
          try {
            // pointcutExpression对象包含KindedpPointcut类型的属性pointcut "execution(* com.yy..rest..*(..))"
            // KindedpPointcut包含SignaturePattern类型的属性signature "* com.yy..rest..*(..)"
            shadowMatch = obtainPointcutExpression().matchesMethodExecution(methodToMatch);
          }
          catch (ReflectionWorldException ex) {
            // Failed to introspect target method, probably because it has been loaded
            // in a special ClassLoader. Let's try the declaring ClassLoader instead...
            try {
              fallbackExpression = getFallbackPointcutExpression(methodToMatch.getDeclaringClass());
              if (fallbackExpression != null) {
                shadowMatch = fallbackExpression.matchesMethodExecution(methodToMatch);
              }
            }
            catch (ReflectionWorldException ex2) {
              fallbackExpression = null;
            }
          }
          if (shadowMatch == null && targetMethod != originalMethod) {
            methodToMatch = originalMethod;
            try {
              shadowMatch = obtainPointcutExpression().matchesMethodExecution(methodToMatch);
            }
            catch (ReflectionWorldException ex) {
              // Could neither introspect the target class nor the proxy class ->
              // let's try the original method's declaring class before we give up...
              try {
                fallbackExpression = getFallbackPointcutExpression(methodToMatch.getDeclaringClass());
                if (fallbackExpression != null) {
                  shadowMatch = fallbackExpression.matchesMethodExecution(methodToMatch);
                }
              }
              catch (ReflectionWorldException ex2) {
                fallbackExpression = null;
              }
            }
          }
        }
        catch (Throwable ex) {
          // Possibly AspectJ 1.8.10 encountering an invalid signature
          logger.debug("PointcutExpression matching rejected target method", ex);
          fallbackExpression = null;
        }
        if (shadowMatch == null) {
          shadowMatch = new ShadowMatchImpl(org.aspectj.util.FuzzyBoolean.NO, null, null, null);
        }
        else if (shadowMatch.maybeMatches() && fallbackExpression != null) {
          shadowMatch = new DefensiveShadowMatch(shadowMatch,
              fallbackExpression.matchesMethodExecution(methodToMatch));
        }
        this.shadowMatchCache.put(targetMethod, shadowMatch);
      }
    }
  }
  return shadowMatch;
}

//PointcutExpressionImpl类
private ShadowMatchImpl getShadowMatch(Shadow forShadow) {
  org.aspectj.util.FuzzyBoolean match = pointcut.match(forShadow);
  Test residueTest = Literal.TRUE;
  ExposedState state = getExposedState();
  if (match.maybeTrue()) {
    residueTest = pointcut.findResidue(forShadow, state);
  }
  ShadowMatchImpl sm = new ShadowMatchImpl(match, residueTest, state, parameters);
  sm.setMatchingContext(this.matchContext);
  return sm;
}

//WildTypePattern类，真正的验证逻辑就在这个类
protected boolean matchesExactly(ResolvedType type, ResolvedType annotatedType) {
  String targetTypeName = type.getName();

  // System.err.println("match: " + targetTypeName + ", " + knownMatches); //Arrays.asList(importedPrefixes));
  // Ensure the annotation pattern is resolved
  annotationPattern.resolve(type.getWorld());

  return matchesExactlyByName(targetTypeName, type.isAnonymous(), type.isNested()) && matchesParameters(type, STATIC)
      && matchesBounds(type, STATIC)
      && annotationPattern.matches(annotatedType, type.temporaryAnnotationTypes).alwaysTrue();
}

matchesExactlyByName(..)比较全限定类名是否匹配。会把pointcut的expression和目标类的全限定名变为.分隔的数组，对应下标值依次比较。像这样：pattern[pi].matches(target[ti])。
matchesParameters(..)比较方法的参数是否匹配
matchesBounds(..)比较方法或参数带?时是否匹配
annotationPattern(..)比较方法或参数的注解是否匹配
当然，根据&&短路原则，前面的方法返回false时，后面的方法不用走了，直接返回结果。本例debug时，pointcut为”execution( com.xuekg.constructor..(..))，目标target类为：别放一起，两者比较，包名不一样，所以不匹配，返回false

03 CglibAopProxy或JdkDynamicAopProxy生成Proxy代理类阶段

我们知道AbstractAutoProxyCreator类的postProcessBeforeInstantiation()和postProcessAfterInitialization()方法都可以生成proxy代理类。都是调用的this.createProxy(..)`方法，这就是生成Proxy代理类入口，代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
    @Nullable Object[] specificInterceptors, TargetSource targetSource) {

  if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
    AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
  }

  ProxyFactory proxyFactory = new ProxyFactory();
  proxyFactory.copyFrom(this);

  if (!proxyFactory.isProxyTargetClass()) {
    // 检查时通过接口还是目标类创建proxy代理类，true表示通过标类创建
    if (shouldProxyTargetClass(beanClass, beanName)) {
      proxyFactory.setProxyTargetClass(true);
    }
    else {
      evaluateProxyInterfaces(beanClass, proxyFactory);
    }
  }

  Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
  proxyFactory.addAdvisors(advisors);
  proxyFactory.setTargetSource(targetSource);
  customizeProxyFactory(proxyFactory);

  proxyFactory.setFrozen(this.freezeProxy);
  if (advisorsPreFiltered()) {
    proxyFactory.setPreFiltered(true);
  }

  return proxyFactory.getProxy(getProxyClassLoader());
}

首先创建了一个ProxyFactory，看名字就知道含义：proxy的工厂。注意这句代码proxyFactory.copyFrom(this)，其中的this为AnnotationAwareAspectJAutoProxyCreator对象，还记得吗，spring项目初始化时，aop相关实例化xxxProxyAutoConfiguration就是AnnotationAwareAspectJAutoProxyCreator类，他的proxyTargetClass和exposeProxy等属性通过proxyFactory.copyFrom(this)传递给proxyFactory属性。
然后通过buildAdvisors(beanName, specificInterceptors)方法构建advisor,看他的specificInterceptors参数，往上追溯可以知道是post-process方法传递进来的，我们可以知道specificInterceptors之一就是InstantiationModelAwarePointcutAdvisorImpl实例。所以生成的advisors包含InstantiationModelAwarePointcutAdvisorImpl实例，同时将advisors赋值给proxyFactory.addAdvisors(advisors)。接下来，通过proxyFactory.getProxy(getProxyClassLoader())生成proxy代理类

1
2
3
public Object getProxy(@Nullable ClassLoader classLoader) {
  return createAopProxy().getProxy(classLoader);
}

先说createAopProxy()，看内部实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
protected final synchronized AopProxy createAopProxy() {
  if (!this.active) {
    activate();
  }
  return getAopProxyFactory().createAopProxy(this);
}

public AopProxyFactory getAopProxyFactory() {
  return this.aopProxyFactory;
}

public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
  if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
    Class<?> targetClass = config.getTargetClass();
    if (targetClass == null) {
      throw new AopConfigException("TargetSource cannot determine target class: " +
          "Either an interface or a target is required for proxy creation.");
    }
    if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
      return new JdkDynamicAopProxy(config);
    }
    return new ObjenesisCglibAopProxy(config);
  }
  else {
    return new JdkDynamicAopProxy(config);
  }
}

createAopProxy方法正式创建xxxAopProxy了，到底是创建Jdk动态代理还是cglib动态代理呢，看条件，条件之一proxyTargetClass的值是我们所能控制的，因为可以在我们的项目启动类中加入类似
@EnableAspectJAutoProxy(proxyTargetClass = true, exposeProxy = true)的配置。这是全局设置。还有每次创建proxy的设置：shouldProxyTargetClass(beanClass, beanName)，逻辑为beanName有没有接口，有接口proxyTargetClass=false；没有接口，proxyTargetClass=true。如果有Controller的话，由于没有接口，所以生成代理时是cglib代理，即new ObjenesisCglibAopProxy(config)，看其及父类构造函数

1
2
3
4
5
6
7
8
public CglibAopProxy(AdvisedSupport config) throws AopConfigException {
  Assert.notNull(config, "AdvisedSupport must not be null");
  if (config.getAdvisors().length == 0 && config.getTargetSource() == AdvisedSupport.EMPTY_TARGET_SOURCE) {
    throw new AopConfigException("No advisors and no TargetSource specified");
  }
  this.advised = config;
  this.advisedDispatcher = new AdvisedDispatcher(this.advised);
}

AdvisedSupport是proxyFactory的父类，CglibAopProxy拥有一个AdvisedSupport类型的advised属性，而这个advised拥有advisors、proxyTargetClass、exposeProxy等，所以CglibAopProxy就等于有了advisors、proxyTargetClass、exposeProxy。

aopProxy已经创建了，下面说另一部分：getProxy(classLoader)，看内部代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
public Object getProxy(@Nullable ClassLoader classLoader) {
  if (logger.isDebugEnabled()) {
    logger.debug("Creating CGLIB proxy: target source is " + this.advised.getTargetSource());
  }

  try {
    Class<?> rootClass = this.advised.getTargetClass();
    Assert.state(rootClass != null, "Target class must be available for creating a CGLIB proxy");

    Class<?> proxySuperClass = rootClass;
    // 这里判断rootClass是否是Cglib代理所产生的类（内部判断rootClass的className是否包含$$）
    if (ClassUtils.isCglibProxyClass(rootClass)) {
      proxySuperClass = rootClass.getSuperclass();
      Class<?>[] additionalInterfaces = rootClass.getInterfaces();
      for (Class<?> additionalInterface : additionalInterfaces) {
        this.advised.addInterface(additionalInterface);
      }
    }

    // 方法校验，final方法不能被代理，记录日志
    // Validate the class, writing log messages as necessary.
    validateClassIfNecessary(proxySuperClass, classLoader);

    // Configure CGLIB Enhancer...
    Enhancer enhancer = createEnhancer();
    if (classLoader != null) {
      enhancer.setClassLoader(classLoader);
      if (classLoader instanceof SmartClassLoader &&
          ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
        enhancer.setUseCache(false);
      }
    }
    enhancer.setSuperclass(proxySuperClass);
    enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
    enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
    enhancer.setStrategy(new ClassLoaderAwareUndeclaredThrowableStrategy(classLoader));

    Callback[] callbacks = getCallbacks(rootClass);
    Class<?>[] types = new Class<?>[callbacks.length];
    for (int x = 0; x < types.length; x++) {
      types[x] = callbacks[x].getClass();
    }
    // fixedInterceptorMap only populated at this point, after getCallbacks call above
    enhancer.setCallbackFilter(new ProxyCallbackFilter(
        this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
    enhancer.setCallbackTypes(types);

    // Generate the proxy class and create a proxy instance.
    return createProxyClassAndInstance(enhancer, callbacks);
  }
  catch (CodeGenerationException | IllegalArgumentException ex) {
    throw new AopConfigException("Could not generate CGLIB subclass of " + this.advised.getTargetClass() +
        ": Common causes of this problem include using a final class or a non-visible class",
        ex);
  }
  catch (Throwable ex) {
    // TargetSource.getTarget() failed
    throw new AopConfigException("Unexpected AOP exception", ex);
  }
}

getProxy()方法会创建一个Enhancer对象，这个工具类负责生成代理类的class，只不过这个class不是文本的形式，而是在内存中。Enhancer`会被赋值生成proxy代理类是用于的属性，说下这些属性即作用

superclass：目标类
Interfaces：目标类和代理类的接口
namingPolicy：生成代理类名称策略, 如”xxx$$EnhancerBySpringCGLIB$$d2e4a5ae”这个文本形式就是namingPolicy生成的
strategy：生成代理类class策略
callbackFilter：设置对不同方法执行不同的回调逻辑，或者根本不执行回调
callBackTypes：都会赋值给Enhancer对象用于生成Proxy代理类。callBackTypes就是aop interceptor，CGLIB中对于方法的拦截是通过将自定义的拦截器（实现MethodInterceptor接口）加入Callback中并在调用代理时直接激活拦截器中的intercept方法来实现的，DynamicAdvisedInterceptor继承自MethodInterceptor，而包含AspectJMethodBeforeAdvice的advised属性又封装在DynamicAdvisedInterceptor中，DynamicAdvisedInterceptor又赋值到callBack。所以当我们curl访问目标类方法时会被proxy代理类的拦截器拦截，继而会走切面的AspectJMethodBeforeAdvice对象的方法执行切面逻辑。下面就详细下CallbackTypes，看getCallbacks方法代码，如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
private Callback[] getCallbacks(Class<?> rootClass) throws Exception {
  // Parameters used for optimization choices...
  boolean exposeProxy = this.advised.isExposeProxy();
  boolean isFrozen = this.advised.isFrozen();
  boolean isStatic = this.advised.getTargetSource().isStatic();

  // Choose an "aop" interceptor (used for AOP calls).
  Callback aopInterceptor = new DynamicAdvisedInterceptor(this.advised);

  // Choose a "straight to target" interceptor. (used for calls that are
  // unadvised but can return this). May be required to expose the proxy.
  Callback targetInterceptor;
  if (exposeProxy) {
    targetInterceptor = isStatic ?
        new StaticUnadvisedExposedInterceptor(this.advised.getTargetSource().getTarget()) :
        new DynamicUnadvisedExposedInterceptor(this.advised.getTargetSource());
  }
  else {
    targetInterceptor = isStatic ?
        new StaticUnadvisedInterceptor(this.advised.getTargetSource().getTarget()) :
        new DynamicUnadvisedInterceptor(this.advised.getTargetSource());
  }

  // Choose a "direct to target" dispatcher (used for
  // unadvised calls to static targets that cannot return this).
  Callback targetDispatcher = isStatic ?
      new StaticDispatcher(this.advised.getTargetSource().getTarget()) : new SerializableNoOp();

  Callback[] mainCallbacks = new Callback[] {
      aopInterceptor,  // for normal advice
      targetInterceptor,  // invoke target without considering advice, if optimized
      new SerializableNoOp(),  // no override for methods mapped to this
      targetDispatcher, this.advisedDispatcher,
      new EqualsInterceptor(this.advised),
      new HashCodeInterceptor(this.advised)
  };

  Callback[] callbacks;

  // If the target is a static one and the advice chain is frozen,
  // then we can make some optimizations by sending the AOP calls
  // direct to the target using the fixed chain for that method.
  if (isStatic && isFrozen) {
    Method[] methods = rootClass.getMethods();
    Callback[] fixedCallbacks = new Callback[methods.length];
    this.fixedInterceptorMap = new HashMap<>(methods.length);

    // TODO: small memory optimization here (can skip creation for methods with no advice)
    for (int x = 0; x < methods.length; x++) {
      List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(methods[x], rootClass);
      fixedCallbacks[x] = new FixedChainStaticTargetInterceptor(
          chain, this.advised.getTargetSource().getTarget(), this.advised.getTargetClass());
      this.fixedInterceptorMap.put(methods[x].toString(), x);
    }

    // Now copy both the callbacks from mainCallbacks
    // and fixedCallbacks into the callbacks array.
    callbacks = new Callback[mainCallbacks.length + fixedCallbacks.length];
    System.arraycopy(mainCallbacks, 0, callbacks, 0, mainCallbacks.length);
    System.arraycopy(fixedCallbacks, 0, callbacks, mainCallbacks.length, fixedCallbacks.length);
    this.fixedInterceptorOffset = mainCallbacks.length;
  }
  else {
    callbacks = mainCallbacks;
  }
  return callbacks;
}

可以看到，mainCallbacks是最终生成的callbacks，包含7个callback，属于几类，分别说下

DynamicAdvisedInterceptor：核心的aop interceptor，aspect的AspectJMethodBeforeAdvice就被赋值在这里。访问业务方法时就会先访问DynamicAdvisedInterceptor的intercept方法，详情看此方法
StaticUnadvisedExposedInterceptor：用于没有advice chain的静态目标
SerializableNoOp 什么操作也不做，代理类直接调用被代理的方法不进行拦截
Dispatcher 每次调用都会重新加载被代理的对象
···
下面看下getProxy方法createProxyClassAndInstance方法，这个方法创建proxy class并实例化为instance，看下内部代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
protected Object createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks) {
  enhancer.setInterceptDuringConstruction(false);
  enhancer.setCallbacks(callbacks);
  return (this.constructorArgs != null && this.constructorArgTypes != null ?
      enhancer.create(this.constructorArgTypes, this.constructorArgs) :
      enhancer.create());
}

private Object createHelper() {
    this.preValidate();
    Object key = KEY_FACTORY.newInstance(this.superclass != null ? this.superclass.getName() : null, ReflectUtils.getNames(this.interfaces), this.filter == ALL_ZERO ? null : new WeakCacheKey(this.filter), this.callbackTypes, this.useFactory, this.interceptDuringConstruction, this.serialVersionUID);
    this.currentKey = key;
    Object result = super.create(key);
    return result;
}

protected Object create(Object key) {
    try {
        ClassLoader loader = this.getClassLoader();
        Map<ClassLoader, AbstractClassGenerator.ClassLoaderData> cache = CACHE;
        AbstractClassGenerator.ClassLoaderData data = (AbstractClassGenerator.ClassLoaderData)cache.get(loader);
        if (data == null) {
            Class var5 = AbstractClassGenerator.class;
            synchronized(AbstractClassGenerator.class) {
                cache = CACHE;
                data = (AbstractClassGenerator.ClassLoaderData)cache.get(loader);
                if (data == null) {
                    Map<ClassLoader, AbstractClassGenerator.ClassLoaderData> newCache = new WeakHashMap(cache);
                    data = new AbstractClassGenerator.ClassLoaderData(loader);
                    newCache.put(loader, data);
                    CACHE = newCache;
                }
            }
        }

        this.key = key;
          // 获取class
        Object obj = data.get(this, this.getUseCache());
        return obj instanceof Class ? this.firstInstance((Class)obj) : this.nextInstance(obj);
    } catch (RuntimeException var9) {
        throw var9;
    } catch (Error var10) {
        throw var10;
    } catch (Exception var11) {
        throw new CodeGenerationException(var11);
    }
}

public Object get(AbstractClassGenerator gen, boolean useCache) {
    if (!useCache) {
      //生成代理类
        return gen.generate(this);
    } else {
        Object cachedValue = this.generatedClasses.get(gen);
        return gen.unwrapCachedValue(cachedValue);
    }
}
protected V createEntry(final K key, KK cacheKey, Object v) {
  boolean creator = false;
  FutureTask task;
  Object result;
  if (v != null) {
      task = (FutureTask)v;
  } else {
      task = new FutureTask(new Callable<V>() {
          public V call() throws Exception {
              // 异步执行下面的generate()方法
              return LoadingCache.this.loader.apply(key);
          }
      });
      result = this.map.putIfAbsent(cacheKey, task);
      if (result == null) {
          creator = true;
          task.run();
      } else {
          if (!(result instanceof FutureTask)) {
              return result;
          }

          task = (FutureTask)result;
      }
  }

  try {
      result = task.get();
  } catch (InterruptedException var9) {
      throw new IllegalStateException("Interrupted while loading cache item", var9);
  } catch (ExecutionException var10) {
      Throwable cause = var10.getCause();
      if (cause instanceof RuntimeException) {
          throw (RuntimeException)cause;
      }

      throw new IllegalStateException("Unable to load cache item", cause);
  }

  if (creator) {
      this.map.put(cacheKey, result);
  }

  return result;
}

// future新起了一个线程来完成这个生成逻辑
protected Class generate(AbstractClassGenerator.ClassLoaderData data) {
  Object save = CURRENT.get();
  CURRENT.set(this);

  Class var8;
  try {
      ClassLoader classLoader = data.getClassLoader();
      if (classLoader == null) {
          throw new IllegalStateException("ClassLoader is null while trying to define class " + this.getClassName() + ". It seems that the loader has been expired from a weak reference somehow. Please file an issue at cglib's issue tracker.");
      }

      String className;
      synchronized(classLoader) {
        // 声明代理类的名字
          className = this.generateClassName(data.getUniqueNamePredicate());
          data.reserveName(className);
          this.setClassName(className);
      }

      Class gen;
      if (this.attemptLoad) {
          try {
              gen = classLoader.loadClass(this.getClassName());
              Class var25 = gen;
              return var25;
          } catch (ClassNotFoundException var20) {
          }
      }

      // 使用指定策略生成代理类字节流数组
      byte[] b = this.strategy.generate(this);
      className = ClassNameReader.getClassName(new ClassReader(b));
      ProtectionDomain protectionDomain = this.getProtectionDomain();
      synchronized(classLoader) {
          if (protectionDomain == null) {
            // 生成代理类
              gen = ReflectUtils.defineClass(className, b, classLoader);
          } else {
              gen = ReflectUtils.defineClass(className, b, classLoader, protectionDomain);
          }
      }

      var8 = gen;
  } catch (RuntimeException var21) {
      throw var21;
  } catch (Error var22) {
      throw var22;
  } catch (Exception var23) {
      throw new CodeGenerationException(var23);
  } finally {
      CURRENT.set(save);
  }

  return var8;
}

 // 使用指定的name生成政策生成代理类的名字
private String generateClassName(Predicate nameTestPredicate) {
    return this.namingPolicy.getClassName(this.namePrefix, this.source.name, this.key, nameTestPredicate);
}

public String getClassName(String prefix, String source, Object key, Predicate names) {
  if (prefix == null) {
      prefix = "org.springframework.cglib.empty.Object";
  } else if (prefix.startsWith("java")) {
      prefix = "$" + prefix;
  }

  String base = prefix + "$$" + source.substring(source.lastIndexOf(46) + 1) + this.getTag() + "$$" + Integer.toHexString(STRESS_HASH_CODE ? 0 : key.hashCode());
  String attempt = base;

  for(int var7 = 2; names.evaluate(attempt); attempt = base + "_" + var7++) {
  }

  return attempt;
}

已经懵了。
下面看下调用一个方法时，如何进入到代理类的方法中去，DynamicAdvisedInterceptor.intercept()方法。我们看下这个方法的内部

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
  Object oldProxy = null;
  boolean setProxyContext = false;
  Object target = null;
  // TODO: 2020/9/12
  TargetSource targetSource = this.advised.getTargetSource();
  try {
    if (this.advised.exposeProxy) {
      // Make invocation available if necessary.
      oldProxy = AopContext.setCurrentProxy(proxy);
      setProxyContext = true;
    }
    // Get as late as possible to minimize the time we "own" the target, in case it comes from a pool...
    // 通过TargetSource来获取被代理的对象target
    target = targetSource.getTarget();
    Class<?> targetClass = (target != null ? target.getClass() : null);
    // 获取MethodInterceptor集合，而相应的MethodInterceptor包含对应的Advice类型属性
    List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);//(1)
    Object retVal;
    // Check whether we only have one InvokerInterceptor: that is,
    // no real advice, but just reflective invocation of the target.
    if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
      // We can skip creating a MethodInvocation: just invoke the target directly.
      // Note that the final invoker must be an InvokerInterceptor, so we know
      // it does nothing but a reflective operation on the target, and no hot
      // swapping or fancy proxying.
      Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
      // 通过反射调用被代理对象的方法
      retVal = methodProxy.invoke(target, argsToUse);
    }
    else {
      // We need to create a method invocation...
      retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();//(2)
    }
    retVal = processReturnType(proxy, target, method, retVal);
    return retVal;
  }
  finally {
    if (target != null && !targetSource.isStatic()) {
      targetSource.releaseTarget(target);
    }
    if (setProxyContext) {
      // Restore old proxy.
      AopContext.setCurrentProxy(oldProxy);
    }
  }
}

方法(1)处获取MethodIntercetor集合，从而获取对应的dvice集合
方法(2)处创建一个CglibMethodInvocation，CglibMethodInvocation拥有一个MethodInterceptor集合，通过proceed()方法执行interceptor chain。所有这里运用了一个设计模式：责任链模式的变种，类似tomcat filter的形式。
具体如下，运行这个链的入口是DynamicAdvisedInterceptor.intercept()。这个方法会获取interceptor集合，然后创建一个CglibMethodInvocation对象，并把interceptor集合传递给CglibMethodInvocation对象的interceptorsAndDynamicMethodMatchers属性， 然后调用CglibMethodInvocation对象的proceed()，proceed()会遍历interceptorsAndDynamicMethodMatchers(其实就是interceptor集合)从而执行每个interceptor.invoke(MethodInvocation)自身的逻辑，因为这个时候MethodInvocation会传递给invoke方法，所以每一个invoke方法内部都会执行MethodInvocation.proceed()，从而这样形成了一个链式的调用关系。我们看下链式代码结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//MethodInvocation类
public Object proceed() throws Throwable {
  // 链式调用终结点
  if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
      return invokeJoinpoint();
  }
  // 从interceptor集合中获取一个interceptor
  Object interceptorOrInterceptionAdvice =
          this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
  // 调用这个interceptor.invoke方法，开始走链了
  return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
//MethodInterceptor类
public interface MethodInterceptor extends Interceptor {
    
  Object invoke(MethodInvocation invocation) throws Throwable;
}

//MethodInterceptor实现类
public Object invoke(MethodInvocation mi) throws Throwable {
  // 又调回MethodInvocation.proceed()方法
  return mi.proceed();
}

调用了MethodBeforeAdvice.before()方法，MethodBeforeAdvice持有aspectJAdviceMethod属性，这个aspectJAdviceMethod其实就TimeFeeAspect.doTimeFeeIntercepter()方法，所以before方法会进去我们定义的Aspect切面，从而实现了切入方法的功能

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家