Spring框架基础入门2：AOP--面向切面编程

什么是AOP

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程

利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

AOP的优势

1. 减少重复的代码

2. 提供开发的效率

3. 维护方便

AOP的底层原理

JDK的动态代理技术

1、为接口创建代理类的字节码文件

2、使用ClassLoader将字节码文件加载到JVM

3、创建代理类实例对象，执行对象的目标方法

cglib代理技术

为类生成代理对象，被代理类有没有接口都无所谓，底层是生成子类，继承被代理类。

AOP相关的术语

Joinpoint(连接点) 类里面有哪些方法可以增强这些方法称为连接点，理论上所有方法都可作为连接点。

Pointcut(切入点) -- 被增强的连接点就是切入点，可以是一个也可以是多个。

Advice(通知/增强)--我们要添加到切入点的方法就是增强（通知）。通知分为

前置通知：在切入点之前增强

后置通知：在切入点之后增强

环绕通知：在切入点之前和之后都增强

异常通知：切入点异常时增强（切入点正常运行就不增强）

最终通知：无论切入点成功与否都增强

Aspect(切面)-- 是 切入点+通知 的结合，我们可以理解为一个过程：将通知应用到切入点

实际操作

新建一个maven项目并导入相关依赖，和之前的IOC相同，这里不再赘述

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>1.2</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.12</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
    <!--AOP联盟-->
    <dependency>
        <groupId>aopalliance</groupId>
        <artifactId>aopalliance</artifactId>
        <version>1.0</version>
    </dependency>
    <!--Spring Aspects-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <!--aspectj-->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.3</version>
    </dependency>
</dependencies>

我们先来定义一个User类

public class User {

    public void add(){
        System.out.println("add-----");
    }

    public void select(){
        System.out.println("select------");
    }

    public void delete(){
        System.out.println("delete-------");
    }

    public void update(){
        System.out.println("update--------");
    }

然后再定义一个UserProxy类：增强类（切入类）

我们通过xml配置的方式先来实现前置通知。

首先利用IOC生成User对象

<!-- 利用IOC生成user对象   -->
<bean id="user" class="com.qcby.User"/>

然后定义切面类

<!-- 定义切面类   -->
<bean id="userProxy" class="com.qcby.UserProxy"/>

准备工作完成，接下来配置切面以实现前置通知

<!-- 配置切面  :切入点加通知 -->
    <aop:config>
        <!--  配置切面类      -->
        <aop:aspect ref="userProxy">
            <!--aop:before:通知类型为前置通知  method="before"：通知为before-->
            <!--pointcut="execution(public void com.qcby.User.add())"：切入点-->
            <aop:before method="before" pointcut="execution(public void com.qcby.User.add())"/>
        </aop:aspect>
    </aop:config>

我们来测试一下

    @Test
    public void run(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        User user = (User) ac.getBean("user");
        user.add();
    }

接下来实现环绕通知

首先定义环绕通知 

public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕前");
        proceedingJoinPoint.proceed();
        System.out.println("环绕后");
    }

然后在xml文档中配置环绕通知，和前置通知基本一致

<!-- 配置切面  :切入点加通知 -->
    <aop:config>
        <!--  配置切面类      -->
        <aop:aspect ref="userProxy">
            <!--aop:before:通知类型为前置通知  method="before"：通知为before-->
                    <!--pointcut="execution(public void com.qcby.User.add())"：切入点-->
        <!--    <aop:before method="before" pointcut="execution(public void com.qcby.User.add())"/>-->
            <aop:around method="around" pointcut="execution(public void com.qcby.User.add())"/>
        </aop:aspect>
    </aop:config>

测试结果

 后置通知：

 <aop:after-returning method="afterReturning" pointcut="execution(public void com.qcby.User.add())"/>

最终通知：无论切入点是否报错，最终通知都会运行。

 <aop:after method="afterReturning" pointcut="execution(public void com.qcby.User.add())"/>

异常通知：只有在切入点报错时才会执行

<aop:after-throwing method="before" pointcut="execution(public void com.qcby.User.add())"/>

接下来介绍注解的方式实现通知增强

首先还是在xml文档中进行总体配置

        <!--    开启注解扫描    -->
        <context:component-scan base-package="com.qcby"/>

        <!--  开启aspect生成代理对象  ；aspectj：面相切面的框架    -->
        <aop:aspectj-autoproxy/>

然后为User类UserProxy类添加@Component

我们需要在UserProxy类添加额外注解：@Aspect   以此来表示当前类为增强类

然后将before方法定义为前置通知

@Before(value = "execution(public void com.qcby.User.add())")
    public void before(){
        System.out.println("前置通知实现");
    }

 测试结果：

后置通知

@AfterReturning(value = "execution(public void com.qcby.User.add())") 

最终通知

@After(value = "execution(public void com.qcby.User.add())")  //最终通知

异常通知 

@AfterThrowing(value = "execution(public void com.qcby.User.add())")  //异常通知