目录

前言

IOC/DI , AOP 是Spring最重要的两个特性 ，也是面试高频被问到的部分，前面我们已经分析了Spring的IOC相关源码以及DI依赖注入相关源码，从本篇文章开始我们着手分析Spring的AOP源码 。

开始之前，你需要对AOP 原理，JDK动态代理，CGLIB动态代理有一定的理解。这里先上一个图，后面源码分析的时候可以看着图来

AOP的理解

AOP基本概念

AOP是为面向切面编程，为什么要面向切面，何为切面？我们知道对于OOP面向对象而言在某些开发场景中是有一定不足，由于面向对象的思想是纵向的，它面对的是一个一个的对象，当我们需要在多个类中引入同一个公共的业务时(比如：事务,操作日志等)，那么在每个类中都要引入公共的业务代码，从而造成代码大量重复，代码结构不优雅，不方便维护 ，这个时候就需要使用到面向切面的编程来解决这个问题。使用AOP可以把分散在多个类中的公共的代码剥离出来，和业务本身的代码解耦， 然后通过动态代理将公共业务代码作用到多个对象，代码结构也更加优雅。

所以可以认为 面向切面 是对 面向对象 的补充，它的思想是横向的，它面向的是一个切面，如果把一个对象看做一个点，那么多个对象就是一个面，是为切面，AOP多用于：事务，日志，监控，流控等等业务场景。

AOP实现原理

AOP的实现原理是基于动态代理，动态代理就是在运行时期动态的为某个类(原生类)生成代理类以达到代码增强的目的，且代理类是持有原生类的，可以在代理类中调用原生类以及做一些增强业务。

动态代理分为JDK动态代理和CGLIB代理，CGLIB代理需要导入相关的jar包。两者的区别是JDK动态代理要求原始类(被代理类)需要实现至少一个接口。而CGLIB则是基于继承进行代理，原生类可以不实现任何接口。

对于Spring而言默认采用JDK动态代理，如果原生类没有实现任何接口，Spring会选择CGLIB代理，或者你可以通过配置文件强制指定使用CGLIB代理。

AOP案例

下面我们使用AOP来做一个事务管理案例：在每个Service方法执行前后添加事务的代码

1.创建一个普通类，这个类的方法需要有事务

@Service
public class UserServiceImpl implements IUserService {

    public void insert() {
        System.out.println("UserServiceImpl.insert:保存User...");
    }

    public void delete() {
        System.out.println("UserServiceImpl.delete:删除User");
    }
}

2.创建一个切面类，这个类里面提供公共的业务代码，即：事务代码

@Component
@Aspect
public class TranscationManager {

    //定义切点，表达式作用于所有到service的所有的方法
    @Pointcut("execution(* cn.xxx.*.service.*.*(..))")
    public void pointcut(){}

    //前置通知 ， 方法执行前执行，用来开启事务
    @Before("pointcut()")
    public void begin(JoinPoint joinPoint){

        System.out.println("TranscationManager.begin：开启事务...:");
    }
    //后置返回通知 ，方法正常返回后执行， 用来提交事务
    @AfterReturning("pointcut()")
    public void commit(){
        System.out.println("TranscationManager.commit：提交事物...");
    }

    //异常通知，方法出现异常调用，用来回滚事务
    @AfterThrowing(value = "pointcut()",throwing="e")
    public void rollback(JoinPoint joinPoint,Throwable e){
        System.out.println("TranscationManager.rollback:回滚事物咯...:"+e.getMessage());
    }

    //最终通知,不管方法会不会出现异常，都会执行，用来关闭资源
    @After("pointcut()")
    public void close(){
        System.out.println("TranscationManager.close:关闭连接...");
    }


    //环绕通知，拦截原始类的类的方法，可以通过 joinPoint调用原始的类
    @Around("pointcut()")
    public Object around(ProceedingJoinPoint joinPoint){
        

        return null;
    }

}

3.配置Spring支持AOP注解

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
       http://www.springframework.org/schema/aop   http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-4.0.xsd">

    <!--开启IOC注解支持-->
    <context:component-scan base-package="cn.xx" />

    <!--开启AOP注解支持，默认使用jdk动态代理，如果指定 proxy-target-class=true 则实例CGLIB代理-->
    <aop:aspectj-autoproxy />

</beans>

4.测试代码

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:application_aop.xml")
public class AopTest {

    @Autowired
    private IUserService userService ;

    @Test
    public void testAop(){
        userService.insert();
        System.out.println("======================================");
        userService.delete();
    }
}

控制台效果

TranscationManager.begin：开启事务…:
UserServiceImpl.insert:保存User…
TranscationManager.commit：提交事物…
TranscationManager.close:关闭连接…
======================================
TranscationManager.begin：开启事务…:
UserServiceImpl.delete:删除User…
TranscationManager.commit：提交事物…
TranscationManager.close:关闭连接…

这里我们看到了，使用AOP可以把公共的代码剥离出去和业务变身代码解耦，同时也方便扩展。

怎么理解这个AOP案例，首先要明白需求：在多个service方法执行前，否 或 出现异常做出相应的事务处理。我们把UserService看着原生类， 把TranscationManager 切面看着是增强代码，那么Spring是如何做到把 TranscationManager 的增强逻辑 加入到 UserService的方法前后的呢？

1. 找到所有原生类(被代理类)：我们在 TranscationManager中定义了一个切点：@Pointcut("execution(* cn.xxx.*.service.*.*(..))") ：这切点定义了一个表达式，这个表达式的含义就是找到cn.xxx包下所有的service的所有方法，Spring就知道了需要拦截这些方法的执行。

