前文：

《Spring AOP源码：开启注解读取》

《Spring AOP源码2：查找增强器》

《Spring AOP源码3：实现代理》

《Spring事务源码：创建代理类》

《Spring事务源码：事务创建》

《Spring事务源码：事务的提交与回滚》

写在开头：本文为个人学习笔记，内容比较随意，夹杂个人理解，如有错误，欢迎指正。

前言

在之前的文章中，我们介绍了AOP与Spring事务的内容（事务管理也是通过AOP的动态代理实现的），包括代理的创建、执行等，但是遗留了一个问题，那就是多个增强的执行顺序是怎样的，本文我们就来进行下梳理。

AOP在被设置在了后置处理器中，每个bean创建完后会判断是否需要创建代理类，如果需要则获取所有的通知方法（包括继承了Advisor接口的实现类与@Aspect标注的切面类中的增强方法，包装为Advisor类）并放入缓存中以便下次代理，然后筛选出适用于当前bean的增强并封装为代理对象。当执行到该bean时，便会将当前bean上的增强方法取出来形成责任链，顺序进入代理类中的增强方法，当责任链进入完后便会执行真正的方法，即该bean被调用的方法。（注意只是进入通知对象中，比如AspectJAfterAdvice在进入后会先执行目标方法，然后才执行After的增强方法）。

前言

一、第一次排序

1、排序过程

二、第二次排序

1、排序触发点

2、sortAdvisors

三、增强的排序顺序与执行顺序

四、AOP与事务的执行顺序

一、第一次排序

1、排序过程

第一次排序在ReflectiveAspectJAdvisorFactory#getAdvisorMethods，调用结构如下：

|-AbstractAutoProxyCreator#postProcessBeforeInstantiation
  |-AspectJAwareAdvisorAutoProxyCreator#shouldSkip
   |-AnnotationAwareAspectJAutoProxyCreator#findCandidateAdvisors
    |-BeanFactoryAspectJAdvisorsBuilder#buildAspectJAdvisors
     |-ReflectiveAspectJAdvisorFactory#getAdvisors
      |-ReflectiveAspectJAdvisorFactory#getAdvisorMethods

遍历所有的@Aspect标注的切面类，getAdvisors方法调用getAdvisorMethods获取当前切面类里的所有增强方法。

注意这里的advisors.size()，因为每次会将新Advisor加入到集合中，所以值是不断变大的，代代表的每个Advisor在集合中的优先级，在创建为Advisor时封装为其declarationOrder属性。

	public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
		Class<?> aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
		String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName();
		validate(aspectClass);

		MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory =
				new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);

		List<Advisor> advisors = new ArrayList<Advisor>();
		for (Method method : getAdvisorMethods(aspectClass)) {
			Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName);
			if (advisor != null) {
				advisors.add(advisor);
			}
		}
        // 其余代码
	}

getAdvisorMethods首先获取所有的增强方法，然后使用了一个预定义的比较器METHOD_COMPARATOR对他们排序。

	private List<Method> getAdvisorMethods(Class<?> aspectClass) {
		final List<Method> methods = new ArrayList<Method>();
		ReflectionUtils.doWithMethods(aspectClass, new ReflectionUtils.MethodCallback() {
			@Override
			public void doWith(Method method) throws IllegalArgumentException {
				if (AnnotationUtils.getAnnotation(method, Pointcut.class) == null) {
					methods.add(method);
				}
			}
		});
		Collections.sort(methods, METHOD_COMPARATOR);
		return methods;
	}

