@EnableAspectJAutoProxy自动为bean创建代理对象

@EnableAspectJAutoProxy可以自动为spring容器中符合条件的bean创建代理对象，@EnableAspectJAutoProxy需要结合@Aspect注解一起使用。

案例

来一个配置

@ComponentScan
@Configuration
//开启AspectJ注解
@EnableAspectJAutoProxy
public class MainConfig {
}

来两个方法：

@Component
public class CarService {public void sayCar(){System.out.println("carService");}
}@Component
public class UserService {public void sayUser(){System.out.println("userService");}
}

来个切面：

@Aspect
@Component
public class MyAspect {@Pointcut("execution(* com.spring.beanAOP6..*(..))")public void pointCut() {}@Before("pointCut()")public void before(JoinPoint joinPoint) {MethodSignature signature = (MethodSignature) joinPoint.getSignature();String name = signature.getMethod().getName();System.out.println(String.format("进入%s方法", name));}
}

测试：

@Testpublic void testAop11(){AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfig.class);CarService carService = context.getBean("carService", CarService.class);carService.say();com.spring.beanAOP6.UserService userService = context.getBean("userService", com.spring.beanAOP6.UserService.class);userService.say();}

运行结果：

进入sayCar方法
carService
进入sayUser方法
userService

AspectJ中有几个关键信息

• 使用@Component将这个类注册到spring容器中
• 使用@Aspect标注这是一个AsectJ来定义通知的配置类
• 定义切点，目前的配置。会拦截beanAOP6包中以及其子包中所有类的所有方法。
• 定义一个前置通知，这个通知会对@Pointcut定义的切入点起效

通知执行顺序

@EnaleAspectJAutoProxy允许spring容器中通过Advisor 、@Aspect 来定义通知，当spring容器中存在多个Advisor、@Aspect时，组成的拦截器调用链顺序是什么样的呢？在介绍这个之前，我们需要先回顾一下aop中4种通知相关知识。

spring aop中4种通知（Advice）

1. MethodInterceptor
2. MethodBeforeAdvice
3. AfterReturningAdvice
4. ThrowsAdvice

所有的通知最终都需要转换成MethodInterceptor类型的通知，然后组成一个MethodInterceptor列表，我们称之为方法调用链或者拦截器链，上面列表中后面3个通过下面的转换器将其包装为MethodInterceptor类型的通知

1. MethodBeforeAdvice -> MethodBeforeAdviceInterceptor
2. AfterReturningAdvice -> AfterReturningAdviceInterceptor
3. ThrowsAdvice -> ThrowsAdviceInterceptor

org.aopalliance.intercept.MethodInterceptor：方法拦截器

方法拦截器，这个比较强大，可以在方法执行前后执行一些增强操作，其他类型的通知最终都会被包装为 MethodInterceptor 来执行。

下面我们自定义一个MethodInterceptor