2. 找到了service的方法，如何在方法前，后做事情？我们在TranscationManager中定义了@Before(“pointcut()”) 前置通知，@AfterReturning(“pointcut()”)后置通知等，当我们调用userService的方法之前就会触发 Before 前置通知中的逻辑 ，方法执行完成就会触发 AfterReturning 后置通知的逻辑，异常通知和最终通知也是一个道理。

3. 实现原理就是动态代理，其实Spring为所有切点切到的类都生成了代理类，也就是说在test类中注入的 @Autowired private IUserService userService ; 其实并不是我们写的那个UserService,而是基于UserService代理出来的一个代理类。代理类持有原生类，且代理类和原生类有相同的方法，所以你感觉你在调用UserService,其实在调用代理类。

   在代理类中的方法对原生类方法做了增强 ，而增强的逻辑就是 TranscationManager 中的逻辑，比如调用userService.insert 实则进入了代理类的insert方法，方法中先调用TranscationManager@Before 前置通知业务，然后调用原生类的insert，方法结尾调用TranscationManager@AfterReturning 后置通知，出现异常调用TranscationManager@AfterThrowing异常通知等等。这样是不是就达到了上面的增强效果了。

如果没有去研究过JDK动态代理和CGLIB代理可能你看起来比较晕，对于Spring切面的东西这里不做太多解释了，不是本篇主要内容，下面我就对于这个AOP案例做源码分析。

AOP解析器

在上面的案例中我们通过 <aop:aspectj-autoproxy /> 配置来开启AOP支持，稍微动动脑袋能想到Spring一定会有一个类来处理该配置。 在Spring中有一个接口叫 NamespaceHandlerSupport ，它提供了Spring配置文件的namespace的解析支持。

其中有一个实现叫 AopNamespaceHandler , 它是针对于 <aop: 开头的namespace 解析支持，看一下这个类的源码

AOP解析器：AspectJAutoProxyBeanDefinitionParser

//aop命名空间的NamespaceHandler 。
//为<aop:config>标签提供一个BeanDefinitionParser 。 config标签可以包括嵌套的pointcut 、 advisor和aspect标签。
public class AopNamespaceHandler extends NamespaceHandlerSupport {

	/**
	 * Register the {@link BeanDefinitionParser BeanDefinitionParsers} for the
	 * '{@code config}', '{@code spring-configured}', '{@code aspectj-autoproxy}'
	 * and '{@code scoped-proxy}' tags.
	 */
	@Override
	public void init() {
		// In 2.0 XSD as well as in 2.5+ XSDs
		//<aop:config 解析器
		registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
		//【主角在这里】注册针对于<aop:aspectj-autoproxy 的解析器 AspectJAutoProxyBeanDefinitionParser
		registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
		registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());

		// Only in 2.0 XSD: moved to context namespace in 2.5+
		registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
	}

}

到这里我们看到了针对于 <aop:aspectj-autoproxy 的解析器 AspectJAutoProxyBeanDefinitionParser，它实现了BeanDefinitionParser，解析逻辑都在parse方法中，源码如下：

class AspectJAutoProxyBeanDefinitionParser implements BeanDefinitionParser {

	//Element就是 <aop:aspectj-autoproxy 元素的封装
	@Override
	@Nullable
	public BeanDefinition parse(Element element, ParserContext parserContext) {
		//注册一个 AspectJAnnotationAutoProxyCreator
		//用于处理当前应用程序上下文中的所有 AspectJ 切面，以及 Spring Advisor。
		AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);
		//处理子节点
		extendBeanDefinition(element, parserContext);
		return null;
	}

	...省略...

}

该方法的作用主要是注册了一个 AspectJAnnotationAutoProxyCreator 自动代理创建器，它的作用就是用来处理Aop。 AspectJAutoProxyBeanDefinitionParser 的 parse 方法是在IOC启动过程中,通过DefaultBeanDefinitionDocumentReader#parseBeanDefinitions 委派 BeanDefinitionParserDelegate#parseCustomElement去解析的。

注册AnnotationAwareAspectJAutoProxyCreator

parse方法中比较重要的就是 AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary ， 它创建了一个 AnnotationAwareAspectJAutoProxyCreator 代理自动创建器 ,AOP的功能重要就是通过它来完成的，它可以根据 Point 解定义的切点来自动代理相匹配的 bean，跟一下该方法源码：

public static void registerAspectJAnnotationAutoProxyCreatorIfNecessary(
			ParserContext parserContext, Element sourceElement) {
		//【重要】通过BeanDefinitionRegistry注册一个 AnnotationAwareAspectJAutoProxyCreator
		BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(
				parserContext.getRegistry(), parserContext.extractSource(sourceElement));
				
		//对 proxy-target-class 和 expose-proxy 属性处理
		useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
		//注册组件 把 beanDefinition 注册到ParserContext上下文中
		registerComponentIfNecessary(beanDefinition, parserContext);
	}

该方法做了三件事情

• 通过BeanDefinitionRegistry注册一个 AnnotationAwareAspectJAutoProxyCreator ，该类是AspectJ 切面处理类
• 对 proxy-target-class 和 expose-proxy 属性处理 ，就是把BeanDefinition中的proxyTargetClass和exposeProxy属性设置为true
• 这次组件， 把AnnotationAwareAspectJAutoProxyCreator 的 beanDefinition 注册到ParserContext上下文中