我们来看下这个比较器

	private static final Comparator<Method> METHOD_COMPARATOR;

	static {
		CompoundComparator<Method> comparator = new CompoundComparator<Method>();
        // 按照Around, Before, After, AfterReturning, AfterThrowing顺序排序
		comparator.addComparator(new ConvertingComparator<Method, Annotation>(
				new InstanceComparator<Annotation>(
						Around.class, Before.class, After.class, AfterReturning.class, AfterThrowing.class),
				new Converter<Method, Annotation>() {
					@Override
					public Annotation convert(Method method) {
						AspectJAnnotation<?> ann = AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(method);
						return (ann != null ? ann.getAnnotation() : null);
					}
				}));
        // 按方法名排序
		comparator.addComparator(new ConvertingComparator<Method, String>(
				new Converter<Method, String>() {
					@Override
					public String convert(Method method) {
						return method.getName();
					}
				}));
		METHOD_COMPARATOR = comparator;
	}

通过上面流程图我们知道，该排序比较器首先是按照 Around, Before, After, AfterReturning, AfterThrowing 等注解类型进行排序的，如果有相同类型的通知方法，再按照方法名称进行排序。如此一来，后面在遍历通知方法生成 advisor 实例的时候也会按照这个顺序一个一个放入 advisor 列表中。（注意这是对同一个切面类中的方法的排序结果）

二、第二次排序

1、排序触发点

|-AbstractAutoProxyCreator#postProcessAfterInitialization
 |-AbstractAutoProxyCreator#wrapIfNecessary
  |-AbstractAdvisorAutoProxyCreator#getAdvicesAndAdvisorsForBean
   |-AbstractAdvisorAutoProxyCreator#findEligibleAdvisors
    |-AspectJAwareAdvisorAutoProxyCreator#sortAdvisors

第二次排序是在findEligibleAdvisors方法中的sortAdvisors内，此时已经将所有增强方法找了出来并做了过滤，注意这里findCandidateAdvisors是先把Advisors接口实现类加入到了集合中，所以在第二次排序前集合中增强方法的顺序是{Advisors接口实现类、@Aspect标准的切面类1、@Aspect标准的切面类2}这样，而每个切面类中的通知方法排序顺序则是按照第一次排序中的结果来的，至于切面类的顺序则要看Spring获取他们的先后顺序。

    protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
        // 1.查找所有的候选Advisor
        List<Advisor> candidateAdvisors = findCandidateAdvisors();
        // 2.从所有候选的Advisor中找出符合条件的
        List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
        // 3.扩展方法，留个子类实现
        extendAdvisors(eligibleAdvisors);
        if (!eligibleAdvisors.isEmpty()) {
            // 4.对符合条件的Advisor进行排序
            eligibleAdvisors = sortAdvisors(eligibleAdvisors);
        }
        return eligibleAdvisors;
    }

    protected List<Advisor> findCandidateAdvisors() {
        // 1.走父类AbstractAdvisorAutoProxyCreator实现的findCandidateAdvisors
        List<Advisor> advisors = super.findCandidateAdvisors();
        // 2.为bean工厂中的所有AspectJ注解类中的方法构建advisor
        advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
        return advisors;
    }

2、sortAdvisors

sortAdvisors将所有的通知使用比较器DEFAULT_PRECEDENCE_COMPARATOR封装为了PartiallyComparableAdvisorHolder对象，并使用了PartialOrder中的sort方法排序。

	protected List<Advisor> sortAdvisors(List<Advisor> advisors) {
		List<PartiallyComparableAdvisorHolder> partiallyComparableAdvisors =
				new ArrayList<PartiallyComparableAdvisorHolder>(advisors.size());
		for (Advisor element : advisors) {
			partiallyComparableAdvisors.add(
					new PartiallyComparableAdvisorHolder(element, DEFAULT_PRECEDENCE_COMPARATOR));
		}
		List<PartiallyComparableAdvisorHolder> sorted =
				PartialOrder.sort(partiallyComparableAdvisors);
		if (sorted != null) {
			List<Advisor> result = new ArrayList<Advisor>(advisors.size());
			for (PartiallyComparableAdvisorHolder pcAdvisor : sorted) {
				result.add(pcAdvisor.getAdvisor());
			}
			return result;
		}
		else {
			return super.sortAdvisors(advisors);
		}
	}

