aop原理

1. 使用

1.1 依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

1.2 定义切面类

定义一个切面类，指定增强的方法，方法前两个注解必须有
execution( * com.lzp..controller..*(…)) 代表 com.lzp包下所有包下controller包下所有类的所有方法都会被代理，* 就代表所有，第一个*是所有方法的返回值，第一个*前面还有方法修饰符，public之类的，缺省就表示所有修饰符，最后一个*代表所有方法名，(…)代表方法参数，…是指所有参数，倒数第二个*代表类，第二个*代表包。这样调用对应包下的方法时就会被增强。
所以顺序就是 修饰符 返回值 包名 类名 方法名 方法参数

@Aspect
@Component
@Slf4j
public class TestAspect {

    @Around("execution( * com.lzp.*.controller.*.*(..))")
    public void arround(ProceedingJoinPoint pjp) {
        try {
            log.info("1、Around：方法环绕开始.....");
            Object o =  pjp.proceed();
            log.info("3、Around：方法环绕结束，结果是 :" + o);
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }
}

• 表达式多种多样，根据需求配置即可
• 表达式还可以针对注解使用 自定义和非自定义注解都可以
• 表达式参考

1.3 定义被增强的方法

在规则配置的包下的类中定义方法即可，这样在调用test01方法时，就会进行增强了。

@RestController
public class TestController {
    protected final  Log logger = LogFactory.getLog(getClass());
    @GetMapping("/")
    public String test01(){
        if(logger.isDebugEnabled()){
            logger.fatal(123);
        }
        return "hello11122222";
    }
}

注意：切面类和被增强方法所在的类，都要注册到sping中。

2. 自动配置

2.1 AopAutoConfiguration

引入依赖后会自动配置aop
AopAutoConfiguration

@Configuration(proxyBeanMethods = false)
//引入依赖后这里就会通过
@ConditionalOnProperty(prefix = "spring.aop", name = "auto", havingValue = "true", matchIfMissing = true)
public class AopAutoConfiguration {

	@Configuration(proxyBeanMethods = false)
	@ConditionalOnClass(Advice.class)
	static class AspectJAutoProxyingConfiguration {

		@Configuration(proxyBeanMethods = false)
		@EnableAspectJAutoProxy(proxyTargetClass = false)
		@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "false")
		static class JdkDynamicAutoProxyConfiguration {

		}
		//默认使用这个cglib创建代理 @EnableAspectJAutoProxy是开启aop功能
		@Configuration(proxyBeanMethods = false)
		@EnableAspectJAutoProxy(proxyTargetClass = true)
		@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true",
				matchIfMissing = true)
		static class CglibAutoProxyConfiguration {

		}

	}

	@Configuration(proxyBeanMethods = false)
	@ConditionalOnMissingClass("org.aspectj.weaver.Advice")
	@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true",
			matchIfMissing = true)
	static class ClassProxyingConfiguration {

		@Bean
		static BeanFactoryPostProcessor forceAutoProxyCreatorToUseClassProxying() {
			return (beanFactory) -> {
				if (beanFactory instanceof BeanDefinitionRegistry) {
					BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
					AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
					AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
				}
			};
		}
	}
}

2.2 @EnableAspectJAutoProxy

@EnableAspectJAutoProxy会引入AspectJAutoProxyRegistrar，这个Registrar会引入AnnotationAwareAspectJAutoProxyCreator的bean定义信息。关键类，aop的功能就是由它和它的父类们实现的。

AnnotationAwareAspectJAutoProxyCreator继承了AbstractAutoProxyCreator实现了InstantiationAwareBeanPostProcessor接口

AbstractAutowireCapableBeanFactory#createBean方法在执行doCreateBean之前会执行本类的resolveBeforeInstantiation方法。

	@Nullable
	protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
		Object bean = null;
		if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
			// Make sure bean class is actually resolved at this point.
			if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
				Class<?> targetType = determineTargetType(beanName, mbd);
				if (targetType != null) {
					//关键方法
					bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
					if (bean != null) {
						bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
					}
				}
			}
			mbd.beforeInstantiationResolved = (bean != null);
		}
		return bean;
	}