我们继续跟踪注册AnnotationAwareAspectJAutoProxyCreator 的代码：AopConfigUtils#registerAspectJAnnotationAutoProxyCreatorIfNecessary

	@Nullable
	public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry,
			@Nullable Object source) {

		return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
	}

	//BeanDefinitionRegistry：bean的注册器
	//cls:AnnotationAwareAspectJAutoProxyCreator的类型
	@Nullable
	private static BeanDefinition registerOrEscalateApcAsRequired(
			Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) {

		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
		//如果容器中已经包含了 org.springframework.aop.config.internalAutoProxyCreator 自动代理创建者的BeanDefinition
		if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
			//获取BeanDefinition
			BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
			//class比较
			if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
				//如果已经有自动创建器了，按照优先级比较选择使用哪一个
				int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
				int requiredPriority = findPriorityForClass(cls);
				if (currentPriority < requiredPriority) {
					apcDefinition.setBeanClassName(cls.getName());
				}
			}
			return null;
		}
		//如果容器中还没有注册自动创建器，就注册一个
		RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
		beanDefinition.setSource(source);
		beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
		beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
		//通过BeanDefinitionRegistry注册一个 代理自动创建器
		registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
		return beanDefinition;
	}

方法会判断容器中如果已经注册了 自动代理创建器，则按照优先级选择使用哪个，如果么有注册就使用BeanDefinitionRegistry注册一个。

处理proxy-target-class和ExposeProxy

proxy-target-class 的对于 <aop:aspectj-autoproxy proxy-target-class=“true” /> 属性的处理，该属性的作用是指定代理的方式为CGLIB。

//对 proxy-target-class 和 expose-proxy 属性处理
private static void useClassProxyingIfNecessary(BeanDefinitionRegistry registry, @Nullable Element sourceElement) {
	if (sourceElement != null) {
		//获取  <aop:aspectj-autoproxy proxy-target-class="" />  proxy-target-class 属性
		boolean proxyTargetClass = Boolean.parseBoolean(sourceElement.getAttribute(PROXY_TARGET_CLASS_ATTRIBUTE));
		if (proxyTargetClass) {
			//如果proxyTargetClass=true,则使用CGLIB代理
			//definition.getPropertyValues().add("proxyTargetClass", Boolean.TRUE);
			//把 definition 中的 proxyTargetClass设置为true
			AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
		}
		//当exposeProxy为true时暴露代理对象，会把proxy动态代理对象设置到AopContext上下文中
		boolean exposeProxy = Boolean.parseBoolean(sourceElement.getAttribute(EXPOSE_PROXY_ATTRIBUTE));
		if (exposeProxy) {
			//definition.getPropertyValues().add("exposeProxy", Boolean.TRUE);
			//把 definition 中的 exposeProxy 设置为true
			AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
		}
	}
}

这里做了两个事情

• 根据配置：<aop:aspectj-autoproxy proxy-target-class=“true” /> 将 definition 中的 proxyTargetClass设置为true ，生成代理将会使用CGLIB方式，否则默认使用JDK动态代理
• 根据配置：<aop:aspectj-autoproxy proxy-target-class=“true” expose-proxy=“true” /> 将 definition 中的 exposeProxy设置为true ，目的是把创建的代理对象添加到AopContext上下文中，为什么要这麽做？如果有如下代码：

  public class AServiceImpl implements AService{
  	@Transactional
  	public void a(){
  		this.b();
  	}
  	@Transactional(propagation = Propagation.REQUIRES_NEW)
  	public void b(){
  	}
  }
  

  这里的 this 是原生类，并不是代理类，也就意味这b的 @Transactional(propagation = Propagation.REQUIRES_NEW)
  事务增强代码是不会执行的,对于这个问题我们可以做如下处理

1. 修改配置：<aop:aspectj-autoproxy expose-proxy=“true” />
2. this.b() 修改为：((AService)AopContext.currentProxy()).b(); 得到代理类执行b()方法

增强器

上面的一个大堆流程主要是创建了一个 AnnotationAwareAspectJAutoProxyCreator ，那么它是如何来处理AOP的呢？看一下它的继承体系

AnnotationAwareAspectJAutoProxyCreator是一个BeanPostProcessor，当Spring实例化这个Bean时会在这个Bean的initMethod初始化之后调用postProcessAfterInitialization方法，Aop的实现就在这里开始。AbstractAutoProxyCreator#postProcessAfterInitialization源码如下：

	 * Create a proxy with the configured interceptors if the bean is
	 * identified as one to proxy by the subclass.
	 * @see #getAdvicesAndAdvisorsForBean
	 */
	 //如果 bean 被子类标识为代理，则使用配置的拦截器创建一个代理。
	@Override
	public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) throws BeansException {
		if (bean != null) {
			//根据Bean的class和name，创建一个缓存的key  ，
			Object cacheKey = getCacheKey(bean.getClass(), beanName);
			if (!this.earlyProxyReferences.contains(cacheKey)) {
				//对适合代理的Bean进行封装
				return wrapIfNecessary(bean, beanName, cacheKey);
			}
		}
		return bean;
	}


	//创建代理
	protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
		//如果已经处理过，就直接返回Bean
		if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
			return bean;
		}
		//不需要增强
		if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
			return bean;
		}
		//是基础设施类(比如 Pointcut.class，Aspect.class等基础类不需要代理)，
		// 或者是原始类不做代理，比如 beanName以　．ORIGINAL　结尾就会跳过代理
		if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
			this.advisedBeans.put(cacheKey, Boolean.FALSE);
			return bean;
		}

		// Create proxy if we have advice.
		//获取增强，即：获取到上面案例中的TranscationManager中的增强方法，封装成一个一个，InstantiationModelAwarePointcutAdvisorImpl，该类可以是对切面方法的封装
		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));
			//把代理的type放入proxyTypes
			this.proxyTypes.put(cacheKey, proxy.getClass());
			return proxy;
		}
		//缓存的key放入advisedBeans
		this.advisedBeans.put(cacheKey, Boolean.FALSE);
		return bean;
	}

