Spring源码学习（4）- AOP

AOP基本概念

AOP全称是Aspect Oriented Programming，面向切面编程，作为面向对象编程的一种补充
它将功能分为两个部分：

• 核心关注点：原本的业务逻辑
• 横切关注点：增强的逻辑

好处：
1.侵入性少
2.方便增加或者删除增强的逻辑
3.减少代码冗余

相关概念：

• 切面（Aspect）：通知和切入点的结合
• 连接点（Join point）：被增强的方法
• 通知(Advice)：指拦截到Joinpoint之后所要做的事情
• 切入点（Pointcut）：切入点是与连接点匹配的表达式，用于确定是否需要执行通知，可以将切入点理解为需要被拦截的Join point

通知(Advice)的类型：

• 前置通知（Before advice）：在某个连接点（Join point）之前执行的通知
• 返回后通知（After returning advice）：在某个连接点（Join point）正常完成后执行的通知。
• 抛出异常后通知（After throwing advice）：在方法抛出异常后执行的通知。
• 后置通知（After（finally）advice）：当某个连接点（Join point）退出的时候执行的通知
• 环绕通知（Around advice）：这是最强大的一种通知类型。环绕通知可以在方法前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。

AOP的使用

Xml配置方式

在配置文件中

<!-- 开启aop注解扫描 -->
<aop:aspectj-autoproxy proxy-target-class="false" expose-proxy="true"/>

<bean id="beforeAdviceBean" class="test.aop.BeforeAdviceBean"/>
<bean id="aspectXml1" class="test.aop.aspectj.AspectXml1"/>

<!-- aop的相关配置 -->
<aop:config proxy-target-class="false">
	<!-- ------------------- 切入点  ------------------------->
	<!--<aop:pointcut>在此处定义的 pointcut 是全局的 pointcut 可以供所有的aspect 使用-->
	<!--id:表示这个 pointcut 的名称，以方便使用-->
	<aop:pointcut id="addpointcut" expression="execution(public * test.aop.service..*.add(..))"/>
	<aop:pointcut id="delpointcut" expression="execution(public * test.aop.service..*.del*(..))"/>
	<aop:pointcut id="myMethods" expression="execution(public * test.aop.service..*.* (..))"/>
	<!--advisor 必须在 aspect 之前，要不然有 xml 约束报错-->
	<aop:advisor advice-ref="beforeAdviceBean" order="2" pointcut-ref="myMethods"/>
	<aop:aspect id="aspect1" ref="aspectXml1" order="0">
		<aop:pointcut id="myMethod2" expression="execution(public * com.xiangxue.jack.service..*.*(..)) and @annotation(org.springframework.web.bind.annotation.RequestMapping)"/>
		<!-- 前置通知 -->
		<aop:before method="before" pointcut-ref="myMethods"/>
		<!-- 后置通知 -->
		<aop:after method="after" pointcut-ref="myMethod2"/>
		<!-- 返回通知 returning="returnVal" 定义返回值 必须与类中声明的名称一样-->
		<aop:after-returning method="afterReturning" returning="returnVal" pointcut="execution(public * com.xiangxue.jack.service..*.*(..))"/>
		<!-- 异常通知 throwing="throwable" 指定异常通知错误信息变量,必须与类中声明的名称一样-->
		<aop:after-throwing method="afterthrowing" throwing="throwable" pointcut-ref="myMethods"/>
		<!-- 环绕通知 -->
		<aop:around method="around" pointcut-ref="myMethod2"/>
	</aop:aspect>
</aop:config>

注解方式

1.在配置类上标注@EnableAspectJAutoProxy(proxyTargetClass = true , exposeProxy = true)，打开AOP注解的扫描 ---- 等同于xml方式的<aop:aspectj-autoproxy proxy-target-class=“false” expose-proxy=“true”/>
2.创建一个切面类，在类上使用@Aspect注解跟@Component注解
3.编写切入点跟通知

@Component
@Aspect
public class AspectAnnotation {
      

    @Pointcut("execution(public * test.aop.service.*.*(..))")
    public void pc1(){
   }

    @Pointcut("execution(public * test.aop.service.*.add*(..))")
    public void pc2(){
   }

    @Pointcut("execution(public * test.aop.service1.*.*(..))")
    public void pc3(){
   }

    @Before("pc2()")
    public void before() {
   
        System.out.println("===============只拦截add方法=========");
    }

    @Around("pc1()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
   
        System.out.println("==============AspectAnnotation around前置通知=========");
        Object result = joinPoint.proceed();
        System.out.println("==============AspectAnnotation around后置通知=========");

        return result;
    }

    @Before("pc3()")
    public void before1(JoinPoint joinPoint) {
   
        Signature signature = joinPoint.getSignature();
        Object[] args = joinPoint.getArgs();
        System.out.println("===============service1包的拦截=========");
    }

    @Before("pc3()&&args(bankId,id,list)")
    public void before2(String bankId,Integer id,List list) {
   
        System.out.println("===============service1包的拦截=========");
    }

    @Before(value = "@annotation(targetMethod)",argNames = "joinPoint,targetMethod")
    public void xx(JoinPoint joinPoint, TargetMethod targetMethod) {
   
        System.out.println("===============注解拦截 前置通知=========");
        System.out.println("==================targetMethod.name = " + targetMethod.name());
    }

    @AfterReturning(value = "@annotation(returnValue)",returning = "retVal")
    public void afterReturning(JoinPoint joinPoint, ReturnValue returnValue, Object retVal) {
   
        System.out.println("==============AspectAnnotation 后置通知  拿返回值=========" + retVal);
    }

    @AfterThrowing(value = "@annotation(throwsAnno)",throwing = "e")
    public void throwMethod(JoinPoint joinPoint, ThrowsAnno throwsAnno, Throwable e) {
   
        System.out.println("==============AspectAnnotation 异常通知  拿异常=========" + e);
    }
}

开启扫描aop的时候，有两个属性可以设置 proxyTargetClass 跟 exposeProxy ，值都是boolean类型

• proxyTargetClass ，默认为false
  如果为true，使用cglib代理
  如果为false，实现了接口，使用JDK动态代理，没有实现接口，使用cglib
• exposeProxy
  设置代理对象是否需要暴露（是否需要把代理对象设置到ThreadLocal中）

AOP原理

当一个bean实例化完成后，会判断该bean是否生成代理，相关代码依赖注入后，初始化bean的地方，如下

又一处BeanPostProcessor的运用

//bean 实例化+ioc依赖注入完以后的调用
exposedObject = initializeBean(beanName, exposedObject, mbd);

// 进入initializeBean方法，看到下面代码
if (mbd == null || !mbd.isSynthetic()) {
   
	// aop的入口
	wrappedBean = applyBeanPostProcessorsAfterInitialization