DEFAULT_PRECEDENCE_COMPARATOR实际上是一个AspectJPrecedenceComparator对象，其内部重写了compare方法，并内嵌了一个成员变量advisorComparator，其实际为AnnotationAwareOrderComparator对象，同样是一个比较器。

    // AspectJAwareAdvisorAutoProxyCreator.java
    private static final Comparator<Advisor> DEFAULT_PRECEDENCE_COMPARATOR = new AspectJPrecedenceComparator();


    // AspectJPrecedenceComparator.java
    private final Comparator<? super Advisor> advisorComparator;
    class AspectJPrecedenceComparator implements Comparator<Advisor> {
	    public AspectJPrecedenceComparator() {
		    this.advisorComparator = AnnotationAwareOrderComparator.INSTANCE;
	    }

        public int compare(Advisor o1, Advisor o2) {
            // ... 
	    }
    }

    // AnnotationAwareOrderComparator.java
    public class AnnotationAwareOrderComparator extends OrderComparator {
	    public static final AnnotationAwareOrderComparator INSTANCE = new AnnotationAwareOrderComparator();
    }

PartialOrder的sort排序可以看下这篇文章《搞懂AOP之三，偏序排序》，篇幅原因本文就不做详细介绍了，只要知道其内部是调用了传入对象自身的比较器来实现的排序效果即可

		void addDirectedLinks(SortObject other) {
			int cmp = object.compareTo(other.object);
			if (cmp == 0) {
				return;
			}
			if (cmp > 0) {
				this.smallerObjects.add(other);
				other.biggerObjects.add(this);
			} else {
				this.biggerObjects.add(other);
				other.smallerObjects.add(this);
			}
		}

AspectJPrecedenceComparator#compare

上文中传入的PartiallyComparableAdvisorHolder对象的比较器为AspectJPrecedenceComparator，因此调用的是这个类的compare方法，不过他也是调用的另一个比较器AnnotationAwareOrderComparator的compare发发，但该类未重写compare方法，因此复用的是OrderComparator中的实现。

    // AspectJPrecedenceComparator.java
	public int compare(Advisor o1, Advisor o2) {
        // 调用advisorComparator的compare方法比较两个通知
		int advisorPrecedence = this.advisorComparator.compare(o1, o2);
        // 其余代码
		return advisorPrecedence;
	}

从下面的代码可知，先比较PriorityOrdered，两者之中，只有其一实现了 PriorityOrdered接口，那么类型为 PriorityOrdered 优先级高。如果都实现了再按 Ordered 的规则比较。

    // OrderComparator.java
	public int compare(Object o1, Object o2) {
		return doCompare(o1, o2, null);
	}

	private int doCompare(Object o1, Object o2, OrderSourceProvider sourceProvider) {
		boolean p1 = (o1 instanceof PriorityOrdered);
		boolean p2 = (o2 instanceof PriorityOrdered);
		if (p1 && !p2) {
			return -1;
		}
		else if (p2 && !p1) {
			return 1;
		}

		int i1 = getOrder(o1, sourceProvider);
		int i2 = getOrder(o2, sourceProvider);
		return (i1 < i2) ? -1 : (i1 > i2) ? 1 : 0;
	}

由于上文中传入的sourceProvider为null，我们这里直接看最后一行getOrder(obj)，这里是对增强方法的类对象调用了findOrder方法获取优先级设置，如果没获取到设置为默认值Integer.MAX_VALUE，因为order值越小优先级越高，所以这里默认是设置为了最低优先级。

	private int getOrder(Object obj, OrderSourceProvider sourceProvider) {
		Integer order = null;
		if (sourceProvider != null) {
            // 其余代码
		}
		return (order != null ? order : getOrder(obj));
	}

    int LOWEST_PRECEDENCE = Integer.MAX_VALUE;
	protected int getOrder(Object obj) {
		Integer order = findOrder(obj);
		return (order != null ? order : Ordered.LOWEST_PRECEDENCE);
	}