方法中先判断了Bean是否需要创建代理，比如当前bean是Aspect,pintcut等基础设施类就不需要代理，然后调用 getAdvicesAndAdvisorsForBean 获取到增强器 ，最后 调用createProxy方法创建代理对象。

获取增强器

获取增强器是在 AbstractAdvisorAutoProxyCreator#getAdvicesAndAdvisorsForBean中完成的 ，我们来一步步跟踪一下它的获取流程

	//[第一步] 找到增强器
	@Override
	@Nullable
	protected Object[] getAdvicesAndAdvisorsForBean(
			Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
		//找打增强器，提取成Advisor
		List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
		if (advisors.isEmpty()) {
			return DO_NOT_PROXY;
		}
		return advisors.toArray();
	}

	//[第二步]  找到所有增强器，以及找到bean适用的增强器
	protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
		//找到所有增强方法
		List<Advisor> candidateAdvisors = findCandidateAdvisors();
		//找到当前bean适用的增强方法
		List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
		extendAdvisors(eligibleAdvisors);
		if (!eligibleAdvisors.isEmpty()) {
			eligibleAdvisors = sortAdvisors(eligibleAdvisors);
		}
		return eligibleAdvisors;
	}

上面逻辑做了两件事情， 找到所有增强器，以及找到bean适用的增强器，查找所有增强器在 AnnotationAwareAspectJAutoProxyCreator#findCandidateAdvisors中完成的，源码如下：

@Override
	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) {
		//调用 aspectJAdvisorsBuilder.buildAspectJAdvisors 构建增强器
			advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
		}
		return advisors;
	}

这里主要通过 aspectJAdvisorsBuilder 去查找增强器，然后添加到advisors集合中返回。

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<>();
					//获取到spring中所有的beanNames
					String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
							this.beanFactory, Object.class, true, false);
					for (String beanName : beanNames) {
						//循环BeanName 获取增强方法
						if (!isEligibleBean(beanName)) {
						//不合法的Bean跳过
							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;
						}
						//是否是切面类，有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)) {
								//增强方法，缓存起来
									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;
	}

上面方法会先得到切面类 aspectNames，然后根据切面类从 advisorsCache缓存中得到增强方法并返回。

解析切面中的增强方法

当然如果还没有切面和增强方法，就会先从容器中得到所有的BeanName循环得到class，通过判断是否有aspect注解来得到切面。得到切面后，通过this.advisorFactory.getAdvisors(factory)提取切面中的增强方法，并缓存到advisorsCache map中。下面是 ReflectiveAspectJAdvisorFactory#getAdvisors 源码

@Override
	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<>();
		//使用反射工具， ReflectionUtils#doWithMethods 获取切面类的所有方法
		for (Method method : getAdvisorMethods(aspectClass)) {
			//提取增强方法 ， 把 method 提出成 Advisor【重要】
			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;
	}

上面业务中通过 getAdvisorMethods(aspectClass) 获取切面类所有的方法，底层通过ReflectionUtils#doWithMethods 反射实现。 然后调用 ReflectiveAspectJAdvisorFactory#getAdvisor 提取出切面中的增强器 Advisor(对增强方法的封装)。重点看一下 getAdvisor 源码

@Override
	@Nullable
	public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory,
			int declarationOrderInAspect, String aspectName) {
		//验证
		validate(aspectInstanceFactory.getAspectMetadata().getAspectClass());
		//获取切点信息，其实就是获取注解表达式获取如：@Before("point()")
		AspectJExpressionPointcut expressionPointcut = getPointcut(
				candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());
		if (expressionPointcut == null) {
			return null;
		}
		//根据切点信息生成增强器
		//把切面的增强方法提取成一个一个的  Advisor，
		//由Advisor的实现类InstantiationModelAwarePointcutAdvisorImpl 进行统一封装 
		return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,
				this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
	}

==============================================================================================
		//获取切点信息，其实就是获取注解表达式获取如：@Before("point()")
	@Nullable
	private AspectJExpressionPointcut getPointcut(Method candidateAdviceMethod, Class<?> candidateAspectClass) {
		//【第一步】找到方法上的注解
		AspectJAnnotation<?> aspectJAnnotation =
				AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
		if (aspectJAnnotation == null) {
			return null;
		}
		
		AspectJExpressionPointcut ajexp =
				new AspectJExpressionPointcut(candidateAspectClass, new String[0], new Class<?>[0]);
		//【第二步】得到注解表达式：如：pointcut()或者 @Pointcut(" execution(...)")
		//封装到AspectJExpressionPointcut对象
		ajexp.setExpression(aspectJAnnotation.getPointcutExpression());
		if (this.beanFactory != null) {
			ajexp.setBeanFactory(this.beanFactory);
		}
		return ajexp;
	}
===============================================================================================

	//找到切面注解
	@SuppressWarnings("unchecked")
	@Nullable
	protected static AspectJAnnotation<?> findAspectJAnnotationOnMethod(Method method) {
		//就是要找这些注解
		Class<?>[] classesToLookFor = new Class<?>[] {
				Before.class, Around.class, After.class, AfterReturning.class, AfterThrowing.class, Pointcut.class};
		for (Class<?> c : classesToLookFor) {
			//找到指定方法的注解，封装成AspectJAnnotation
			AspectJAnnotation<?> foundAnnotation = findAnnotation(method, (Class<Annotation>) c);
			if (foundAnnotation != null) {
				return foundAnnotation;
			}
		}
		return null;
	}

在上面逻辑中，把切面的增强方法提取成一个一个的 Advisor，由Advisor的实现类InstantiationModelAwarePointcutAdvisorImpl 进行统一封装 ,源码如下：

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