resolveBeforeInstantiation方法会调用本类的applyBeanPostProcessorsBeforeInstantiation方法
遍历processors 调用对应postProcessBeforeInstantiation方法，这里的关键是AnnotationAwareAspectJAutoProxyCreator这个processor，上面自动配置引入的就是这个类，会执行他的父类AbstractAutoProxyCreator#postProcessBeforeInstantiation方法

aop的功能由此开始实现
明确 第一个bean实例化时就会走这个方法。

3. 原理

3.1 解析切面类

解析切面类由
AbstractAutoProxyCreator#postProcessBeforeInstantiation完成
重写InstantiationAwareBeanPostProcessor接口的postProcessBeforeInstantiation方法
这里的逻辑是普通类进入判断，advisedBeans的value设置为false，需要增强的类不会进入判断，通过shouldSkip方法获取到切面中配置的增强方法（也就是加了@around注解的方法）
这里普通的类（包括切面类）会进入判断，但是切面类中配置的增强类不会进入判断，

3.1.1 第一个判断

加了@aspect的类会通过
AnnotationAwareAspectJAutoProxyCreator重写了isInfrastructureClass方法，所以会执行AnnotationAwareAspectJAutoProxyCreator类的isInfrastructureClass方法

3.1.2 第二个判断

需要被增强的类 普通类会进入，步骤1的TestController不应该跳过
会调用子类的子类AspectJAwareAdvisorAutoProxyCreator#shouldSkip方法

AnnotationAwareAspectJAutoProxyCreator#findCandidateAdvisors