来看findOrder方法，有两种获取order的方式，按顺序如下：

如果实现了Ordered或PriorityOrdered接口，则根据 getOrder() 返回值进行比较，值越小优先级越高；
如果标注了@Order/@Priority注解，则根据其value()返回值进行比较，值越小优先级越高；

    // AnnotationAwareOrderComparator.java
	protected Integer findOrder(Object obj) {
		// 1、如果实现了Ordered或PriorityOrdered接口
        // 则根据 getOrder() 返回值进行比较，值越小优先级越高
		Integer order = super.findOrder(obj);
		if (order != null) {
			return order;
		}
        // 2、如果标注了@Order/@Priority注解
        // 则根据其value()返回值进行比较，值越小优先级越高；
        if (obj instanceof Class) {
			return OrderUtils.getOrder((Class<?>) obj);
		}
        // 其余代码
	}

来看获取实现了Order接口的优先级，实际上是调用了getOrder方法来获取的

    // OrderComparator.java
	protected Integer findOrder(Object obj) {
		return (obj instanceof Ordered ? ((Ordered) obj).getOrder() : null);
	}

以事务增强BeanFactoryTransactionAttributeSourceAdvisor为例，其getOrder方法可以如果未配置则获取其增强方法是否继承了Order接口，如果还没有则使用默认配置，即最低优先级。

    // AbstractPointcutAdvisor.java
	public void setOrder(int order) {
		this.order = order;
	}

	@Override
	public int getOrder() {
		if (this.order != null) {
			return this.order;
		}
		Advice advice = getAdvice();
		if (advice instanceof Ordered) {
			return ((Ordered) advice).getOrder();
		}
        // int LOWEST_PRECEDENCE = Integer.MAX_VALUE;
		return Ordered.LOWEST_PRECEDENCE;
	}

这里的getAdvice由父类AbstractBeanFactoryPointcutAdvisor实现，结合事务代理的创建逻辑可以得知上一步中获取增强方法的order值判断的是TransactionInterceptor类，由于该类没有继承Order接口，因此BeanFactoryTransactionAttributeSourceAdvisor的优先级为最低。

不过Spring也给我们预留了一个order配置可以在xml配置文件中手动设置优先级。

    // AbstractBeanFactoryPointcutAdvisor.java
	public Advice getAdvice() {
        // 其余代码
        advice = this.beanFactory.getBean(this.adviceBeanName, Advice.class);
	}

    // AopAutoProxyConfigurer#configureAutoProxyCreator
    public static void configureAutoProxyCreator(Element element, ParserContext parserContext) {
        // 其余代码
        // 增强方法TransactionInterceptor
        RootBeanDefinition interceptorDef = new RootBeanDefinition(TransactionInterceptor.class);
        String interceptorName = parserContext.getReaderContext().registerWithGeneratedName(interceptorDef);

        // 设置BeanFactoryTransactionAttributeSourceAdvisor的adviceBeanName为TransactionInterceptor
        RootBeanDefinition advisorDef = new RootBeanDefinition(BeanFactoryTransactionAttributeSourceAdvisor.class);
        advisorDef.getPropertyValues().add("adviceBeanName", interceptorName);
        // 手动设置order值
        if (element.hasAttribute("order")) {
					advisorDef.getPropertyValues().add("order", element.getAttribute("order"));
				}
        // 其余代码
    }

再来看其余切面类的Order值是如何获取的。在getAdvisor方法中，将增强方法封装为了InstantiationModelAwarePointcutAdvisorImpl对象。而该对象又会获取封装时传的aspectInstanceFactory对象的getOrder方法，该类的类型为BeanFactoryAspectInstanceFactory。

    // ReflectiveAspectJAdvisorFactory.java
    public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory,
                          int declarationOrderInAspect, String aspectName) {
        // 其余代码
        // 根据切点信息生成增强器
        return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,
            this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
    }

    // InstantiationModelAwarePointcutAdvisorImpl.java
    @Override
    public int getOrder() {
        return this.aspectInstanceFactory.getOrder();
    }

