Spring之AOP原理及总结

最近在学习事务以及如何使用AOP来削减我们业务代码之间的耦合，以下是我学习AOP的总结。

1.什么是AOP?

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式；

2.在spring中如何使用AOP？

1.导入AOP模块，spring-aspects

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.2.5.RELEASE</version>
</dependency>

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-aspects</artifactId>
  <version>5.0.2.RELEASE</version>
</dependency>
1
2
3
4
5
6
7
8
9
10
11

2.定义一个业务逻辑类，如（MathCalculator）；在业务逻辑运行的时候将日志进行打印（方法之前、方法运行结束、方法出现异常，xxx）

public class MathCalculator {
	
	public int div(int i,int j){
		System.out.println("MathCalculator...div...");
		return i/j;	
	}

}
1
2
3
4
5
6
7
8

3.定义一个切面类，如日志切面类（LogAspects）。

import java.util.Arrays;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;

/**
 * 切面类
 * 
 * @Aspect： 告诉Spring当前类是一个切面类
 *
 */
@Aspect
public class LogAspects {
	
	//抽取公共的切入点表达式
	//1、本类引用
	//2、其他的切面引用
	@Pointcut("execution(public int com.yudi.aop.MathCalculator.*(..))")
	public void pointCut(){};
	
	//@Before在目标方法之前切入；切入点表达式（指定在哪个方法切入）
	@Before("pointCut()")
	public void logStart(JoinPoint joinPoint){
		Object[] args = joinPoint.getArgs();
		System.out.println(""+joinPoint.getSignature().getName()+"运行。。。@Before:参数列表是：{"+Arrays.asList(args)+"}");
	}
	
	@After("pointCut()")
	public void logEnd(JoinPoint joinPoint){
		System.out.println(""+joinPoint.getSignature().getName()+"结束。。。@After");
	}
	
	//JoinPoint一定要出现在参数表的第一位
	@AfterReturning(value="pointCut()",returning="result")
	public void logReturn(JoinPoint joinPoint,Object result){
		System.out.println(""+joinPoint.getSignature().getName()+"正常返回。。。@AfterReturning:运行结果：{"+result+"}");
	}
	
	@AfterThrowing(value="pointCut()",throwing="exception")
	public void logException(JoinPoint joinPoint,Exception exception){
		System.out.println(""+joinPoint.getSignature().getName()+"异常。。。异常信息：{"+exception+"}");
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

4.将业务逻辑类和切面类都加载到IOC容器中，这样我们的AOP才会生效。

@EnableAspectJAutoProxy
@Configuration
public class MainConfigOfAOP {
	 
	//业务逻辑类加入容器中
	@Bean
	public MathCalculator calculator(){
		return new MathCalculator();
	}

	//切面类加入到容器中
	@Bean
	public LogAspects logAspects(){
		return new LogAspects();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

注意@EnableAspectJAutoProxy这个注解，开启基于注解的AOP功能。点进这个注解看一下，他是如何生效的。
4.1 发现给容器中导入了这样一个组件

4.2点进这个类，发现实现了ImportBeanDefinitionRegistrar 接口（Bean定义信息注册器），重写了
registerBeanDefinitions方法，


发现给容器中注册了一个AnnotationAwareAspectJAutoProxyCreator这个组件，点进这个类看下它是干什么的，

5.写一个测试类，通过Debug调试，看Spring在底层是如何处理，并让AOP生效的

public class IOCTest_AOP {
	
	@Test
	public void test01(){
		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfAOP.class);
		
		//1、不要自己创建对象
		MathCalculator mathCalculator = applicationContext.getBean(MathCalculator.class);
		
		mathCalculator.div(1, 0);
		
		applicationContext.close();
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

6.开始分析测试类的第一行和第三行代码。分别打上断点进行debug调试。

6.1 register方法

6.2 refresh方法

6.3 registerBeanPostProcessors(beanFactory);注册Bean的后置处理器，前面的说到的AnnotationAwareAspectJAutoProxyCreator这个组件就是在这里被加载到IOC容器里面的，点进去看他是如何完成注册的

续上：（由于整个方法太长）

以上是AnnotationAwareAspectJAutoProxyCreator这个组件被加载进IOC容器的过程，接着我们要分析我们的切面类和我们的业务逻辑组件类是如何被创建，并加载到Spring的IOC容器中
回到，这个方法，初始化所有的单实例Bean

点进去这个方法，在最后一行

继续往下走，点进去

点进getBean方法，看Spring是如何创建Bean对象的

doGetBean整个方法比较长，下面依次说明

续上：

续上：

点进createBean方法：值得注意的是

上面的创建代理对象的过程，Spring可以自己决定是使用基于JDK的自动代理，还是Cglib的方式
到此我们已经完成了业务逻辑组件类的代理对象的创建，以及加载BeanPostProcessor到ioc容器中。测试类的第一行代码已经完成，接着就是我们的目标方法执行，

7.目标方法的执行

Step Into 我们来到了CglibAopProxy.intercept（）方法

如果有拦截器链，把需要执行的目标对象，目标方法，
拦截器链等信息传入创建一个 CglibMethodInvocation 对象，并调用 Object retVal =  mi.proceed();
拦截器链的触发过程;
如果没有拦截器执行执行目标方法，或者拦截器的索引和拦截器数组-1大小一样（指定到了最后一个拦截器）执行目标方法；
链式获取每一个拦截器，拦截器执行invoke方法，每一个拦截器等待下一个拦截器执行完成返回以后再来执行；拦截器链的机制，保证通知方法与目标方法的执行顺序；
1
2
3
4
5

8.总结：

 * 	总结：
 * 		1）、 @EnableAspectJAutoProxy 开启AOP功能
 * 		2）、 @EnableAspectJAutoProxy 会给容器中注册一个组件 AnnotationAwareAspectJAutoProxyCreator
 * 		3）、AnnotationAwareAspectJAutoProxyCreator是一个后置处理器；
 * 		4）、容器的创建流程：
 * 			1）、registerBeanPostProcessors（）注册后置处理器；创建AnnotationAwareAspectJAutoProxyCreator对象
 * 			2）、finishBeanFactoryInitialization（）初始化剩下的单实例bean
 * 				1）、创建业务逻辑组件和切面组件
 * 				2）、AnnotationAwareAspectJAutoProxyCreator拦截组件的创建过程
 * 				3）、组件创建完之后，判断组件是否需要增强
 * 					是：切面的通知方法，包装成增强器（Advisor）;给业务逻辑组件创建一个代理对象（cglib）；
 * 		5）、执行目标方法：
 * 			1）、代理对象执行目标方法
 * 			2）、CglibAopProxy.intercept()；
 * 				1）、得到目标方法的拦截器链（增强器包装成拦截器MethodInterceptor）
 * 				2）、利用拦截器的链式机制，依次进入每一个拦截器进行执行；
 * 				3）、效果：
 * 					正常执行：前置通知-》目标方法-》后置通知-》返回通知
 * 					出现异常：前置通知-》目标方法-》后置通知-》异常通知
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19