BeanFactoryAspectJAdvisorsBuilder#buildAspectJAdvisors
也就是找到切面类。步骤1的TestAspect类 。
第一个bean实例化时就会通过这个方法缓存所有加了@aspect注解的bean。

	public List<Advisor> buildAspectJAdvisors() {
		List<String> aspectNames = this.aspectBeanNames;
		//缓存中没有的话去获取，这里在第一个bean执行createBean方法时就会为空，然后创建缓存，后面的bean实例化时就可以直接获取了。
		if (aspectNames == null) {
			synchronized (this) {
				aspectNames = this.aspectBeanNames;
				if (aspectNames == null) {
					List<Advisor> advisors = new ArrayList<>();
					aspectNames = new ArrayList<>();
					//获取到所有的beanName
					String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
							this.beanFactory, Object.class, true, false);
					//遍历所有的beanName
					for (String beanName : beanNames) {
						if (!isEligibleBean(beanName)) {
							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, false);
						if (beanType == null) {
							continue;
						}
						//只有是加了@Aspect注解的类才会进入判断
						if (this.advisorFactory.isAspect(beanType)) {
							//先把名字加到缓存中，方法开始就是从这里拿到切面类的名字
							aspectNames.add(beanName);
							AspectMetadata amd = new AspectMetadata(beanType, beanName);
							if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
								//构建工厂
								MetadataAwareAspectInstanceFactory factory =
										new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
								//关键方法 解析切面类中的增强方法		
								List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
								if (this.beanFactory.isSingleton(beanName)) {
									//加到缓存中 classAdvisors也就是增强方法 可能有多个
									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 ArrayList<>();
		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;
	}

有的话直接从缓存中拿

没有的话需要获取到切面类，然后解析。

3.2 解析切面类流程

在实例化第一个单例bean时，会对我们定义的切面类进行解析 然后缓存到advisorsCache中，key是beanName，value是advisor数组。每个切面类可能有多个增强方法
过程就是获取到切面类，然后获取到所有切面类的方法（除了pointcut注解的方法），然后遍历，封装成Advisor类型。
ReflectiveAspectJAdvisorFactory#getAdvisors

	@Override
	public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
		//获取到切面类
		Class<?> aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
		//切面类的name
		String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName();
		validate(aspectClass);

		// We need to wrap the MetadataAwareAspectInstanceFactory with a decorator
		// so that it will only instantiate once.
		//我们需要用装饰器包装 MetadataAwareAspectInstanceFactory，以便它只实例化一次。
		MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory =
				new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);

		List<Advisor> advisors = new ArrayList<>();
		//获取遍历切面类所有的增强方法 @before @around @after 
		for (Method method : getAdvisorMethods(aspectClass)) {
			// Prior to Spring Framework 5.2.7, advisors.size() was supplied as the declarationOrderInAspect
			// to getAdvisor(...) to represent the "current position" in the declared methods list.
			// However, since Java 7 the "current position" is not valid since the JDK no longer
			// returns declared methods in the order in which they are declared in the source code.
			// Thus, we now hard code the declarationOrderInAspect to 0 for all advice methods
			// discovered via reflection in order to support reliable advice ordering across JVM launches.
			// Specifically, a value of 0 aligns with the default value used in
			// AspectJPrecedenceComparator.getAspectDeclarationOrder(Advisor).
			//遍历每个方法 一个一个解析
			Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, 0, 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;
	}

ReflectiveAspectJAdvisorFactory#getAdvisor

	public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory,
			int declarationOrderInAspect, String aspectName) {

		validate(aspectInstanceFactory.getAspectMetadata().getAspectClass());
		//找到注解及注解配置的表达式 @around @after @before
		AspectJExpressionPointcut expressionPointcut = getPointcut(
				candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());
		if (expressionPointcut == null) {
			return null;
		}
		//针对每个增强方法 构建一个对象
		return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,
				this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
	}

	@Nullable
	private AspectJExpressionPointcut getPointcut(Method candidateAdviceMethod, Class<?> candidateAspectClass) {
		//找到注解及注解配置的表达式 @around @after @before
		AspectJAnnotation<?> aspectJAnnotation =
				AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
		if (aspectJAnnotation == null) {
			return null;
		}
		//构建对象
		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;
	}

InstantiationModelAwarePointcutAdvisorImpl#InstantiationModelAwarePointcutAdvisorImpl

	public InstantiationModelAwarePointcutAdvisorImpl(AspectJExpressionPointcut declaredPointcut,
			Method aspectJAdviceMethod, AspectJAdvisorFactory aspectJAdvisorFactory,
			MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {

        //当前的切点表达式
        this.declaredPointcut = declaredPointcut;
        //切面的class对象
        this.declaringClass = aspectJAdviceMethod.getDeclaringClass();
        //切面方法的名称
        this.methodName = aspectJAdviceMethod.getName();
        //切面方法的参数类型
        this.parameterTypes = aspectJAdviceMethod.getParameterTypes();
        //切面方法对象
        this.aspectJAdviceMethod = aspectJAdviceMethod;
        //aspectj的通知工厂
        this.aspectJAdvisorFactory = aspectJAdvisorFactory;
        //aspect的实例工厂
        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;
			//将切面中的通知构造为advice通知对象
			this.instantiatedAdvice = instantiateAdvice(this.declaredPointcut);
		}
	}

ReflectiveAspectJAdvisorFactory#getAdvice
getAdvisors方法中的getAdvisor方法需要的对象了。每个增强方法都会是一个Advice类型

	public Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut expressionPointcut,
			MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {
		//切面类的class
		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 AtPointcut:
				if (logger.isDebugEnabled()) {
					logger.debug("Processing pointcut '" + candidateAdviceMethod.getName() + "'");
				}
				return null;
			// 参数是 当前方法 切点表达式 工厂
			case AtAround:
				springAdvice = new AspectJAroundAdvice(
						candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
				break;
			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;
			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;
	}

这样就把切面类的增强方法都解析完了。除了@pointcut的方法。

3.3 注意

父类AbstractAutoProxyCreator 实现了两个接口InstantiationAwareBeanPostProcessor和BeanPostProcessor。

• InstantiationAwareBeanPostProcessor接口的postProcessBeforeInstantiation方法在createBean方法doCreateBean之前会调用。作用就是解析切面类
• BeanPostProcessor接口的postProcessAfterInitialization方法在创建完bean，初始化（initializeBean）时调用。作用是为需要增强的类创建代理

AbstractAutoProxyCreator#postProcessAfterInitialization
重写接口BeanPostProcessor接口的postProcessAfterInitialization方法

3.4 创建代理

在createBean方法的doCreateBean方法中执行实例化bean，填充bean，和初始化bean，在初始化bean方法initializeBean中，会执行postProcessBeforeInitialization、postProcessAfterInitialization方法，关于aop创建代理是在AbstractAutoProxyCreator类的postProcessAfterInitialization方法中。

AbstractAutoProxyCreator#wrapIfNecessary

	protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
		if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
			return bean;
		}
		//普通类会把advisedBeans中对应的bean的value设置为false，而切面类中指定的增强类则不会
		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;
	}

AbstractAdvisorAutoProxyCreator#getAdvicesAndAdvisorsForBean方法会调用AbstractAdvisorAutoProxyCreator#findEligibleAdvisors方法

	protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
		 //找到Spring IoC容器中所有的候选通知 也就是切面类中加了@around @beafore @after注解的方法
		List<Advisor> candidateAdvisors = findCandidateAdvisors();
		//判断找到的通知能不能作用到当前的类上 关键
		List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
		//对我们的advisor进行排序
		extendAdvisors(eligibleAdvisors);
		if (!eligibleAdvisors.isEmpty()) {
			eligibleAdvisors = sortAdvisors(eligibleAdvisors);
		}
		return eligibleAdvisors;
	}

AbstractAdvisorAutoProxyCreator#findAdvisorsThatCanApply

AopUtils#findAdvisorsThatCanApply

	public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
		//为空直接返回
		if (candidateAdvisors.isEmpty()) {
			return candidateAdvisors;
		}
		List<Advisor> eligibleAdvisors = new ArrayList<>();
		//遍历
		for (Advisor candidate : candidateAdvisors) {
			//这里不会进入 因为没有实现IntroductionAdvisor 
			if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
				eligibleAdvisors.add(candidate);
			}
		}
		boolean hasIntroductions = !eligibleAdvisors.isEmpty();
		//遍历 
		for (Advisor candidate : candidateAdvisors) {
			//这里不会进入 因为没有实现IntroductionAdvisor 
			if (candidate instanceof IntroductionAdvisor) {
				// already processed
				continue;
			}
			//会进这个判断
			if (canApply(candidate, clazz, hasIntroductions)) {
				eligibleAdvisors.add(candidate);
			}
		}
		return eligibleAdvisors;
	}

