Spring AOP

SpringAOP

SpringAOP（Aspect Oriented Programming），即：面向切面编程。通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。

代理模式

文中提到的基于接口的JDK动态代理与基于子类的CGLib动态代理两种动态代理的方式都是实现SpringAOP的基础。

简单转账功能

准备数据

# 删除spring_aop数据库
drop database if exists spring_aop;

# 创建spring_aop数据库
create database spring_aop;

# 使用spring_aop数据库
use spring_aop;

# 创建account表
create table account (
    id int(11) auto_increment primary key,
    accountNum varchar(20) default NULL,
    money int(8) default 0
);

# 新增数据
insert into account (accountNum, money) values
("622200001",1000),("622200002",1000);

导包

1、导入Spring基础包；

2、导入操作数据库、连接数据库、测试需要的包。

核心配置文件

配置自动扫包

配置数据源

代码编写

数据库连接工具类：ConnectionUtils.java


Account模块实体类：Account.java

Account模块Dao层：AccountDao.java

Account模块Dao层实现类：AccountDaoImpl.java

Account模块Service层：AccountService.java

Account模块Service层实现类：AccountServiceImpl.java

Account模块测试类：AccountTest.java

执行结果

控制台打印结果

修改前数据库中值

修改后数据库中值

缺点分析

在业务层的代码加入一行异常代码 如下图所示：

执行报ArithmeticException错，如下图所示：

查看数据库中数据发现出账账户money的列值由原来的900变成了800，说明存款确实减少了100

但是由于在代码执行的过程中，出现了异常，导致入账账户并没有增加100

这就出现了数据的事务问题，破坏了数据的原子性和一致性。

引入代理模式解决事务

实现思路介绍

创建一个工具类，目的是用于管理数据库的事务，提供事务的开启，提交，回滚等操作；
创建一个代理处理器类，目的是生成转账实现类的代理对象，对转账的业务方法提供增强；
在 Spring 的配置文件中，通过 xml 文件的标签实例化管理事务的工具类和生成代理对象的处理器类。

代码实现

事务管理器：TransactionManager.java

此工具类主要作用是对数据库连接实现事务的开启，提交以及回滚。


事务代理工具类：TransactionProxyUtils

此类的核心代码是getAccountService方法，该方法返回代理业务类示例。
在代理对象的invoke方法内部，实现对原始被代理对象的增强。

package utils;

@Component
public class TransactionProxyUtils {
    //被代理的业务类接口
    @Autowired
    private AccountService accountService;
    //提供事务管理的工具类
    @Autowired
    private TransactionManager transactionManager;

    /**
     * 获取AccountService代理对象
     *
     * @return
     */
    public AccountService getAccountService() {
        return (AccountService) Proxy.newProxyInstance(
                accountService.getClass().getClassLoader(),
                accountService.getClass().getInterfaces(),
                new InvocationHandler() {
                    /**
                     * 添加事务的支持
                     *
                     * @param proxy     被代理的对象实例本身
                     * @param method    被代理对象正在执行的方法对象
                     * @param args      正在访问的方法参数对象
                     * @return
                     * @throws Throwable
                     */
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        //
                        Object rtValue = null;
                        try {
                            // 执行操作前开启事务
                            transactionManager.beginTransaction();
                            // 执行操作
                            rtValue = method.invoke(accountService, args);
                            // 执行操作后提交事务
                            transactionManager.commit();
                            // 返回结果
                            return rtValue;
                        } catch (Exception e) {
                            // 捕捉到异常执行回滚操作
                            transactionManager.rollback();
                            throw new RuntimeException(e);
                        } finally {
                            // 最终释放连接
                            transactionManager.release();
                        }
                    }
                });

    }
}

核心配置文件：applicationContext.xml

添加事务管理bean

<context:component-scan base-package="transaction"/>

配置代理Service

<!--配置代理的service-->
<bean id="transactionProxyAccountService" factory-bean="transactionProxyUtils" factory-method="getAccountService"/>

Account模块测试类：AccountTest.java

将原本引入的AccountService实例改为AccountService的事务代理对象

@Qualifier("transactionProxyAccountService")

执行结果

首先将数据库中两账户余额都改为1000；

update account set money = 1000;

控制台打印结果

可以看到：在转账前后由开启、提交事务，最后有释放连接。表示事务代理已经对在不改变源代码的基础上对其做了增强。

修改前数据库中值

修改后数据库中值

再次在出账账户金额修改之后，入账账户金额修改之前添加异常代码，如下图所示

可以看到：在捕捉到异常后进行了事务的回滚

查看数据库中数据发现并没有改变

缺点分析

自定义代理模式代码编写过于臃肿；
侵入性比较强，代码不够优雅；
控制事务的实现过于繁琐。

引入AOP(XML)

相关概念

AOP是一种编程设计模式，是一种编程技术，使用AOP后通过修改配置即可实现增加或者去除某些附加功能。