上面构造方法是把增强方法相关的信息进行了赋值，最后调用了一个 instantiateAdvice 来对增强器进行初始化，不同的增强逻辑不同，比如Before,After 他们的增强前置是不同的，所以需要不同的增强器来完成不同的逻辑，见：instantiateAdvice 方法源码

创建增强器

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

@Override
	@Nullable
	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
		//判断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;
		//不同的增强做出不同的处理，创建了不同的 Advice
		switch (aspectJAnnotation.getAnnotationType()) {
			case AtBefore:
			//前置AspectJMethodBeforeAdvice
				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;
	}

这里根据不同的增强注解生成不同的增强器，比如 AtBefore 会对应 AspectJMethodBeforeAdvice ，比如 AtAfter 对应了 AspectJAfterAdvice。增强器中都提供了一个 invoke 来调用增强方法。如AspectJMethodBeforeAdvice

public class AspectJMethodBeforeAdvice extends AbstractAspectJAdvice implements MethodBeforeAdvice, Serializable {

	public AspectJMethodBeforeAdvice(
			Method aspectJBeforeAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aif) {

		super(aspectJBeforeAdviceMethod, pointcut, aif);
	}


	@Override
	public void before(Method method, Object[] args, @Nullable Object target) throws Throwable {
		//调用增强方法，即调用@Before注解的前置通知方法
		invokeAdviceMethod(getJoinPointMatch(), null, null);
	}

	@Override
	public boolean isBeforeAdvice() {
		return true;
	}

	@Override
	public boolean isAfterAdvice() {
		return false;
	}

}

增强器的调用

这里有个疑问，上面已经针对不同的注解生成了不同的增强器，那么这些增强器在什么时候调用呢？当然是在我们调用对象的方法的时候，触发前置，后置等增强。在Spring内部有一个 MethodBeforeAdviceInterceptor 拦截器,该拦截器会在创建Bean的代理的时候被创建，它的作用就是在方法调用前拦截，我们看一下源码：

public class MethodBeforeAdviceInterceptor implements MethodInterceptor, Serializable {

	private MethodBeforeAdvice advice;


	/**
	 * Create a new MethodBeforeAdviceInterceptor for the given advice.
	 * @param advice the MethodBeforeAdvice to wrap
	 */
	public MethodBeforeAdviceInterceptor(MethodBeforeAdvice advice) {
	
		Assert.notNull(advice, "Advice must not be null");	
		//前置增强器
		this.advice = advice;
	}

	@Override
	public Object invoke(MethodInvocation mi) throws Throwable {
		//调用方法前：调用前置增强器中的增强
		this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
		//调用方法
		return mi.proceed();
	}

}

对于后置增强没有Interceptor ，而是在拦截器链中直接调用 AspectJAfterAdvice

public class AspectJAfterAdvice extends AbstractAspectJAdvice
		implements MethodInterceptor, AfterAdvice, Serializable {

	public AspectJAfterAdvice(
			Method aspectJBeforeAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aif) {

		super(aspectJBeforeAdviceMethod, pointcut, aif);
	}


	@Override
	public Object invoke(MethodInvocation mi) throws Throwable {
		try {
			return mi.proceed();
		}
		finally {
			//调用后置增强
			invokeAdviceMethod(getJoinPointMatch(), null, null);
		}
	}

	@Override
	public boolean isBeforeAdvice() {
		return false;
	}

	@Override
	public boolean isAfterAdvice() {
		return true;
	}

}

其他的增强这里就不一一分析了 ， 到这里我们基本上把增强器的解析流程分析完成了。

选择适用的增强器

在上面分析中已经找到了所有增强，但是不是所有增强器都适合，所以会过滤出适用的增强，主要实现在AbstractAdvisorAutoProxyCreator#findAdvisorsThatCanApply，其实就是找到满足我们配置的 切入点 的增强器，具体的细节这里就进去分析了。

创建代理

上面流程走完，找到了适合当前Bean的增强器，然后就会为当前Bean创建代理了，通过AbstractAutoProxyCreator#createProxy 完成

代理创建器:AbstractAutoProxyCreator

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 proxyFactory = new ProxyFactory();
		//拷贝当前类的属性
		proxyFactory.copyFrom(this);
		//判断是基于接口的代理,就是判断 <aop:aspectj-autoproxy proxy-target-class="false" 属性
		//默认fasle,即：走JDK动态代理
		if (!proxyFactory.isProxyTargetClass()) {
			//确定给定的 bean 是否应该用它的目标类而不是它的接口来代理。
			if (shouldProxyTargetClass(beanClass, beanName)) {
				proxyFactory.setProxyTargetClass(true);
			}
			else {
				//找到被代理类的接口interface ，添加到到 proxyFactory 代理工厂中
				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);
		}
		//通过 ProxyFactory 创建代理
		return proxyFactory.getProxy(getProxyClassLoader());
	}

看得出这个方法在配置代理工厂，ProxyFactory，配置好之后通过代理工厂创建代理。方法做了如下事情

• 把当前类中的属性添加到工厂
• 把被代理的接口添加到工厂
• 把增强器添加到工厂
• 把要代理的原始类添加到工厂
• 创建代理

该方法中通过判断 proxy-target-class=“false” 来决定采用JDK动态代理或者CGLIB代理，之前有分析过

• 如果被代理类有接口，Spring默认使用JDK动态代理
• 如果被代理类有接口，可以配置 proxy-target-class=“true” 强制使用CGLIB代理
• 如果被代理类没有接口，只能选择CGLIB代理 ，因为JDK动态代理只是支持有有接口的类，CGLIB是为被代理类生成一个子类，复写其所有方法来达到增强，CGLIB代理需要引入CGLIB库

继续跟进 proxyFactory.getProxy 方法