AopUtils#canApply

	public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
		//这里不会进入 因为没有实现IntroductionAdvisor 
		if (advisor instanceof IntroductionAdvisor) {
			return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
		}
		else if (advisor instanceof PointcutAdvisor) {
			PointcutAdvisor pca = (PointcutAdvisor) advisor;
			//继续重载的canApply
			return canApply(pca.getPointcut(), targetClass, hasIntroductions);
		}
		else {
			// It doesn't have a pointcut so we assume it applies.
			return true;
		}
	}

AopUtils#canApply(org.springframework.aop.Pointcut, java.lang.Class<?>, boolean)
如果该方法返回true就表示匹配，就添加到合适的集合eligibleAdvisors中，然后为当前类创建代理

	public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
		Assert.notNull(pc, "Pointcut must not be null");
		//这里会构建切面类中的表达式
		if (!pc.getClassFilter().matches(targetClass)) {
			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;
		}

		Set<Class<?>> classes = new LinkedHashSet<>();
		//断当前class是不是代理的class对象 不是的话加到classes 
		if (!Proxy.isProxyClass(targetClass)) {
			classes.add(ClassUtils.getUserClass(targetClass));
		}
		//把当前类实现的接口的class都加进来
		classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
		//遍历当前类和当前类实现的接口
		for (Class<?> clazz : classes) {
			//获取到当前类的所有方法
			Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
			//遍历看当前方法是否满足增强条件 也就是能否满足表达式的配置 能满足就返回true
			//@Around("execution( * com.lzp.*.controller.*.*(..))")
			for (Method method : methods) {
				if (introductionAwareMethodMatcher != null ?
						introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :
						methodMatcher.matches(method, targetClass)) {
					return true;
				}
			}
		}

		return false;
	}