class MyMethodInterceptor implements MethodInterceptor {@Overridepublic Object invoke(MethodInvocation invocation) throws Throwable {System.out.println("我是MethodInterceptor start");//调用invocation.proceed()执行下一个拦截器Object result = invocation.proceed();System.out.println("我是MethodInterceptor end");//返回结果return result;}
}

org.springframework.aop.MethodBeforeAdvice：方法前置通知

方法前置通知，可以在方法之前定义增强操作。

下面我们自定义一个MethodBeforeAdvice

class MyMethodBeforeAdvice implements MethodBeforeAdvice {@Overridepublic void before(Method method, Object[] args, @Nullable Object target) throws Throwable {System.out.println("我是MethodBeforeAdvice");}
}

MethodBeforeAdvice最终会被包装为MethodBeforeAdviceInterceptor类型，然后放到拦截器链中去执行，通过MethodBeforeAdviceInterceptor代码可以理解MethodBeforeAdvice的执行过程

public class MethodBeforeAdviceInterceptor implements MethodInterceptor, BeforeAdvice, Serializable {private final 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;}@Overridepublic Object invoke(MethodInvocation mi) throws Throwable {//调用MethodBeforeAdvice的before方法，执行前置通知this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());//执行下一个拦截器return mi.proceed();}}

org.springframework.aop.AfterReturningAdvice：方法返回通知

方法返回通知，用来在方法执行完毕之后执行一些增强操作。

下面我们自定义一个AfterReturningAdvice

class MyAfterReturningAdvice implements AfterReturningAdvice {@Overridepublic void afterReturning(@Nullable Object returnValue, Method method, Object[] args, @Nullable Object target) throws Throwable {System.out.println("我是AfterReturningAdvice");}
}

AfterReturningAdvice最终会被包装为AfterReturningAdviceInterceptor类型，然后放到拦截器链中去执行，通过AfterReturningAdviceInterceptor代码可以理解AfterReturningAdvice的执行过程

public class AfterReturningAdviceInterceptor implements MethodInterceptor, AfterAdvice, Serializable {private final AfterReturningAdvice advice;public AfterReturningAdviceInterceptor(AfterReturningAdvice advice) {this.advice = advice;}@Overridepublic Object invoke(MethodInvocation mi) throws Throwable {//执行下一个拦截器，可以获取目标方法的返回结果Object retVal = mi.proceed();//调用方法返回通知的afterReturning方法，会传入目标方法的返回值等信息this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());return retVal;}}

org.springframework.aop.ThrowsAdvice：异常通知

当目标方法发生异常时，可以通过 ThrowsAdvice 来指定需要回调的方法，我们在此可以记录一些异常信息，或者将异常信息发送到监控系统等。

下面我们自定义一个ThrowsAdvice

/*** 用来定义异常通知* 方法名必须是afterThrowing，格式参考下面2种定义* 1. public void afterThrowing(Exception ex)* 2. public void afterThrowing(Method method, Object[] args, Object target, Exception ex)*/
class MyThrowsAdvice implements ThrowsAdvice {public void afterThrowing(Method method, Object[] args, Object target, Exception ex) {System.out.println("我是ThrowsAdvice");}
}

ThrowsAdvice最终会被包装为ThrowsAdviceInterceptor类型，然后放到拦截器链中去执行，通过ThrowsAdviceInterceptor代码可以理解ThrowsAdvice的执行过程，ThrowsAdviceInterceptor 构造参数传入一个自定义的 ThrowsAdvice 对象

public class ThrowsAdviceInterceptor implements MethodInterceptor, AfterAdvice {private final Object throwsAdvice;public ThrowsAdviceInterceptor(Object throwsAdvice) {this.throwsAdvice = throwsAdvice;}@Overridepublic Object invoke(MethodInvocation mi) throws Throwable {try {return mi.proceed();} catch (Throwable ex) {//调用 ThrowsAdvice 中的 afterThrowing 方法来处理异常this.throwsAdvice.afterThrowing(。。。。);//将异常继续往外抛throw ex;}}
}

拦截器链执行过程

假如目标方法上面有好几个通知，调用目标方法执行，spring会将所有的通知转换得到一个MethodInterceptor列表，然后依次按照下面的方式执行，会先调用第一个拦截器的MethodInterceptor#invoke(MethodInvocation invocation)方法，会传递一个MethodInvocation类型的参数，在此方法中，我们可以调用MethodInvocation#processd方法去执行第二个拦截器，然后依次按照这样的过程执行，到了最后一个MethodInterceptor中，再次调用MethodInvocation#processd时，会调用目标方法。
4种通知的执行顺序

结合上面的过程，假如目标方法上面依次添加了下面4中通知，我们来分析一下他们的执行过程

class MyMethodInterceptor implements MethodInterceptor {@Overridepublic Object invoke(MethodInvocation invocation) throws Throwable {System.out.println("我是MethodInterceptor start");//调用invocation.proceed()执行下一个拦截器Object result = invocation.proceed();System.out.println("我是MethodInterceptor end");//返回结果return result;}
}class MyMethodBeforeAdvice implements MethodBeforeAdvice {@Overridepublic void before(Method method, Object[] args, @Nullable Object target) throws Throwable {System.out.println("我是MethodBeforeAdvice");}
}class MyAfterReturningAdvice implements AfterReturningAdvice {@Overridepublic void afterReturning(@Nullable Object returnValue, Method method, Object[] args, @Nullable Object target) throws Throwable {System.out.println("我是AfterReturningAdvice");}
}class MyThrowsAdvice implements ThrowsAdvice {public void afterThrowing(Method method, Object[] args, Object target, Exception ex) {System.out.println("我是ThrowsAdvice");}
}

根据通知的规定，非MethodInterceptor类型的通知，都会被包装为MethodInterceptor类型的，上面除了第一个之外，其他3个都会被转换为MethodInterceptor，转换之后变成了下面这样：

class MyMethodInterceptor implements MethodInterceptor {@Overridepublic Object invoke(MethodInvocation mi) throws Throwable {System.out.println("我是MethodInterceptor start");//调用mi.proceed()执行下一个拦截器Object retVal = mi.proceed();System.out.println("我是MethodInterceptor end");//返回结果return retVal;}
}class MyMethodBeforeAdvice implements MethodInterceptor {@Overridepublic Object invoke(MethodInvocation mi) throws Throwable {System.out.println("我是MethodBeforeAdvice");//调用mi.proceed()执行下一个拦截器Object retVal = mi.proceed();return retVal;}
}class MyAfterReturningAdvice implements MethodInterceptor {@Overridepublic Object invoke(MethodInvocation mi) throws Throwable {//调用mi.proceed()执行下一个拦截器Object retVal = mi.proceed();System.out.println("我是AfterReturningAdvice");return retVal;}
}class MyThrowsAdvice implements MethodInterceptor {@Overridepublic Object invoke(MethodInvocation mi) throws Throwable {try {//调用mi.proceed()执行下一个拦截器return mi.proceed();} catch (Throwable ex) {System.out.println("我是ThrowsAdvice");throw ex;}}
}

根据通知链的执行过程，最终变成了下面这样：

System.out.println("我是MethodInterceptor start");
System.out.println("我是MethodBeforeAdvice");
Object retVal = null;
try {retVal = 通过反射调用目标方法获取返回值;
} catch (Throwable ex) {System.out.println("我是ThrowsAdvice");throw ex;
}
System.out.println("我是AfterReturningAdvice");
System.out.println("我是MethodInterceptor end");
return retVal;

我们来个案例验证一下：

public class MyMethodInterceptor implements MethodInterceptor {@Overridepublic Object invoke(MethodInvocation invocation) throws Throwable {System.out.println("MyMethodInterceptor start");Object proceed = invocation.proceed();System.out.println("MyMethodInterceptor end");return proceed;}
}public class MyMethodBeforeInterceptor implements MethodBeforeAdvice {@Overridepublic void before(Method method, Object[] args, Object target) throws Throwable {System.out.println("MyMethodBeforeInterceptor before");}
}public class MyMethodAfterInterceptor implements AfterReturningAdvice {@Overridepublic void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {System.out.println("MyMethodAfterInterceptor after");}
}public class MyMethodThrowInterceptor implements ThrowsAdvice {public void afterThrowing(Method method, Object[] args, Object target, Exception ex) {System.out.println("MyMethodThrowInterceptor");}
}

public class UserService {public void say(){System.out.println("userService --> say方法");}
}

测试：

@Testpublic void testAop12(){ProxyFactory proxyFactory = new ProxyFactory();proxyFactory.addAdvice(new MyMethodInterceptor());proxyFactory.addAdvice(new MyMethodAfterInterceptor());proxyFactory.addAdvice(new MyMethodThrowInterceptor());proxyFactory.addAdvice(new MyMethodBeforeInterceptor());proxyFactory.setTarget(new com.spring.beanAOP7.UserService());com.spring.beanAOP7.UserService proxy = (com.spring.beanAOP7.UserService) proxyFactory.getProxy();proxy.say();}

运行结果：

MyMethodInterceptor start
MyMethodBeforeInterceptor before
userService --> say方法
MyMethodAfterInterceptor after
MyMethodInterceptor end

单个@Aspect中多个通知的执行顺序

@Aspect标注的类中可以使用下面5中注解来定义通知

@Before
@Around
@After
@AfterReturning
@AfterThrowing

当单个@Aspect中定义了多种类型的通知时，@EnableAspectJAutoProxy内部会对其进行排序，排序顺序如下

@AfterThrowing
@AfterReturning
@After
@Around
@Before

下面我们来个@Aspect类，同时定义5种通知，然后来一步步分析一下其执行的属性。

@Component
public class ColorService {public String color(){System.out.println("color");return "color";}
}@ComponentScan
@Configuration
@EnableAspectJAutoProxy
public class MainConfig {}

@Aspect
@Component
public class MyAspect {@Pointcut("execution(* com.spring.beanAOP8.ColorService.*(..))")public void pc() {}@Before("pc()")public void before() {System.out.println("@Before通知!");}@Around("pc()")public Object around(ProceedingJoinPoint joinPoint) throws Throwable {System.out.println("@Around通知start");Object result = joinPoint.proceed();System.out.println("@Around绕通知end");return result;}@After("pc()")public void after() throws Throwable {System.out.println("@After通知!");}@AfterReturning("pc()")public void afterReturning() throws Throwable {System.out.println("@AfterReturning通知!");}@AfterThrowing("pc()")public void afterThrowing() {System.out.println("@AfterThrowing通知!");}
}

 @Testpublic void testAop13(){AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(com.spring.beanAOP8.MainConfig.class);ColorService colorService = context.getBean("colorService", ColorService.class);colorService.color();}

@Around通知start
@Before通知!
color
@AfterReturning通知!
@After通知!
@Around绕通知end

这输出好像和我们上面说的不一样的？？？

排序规则和输出结果都没有问题，我们分析分析

@Aspect中5种通知回顾

5种通知对应的Advice类

• @AfterThrowing --> AspectJAfterThrowingAdvice
• @AfterReturning --> AspectJAfterReturningAdvice
• @After --> AspectJAfterAdvice
• @Around --> AspectJAroundAdvice
• @Before --> AspectJMethodBeforeAdvice

@AfterThrowing：AspectJAfterThrowingAdvice

public class AspectJAfterThrowingAdvice implements MethodInterceptor {@Overridepublic Object invoke(MethodInvocation mi) throws Throwable {try {//执行下一个拦截器return mi.proceed();} catch (Throwable ex) {//通过反射调用@AfterThrowing标注的方法//继续抛出异常throw ex;}}
}

AspectJAfterThrowingAdvice 实现了 MethodInterceptor 接口，不需要进行包装。

@AfterReturning：AspectJAfterReturningAdvice

public class AspectJAfterReturningAdvice implements AfterReturningAdvice {@Overridepublic void afterReturning(@Nullable Object returnValue, Method method, Object[] args, @Nullable Object target) throws Throwable {// 调用@AfterReturning标注的方法}
}

AspectJAfterReturningAdvice 实现了 AfterReturningAdvice 接口，是一个方法返回通知，不是MethodInterceptor类型的，所以最终需包装为MethodInterceptor类型，变成下面这样

public class AspectJAfterReturningAdvice implements MethodInterceptor {@Overridepublic Object invoke(MethodInvocation mi) throws Throwable {//执行下一个拦截器Object retVal = mi.proceed();//调用@AfterReturning标注的方法return retVal;}
}

@After：AspectJAfterAdvice

public class AspectJAfterAdvice implements MethodInterceptor {@Overridepublic Object invoke(MethodInvocation mi) throws Throwable {try {//执行下一个拦截器return mi.proceed();} finally {//调用@After标注的方法}}
}

AspectJAfterAdvice 实现了 MethodInterceptor接口，所以最终执行的时候不需要进行包装。

注意 invoke 方法内部使用了 try…finally 的方式，@After方法的调用放在了finally中，所以不管是否有异常，@After类型的通知都会被执行。

@Around：AspectJAroundAdvice

public class AspectJAroundAdvice extends AbstractAspectJAdvice implements MethodInterceptor, Serializable {@Overridepublic Object invoke(MethodInvocation mi) throws Throwable {return 调用 @Around标注的方法 ;}
}

AspectJAroundAdvice 实现了 MethodInterceptor接口，最终执行的时候也不需要进行包装。

@Before：AspectJMethodBeforeAdvice

public class AspectJMethodBeforeAdvice implements MethodBeforeAdvice, Serializable {@Overridepublic void before(Method method, Object[] args, @Nullable Object target) throws Throwable {invokeAdviceMethod(getJoinPointMatch(), null, null);}
}

AspectJMethodBeforeAdvice 实现了 MethodBeforeAdvice接口，是一个前置通知，不是MethodInterceptor类型的，所以最终需包装为MethodInterceptor类型，变成下面这样

public class AspectJMethodBeforeAdvice implements MethodInterceptor {@Overridepublic Object invoke(MethodInvocation mi) throws Throwable {//调用@Before标注的方法//执行下一个拦截器return mi.proceed();}
}

我们在来看下定义的通知

@Aspect
@Component
public class MyAspect {@Pointcut("execution(* com.spring.beanAOP8.ColorService.*(..))")public void pc() {}@Before("pc()")public void before() {System.out.println("@Before通知!");}@Around("pc()")public Object around(ProceedingJoinPoint joinPoint) throws Throwable {System.out.println("@Around通知start");Object result = joinPoint.proceed();System.out.println("@Around绕通知end");return result;}@After("pc()")public void after() throws Throwable {System.out.println("@After通知!");}@AfterReturning("pc()")public void afterReturning() throws Throwable {System.out.println("@AfterReturning通知!");}@AfterThrowing("pc()")public void afterThrowing() {System.out.println("@AfterThrowing通知!");}
}

我们给出的结论是，会按照下面的顺序执行

@AfterThrowing -> @AfterReturning -> @After -> @Around -> @Before

按照上面的顺序，一步步来分析。

先执行第1个通知@AfterThrowing，变成下面这样

try {//执行下一个拦截器return mi.proceed();
} catch (Throwable ex) {System.out.println("@AfterThrowing通知!");//继续抛出异常throw ex;
}

mi.processed()会执行第2个通知@AfterReturning，变成了下面这样

try {//执行下一个拦截器Object retVal = mi.proceed();System.out.println("@AfterReturning通知!");return retVal;
} catch (Throwable ex) {System.out.println("@AfterThrowing通知!");//继续抛出异常throw ex;
}

继续mi.proceed()执行第3个通知@After，变成了下面这样

try {Object result = null;try {//执行下一个拦截器result = mi.proceed();} finally {System.out.println("@After通知!");}System.out.println("@AfterReturning通知!");return retVal;
} catch (Throwable ex) {System.out.println("@AfterThrowing通知!");//继续抛出异常throw ex;
}

继续mi.proceed()执行第4个通知@Around，变成了下面这样

try {Object result = null;try {System.out.println("@Around通知start");result = joinPoint.proceed();System.out.println("@Around绕通知end");return result;} finally {System.out.println("@After通知!");}System.out.println("@AfterReturning通知!");return retVal;
} catch (Throwable ex) {System.out.println("@AfterThrowing通知!");//继续抛出异常throw ex;
}

继续joinPoint.proceed()执行第5个通知@Before，变成了下面这样

try {Object result = null;try {System.out.println("@Around通知start");System.out.println("@Before通知!");result = mi.proceed();System.out.println("@Around绕通知end");return result;} finally {System.out.println("@After通知!");}System.out.println("@AfterReturning通知!");return retVal;
} catch (Throwable ex) {System.out.println("@AfterThrowing通知!");//继续抛出异常throw ex;
}

继续joinPoint.proceed()会调用目标方法，变成了下面这样

try {Object result = null;try {System.out.println("@Around通知start");System.out.println("@Before通知!");result = // 通过反射调用目标方法;System.out.println("@Around绕通知end");return result;} finally {System.out.println("@After通知!");}System.out.println("@AfterReturning通知!");return retVal;
} catch (Throwable ex) {System.out.println("@AfterThrowing通知!");//继续抛出异常throw ex;
}

所以最终输出

@Around通知start
@Before通知!
@Around绕通知end
@After通知!
@AfterReturning通知!

@EnableAspectJAutoProxy中为通知指定顺序

@EnableAspectJAutoProxy用在spring环境中，可以通过@Aspect以及Advisor来定义多个通知，当spring容器中有多个@Aspect、Advisor时，他们的顺序是什么样的呢？

我们先看一下如何为@Aspect、自定义Advisor指定顺序。

为@Aspect指定顺序：用@Order注解

需要在@Aspect标注的类上使用@org.springframework.core.annotation.Order注解，值越小，通知的优先级越高。

为Advisor指定顺序：实现Ordered接口

自定义的Advisor通过org.springframework.core.Ordered接口来指定顺序，这个接口有个public int getOrder()方法，用来返回通知的顺序。

spring为我们提供了一个Advisor类型的抽象类org.springframework.aop.support.AbstractPointcutAdvisor，这个类实现了Ordered接口，spring中大部分Advisor会是继承AbstractPointcutAdvisor，若需要自定义Advisor，也可以继承这个类，这个类的getOrder方法比较关键，来看一下

public abstract class AbstractPointcutAdvisor implements PointcutAdvisor, Ordered, Serializable {@Nullableprivate Integer order;public void setOrder(int order) {this.order = order;}@Overridepublic int getOrder() {//若当前Advisor指定了order，则直接返回if (this.order != null) {return this.order;}//获取当前类中配置的通知对象AdviceAdvice advice = getAdvice();//若advice实现了Ordered接口，这从advice中获取通知的顺序if (advice instanceof Ordered) {return ((Ordered) advice).getOrder();}//否则通知的优先级最低，Integer.MAX_VALUEreturn Ordered.LOWEST_PRECEDENCE;}
}

Spring为我们提供了一个默认的Advisor类：DefaultPointcutAdvisor，这个类就继承了AbstractPointcutAdvisor，通常我们可以直接使用DefaultPointcutAdvisor来自定义通知。

多个@Aspect、Advisor排序规则

排序规则

1、在spring容器中获取@Aspect、Advisor类型的所有bean，得到一个列表 list1

2、对list1按照order的值升序排序，得到结果list2

3、然后再对list2中@Aspect类型的bean内部的通知进行排序，规则
@AfterThrowing -> @AfterReturning -> @After -> @Around -> @Before

4、最后运行的时候会得到上面排序产生的方法调用链列表去执行。

案例不写了，大家下去可以自己尝试一下

@EnableAspectJAutoProxy另外2个功能

这个注解还有2个参数，大家看一下下面的注释，比较简单，就不用案例演示了。

public @interface EnableAspectJAutoProxy {/*** 是否基于类来创建代理，而不是基于接口来创建代理* 当为true的时候会使用cglib来直接对目标类创建代理对象* 默认为 false：即目标bean如果有接口的会采用jdk动态代理来创建代理对象，没有接口的目标bean，会采用cglib来创建代理对象*/boolean proxyTargetClass() default false;/*** 是否需要将代理对象暴露在ThreadLocal中，当为true的时候* 可以通过org.springframework.aop.framework.AopContext#currentProxy获取当前代理对象*/boolean exposeProxy() default false;}

@EnableAspectJAutoProxy原理

@EnableAspectJAutoProxy会在spring容器中注册一个bean：AnnotationAwareAspectJAutoProxyCreator

AnnotationAwareAspectJAutoProxyCreator是BeanPostProcessor类型的，BeanPostProcessor大家应该比较熟悉了，bean后置处理器，可以在bean声明周期中对bean进行操作，比如对bean生成代理等；而AnnotationAwareAspectJAutoProxyCreator就是对符合条件的bean，自动生成代理对象，源码就这里就不细说了，有兴趣的可以从postProcessAfterInitialization方法看，比较简单。