从代码上来看，getOrder()逻辑如下：

通过名称获取切面类，也就是标注了@Aspect的类；
如果切面类实现了 Ordered 接口，就调用 getOrder() 方法获取，返回（PriorityOrdered 是 Ordered 的子接口，也有 getOrder() 方法，这里也会获取到）；
如果上面没有获取到，则查找切面类是是否有 @Order 注解，如果有，则返回 @Order 注解指定的值；如果没有，查找切面类是否有 @Priority注解，如果有，则返回 @Priority 注解指定的值；
如果以上没有获取到值，就返回默认值：Ordered.LOWEST_PRECEDENCE。

    // BeanFactoryAspectInstanceFactory.java
    public int getOrder() {
        // this.name 指的是标注了 @Aspect 注解的类
        Class<?> type = this.beanFactory.getType(this.name);
        if (type != null) {
            // 如果实现了 Ordered 接口，就调用 getOrder() 方法获取
            // PriorityOrdered 是 Ordered 的子接口，也有 getOrder() 方法，因此这里也会获取到
            if (Ordered.class.isAssignableFrom(type) && this.beanFactory.isSingleton(this.name)) {
                return ((Ordered) this.beanFactory.getBean(this.name)).getOrder();
            }
            // 1. 查找类是是否有 @Order 注解，如果有，则返回 @Order 注解指定的值；
            // 2. 否则查询类是否有 @Priority 注解，如果有，则返回 @Priority 注解指定的值；
            // 3. 如果以上都不满足，返回 Ordered.LOWEST_PRECEDENCE，值为 Integer.MAX_VALUE
            return OrderUtils.getOrder(type, Ordered.LOWEST_PRECEDENCE);
        }
        return Ordered.LOWEST_PRECEDENCE;
}

回过头来看OrderUtils.getOrder((Class<?>) obj)

    // AnnotationAwareOrderComparator.java
	protected Integer findOrder(Object obj) {
		// 1、获取Ordered或PriorityOrdered接口设置的值

        // 2、如果标注了@Order/@Priority注解
        // 则根据其value()返回值进行比较，值越小优先级越高；
        if (obj instanceof Class) {
			return OrderUtils.getOrder((Class<?>) obj);
		}
        // 其余代码
	}

很简单的逻辑，先后获取@Order与@priorityOrder的优先级设置，

    // OrderUtils.java
	public static Integer getOrder(Class<?> type) {
		return getOrder(type, null);
	}

	public static Integer getOrder(Class<?> type, Integer defaultOrder) {
		Order order = AnnotationUtils.findAnnotation(type, Order.class);
		if (order != null) {
			return order.value();
		}
		Integer priorityOrder = getPriority(type);
		if (priorityOrder != null) {
			return priorityOrder;
		}
		return defaultOrder;
	}

	public static Integer getPriority(Class<?> type) {
		if (priorityAnnotationType != null) {
			Annotation priority = AnnotationUtils.findAnnotation(type, priorityAnnotationType);
			if (priority != null) {
				return (Integer) AnnotationUtils.getValue(priority);
			}
		}
		return null;
	}