public Object getProxy(@Nullable ClassLoader classLoader) {
		//先创建一个JDKDynamicAopProxy  ， 然后创建代理类
		return createAopProxy().getProxy(classLoader);
	}


-----------------------------------------------------------------------------------------------

	@Override
	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.");
			}
			//判断目标是否有接口，选择使用JdkDynamicAopProxy创建代理，否则使用CGLIB
			if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
				return new JdkDynamicAopProxy(config);
			}
			//使用ObjenesisCglibAopProxy创建代理
			return new ObjenesisCglibAopProxy(config);
		}
		else {
			return new JdkDynamicAopProxy(config);
		}
	}

ProxyFactory#getProxy 首先会创建一个AopProxy 代理创建器，根据目标类是否有接口来选择使用JDK代理：JdkDynamicAopProxy 和CGLIB代理：ObjenesisCglibAopProxy。然后调用getProxy方法创建代理。

JDK动态代理：JDKDynamicAopProxy

JdkDynamicAopProxy 实现了 InvocationHandler，InvocationHandler是JDK动态代理最核心的一个类，代理对象的方法调用都会被委托到 invoke 方法中去执行，JdkDynamicAopProxy#getProxy 源码如下：

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {

	//创建代理
	@Override
	public Object getProxy(@Nullable ClassLoader classLoader) {
		if (logger.isDebugEnabled()) {
			logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
		}
		Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
		findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
		//创建代理类
		return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
	}


	//...省略代码...
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		//方法调用
		MethodInvocation invocation;
		Object oldProxy = null;
		boolean setProxyContext = false;
		
		TargetSource targetSource = this.advised.targetSource;
		Object target = null;

		try {
			// 如果是equals方法：目标类本身没有实现 equals(Object) 方法。
			if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
				// The target does not implement the equals(Object) method itself.
				return equals(args[0]);
			}
			//如果是hashCode方法：目标类本身没有实现 hashCode() 方法。
			else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
				// The target does not implement the hashCode() method itself.
				return hashCode();
			}
			else if (method.getDeclaringClass() == DecoratingProxy.class) {
				// There is only getDecoratedClass() declared -> dispatch to proxy config.
				return AopProxyUtils.ultimateTargetClass(this.advised);
			}
			//调用Advised 接口或者其父接口中定义的方法
			else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
					method.getDeclaringClass().isAssignableFrom(Advised.class)) {
				// Service invocations on ProxyConfig with the proxy config...
				return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
			}

			Object retVal;
			
			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.
			//目标类
			target = targetSource.getTarget();
			Class<?> targetClass = (target != null ? target.getClass() : null);

			// Get the interception chain for this method.
			//获取此方法的拦截器通知链
			List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

			// Check whether we have any advice. If we don't, we can fallback on direct
			// reflective invocation of the target, and avoid creating a MethodInvocation.
			if (chain.isEmpty()) {
			//如果没有拦截器能应用到该方法，直接反射调用方法
				// 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 = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
			}
			else {
				//创建 ReflectiveMethodInvocation 方法调用
				// We need to create a method invocation...
				invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
				// Proceed to the joinpoint through the interceptor chain.
				//通过拦截器链进入连接点
				retVal = invocation.proceed();
			}

			// Massage return value if necessary.
			Class<?> returnType = method.getReturnType();
			if (retVal != null && retVal == target &&
					returnType != Object.class && returnType.isInstance(proxy) &&
					!RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
				// Special case: it returned "this" and the return type of the method
				// is type-compatible. Note that we can't help if the target sets
				// a reference to itself in another returned object.
				retVal = proxy;
			}
			else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
				throw new AopInvocationException(
						"Null return value from advice does not match primitive return type for: " + method);
			}
			return retVal;
		}
		finally {
			if (target != null && !targetSource.isStatic()) {
				// Must have come from TargetSource.
				targetSource.releaseTarget(target);
			}
			if (setProxyContext) {
				// Restore old proxy.
				AopContext.setCurrentProxy(oldProxy);
			}
		}
	}
}

invoke方法中首先获取方法的拦截器通知链，如果有就会创建 MethodInvocation来调用方法,应用通知，如果没有拦截器链就直接反射调用方法。

方法增强拦截器：advice的织入

拦截器通知链是通过getInterceptorsAndDynamicInterceptionAdvice得到的：

	public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, @Nullable Class<?> targetClass) {
		MethodCacheKey cacheKey = new MethodCacheKey(method);
		//去缓存查询
		List<Object> cached = this.methodCache.get(cacheKey);
		if (cached == null) {
			//获取拦截器通知链
			cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(
					this, method, targetClass);
			this.methodCache.put(cacheKey, cached);
		}
		return cached;
	}
-----------------------------------------------
	public List<Object> getInterceptorsAndDynamicInterceptionAdvice(
			Advised config, Method method, @Nullable Class<?> targetClass) {

		// This is somewhat tricky... We have to process introductions first,
		// but we need to preserve order in the ultimate list.
		//用来装拦截器
		List<Object> interceptorList = new ArrayList<>(config.getAdvisors().length);
		Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());
		boolean hasIntroductions = hasMatchingIntroductions(config, actualClass);
		//注册一系列 AdvisorAdapter,用于将 Advisor 转化成 MethodInterceptor
		AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();

		for (Advisor advisor : config.getAdvisors()) {
			if (advisor instanceof PointcutAdvisor) {
				// Add it conditionally.
				PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
				if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {
				//把advisor转换成MethodInterceptor
					MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
					//检查当前 advisor 的 pointcut 是否可以匹配当前方法
					MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
					if (MethodMatchers.matches(mm, method, actualClass, hasIntroductions)) {
						if (mm.isRuntime()) {
							// Creating a new object instance in the getInterceptors() method
							// isn't a problem as we normally cache created chains.
							for (MethodInterceptor interceptor : interceptors) {
								//加到interceptorList
								interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));
							}
						}
						else {
						
							interceptorList.addAll(Arrays.asList(interceptors));
						}
					}
				}
			}
			else if (advisor instanceof IntroductionAdvisor) {
				IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
				if (config.isPreFiltered() || ia.getClassFilter().matches(actualClass)) {
					Interceptor[] interceptors = registry.getInterceptors(advisor);
					interceptorList.addAll(Arrays.asList(interceptors));
				}
			}
			else {
				Interceptor[] interceptors = registry.getInterceptors(advisor);
				interceptorList.addAll(Arrays.asList(interceptors));
			}
		}

		return interceptorList;
	}

