Spring AOP

1. AOP简介

1.1 什么是AOP

AOP( Aspect Oriented Programming) 意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

AOP 是 OOP 的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

1.2 AOP的作用及优势

作用: 在不修改目标代码的情况下，通过简单的配置就可以实现对目标对象的增强.
优势: 减少重复代码,提高开发效率,并且便于维护.

1.3 AOP的底层实现

AOP 的底层是通过 Spring 提供的的动态代理技术实现的。在运行期间，Spring通过动态代理技术动态的生成代理对象，代理对象方法执行时进行增强功能的介入，在去调用目标对象的方法，从而完成功能的增强。

1.4 AOP的动态代理技术

常用的动态代理技术
JDK 代理 : 基于接口的动态代理技术
cglib 代理：基于父类的动态代理技术

关于动态代理,有兴趣的朋友可以去我的另一篇博客查看.
https://blog.csdn.net/weixin_40136114/article/details/102572445

1.5 AOP相关概念

Spring 的 AOP 实现底层就是对动态代理的代码进行了封装，封装后我们只需要对需要关注的部分进行代码编写，并通过配置的方式完成指定目标的方法增强。

下面介绍一下AOP常用的术语：

• Target(目标对象)：代理的目标对象
• Proxy (代理)：一个类被 AOP 织入增强后，就产生一个结果代理类
• Joinpoint(连接点)：所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法，因为spring只支持方法类型的连接点
• Pointcut(切点)：真正被增强的方法
• Advice(通知/ 增强)：所谓通知是指拦截到连接点之后所要做的事情就是通知
• Aspect(切面)：切入点和通知的结合
• Weaving(织入)：是指把增强应用到目标对象来创建新的代理对象的过程。

2. 基于XML的AOP开发

2.1 通知的类型

名称	标签	说明
前置通知	<aop:before>	用于配置前置通知.指定增强的方法在切入点方法之前执行
后置通知	<aop:after-returning>	用于配置后置通知.指定增强的方法在切入点方法之后执行
环绕通知	<aop:around>	用于配置环绕通知.指定增强的方法在切入点方法之前和之后都执行
异常抛出通知	<aop:throwing>	用于配置异常抛出通知.指定增强的方法在出现异常时执行
最终通知	<aop:after>	用于配置最终通知.指定增强的方法是否有异常都会执行

2.2 切点表达式的写法

execution([修饰符] 返回值类型 包名.类名.方法名(参数))

• 访问修饰符可以省略
• 返回值类型、包名、类名、方法名可以使用星号* 代表任意
• 包名与类名之间一个点代表当前包下的类，两个点表示当前包及其子包下的类
• 参数列表可以使用两个点表示任意个数，任意类型的参数列表

2.3 相关代码

2.3.1 导入相关坐标

<!--导入spring的context坐标，context依赖aop-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.0.5.RELEASE</version>
</dependency>
<!-- aspectj的织入 -->
<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjweaver</artifactId>
  <version>1.8.13</version>
</dependency>

2.3.2 创建相关类和接口

//目标接口
public interface TargetInterface {
    public void method();
}

//目标类
public class Target implements TargetInterface {
    @Override
    public void method() {
        System.out.println("Target running....");
    }
}

//切面类
public class MyAspect {
    public void before(){
        System.out.println("前置增强...");
    }

    public void afterReturning(){
        System.out.println("后置增强...");
    }

    //ProceedingJoinPoint:正在执行的连接点(切点)
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕前增强...");
        Object proceed=pjp.proceed(); //切点方法
        System.out.println("环绕后增强...");
        return proceed;
    }

    public void afterThrowing(){
        System.out.println("异常抛出增强...");
    }

    public void after(){
        System.out.println("最终增强...");
    }
}

2.3.3 applicationContext.xml配置

引入aop命名空间

<!--配置目标类-->
<bean id="target" class="com.springboot.Target"></bean>
<!--配置切面类-->
<bean id="myAspect" class="com.springboot.MyAspect"></bean>

<aop:config>
    <!--引用myAspect的Bean为切面对象-->
    <aop:aspect ref="myAspect">
        <!--配置Target的method方法执行时要进行myAspect的before方法前置增强-->
        <aop:around method="around" pointcut="execution(* com.springboot.Target.*(..))"></aop:around>
    </aop:aspect>
</aop:config>

2.3.4 测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {

    @Autowired
    private TargetInterface target;

    @Test
    public void test(){
        target.method();
    }
}

测试结果:

3. 基于注解的AOP开发

//目标接口
public interface TargetInterface {
    public void method();
}

//目标类
@Component("target")
public class Target implements TargetInterface {
    @Override
    public void method() {
        System.out.println("Target running....");
    }
}

切面类

@Component("myAspect")
@Aspect  //该类为切面类
public class MyAspect {
    //定义切点表达式
    @Pointcut("execution(*com.springboot.Target.*(..))")
    public void pointcut(){}

    @Before("pointcut()")
    public void before(){
        System.out.println("前置增强...");
    }

    @AfterReturning("pointcut()")
    public void afterReturning(){
        System.out.println("后置增强...");
    }

    //ProceedingJoinPoint:正在执行的连接点(切点)
    @Around("pointcut()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕前增强...");
        Object proceed=pjp.proceed(); //切点方法
        System.out.println("环绕后增强...");
        return proceed;
    }

    @AfterThrowing("pointcut()")
    public void afterThrowing(){
        System.out.println("异常抛出增强...");
    }

    @After("pointcut()")
    public void after(){
        System.out.println("最终增强...");
    }
}

**
核心配置类

@Configuration //配置该类为spring的核心配置类
@ComponentScan("com.springboot")
 //指定spring在初始化容器时要扫描com.springboot包及其子包
public class SpringConfiguration {
}

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfiguration.class)
public class Aop_AnnoTest {

    @Autowired
    private TargetInterface target;

    @Test
    public void test(){
        target.save();
    }
}

测试结果

同一切面中，不同增强的织入顺序为：环绕增强前半部分->前置增强->原目标函数调用->环绕增强后半部分->最终增强->后置增强。