再往上回到AspectJPrecedenceComparator#compare中，调用完this.advisorComparator.compare后，如果存在优先级相同，且两个advisor是在同一aspect中定义的，则调用comparePrecedenceWithinAspect继续比较。

    // AspectJPrecedenceComparator.java
    private static final int SAME_PRECEDENCE = 0;
    
    public int compare(Advisor o1, Advisor o2) {
        // 比较规则：AnnotationAwareOrderComparator
        int advisorPrecedence = this.advisorComparator.compare(o1, o2);
        // 顺序相同，且来源于同一 aspect，调用 comparePrecedenceWithinAspect 再次比较
        if (advisorPrecedence == SAME_PRECEDENCE && declaredInSameAspect(o1, o2)) {
            // 比较声明顺序，如果其中有一个是after通知，则后声明的优先级高；否则先声明的优先级高
            advisorPrecedence = comparePrecedenceWithinAspect(o1, o2);
        }
        return advisorPrecedence;
    }

	private boolean declaredInSameAspect(Advisor advisor1, Advisor advisor2) {
		return (hasAspectName(advisor1) && hasAspectName(advisor2) &&
				getAspectName(advisor1).equals(getAspectName(advisor2)));
	}

比较规则如下：比较两者的declarationOrderInAspect值，如果两者之一为after通知，declarationOrderInAspect大的优先级高；如果两者都不是after通知，declarationOrderInAspect小的优先级高。

// AspectJPrecedenceComparator.java
private int comparePrecedenceWithinAspect(Advisor advisor1, Advisor advisor2) {
    boolean oneOrOtherIsAfterAdvice = (AspectJAopUtils.isAfterAdvice(advisor1) 
            || AspectJAopUtils.isAfterAdvice(advisor2));
    int adviceDeclarationOrderDelta = getAspectDeclarationOrder(advisor1) 
            - getAspectDeclarationOrder(advisor2);
    // 其中有一个是after通知，declarationOrderInAspect大的优先级高
    if (oneOrOtherIsAfterAdvice) {
        if (adviceDeclarationOrderDelta < 0) {
            return LOWER_PRECEDENCE;
        }
        else if (adviceDeclarationOrderDelta == 0) {
            return SAME_PRECEDENCE;
        }
        else {
            return HIGHER_PRECEDENCE;
        }
    }
    // 两者都不是after通知，declarationOrderInAspect小的优先级高
    else {
        if (adviceDeclarationOrderDelta < 0) {
            return HIGHER_PRECEDENCE;
        }
        else if (adviceDeclarationOrderDelta == 0) {
            return SAME_PRECEDENCE;
        }
        else {
            return LOWER_PRECEDENCE;
        }
    }
}

这里的declarationOrderInAspect便是上文提到的advisor.size()。

    // ReflectiveAspectJAdvisorFactory.java
    public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
        // 其余代码
        List<Advisor> advisors = new ArrayList<>();
        //获取这个类所有的增强方法
        for (Method method : getAdvisorMethods(aspectClass)) {
            // 生成增强实例，advisors.size() 依次为 0，1，2，... 这是
            // declarationOrderInAspect 的值，后面排序会用到
            Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, 
                advisors.size(), aspectName);
            if (advisor != null) {
                advisors.add(advisor);
            }
        }
        // 其余代码
    }

最后，同一个切面类中的增强排序结果为afterthrow、afterreurn、after、around、before。

综上，整个第二次排序的规则如下

首先判断当前Advisor所在的切面类是否实现Ordered/PriorityOrdered接口，是的话调用getOrder方法获取
否则判断当前Advisor所在的切面类是否包含@Order/@Priority注解，是的话从注解获取
没有取到值，默认为最低优先级，值为最大Int
不同切面类但是order值是一样的，则按spring获取到切面bean的顺序做排序，先获取先执行
一个切面类中的多个Advisor按afterthrow、afterreurn、after、around、before，相同Advisor按方法名排序。

三、增强的排序顺序与执行顺序

排序顺序与执行顺序是不同的，这是因为进入通知方法不等于执行增强，就比如@After就是进入invoke方法后先继续执行后续的增强链，最后才执行的该增强，而@Before则是先执行增强方法再继续调用增强链。

    // AspectJAfterAdvice.java
	@Override
	public Object invoke(MethodInvocation mi) throws Throwable {
		try {
			return mi.proceed();
		}
		finally {
			invokeAdviceMethod(getJoinPointMatch(), null, null);
		}
	}

    // MethodBeforeAdviceInterceptor.java
	@Override
	public Object invoke(MethodInvocation mi) throws Throwable {
		this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
		return mi.proceed();
	}
}

