Spring之AOP底层源码解析

Spring之AOP底层源码解析

1、动态代理

代理模式的解释：为其他对象提供一种代理以控制对这个对象的访问，增强一个类中的某个方法，对程序进行扩展。

举个例子

public class UserService {public void test() {System.out.println("test...");}
}

此时，我们 new 一个 UserService 对象，然后执行 test() 方法，结果是显而易见的。

那如果我们现在想在不修改 UserService 类的源码前提下，给 test() 方法增加额外的逻辑，那么就可以使用动态代理机制来创建 UserService 对象了，比如：

		public static void main(String[] args) {// 被代理对象UserService target = new UserService();// 通过cglib技术Enhancer enhancer = new Enhancer();// 设置要代理的类enhancer.setSuperclass(UserService.class);// 定义额外的逻辑，也就是代理逻辑enhancer.setCallbacks(new Callback[]{new MethodInterceptor() {/**** @param o 代理对象* @param method 当前正在执行的方法* @param objects 方法所需要的参数* @param methodProxy* @return* @throws Throwable*/@Overridepublic Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {System.out.println("before...");// 执行被代理对象的原始方法Object result = methodProxy.invoke(target, objects);// Object result = methodProxy.invokeSuper(o, objects); 这种方式也可以System.out.println("after...");return result;}}});// 动态代理所创建出来的UserService代理对象UserService userService = (UserService) enhancer.create();// 执行这个userService的test方法时，就会额外执行一些其他逻辑userService.test();}

得到的都是 UserService 对象，但是执行 test() 方法时的效果却不一样了，这就是代理所带来的效果。

上面是通过 cglib 来实现的动态代理对象的创建，是基于子父类的，被代理类（UserService）是父类，代理类是子类，代理对象就是代理类的实例对象，代理类是由 cglib 创建的，对于程序员来说不用关心。

除了 cglib 技术，JDK 本身也提供了一种创建代理对象的动态代理机制，但是它只能代理接口，也就是 UserService 得先有一个接口才能利用 JDK 动态代理机制来生成一个代理对象，比如：

public interface UserInterface {public void test();}public class UserService implements UserInterface {public void test() {System.out.println("test...");}
}

利用 JDK 动态代理来生成一个代理对象：

		public static void main(String[] args) {// 被代理对象UserService target = new UserService();/*** UserInterface接口的代理对象* 注意第一个参数可以是任意类的类加载器，而第二个参数必须是代理对象的类型*/Object proxy = Proxy.newProxyInstance(UserService.class.getClassLoader(), new Class[]{UserInterface.class}, new InvocationHandler() {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("before...");// 通过反射机制调用被代理对象的原始方法Object result = method.invoke(target, args);System.out.println("after...");return result;}});UserInterface userService = (UserInterface) proxy;userService.test();}

如果你把 new Class[]{UserInterface.class}，替换成 new Class[]{UserService.class}，那么代码会直接报错：

表示一定要是个接口。

由于这个限制，所以产生的代理对象的类型是 UserInterface，而不是 UserService，这是需要注意的。

2、ProxyFactory

上面我们介绍了两种动态代理技术，那么在 Spring 中进行了封装，封装出来的类叫做 ProxyFactory，表示是创建代理对象的一个工厂，使用起来会比上面的更加方便，比如：

		public static void main(String[] args) {// 被代理对象UserService target = new UserService();// 创建代理对象工厂ProxyFactory proxyFactory = new ProxyFactory();// 设置要代理的目标类proxyFactory.setTarget(target);/*** 注意：如果没有加上下面这行代码，那么默认走的是cglib动态代理；* 而如果我们设置了接口，那么走的就是jdk动态代理*/proxyFactory.setInterfaces(UserInterface);// 设置代理逻辑，MethodInterceptor表示方法拦截器proxyFactory.addAdvice(new MethodInterceptor() {@Overridepublic Object invoke(MethodInvocation invocation) throws Throwable {System.out.println("before...");Object result = invocation.proceed();System.out.println("after...");return result;}});// 通过代理对象工厂，获取代理对象UserInterface userService = (UserInterface) proxyFactory.getProxy();userService.test();}

通过 ProxyFactory，我们可以不再关心到底是用 cglib 还是 JDK 动态代理了，ProxyFactory 会帮助我们去判断，如果 UserService 实现了接口，那么ProxyFactory 底层就会采用 JDK 动态代理，如果没有实现接口，就会采用 cglib 动态代理。上面的代码，就是由于 UserService 实现了 UserInterface 接口，所以最后产生的代理对象是 UserInterface 类型。

3、Advice的分类

1、Before Advice：方法调用前执行

public class XiexuBeforeAdvice implements MethodBeforeAdvice {@Overridepublic void before(Method method, Object[] args, Object target) throws Throwable {System.out.println("方法调用前执行");}
}

2、After Returning Advice：方法 Return 后执行

		public class XiexuAfterReturningAdvice implements AfterReturningAdvice {/*** @param returnValue 执行完被代理方法之后的返回值* @param method      被代理方法* @param args        方法所需要的参数* @param target      被代理对象* @throws Throwable*/@Overridepublic void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {System.out.println("方法return后执行");}}

3、After Throwing Advice：方法抛异常后执行

public class XiexuThrowsAdvice implements ThrowsAdvice {/*** NullPointerException ex：当方法抛出的异常类型为NullPointerException类型时，才会调用该方法*/public void afterThrowing(Method method, Object[] args, Object target, NullPointerException ex) {System.out.println("方法抛出异常后执行");}}

4、After Advice：方法执行完之后执行，不管当前方法有没有抛出异常，这个 Advice 方法都会执行

5、Around Advice：这是功能最强大的 Advice，可以自定义执行顺序

public class XiexuAroundAdvice implements MethodInterceptor {@Nullable@Overridepublic Object invoke(@NotNull MethodInvocation invocation) throws Throwable {System.out.println("方法执行Around前");// 执行被代理方法Object proceed = invocation.proceed();System.out.println("方法执行Around后");return proceed;}
}

3.1、MethodInterceptor链

除了Around advice，其他 advice 在执行完各自的逻辑代码后，都会自动调用 proceed() 去执行被代理方法，而每次调用 proceed() 就会去看还有没有设置其他的 advice，如果有就会继续执行其他 advice 的代理逻辑。

这里就是用到了「责任链」设计模式。

	public static void main(String[] args) {// 被代理对象UserService target = new UserService();// 代理对象工厂ProxyFactory proxyFactory = new ProxyFactory();// 设置目标对象proxyFactory.setTarget(target);proxyFactory.addAdvice(new XiexuBeforeAdvice());proxyFactory.addAdvice(new XiexuAroundAdvice());proxyFactory.addAdvice(new XiexuAroundAdvice());// 获取代理对象UserService proxy = (UserService) proxyFactory.getProxy();proxy.test(); // 执行这行代码的时候，底层就会去执行invocation.proceed()}

proceed() 方法源码：

	@Override@Nullablepublic Object proceed() throws Throwable {/*** currentInterceptorIndex初始值为-1，每调用一个Interceptor就会加1* 当调用完了最后一个Interceptor后就会执行被代理的方法*/if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {// 执行被代理的方法，点进invokeJoinpoint()看看return invokeJoinpoint();}// currentInterceptorIndex初始值为-1Object interceptorOrInterceptionAdvice =this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);/*** 如果当前interceptor是InterceptorAndDynamicMethodMatcher，则先进行匹配，匹配成功后再调用该interceptor* 如果没有匹配则递归调用proceed()方法，调用下一个interceptor*/if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {InterceptorAndDynamicMethodMatcher dm =(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;Class<?> targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass());// 动态匹配，根据方法参数进行匹配if (dm.methodMatcher.matches(this.method, targetClass, this.arguments)) {return dm.interceptor.invoke(this);} else {// 不匹配则执行下一个MethodInterceptorreturn proceed();}} else {/*** 直接调用MethodInterceptor，传入this，在内部会再次调用proceed()方法进行递归* 比如MethodBeforeAdviceInterceptor*/return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);}}

4、Advisor的理解

跟 Advice 类似的还有一个 Advisor 的概念，一个 Advisor 是由一个 Pointcut 和一个 Advice 组成的，通过 Pointcut 可以指定需要被代理的逻辑，比如一个 UserService 类中有两个方法，按上面 ProxyFactory 的例子，这两个方法都会被代理、被增强，那么我们现在可以通过 Advisor，来控制具体代理哪一个方法，比如：

public class Test {public static void main(String[] args) {// 被代理对象UserService target = new UserService();// 代理对象工厂ProxyFactory proxyFactory = new ProxyFactory();// 设置目标对象proxyFactory.setTarget(target);proxyFactory.addAdvisor(new PointcutAdvisor() {/*** Pointcut可以去定义我们的代理逻辑要应用到哪个方法或哪个类上面* @return*/@Overridepublic Pointcut getPointcut() {return new StaticMethodMatcherPointcut() {@Overridepublic boolean matches(Method method, Class<?> targetClass) {// 表示只有test()方法才需要走代理逻辑return method.getName().equals("test");}};}/*** Advice只是表示一段代理逻辑* @return*/@Overridepublic Advice getAdvice() {return new XiexuAroundAdvice();}/*** 这个方法可以忽略* @return*/@Overridepublic boolean isPerInstance() {return false;}});// 获取代理对象UserInterface userService = (UserInterface) proxyFactory.getProxy();userService.test();}}

上面代码表示，产生的代理对象，只有在执行 test() 这个方法时才会被增强，才会执行额外的逻辑，而在执行其他方法时是不会被增强的。

5、创建代理对象的方式

上面介绍了 Spring 中所提供的 ProxyFactory、Advisor、Advice、PointCut 等技术来实现代理对象的创建，但是我们在使用 Spring 时，并不会直接这么去使用 ProxyFactory，比如说，我们希望 ProxyFactory 所产生的代理对象能直接就是 Bean，能直接从 Spring 容器中得到 UserSerivce 的代理对象，而这些 Spring 都是支持的，只不过作为开发者的我们肯定得先告诉 Spring，哪些类需要被代理，代理逻辑是什么。

5.1、ProxyFactoryBean

		// 将产生的代理对象成为一个Bean@Beanpublic ProxyFactoryBean userService() {UserService userService = new UserService();// 创建ProxyFactoryBean对象ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();// 设置要代理的对象proxyFactoryBean.setTarget(userService);// 代理逻辑proxyFactoryBean.addAdvice(new MethodInterceptor() {@Overridepublic Object invoke(MethodInvocation invocation) throws Throwable {System.out.println("before...");Object result = invocation.proceed();System.out.println("after...");return result;}});return proxyFactoryBean;}

通过这种方式来定义一个 UserService 的 Bean，并且是经过了 AOP 的。但是这种方式只能针对某一个 Bean。它是一个 FactoryBean，所以利用的就是FactoryBean 技术，间接地将 UserService 的代理对象作为了 Bean。

ProxyFactoryBean 还有额外的功能，比如可以把某个 Advice 或 Advisor 定义成为 Bean，然后在 ProxyFactoryBean 中进行设置：

		@Beanpublic MethodInterceptor XiexuAroundAdvice() {return new MethodInterceptor() {@Overridepublic Object invoke(MethodInvocation invocation) throws Throwable {System.out.println("before...");Object result = invocation.proceed();System.out.println("after...");return result;}};}@Beanpublic ProxyFactoryBean userService() {// 被代理对象UserService userService = new UserService();ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();// 设置目标对象proxyFactoryBean.setTarget(userService);proxyFactoryBean.setInterceptorNames("XiexuAroundAdvice");return proxyFactoryBean;}

5.2、BeanNameAutoProxyCreator

ProxyFactoryBean 得自己指定被代理的对象，那么我们可以通过 BeanNameAutoProxyCreator 指定某个 bean 的名字，来对该 bean 进行代理

		@Beanpublic MethodInterceptor XiexuAroundAdvice() {return new MethodInterceptor() {@Overridepublic Object invoke(MethodInvocation invocation) throws Throwable {System.out.println("before...");Object result = invocation.proceed();System.out.println("after...");return result;}};}@Beanpublic BeanNameAutoProxyCreator beanNameAutoProxyCreator() {BeanNameAutoProxyCreator beanNameAutoProxyCreator = new BeanNameAutoProxyCreator();beanNameAutoProxyCreator.setBeanNames("userSe*");beanNameAutoProxyCreator.setInterceptorNames("XiexuAroundAdvice");beanNameAutoProxyCreator.setProxyTargetClass(true);return beanNameAutoProxyCreator;}

通过 BeanNameAutoProxyCreator 可以对批量的 Bean 进行 AOP，并且指定了代理逻辑，指定了一个 InterceptorName，也就是一个 Advice，前提条件是这个 Advice 也得是一个 Bean，这样 Spring 才能找到，但是 BeanNameAutoProxyCreator 的缺点很明显，它只能根据 beanName 来指定想要代理的 Bean。

5.3、DefaultAdvisorAutoProxyCreator

public class AppConfig {/*** 定义一个Advisor类型的Bean** @return*/@Beanpublic DefaultPointcutAdvisor defaultPointcutAdvisor() {NameMatchMethodPointcut pointcut = new NameMatchMethodPointcut();pointcut.addMethodName("test");DefaultPointcutAdvisor defaultPointcutAdvisor = new DefaultPointcutAdvisor();defaultPointcutAdvisor.setPointcut(pointcut);defaultPointcutAdvisor.setAdvice(new XiexuAfterReturningAdvice());return defaultPointcutAdvisor;}@Beanpublic DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();return defaultAdvisorAutoProxyCreator;}}

通过 DefaultAdvisorAutoProxyCreator 会直接去找所有 Advisor 类型的 Bean，然后根据 Advisor 中的 PointCut 和 Advice 信息，确定要代理的 Bean 以及代理逻辑。

通过这种方式，我们得依靠某一个类来实现定义我们的 Advisor，或者 Advice，或者 Pointcut，那么这个步骤能不能更加简化一点呢？

答案是可以的，我们可以通过注解的方式进行简化！

比如我们可以只定义一个类，然后通过在类中的方法上加上某些注解，来定义 PointCut 以及 Advice，比如：

		@Aspect@Componentpublic class XiexuAspect {@Before("execution(public void cn.xx.UserService.test())")public void xiexuBefore(JoinPoint joinPoint) {System.out.println("xiexuBefore");}}

通过上面这个类，我们就直接定义好了所要代理的方法（通过一个表达式），以及代理逻辑（被 @Before 修饰的方法），简单明了，这样对于 Spring 来说，它要做的就是来解析这些注解了，解析之后得到对应的 Pointcut 对象、Advice 对象，生成 Advisor 对象，扔进 ProxyFactory 中，进而产生对应的代理对象，具体怎么解析这些注解就是 @EnableAspectJAutoProxy 注解所要做的事情了，后面详细分析。

6、对Spring AOP的理解

OOP 表示面向对象编程，是一种编程思想，AOP 表示面向切面编程，也是一种编程思想，而我们上面所描述的就是 Spring 为了让程序员更加方便的做到面向切面编程所提供的技术支持，换句话说，就是 Spring 提供了一套机制，可以让我们更加容易的进行 AOP，所以这套机制我们也可以称之为 Spring AOP。

但是值得注意的是，上面所提供的注解的方式来定义 Pointcut 和 Advice，Spring 并不是首创，首创是 AspectJ，而且也不仅仅只有 Spring 提供了一套机制来支持 AOP，还有比如 JBoss 4.0、aspectwerkz 等技术都提供了对于 AOP 的支持。而刚刚说的注解的方式，Spring 是依赖了 AspectJ 的，换句话说，Spring 是直接把 AspectJ 中所定义的那些注解直接拿过来用，自己没有再重新定义了，不过也仅仅只是把注解的定义复制过来了，每个注解具体底层是怎么解析的，还是 Spring 自己做的，所以我们在使用 Spring 时，如果你想用 @Before、@Around 等注解，是需要单独引入 AspectJ 相关 jar 包的，比如：

compile group: 'org.aspectj', name: 'aspectjrt', version: '1.9.5'
compile group: 'org.aspectj', name: 'aspectjweaver', version: '1.9.5'

值得注意的是：AspectJ 是在编译时对字节码进行了修改，是直接在 UserService 类对应的字节码中进行增强的，也就是可以理解为是在编译时就会去解析@Before 这些注解，然后得到代理逻辑，加入到被代理类中的字节码中去的，所以如果想用 AspectJ 技术来生成代理对象 ，是需要用单独的 AspectJ 编译器的。我们在项目中很少这么使用，我们仅仅只是用了 @Before 这些注解，而我们在启动 Spring 的过程中，Spring 会去解析这些注解，然后利用动态代理机制生成代理对象的。

IDEA 中使用 AspectJ：https://blog.csdn.net/gavin_john/article/details/80156963

7、AOP中的概念

上面我们已经提到 Advisor、Advice、PointCut 等概念了，还有一些其他的概念，首先关于 AOP 中的概念本身是比较难理解的，Spring 官网上是这么说的：

Let us begin by defining some central AOP concepts and terminology. These terms are not Spring-specific. Unfortunately, AOP terminology is not particularly intuitive. However, it would be even more confusing if Spring used its own terminology

意思是，AOP 中的这些概念并不是 Spring 特有的，而且不幸的是，AOP 中的概念不是特别直观的，如果 Spring 重新定义自己的那可能会导致更加混乱。

1、Aspect：表示切面，比如被 @Aspect 注解的类就是切面，可以在切面中去定义 Pointcut、Advice 等等。

2、Join point：表示连接点，表示一个程序在执行过程中的一个点，比如一个方法的执行（被代理方法）、一个异常的处理，在 Spring AOP 中，一个连接点通常表示一个方法的执行。

3、Advice：表示通知，表示在一个特定连接点上所采取的动作。Advice 分为不同的类型，后面详细讨论，在很多 AOP 框架中，包括 Spring，会用Interceptor 拦截器来实现 Advice，并且会在连接点周围维护一个 Interceptor 链。

4、Pointcut：表示切点，用来匹配一个或多个连接点，Advice 与切点表达式是关联在一起的，Advice 将会执行在和切点表达式所匹配的连接点上。

5、Introduction：可以使用 @DeclareParents 来给所匹配的类添加一个接口，并指定一个默认实现。

6、Target object：目标对象，也就是被代理对象。

7、AOP Proxy：表示代理工厂，用来创建代理对象的，在 Spring Framework 中，要么是 JDK 动态代理，要么是 CGLIB 动态代理。

8、Weaving：表示织入，表示创建代理对象的动作，这个动作可以发生在编译时期（比如 Aspejctj），也可以发生在运行时期（比如 Spring AOP）。

8、Advice在Spring AOP中对应的API

上面说到的 AspjectJ 中的注解，其中有五个是用来定义 Advice 的，表示代理逻辑，以及执行时机：

1、@Before

2、@AfterReturning

3、@AfterThrowing

4、@After

5、@Around

我们前面也提到过，Spring 自己也提供了类似的实现类：

1、接口MethodBeforeAdvice，继承了接口BeforeAdvice

2、接口AfterReturningAdvice，继承了接口AfterAdvice

3、接口ThrowsAdvice，继承了接口AfterAdvice

4、接口AfterAdvice，继承了接口Advice

5、接口MethodInterceptor，继承了接口Interceptor

Spring 会把这五个注解解析成对应的 Advice 类：

1、@Before：AspectJMethodBeforeAdvice，实际上就是一个 MethodBeforeAdvice

2、@AfterReturning：AspectJAfterReturningAdvice，实际上就是一个 AfterReturningAdvice

3、@AfterThrowing：AspectJAfterThrowingAdvice，实际上就是一个 MethodInterceptor

4、@After：AspectJAfterAdvice，实际上就是一个 MethodInterceptor

5、@Around：AspectJAroundAdvice，实际上就是一个 MethodInterceptor

9、TargetSource的使用

在我们日常的 AOP 中，被代理对象就是 Bean 对象，是由 BeanFactory 给我们创建出来的，但是 Spring AOP 中提供了 TargetSource 机制，可以让我们自定义逻辑来创建被代理对象。

比如之前提到的 @Lazy 注解，当加在属性上时，会产生一个代理对象并赋值给这个属性，产生代理对象的代码为：

	/*** 创建@Lazy懒加载的代理对象** @param descriptor* @param beanName* @return*/protected Object buildLazyResolutionProxy(final DependencyDescriptor descriptor, final @Nullable String beanName) {// 获取Spring的Bean工厂BeanFactory beanFactory = getBeanFactory();Assert.state(beanFactory instanceof DefaultListableBeanFactory, "BeanFactory needs to be a DefaultListableBeanFactory");final DefaultListableBeanFactory dlbf = (DefaultListableBeanFactory) beanFactory;/*** 创建TargetSource对象*/TargetSource ts = new TargetSource() {@Overridepublic Class<?> getTargetClass() {return descriptor.getDependencyType();}@Overridepublic boolean isStatic() {return false;}/*** Lazy的效果：* 当属性上有@Lazy注解，刚开始进行依赖注入时，该属性是被赋了一个代理对象，* 当你真正用到该属性时，这时候才会根据当前属性的类型和名字，去BeanFactory中找到对应的Bean，这时候才会真正去执行对应Bean的原方法。* 当set方法的参数有@Lazy注解时，同理。* @return*/@Overridepublic Object getTarget() {Set<String> autowiredBeanNames = (beanName != null ? new LinkedHashSet<>(1) : null);// 根据属性的类型和名字去Bean工厂找被代理的对象Object target = dlbf.doResolveDependency(descriptor, beanName, autowiredBeanNames, null);if (target == null) {Class<?> type = getTargetClass();if (Map.class == type) {return Collections.emptyMap();} else if (List.class == type) {return Collections.emptyList();} else if (Set.class == type || Collection.class == type) {return Collections.emptySet();}throw new NoSuchBeanDefinitionException(descriptor.getResolvableType(), "Optional dependency not present for lazy injection point");}if (autowiredBeanNames != null) {for (String autowiredBeanName : autowiredBeanNames) {if (dlbf.containsBean(autowiredBeanName)) {dlbf.registerDependentBean(autowiredBeanName, beanName);}}}// 找到被代理的对象，直接返回return target;}@Overridepublic void releaseTarget(Object target) {}};// 创建ProxyFactory对象ProxyFactory pf = new ProxyFactory();// 设置被代理对象为TargetSourcepf.setTargetSource(ts);Class<?> dependencyType = descriptor.getDependencyType();if (dependencyType.isInterface()) {pf.addInterface(dependencyType);}// 返回一个代理对象return pf.getProxy(dlbf.getBeanClassLoader());}

这段代码就利用了 ProxyFactory 来生成代理对象，以及使用了 TargetSource，以达到代理对象在执行某个方法时，会去调用 TargetSource 的 getTarget() 方法得到一个被代理对象。

10、ProxyFactory选择CGLIB或JDK动态代理的原理

ProxyFactory 在生成代理对象之前需要先决定到底是使用 JDK 动态代理还是 CGLIB 动态代理：

	@Overridepublic AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {/*** config指的是我们在外面创建的ProxyFactory对象* NativeDetector.inNativeImage()：当前Spring项目是不是在GraalVM虚拟机上运行的，如果是则使用JDK动态代理创建代理对象* config.isOptimize()：如果isOptimize为true，则会使用cglib动态代理创建代理对象，因为Spring认为cglib比jdk动态代理要快* config.isProxyTargetClass()：要代理的是不是一个类，如果为true则使用cglib动态代理创建代理对象* hasNoUserSuppliedProxyInterfaces(config)：当前ProxyFactory对象有没有去添加接口（addInterface），* 如果添加了则返回false并使用JDK动态代理创建代理对象，如果没有添加接口则返回true并使用cglib动态代理创建代理对象*/if (!NativeDetector.inNativeImage() &&/*** 类似于：* ProxyFactory proxyFactory = new ProxyFactory();* proxyFactory.setOptimize(true);* proxyFactory.setProxyTargetClass(true);* 如果添加了proxyFactory.addInterface();* 那么hasNoUserSuppliedProxyInterfaces(config)为false，如果没有添加则为true*/(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.");}/*** targetClass.isInterface()：如果被代理的类是一个接口* 举个例子：* ProxyFactory proxyFactory = new ProxyFactory();* proxyFactory.setTargetClass(UserInterface.class);* 这样的话就表示被代理类是一个接口* Proxy.isProxyClass(targetClass)：当前所设置的被代理类是不是已经进行过JDK动态代理而生成的代理类*/if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {/*** 使用jdk动态代理创建代理对象*/return new JdkDynamicAopProxy(config);}/*** 返回Cglib创建的代理对象*/return new ObjenesisCglibAopProxy(config);} else {/*** 使用jdk动态代理创建代理对象*/return new JdkDynamicAopProxy(config);}}

11、代理对象创建过程

11.1、JdkDynamicAopProxy

1、在构造 JdkDynamicAopProxy 对象时，会先拿到被代理对象自己所实现的接口，并且额外增加 SpringProxy、Advised、DecoratingProxy 三个接口，组合成一个 Class[]，并赋值给 proxiedInterfaces 属性

2、并且检查这些接口中是否定义了equals()、hashcode()方法

3、执行 Proxy.newProxyInstance(classLoader, this.proxiedInterfaces, this)，得到代理对象，JdkDynamicAopProxy 作为 InvocationHandler，代理对象在执行某个方法时，会进入到 JdkDynamicAopProxy 的 invoke() 方法中

12、代理对象执行过程

1、在使用 ProxyFactory 创建代理对象之前，需要往 ProxyFactory 中先添加 Advisor

2、代理对象在执行某个方法时，会把 ProxyFactory 中的 Advisor 拿出来和当前正在执行的方法进行匹配筛选

3、把和当前正在执行的方法所匹配的 Advisor 适配成 MethodInterceptor

4、把和当前方法匹配的 MethodInterceptor 链，以及被代理对象、代理对象、代理类、当前 Method 对象、方法参数封装成 MethodInvocation 对象

5、调用 MethodInvocation 的 proceed() 方法，开始执行各个 MethodInterceptor 以及被代理对象的对应方法

6、按顺序调用每个 MethodInterceptor 的 invoke() 方法，并且会把 MethodInvocation 对象传入 invoke() 方法

7、直到执行完最后一个 MethodInterceptor 了，就会调用 invokeJoinpoint() 方法，从而执行被代理对象的当前方法

12.1、各注解对应的MethodInterceptor

1、@Before 对应的是 AspectJMethodBeforeAdvice，在进行动态代理时会把 AspectJMethodBeforeAdvice 转成 MethodBeforeAdviceInterceptor

• 先执行 advice 对应的方法
• 再执行 MethodInvocation 的 proceed()，会执行下一个 Interceptor，如果没有下一个 Interceptor 了，会执行 target 对应的方法

2、@After 对应的是 AspectJAfterAdvice，直接实现了 MethodInterceptor

• 先执行 MethodInvocation 的 proceed()，会执行下一个 Interceptor，如果没有下一个 Interceptor 了，会执行 target 对应的方法
• 再执行 advice 对应的方法

3、@Around 对应的是 AspectJAroundAdvice，直接实现了 MethodInterceptor

• 直接执行 advice 对应的方法，由 @Around 自己决定要不要继续往后面调用

4、@AfterThrowing 对应的是 AspectJAfterThrowingAdvice，直接实现了 MethodInterceptor

• 先执行 MethodInvocation的 proceed()，会执行下一个 Interceptor，如果没有下一个 Interceptor 了，会执行 target 对应的方法
• 如果上面抛了 Throwable，那么则会执行 advice 对应的方法

5、@AfterReturning 对应的是 AspectJAfterReturningAdvice，在进行动态代理时会把 AspectJAfterReturningAdvice 转成 AfterReturningAdviceInterceptor

• 先执行 MethodInvocation 的 proceed()，会执行下一个 Interceptor，如果没有下一个 Interceptor 了，会执行 target 对应的方法
• 执行上面的方法后得到最终的方法的返回值
• 再执行 Advice 对应的方法

13、AbstractAdvisorAutoProxyCreator

DefaultAdvisorAutoProxyCreator 的父类是 AbstractAdvisorAutoProxyCreator。

AbstractAdvisorAutoProxyCreator 非常强大以及重要，只要 Spring 容器中存在这个类型的 Bean，就相当于开启了 AOP，AbstractAdvisorAutoProxyCreator实际上就是一个 BeanPostProcessor，所以在创建某个 Bean 时，就会进入到它对应的生命周期方法中，比如在某个 Bean 初始化之后，会调用wrapIfNecessary() 方法进行 AOP，底层逻辑是：AbstractAdvisorAutoProxyCreator 会找到所有的 Advisor，然后判断当前这个 Bean 是否存在某个 Advisor 与之匹配（根据 Pointcut），如果匹配就表示当前这个 Bean 有对应的切面逻辑，需要进行AOP，需要产生一个代理对象。

14、@EnableAspectJAutoProxy

这个注解主要就是往 Spring 容器中添加了一个 AnnotationAwareAspectJAutoProxyCreator 类型的Bean。

AspectJAwareAdvisorAutoProxyCreator 继承了 AbstractAdvisorAutoProxyCreator，重写了 findCandidateAdvisors() 方法，AbstractAdvisorAutoProxyCreator 只能找到所有 Advisor 类型的 Bean 对象，但是 AspectJAwareAdvisorAutoProxyCreator 除了可以找到所有 Advisor 类型的 Bean 对象，还能把 @Aspect 注解所标注的 Bean 中的 @Before 等注解及方法进行解析，并生成对应的 Advisor 对象。

@Aspect
@Component
public class XxAspect {@Before("execution(public void cn.xx.UserService.test())")public void xiexuBefore(JoinPoint joinPoint) {System.out.println("xiexuBefore");}}

所以，我们可以这样理解 @EnableAspectJAutoProxy，其实就是向 Spring 容器中添加了一个 AbstractAdvisorAutoProxyCreator 类型的Bean，从而开启了 AOP，并且还会解析 @Before 等注解并生成 Advisor。

15、Spring中AOP原理流程图

https://www.processon.com/view/link/5faa4ccce0b34d7a1aa2a9a5