学习AOP中的常用术语：

Join point（连接点）：所谓连接点是指那些可以被拦截到的点；

Pointcut（切入点）：对连接点进行拦截的定义；

Advice（通知）：所谓通知是指拦截到Joinpoint之后所要执行的代码。也就是对方法做的增强功能。通知分为如下几类：

前置通知：在连接点之前运行的通知类型，它不会阻止流程进行到连接点，除非此处抛出异常；

后置通知：在连接点正常完成后要运行的通知，如果连接点抛出异常，则不会执行；

最终通知：无论连接点执行后的结果如何，正常还是异常，都会执行的通知；

异常通知：如果连接点执行因抛出异常而退出，则执行此通知；

环绕通知：环绕通知可以在方法调用之前和之后执行自定义行为。

Target（目标）
Target指的是代理的目标对象。

Aspect（切面）
类是对物体特征的抽象，切面就是对横切关注点的抽象。

Weaving（织入）
将切面应用到目标对象并导致代理对象创建的过程。

Proxy（代理）
一个类被AOP织入增强后，产生的结果就是代理类。

代码实现

删除事务代理工具类：TransactionProxyUtils.java

导入aspectjweaver包

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.3</version>
</dependency>

配置文件中添加 AOP 的相关配置

<!-- aop相关的节点配置 -->
<aop:config>
    <!-- 切入点  表示哪些类的哪些方法在执行的时候会应用Spring配置的通知进行增强 -->
    <aop:pointcut expression="execution ( * services.*.*(..))" id="pc"/>
    <!-- 配置切面类的节点  作用主要就是整合通知和切入点 -->
    <aop:aspect ref="transactionManager">
        <aop:before method="beginTransaction" pointcut-ref="pc"/>
        <aop:after-returning method="commit" pointcut-ref="pc"/>
        <aop:after method="release" pointcut-ref="pc"/>
        <aop:after-throwing method="rollback" pointcut-ref="pc"/>
    </aop:aspect>
</aop:config>

修改测试类代码

执行结果

控制台打印结果

修改前数据库中值

修改后数据库中值

再次在出账账户金额修改之后，入账账户金额修改之前添加异常代码，如下图所示

可以看到：在捕捉到异常后进行了事务的回滚

查看数据库中数据发现并没有改变

XML改注解(AOP)

注解介绍

@Aspect
此注解用于表明某个类为切面类，而切面类的作用我们之前也解释过，用于整合切入点和通知

@Pointcut
此注解用于声明一个切入点，表明哪些类的哪些方法需要被增强

@Before 前置通知
在连接点之前运行的通知类型，它不会阻止流程进行到连接点，只是在到达连接点之前运行该通知内的行为

@AfterReturning 后置通知
在连接点正常完成后要运行的通知，正常的连接点逻辑执行完，会运行该通知

@After 最终通知
无论连接点执行后的结果如何，正常还是异常，都会执行的通知

@AfterThrowing 异常通知
如果连接点执行因抛出异常而退出，则执行此通知

代码实现

删除XML中的AOPXML配置并注解代理模式；

<!-- 注解  开启代理模式 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

注释事务管理器类：TransactionManager.java

package transaction;

import org.aspectj.lang.annotation.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import utils.ConnectionUtils;

import java.sql.SQLException;

@Component
@Aspect
public class TransactionManager {
    // 数据库连接工具类
    @Autowired
    private ConnectionUtils connectionUtils;

    @Pointcut("execution(* services.*.*(..))")
    private void transactionPointcut() {
    }

    /**
     * 开启事务
     */
    @Before("transactionPointcut()")
    public void beginTransaction() {
        try {
            System.out.println("开启事务");
            connectionUtils.getThreadConnection().setAutoCommit(false);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 提交事务
     */
    @AfterReturning("transactionPointcut()")
    public void commit() {
        try {
            System.out.println("提交事务");
            connectionUtils.getThreadConnection().commit();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 回滚事务
     */
    @AfterThrowing("transactionPointcut()")
    public void rollback() {
        try {
            System.out.println("回滚事务");
            connectionUtils.getThreadConnection().rollback();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 释放连接
     */
    @After("transactionPointcut()")
    public void release() {
        try {
            System.out.println("释放连接");
            connectionUtils.getThreadConnection().close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        connectionUtils.removeConnection();
    }
}

执行结果

控制台打印结果

修改前数据库中值

修改后数据库中值

再次在出账账户金额修改之后，入账账户金额修改之前添加异常代码，如下图所示

查看数据库中数据发现并没有改变

总结

SpringAOP的作用就是把程序中重复的代码抽取出来，在需要执行的时候，使用动态代理技术，在不修改源码的基础上，对已有方法进行增强。优势就是减少了重复代码，提高代码复用性，提高开发效率，使得代码的维护更加方便。