先说结论，invoke方法的执行顺序如下，但增强的执行顺序却是@Around、@Before、@After、@AfterReturning/@Afterthrow，这与通知类的invoek实现有关。

afterthrow{
	afterreurn{
		after{
			around{
				before{
				真正的方法
				}
			}
		}
	}
}

下面举个例子就知道了

@RestController("QueryAspect")
@Aspect
public class QueryAspect {
    //切点
    @Pointcut("execution(void com.epoint.DQSXKeQiao.Eco.Service.DepositServiceImpl.deposit(Long, Integer))")
    public void pointCut(){};
 
    @Before(value = "pointCut()")
    public void methodBefore(JoinPoint joinPoint) throws Exception {
        System.out.println("调用目标方法前 @Before 可以提前获取到参数信息：" + Arrays.toString(joinPoint.getArgs()));
        //模拟 before 出错
        //int a = 1 / 0;
    }
 
    @After(value = "pointCut()")
    public void methodAfter(JoinPoint joinPoint) {
        System.out.println("调用目标方法后 @After");
        // 模拟 After 异常
        //int a = 1 / 0;
    }
 
    @AfterReturning(returning = "result", pointcut = "pointCut()")
    public void methodAfterReturning(JoinPoint joinPoint, Object result) {
        System.out.println("目标方法返回后 @AfterReturning, 此时可以获取到返回结果 " + result);
        //模拟 AfterReturning 出错
        //int a = 1 / 0;
    }
 
    @AfterThrowing(value = "pointCut()", throwing = "ex")
    public void methodAfterThrowing(JoinPoint joinPoint, Exception ex) {
        System.out.println("抛出异常后， @AfterThrowing " + ex);
        //模拟 @AfterThrowing 异常
        //int a = 1 / 0;
    }
 
    @Around(value = "pointCut()")
    public Object methodAround(ProceedingJoinPoint pdj) throws Throwable {
        Object result = null;
        System.out.println("调用目标方法前 @Around ");
        try {
            //调用目标方法
            result = pdj.proceed();
        } catch (Throwable ex) {
            System.out.println("捕捉到异常信息：" + ex);
        }
        System.out.println("调用目标方法后 @Around ");
        return result;
    }
}


@RestController("depositServiceImpl")
public class DepositServiceImpl
{   
    public void deposit(Long userId, Integer money) {
       int a = 1;
    }
}

执行结果如下

@Around 通知最先执行，如果在 @Around 通知主动调用目标方法之前报错了，那么后面拦截器方法包括目标方法都不会执行了。当然就算不报错也可以进行一些校验操作，不想让流程往下面走直接返回也行。
@Before 通知的功能跟 @Around 前半部分类似，所以一般 @Before 不会跟 @Around 一起使用。
目标方法在 @Before 通知之后执行。如果目标方法报错会触发 @AfterThrowing 通知的增强方法，否则就会执行 @AfterReturning 的增强，可见这两个通知是不会同时执行的。
@After 通知在 @AfterReturning 或 @AfterThrowing 之后执行，可见无论目标方法是否异常，该通知方法都会执行。所以可以做一些资源释放的工作或者一些记录工作。
@After 通知执行完毕之后还会回到 @Around 通知方法，所以如果想做一些事情还能继续做。

四、AOP与事务的执行顺序

由于AOP 和事务都没有指定 order,所以第二节的排序结果还是事务代理在前，AOP增强在后，这在同时使用事务与AOP代理时会出现一个问题。

以下面的代码为例，我们可以看到事务管理在最外层，当出现异常时around的增强方法捕获了目标方法或者任何一个拦截器抛出的异常，但是却有没有把异常抛出来，将会导致事务捕捉不到异常了，使得无法进行回滚。