3.4.1 构建切点表达式

回到AbstractAutoProxyCreator#wrapIfNecessary方法，获取到specificInterceptors了，然后会创建当前类的代理对象，然后返回

AbstractAutoProxyCreator#createProxy

	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);
		//cglib
		if (proxyFactory.isProxyTargetClass()) {
			// Explicit handling of JDK proxy targets and lambdas (for introduction advice scenarios)
			if (Proxy.isProxyClass(beanClass) || ClassUtils.isLambdaClass(beanClass)) {
				// Must allow for introductions; can't just set interfaces to the proxy's interfaces only.
				for (Class<?> ifc : beanClass.getInterfaces()) {
					proxyFactory.addInterface(ifc);
				}
			}
		}
		//jdk
		else {
			// No proxyTargetClass flag enforced, let's apply our default checks...
			if (shouldProxyTargetClass(beanClass, beanName)) {
				proxyFactory.setProxyTargetClass(true);
			}
			else {
				evaluateProxyInterfaces(beanClass, proxyFactory);
			}
		}
		
		Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
		//添加增强方法 也就是@around @after @before
		proxyFactory.addAdvisors(advisors);
		//目标类
		proxyFactory.setTargetSource(targetSource);
		customizeProxyFactory(proxyFactory);

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

		// Use original ClassLoader if bean class not locally loaded in overriding class loader
		ClassLoader classLoader = getProxyClassLoader();
		if (classLoader instanceof SmartClassLoader && classLoader != beanClass.getClassLoader()) {
			classLoader = ((SmartClassLoader) classLoader).getOriginalClassLoader();
		}
		//执行代理工厂的创建代理方法
		return proxyFactory.getProxy(classLoader);
	}

ProxyFactory#getProxy(java.lang.ClassLoader)

创建方法肯定是创建了cglib代理工厂
注：springboot aop默认使用cglib动态代理，切换为jdk动态代理的方法是
spring.aop.proxy-target-class=false
jdk动态代理时：如果代理类没有实现接口也创建cglib代理，否则创建jdk代理

CglibAopProxy#getProxy(java.lang.ClassLoader)

	public Object getProxy(@Nullable ClassLoader classLoader) {
		if (logger.isTraceEnabled()) {
			logger.trace("Creating CGLIB proxy: " + 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;
			if (rootClass.getName().contains(ClassUtils.CGLIB_CLASS_SEPARATOR)) {
				proxySuperClass = rootClass.getSuperclass();
				Class<?>[] additionalInterfaces = rootClass.getInterfaces();
				for (Class<?> additionalInterface : additionalInterfaces) {
					this.advised.addInterface(additionalInterface);
				}
			}

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

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

最终创建的代理

4.总结

aop的功能就是不改变原方法内容，对原方法进行增强，想要实现这个功能一定就是动态代理了。
实现原理：
1.关键类：AnnotationAwareAspectJAutoProxyCreator,自动配置中的@EnableAspectJAutoProxy注解会引入这个类，aop的功能就是通过这个类以及它的父类们共同完成的。
2.关键方法：
AnnotationAwareAspectJAutoProxyCreator的父类（不是直接父类）AbstractAutoProxyCreator 实现了两个接口InstantiationAwareBeanPostProcessor和BeanPostProcessor。
1.1.AbstractAutoProxyCreator类实现接口InstantiationAwareBeanPostProcessor重写的postProcessBeforeInstantiation方法。
这个方法在bean实例化时的createBean方法中执行，在doCreateBean方法之前，在实例化第一个单例bean时，对所有我们自定义的切面类进行解析。然后放到缓存中，key是切面类name，value是advisor类型的数组，因为一个切面类可以有多个增强方法。
1.2.AbstractAutoProxyCreator类实现接口BeanPostProcessor重写了postProcessAfterInitialization方法。
这个方法在bean实例化时的initializeBean方法完成，在doCreateBean方法中，populateBean方法之后。对所有正在实例化的bean进行判断，看能否和1.1中生成的增强方法进行匹配，能匹配的话就对当前类创建代理。