getInterceptorsAndDynamicInterceptionAdvice这个方法主要是把Advisor 转成 MethodInterceptor ， 也就是说Advisor可以应用到连接点，也就是当代理对象方法被调用时就可以触发相应的 Advisor 通知了。

在AOP中为各种通知封装了不同的拦截器，在上面代码中出现一个注册器：GlobalAdvisorAdapterRegistry 其中委托AdvisorAdapterRegistry 来实现增强拦截器的注册,默认实现类是DefaultAdvisorAdapterRegistry 代码如下：

public class DefaultAdvisorAdapterRegistry implements AdvisorAdapterRegistry, Serializable {

	private final List<AdvisorAdapter> adapters = new ArrayList<>(3);


	/**
	 * Create a new DefaultAdvisorAdapterRegistry, registering well-known adapters.
	 * 创建一个注册器，用来注册各种适配器
	 */
	public DefaultAdvisorAdapterRegistry() {
		//方法前置通知适配器
		registerAdvisorAdapter(new MethodBeforeAdviceAdapter());
		//后置通知适配器
		registerAdvisorAdapter(new AfterReturningAdviceAdapter());
		//异常通知适配器
		registerAdvisorAdapter(new ThrowsAdviceAdapter());
	}

	//把advice　通知　包裹成　Advisor 增强器
	@Override
	public Advisor wrap(Object adviceObject) throws UnknownAdviceTypeException {
		if (adviceObject instanceof Advisor) {
			return (Advisor) adviceObject;
		}
		if (!(adviceObject instanceof Advice)) {
			throw new UnknownAdviceTypeException(adviceObject);
		}
		Advice advice = (Advice) adviceObject;
		if (advice instanceof MethodInterceptor) {
			// So well-known it doesn't even need an adapter.
			return new DefaultPointcutAdvisor(advice);
		}
		for (AdvisorAdapter adapter : this.adapters) {
			// Check that it is supported.
			if (adapter.supportsAdvice(advice)) {
				return new DefaultPointcutAdvisor(advice);
			}
		}
		throw new UnknownAdviceTypeException(advice);
	}

	//获取增强的方法拦截器
	@Override
	public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
		List<MethodInterceptor> interceptors = new ArrayList<>(3);
		//通知
		Advice advice = advisor.getAdvice();
		if (advice instanceof MethodInterceptor) {
			interceptors.add((MethodInterceptor) advice);
		}
		for (AdvisorAdapter adapter : this.adapters) {
			
			if (adapter.supportsAdvice(advice)) {
				//通过适配器把advisor转发成MethodInterceptor
				interceptors.add(adapter.getInterceptor(advisor));
			}
		}
		if (interceptors.isEmpty()) {
			throw new UnknownAdviceTypeException(advisor.getAdvice());
		}
		return interceptors.toArray(new MethodInterceptor[0]);
	}

	//注册适配器
	@Override
	public void registerAdvisorAdapter(AdvisorAdapter adapter) {
		this.adapters.add(adapter);
	}

}

下面是 MethodBeforeAdviceAdapter的源码：

class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {

	@Override
	public boolean supportsAdvice(Advice advice) {
		//是否支持
		return (advice instanceof MethodBeforeAdvice);
	}

	@Override
	public MethodInterceptor getInterceptor(Advisor advisor) {
		MethodBeforeAdvice advice = (MethodBeforeAdvice) advisor.getAdvice();
		//给定一个MethodBeforeAdvice 前置通知  ，返回一个MethodBeforeAdviceInterceptor 方法前置拦截
		return new MethodBeforeAdviceInterceptor(advice);
	}

}

MethodBeforeAdviceInterceptor 是针对于前置通知的拦截器，在拦截方法的执行之前，可用触发前置通知，源码如下：

public class MethodBeforeAdviceInterceptor implements MethodInterceptor, Serializable {
	//方法前置通知增强
	private MethodBeforeAdvice advice;


	/**
	 * Create a new MethodBeforeAdviceInterceptor for the given advice.
	 * @param advice the MethodBeforeAdvice to wrap
	 */
	public MethodBeforeAdviceInterceptor(MethodBeforeAdvice advice) {
		Assert.notNull(advice, "Advice must not be null");
		this.advice = advice;
	}

	@Override
	public Object invoke(MethodInvocation mi) throws Throwable {
		//调用前置通知增强
		this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
		//调用目标方法
		return mi.proceed();
	}

}

下面是 AfterReturningAdviceAdapter 后置通知适配器源码：

class AfterReturningAdviceAdapter implements AdvisorAdapter, Serializable {

	@Override
	public boolean supportsAdvice(Advice advice) {
		return (advice instanceof AfterReturningAdvice);
	}

	@Override
	public MethodInterceptor getInterceptor(Advisor advisor) {
		AfterReturningAdvice advice = (AfterReturningAdvice) advisor.getAdvice();
		return new AfterReturningAdviceInterceptor(advice);
	}

}

下面是 AfterReturningAdviceInterceptor后置通知拦截器