try {
	try {

		Object result = null;
        System.out.println("调用目标方法前 @Around ");
        try {
			//执行 @Before 的通知方法
			this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
			try {
					try {
						//执行目标方法
						return invokeJoinpoint();
					} catch (Throwable ex) {
						if (shouldInvokeOnThrowing(ex)) {
							//执行 @AfterThrowing 的通知方法
							invokeAdviceMethod(getJoinPointMatch(), null, ex);
						}
						throw ex;
					}
					//执行 @AfterReturning 的通知方法
					this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
			} finally {
				//执行 @After 的通知方法
				invokeAdviceMethod(getJoinPointMatch(), null, null);
			} 
		} catch (Throwable ex) {
            System.out.println("捕捉到异常信息：" + ex);
        }
        System.out.println("调用目标方法后 @Around ");
        //如果执行过程中都没有异常，则返回执行结果，就不会执行事务的回滚操作
        return result;
	} catch (IllegalArgumentException ex) {
		throw new AopInvocationException("Mismatch on arguments to advice method [" +
				this.aspectJAdviceMethod + "]; pointcut expression [" +
				this.pointcut.getPointcutExpression() + "]", ex);
	} catch (InvocationTargetException ex) {
		throw ex.getTargetException();
	}
} catch (Throwable ex) {
	// 事务捕捉到异常后进行回滚操作
	completeTransactionAfterThrowing(txInfo, ex);
	throw ex;
} finally {
	cleanupTransactionInfo(txInfo);
}

处理这个问题有2个方案：

方案一：Around捕捉到异常之后执行 throw ex把异常继续向外抛出，就像 @AfterThrowing 一样，这样一来事务就可以捕捉到该异常了，或者就不要在这个通知方法里捕获异常了，让外边的事务去处理吧。

该方法虽然可以解决问题，但是也会有一些不适用的情况，比如有些时候就是不想把异常抛出去，因为外边可能处理不了这个异常的话就会导致程序中断或者引起其他一些更为棘手的问题。

方法二：让事务拦截器直接尝试捕获目标方法的异常，就像下面这样

try {
 
	Object result = null;
    System.out.println("调用目标方法前 @Around ");
    try {
		//执行 @Before 的通知方法
		this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
		try {
				try {
					//事务的 try catch 在最内层执行
					try {
						//执行目标方法
						return invokeJoinpoint();
					} catch (Throwable ex) {
						// 事务捕捉到异常后进行回滚操作
						completeTransactionAfterThrowing(txInfo, ex);
						throw ex;
					} finally {
						cleanupTransactionInfo(txInfo);
					}
				} catch (Throwable ex) {
					if (shouldInvokeOnThrowing(ex)) {
						//执行 @AfterThrowing 的通知方法
						invokeAdviceMethod(getJoinPointMatch(), null, ex);
					}
					throw ex;
				} 
				//执行 @AfterReturning 的通知方法
				this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
		} finally {
			//执行 @After 的通知方法
			invokeAdviceMethod(getJoinPointMatch(), null, null);
		} 
	} catch (Throwable ex) {
        System.out.println("捕捉到异常信息：" + ex);
    }
    System.out.println("调用目标方法后 @Around ");
    //如果执行过程中都没有异常，则返回执行结果，就不会执行事务的回滚操作
    return result;
} catch (IllegalArgumentException ex) {
	throw new AopInvocationException("Mismatch on arguments to advice method [" +
			this.aspectJAdviceMethod + "]; pointcut expression [" +
			this.pointcut.getPointcutExpression() + "]", ex);
} catch (InvocationTargetException ex) {
	throw ex.getTargetException();
}

这样的话事务就能正常捕获到异常了，结合我们上文的介绍相信大家也能猜到这样的调整只需要我们在切面类上设置下@Order(1)的优先级就好了。