SpringAOP 切面编程原理解析
前言
我们在学习 SpringAOP 的时候一直听说是面向切面编程，还有经常听到说 aop 可以用来做日志、做接口调用统计、做分库分表动态切换等等，觉得很神奇，明明我们只使用 @Aspect 注解了一个独立的 class，怎么能够这么强大呢？
本篇试着从源码角度分析一下 aop 的原理，在开始之前我们提出几个问题，一边学习一边解答。
- 被增强的类还是原来的类嘛？
- 类什么时候被增强的？
我假定看本文的读者已经有基本的 springioc 相关的基础，最好也了解过 springaop 的源码，当然没有阅读过就需要大家更加集中精神。
SpringIOC 是对类的解耦，SpringAOP 就是对方法的解耦。牢记这句话
本人的 Spring 源码注释项目：https://github.com/Lingouzi/spring-framework.git
解析
Demo
老规矩，上 demo
// 来个接口
public interface Calculate {
int div(int numA, int numB);
}
// 实现类
public class LybqCalculate implements Calculate {
@Override
public int div(int numA, int numB) {
System.out.println("执行目标方法:div");
return numA / numB;
}
}
/**
* 被 @Aspect 注解的 bean 就是一个切面，就是一个 Aspect
*/
@Aspect
@Order
public class LogAspect {
/**
* 被 @Pointcut 注解的，就是一个切点，这个决定了我们要增强哪个方法。
* 【springaop 只能增强 springioc 容器管理下的 bean 中的方法。它和 aspectj 还是有区别的，springaop 只是实现了 aspectj 的部分思想】
*/
@Pointcut("execution(* top.ybq87.LybqCalculate.*(..))")
public void pointCut() {
}
/**
* 各种通知，Advise，我们前面定义了切点，就拦截了 bean 的方法，那么要对这些方法做什么呢？就在通知方法这里进行
* @param joinPoint
* @throws Throwable
*/
@Before(value = "pointCut()")
public void methodBefore(JoinPoint joinPoint) throws Throwable {
String methodName = joinPoint.getSignature().getName();
System.out.println("执行目标方法【" + methodName + "】的<前置通知>,入参" + Arrays.asList(joinPoint.getArgs()));
}
@After(value = "pointCut()")
public void methodAfter(JoinPoint joinPoint) {
String methodName = joinPoint.getSignature().getName();
System.out.println("执行目标方法【" + methodName + "】的<后置通知>,入参" + Arrays.asList(joinPoint.getArgs()));
}
@AfterReturning(value = "pointCut()", returning = "result")
public void methodReturning(JoinPoint joinPoint, Object result) {
String methodName = joinPoint.getSignature().getName();
System.out.println("执行目标方法【" + methodName + "】的<返回通知>,入参" + Arrays.asList(joinPoint.getArgs()) + ";返回值：" + result);
}
@AfterThrowing(value = "pointCut()")
public void methodAfterThrowing(JoinPoint joinPoint) {
String methodName = joinPoint.getSignature().getName();
System.out.println("执行目标方法【" + methodName + "】的<异常通知>,入参" + Arrays.asList(joinPoint.getArgs()));
}
// 还有个 Around 方法，留给大家自己研究了
}
// 配置类，注入下实现类和我们的切面方法
@Configuration
@EnableAspectJAutoProxy
public class MainConfig {
@Bean
public Calculate calculate() {
return new LybqCalculate();
}
@Bean
public LogAspect logAspect() {
return new LogAspect();
}
}
// main 方法
public class MainClass {
public static void main(String[] args) {
AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(MainConfig.class);
Calculate calculate = (Calculate) ac.getBean("calculate");
calculate.div(6, 2);
}
}
// 跑起来的打印结果
执行目标方法【div】的<前置通知>,入参[6, 2]
执行目标方法:div
执行目标方法【div】的<后置通知>,入参[6, 2]
执行目标方法【div】的<返回通知>,入参[6, 2];返回值：3
如上，代码比较简单，完整的 demo 见我的spring 源码解析项目。
被增强的类还是原来的类嘛？
这个问题大家一定很奇怪，这里我再具体描述下：我们 mian 方法中使用的 calculate 对象还是你以为的那个calculate对象嘛？
断点打印看看
这里我们看到这个类被标注为了 $Proxy说明这是一个代理类，也就是被增强的类了，不是原来的狗子了。
SpringAOP 通过动态代理技术，对类和方法进行增强，其中主要有 2 种动态代理方式
JDK 动态代理、cglib 动态代理
类什么时候被增强的？
既然它变强了，那么一定是因为它秃了，明明这个方法只能打印执行目标方法:div，但是实际上却被一众小弟环绕，那么它怎么变秃的呢？
抄作业开始，【所以我说希望读者有一定的源码基础才好嘛】，看过源码的应该了解，bean 的实例化和初始化都是在finishBeanFactoryInitialization，进行的，而更进一步的初始化是在doCreateBean中
AbstractApplicationContext#refresh
--AbstractApplicationContext#finishBeanFactoryInitialization
----DefaultListableBeanFactory#preInstantiateSingletons
------AbstractBeanFactory#doGetBean
--------AbstractAutowireCapableBeanFactory#createBean
----------AbstractAutowireCapableBeanFactory#doCreateBean
跟进到AbstractAutowireCapableBeanFactory#doCreateBean在exposedObject = initializeBean(beanName, exposedObject, mbd);打个断点，跳过其他 bean 的初始化，等到我们的calculate。
目前发现我们的calculate还是原来的狗子，而exposedObject也还是我们期待的那个对象。
step over
明显看到这之后它变了。
关键方法 initializeBean(beanName, exposedObject, mbd)
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
// bean 如果实现了 xxxAware 接口，那么这里进行方法的回调，不是本文重点
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 后置处理器，@PostConstuct 注解的方法
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
/**
* 调用 bean 配置中的 init-method="xxx"
*/
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null