public class AfterReturningAdviceInterceptor implements MethodInterceptor, AfterAdvice, Serializable {

	private final AfterReturningAdvice advice;


	/**
	 * Create a new AfterReturningAdviceInterceptor for the given advice.
	 * @param advice the AfterReturningAdvice to wrap
	 */
	public AfterReturningAdviceInterceptor(AfterReturningAdvice advice) {
		Assert.notNull(advice, "Advice must not be null");
		this.advice = advice;
	}

	@Override
	public Object invoke(MethodInvocation mi) throws Throwable {
		//先调用目标方法
		Object retVal = mi.proceed();
		//再调用后置增强
		this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
		return retVal;
	}

}

下面是ThrowsAdviceInterceptor 异常通知拦截器：

public class ThrowsAdviceInterceptor implements MethodInterceptor, AfterAdvice {

	private static final String AFTER_THROWING = "afterThrowing";

	private static final Log logger = LogFactory.getLog(ThrowsAdviceInterceptor.class);


	private final Object throwsAdvice;
	@Override
	public Object invoke(MethodInvocation mi) throws Throwable {
		try {
			//执行目标方法
			return mi.proceed();
		}
		catch (Throwable ex) {
			//收集异常，获取异常增强方法
			Method handlerMethod = getExceptionHandler(ex);
			if (handlerMethod != null) {
				//调用异常增强
				invokeHandlerMethod(mi, ex, handlerMethod);
			}
			throw ex;
		}
	}

	private void invokeHandlerMethod(MethodInvocation mi, Throwable ex, Method method) throws Throwable {
		Object[] handlerArgs;
		if (method.getParameterCount() == 1) {
			handlerArgs = new Object[] { ex };
		}
		else {
			handlerArgs = new Object[] {mi.getMethod(), mi.getArguments(), mi.getThis(), ex};
		}
		try {
			//调用异常增强
			method.invoke(this.throwsAdvice, handlerArgs);
		}
		catch (InvocationTargetException targetEx) {
			throw targetEx.getTargetException();
		}
	}

使用反射调用方法

上面分析了Advice通知的注入过程，以及前置，后置，异常通知拦截器代码分析，现在代码回到 JdkDynamicAopProxy #invoke方法中 ， 得到方法的拦截器后，如果方法没有拦截器通知链，就直接反射调用方法，否则会创建 ReflectiveMethodInvocation来调用方法

//获取此方法的拦截器通知链
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

// Check whether we have any advice. If we don't, we can fallback on direct
// reflective invocation of the target, and avoid creating a MethodInvocation.
if (chain.isEmpty()) {
//如果没有拦截器能应用到该方法，直接反射调用方法
	// 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 = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
}
else {
	//创建 ReflectiveMethodInvocation 方法调用
	// We need to create a method invocation...
	invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
	// Proceed to the joinpoint through the interceptor chain.
	//通过拦截器链进入连接点
	retVal = invocation.proceed();
}

AopUtils.invokeJoinpointUsingReflection 源码如下：

@Nullable
public static Object invokeJoinpointUsingReflection(@Nullable Object target, Method method, Object[] args)
		throws Throwable {

	// Use reflection to invoke the method.
	try {
		//反射调用方法
		ReflectionUtils.makeAccessible(method);
		return method.invoke(target, args);
	}
	catch (InvocationTargetException ex) {
		// Invoked method threw a checked exception.
		// We must rethrow it. The client won't see the interceptor.
		throw ex.getTargetException();
	}
	catch (IllegalArgumentException ex) {
		throw new AopInvocationException("AOP configuration seems to be invalid: tried calling method [" +
				method + "] on target [" + target + "]", ex);
	}
	catch (IllegalAccessException ex) {
		throw new AopInvocationException("Could not access method [" + method + "]", ex);
	}
}

通过 ReflectiveMethodInvocation 调用方法

@Override
@Nullable
public Object proceed() throws Throwable {
	//	We start with an index of -1 and increment early.
	if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
		return invokeJoinpoint();
	}
	//拦截器
	Object interceptorOrInterceptionAdvice =
			this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
	if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
		// Evaluate dynamic method matcher here: static part will already have
		// been evaluated and found to match.
		//动态匹配参数，看拦截器是否可用执行
		InterceptorAndDynamicMethodMatcher dm =
				(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
		if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
			return dm.interceptor.invoke(this);
		}
		else {
			// Dynamic matching failed.
			// Skip this interceptor and invoke the next in the chain.
			//匹配失败，跳过当前拦截器，执行下一个拦截器
			return proceed();
		}
	}
	else {
		// It's an interceptor, so we just invoke it: The pointcut will have
		// been evaluated statically before this object was constructed.
		return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
	}
}

总结

到这里AOP的源码分析就结束了，最后总结一下大致流程

1. AopNamespaceHandler中注册了一个AOP解析器 AspectJAutoProxyBeanDefinitionParser
2. AspectJAutoProxyBeanDefinitionParser创建了 代理自动创建器AnnotationAwareAspectJAutoProxyCreator
3. AnnotationAwareAspectJAutoProxyCreator 负责解析AOP，和创建代理类
4. AnnotationAwareAspectJAutoProxyCreator解析切面，找到所有的增强方法封装成增强器，并找到适合Bean的增强器
5. 调用AbstractAutoProxyCreator创建代理，默认使用 JDKDynamicAopProxy JDK动态代理，如果 proxy-target-class=“true” 使用CglibAopProxy创建CGLIB代理。
6. 对于前置，后置，异常等等通知都有对应的拦截器，当代理类被调用就会先走方法的拦截器进行增强逻辑的处理。

文章接收，喜欢就一键三连吧，你的肯定是我最大的动力。