二、Spring AOP

一、转账案例

需求： 使用Spring框架整合DbUtils技术，实现用户转账功能。

CREATE TABLE `account` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(32) DEFAULT NULL,
  `money` double DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8

---

1.导入Maven依赖坐标

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.xuguowen</groupId>
    <artifactId>spring_transaction</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.15</version>
        </dependency>
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.6</version>
        </dependency>
        <dependency>
        <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-test</artifactId>
                <version>5.1.5.RELEASE</version>
        </dependency>
        <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
        </dependency>
    </dependencies>
</project>

2.编写Account实体类

/**
 * @author 徐国文
 * @create 2021-10-11 17:02
 * 对应数据库Account表
 */

public class Account {
    private Integer id;
    private String name;
    private Double money;
}

3.编写AccountDao接口和实现类

package cn.xuguowen.dao;

/**
 * @author 徐国文
 * @create 2021-10-11 17:23
 */
public interface AccountDao {
    /**
     * 转出
     * @param outUser 转出用户
     * @param money   转出金额
     */
    void out(String outUser,Double money);

    /**
     * 转入
     * @param inUser    转入用户
     * @param money     转入金额
     */
    void in(String inUser,Double money);
}

package cn.xuguowen.dao.impl;

import cn.xuguowen.dao.AccountDao;
import org.apache.commons.dbutils.QueryRunner;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import java.sql.SQLException;

/**
 * @author 徐国文
 * @create 2021-10-11 17:25
 */
@Repository("accountDao")
public class AccountDaoImpl implements AccountDao {

    @Autowired
    private QueryRunner queryRunner;

    /**
     * 转出操作
     * @param outUser 转出用户
     * @param money   转出金额
     */
    @Override
    public void out(String outUser, Double money) {
        try {
            String sql = "update account set money = money - ? where name = ?";
            queryRunner.update(sql,money,outUser);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    /**
     * 转入操作
     * @param inUser    转入用户
     * @param money     转入金额
     */
    @Override
    public void in(String inUser, Double money) {
        try {
            String sql = "update account set money = money + ? where name = ?";
            queryRunner.update(sql,money,inUser);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }
}

4.编写AccountService接口和实现类

package cn.xuguowen.service;

/**
 * @author 徐国文
 * @create 2021-10-11 17:28
 */
public interface AccountService {
    /**
     * 转账操作
     * @param outUser   转出账户
     * @param inUser    转入账户
     * @param money     转出金额/收入金额
     */
    void transfer(String outUser,String inUser,Double money);
}

package cn.xuguowen.service.impl;

import cn.xuguowen.dao.AccountDao;
import cn.xuguowen.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @author 徐国文
 * @create 2021-10-11 17:30
 */
@Service("accountService")
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;
    /**
     * 转账操作
     * @param outUser   转出账户
     * @param inUser    转入账户
     * @param money     转出金额/收入金额
     */
    @Override
    public void transfer(String outUser, String inUser, Double money) {
        // 转钱
        accountDao.out(outUser,money);

        // 收钱
        accountDao.in(inUser,money);
    }
}

5.编写Spring核心配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
">
    <!-- 配置注解扫描 -->
    <context:component-scan base-package="cn.xuguowen"></context:component-scan>

    <!-- 引入外部的properties文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>

    <!-- 配置数据源实例对象 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>

    <!-- 配置queryRunne实例对象 -->
    <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
        <constructor-arg name="ds" ref="dataSource"></constructor-arg>
    </bean>
</beans>

6.编写测试代码

package cn.xuguowen.transfertest;

import cn.xuguowen.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * @author 徐国文
 * @create 2021-10-11 18:07
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:applicationContext.xml"})
public class TestTransaction {

    @Autowired
    private AccountService accountService;

    @Test
    public void testTransfer() {
        String outUser = "tom";
        String inUser = "jerry";
        accountService.transfer(outUser,inUser,200d);
    }
}

问题： 上面的代码事务在dao层，转出转入操作都是一个独立的事务，但实际开发，应该把业务逻辑控制在一个事务中，所以应该将事务挪到service层。

---

---

二、传统事务解决上述问题

1.编写线程绑定连接工具类

package cn.xuguowen.uitls;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;

/**
 * @author 徐国文
 * @create 2021-10-11 20:29
 * 线程绑定连接工具类：保证dao层的out方法和in方法使用的是同一个connection连接对象
 */
@Component
public class ConnectionUtil {

    // 1.从数据源中获取连接对象
    @Autowired
    private DataSource dataSource;

    // 2.线程存储类:将获取到的连接存储到 threadLocal 当中
    private ThreadLocal<Connection> threadLocal = new ThreadLocal<>();

    /**
     * 线程绑定连接方法
     * @return
     */
    public Connection getThreadConnection() {

        // 3.从线程存储类中获取连接对象
        Connection connection = threadLocal.get();
        // 4.第一次调用该方法从线程存储类中获取到的连接为null
        if (connection == null) {
            try {
                // 5.从数据源中获取一个连接对象
                connection = dataSource.getConnection();
                // 6.将获取到的这个连接对象存储到threadLocal
                threadLocal.set(connection);
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }

        return connection;
    }

    /**
     * 接触线程与连接的绑定
     */
    public void removeConnection() {
        threadLocal.remove();
    }
}

2.编写事务管理类

package cn.xuguowen.uitls;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.sql.Connection;
import java.sql.SQLException;

/**
 * @author 徐国文
 * @create 2021-10-12 17:44
 * 事务管理类：开启手动提交事务、提交事务、回滚事务、释放资源
 */
@Component
public class TransactionManager {

    @Autowired
    private ConnectionUtil connectionUtil;
    /**
     * 开启手动提交事务，关闭自动提交事务
     */
    public void openTransaction() {
        try {
            // 1.获取连接对象
            Connection connection = connectionUtil.getThreadConnection();
            // 2.关闭自动提交事务
            connection.setAutoCommit(false);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    /**
     * 提交事务
     */
    public void commit() {
        try {
            // 获取到的连接是同一个连接对象，因为与线程ThreadLocal进行了绑定
            Connection connection = connectionUtil.getThreadConnection();
            connection.commit();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    /**
     * 回滚事务
     */
    public void rollback() {
        try {
            Connection connection = connectionUtil.getThreadConnection();
            connection.rollback();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    /**
     * 释放资源
     */
    public void close() {
        try {
            // 1.开启自动提交事务
            Connection connection = connectionUtil.getThreadConnection();
            connection.setAutoCommit(true);
            // 2.将连接对象归还连接池
            connectionUtil.getThreadConnection().close();
            // 3.将连接对象与线程ThreadLocal进行解绑
            connectionUtil.removeConnection();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }
}

3.修改service层代码

package cn.xuguowen.service.impl;

import cn.xuguowen.dao.AccountDao;
import cn.xuguowen.service.AccountService;
import cn.xuguowen.uitls.TransactionManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @author 徐国文
 * @create 2021-10-11 17:30
 * 传统事务控制存在的问题：
 *              1.如果当前业务层中存在许多需要涉及到事务操作的方法，那么在每个方法中调用事务管理的方法，就出现代码冗余
 *              2.业务层方法和事务控制方法在业务层中耦合，违背了面向对象开发的原则
 */
@Service("accountService")
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;

    @Autowired
    private TransactionManager transactionManager;
    /**
     * 转账操作
     * @param outUser   转出账户
     * @param inUser    转入账户
     * @param money     转出金额/收入金额
     */
    @Override
    public void transfer(String outUser, String inUser, Double money) {
        // 前提:所有的操作都必须是同一个连接对象，这样才处在同一个事务下

        try {
            // 1.开启手动提交事务：这里会获取到与线程绑定的连接对象
            transactionManager.openTransaction();

            // 转钱
            accountDao.out(outUser,money);

            int i = 1 / 0;

            // 收钱
            accountDao.in(inUser,money);

            // 2.如果上述转钱和收钱操作没有任何异常，那么就提交事务
            transactionManager.commit();
        } catch (Exception e) {
            // 3.如果出现异常，就回滚事务
            transactionManager.rollback();
            e.printStackTrace();
        } finally {
            // 4.不管最终结果如何：都要释放资源
            transactionManager.close();
        }
    }
}

4.修改dao层代码

package cn.xuguowen.dao.impl;

import cn.xuguowen.dao.AccountDao;
import cn.xuguowen.uitls.ConnectionUtil;
import org.apache.commons.dbutils.QueryRunner;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import java.sql.SQLException;

/**
 * @author 徐国文
 * @create 2021-10-11 17:25
 */
@Repository("accountDao")
public class AccountDaoImpl implements AccountDao {

    @Autowired
    private QueryRunner queryRunner;

    @Autowired
    private ConnectionUtil connectionUtil;
    /**
     * 转出操作
     * @param outUser 转出用户
     * @param money   转出金额
     */
    @Override
    public void out(String outUser, Double money) {
        try {
            String sql = "update account set money = money - ? where name = ?";
            // update()存在很多重载方法，当前使用的update()方法是从数据源中获取到的连接
            // 我们现在要将转入转出操作处于同一事务中，所以从线程绑定连接工具类上获取连接对象
            // 第一次获取到的连接对象是在这句代码处获得的 transactionManager.openTransaction()
            // 也就是从数据源中获取的连接对象
            queryRunner.update(connectionUtil.getThreadConnection(),sql,money,outUser);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    /**
     * 转入操作
     * @param inUser    转入用户
     * @param money     转入金额
     */
    @Override
    public void in(String inUser, Double money) {
        try {
            String sql = "update account set money = money + ? where name = ?";
            queryRunner.update(connectionUtil.getThreadConnection(),sql,money,inUser);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }
}

问题分析： 上面代码通过对业务层改造，已经可以实现事务控制了，但是由于我们添加了事务控制，也产生了一个新的问题：业务层方法变得臃肿了，里面充斥着很多重复代码。并且业务层方法和事务控制方法耦合了，违背了面向对象的开发原则。

---

三、Proxy代理模式优化转账案例

我们可以将业务代码和事务代码进行拆分，通过动态代理的方式，对业务方法进行事务的增强。这样就不会对业务层产生影响，解决了耦合性的问题啦！
常用的动态代理技术

• JDK 代理 : 基于接口的动态代理技术·：利用拦截器（必须实现invocationHandler）加上反射机制生成一个代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理，从而实现方法增强。
• CGLIB代理：基于父类的动态代理技术：动态生成一个要代理的子类，子类重写要代理的类的所有不是final的方法。在子类中采用方法拦截技术拦截所有的父类方法的调用，顺势织入横切逻辑，对方法进行增强。
  

---

1.JDK动态代理方式

JDK工厂类

 package cn.xuguowen.proxy;

import cn.xuguowen.service.AccountService;
import cn.xuguowen.uitls.TransactionManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * @author 徐国文
 * @create 2021-10-12 22:34
 * 传统事务管理的方式存在问题：1.重复代码 2.业务层方法和事务管理方法耦合
 * 现在我的目的就是要将业务层的方法和事务管理方法拆分，但是拆分之后也要实现转钱和收钱方法处在同一个事务中
 * 也就是说要在业务层方法执行之前，执行开启手动提交事务的方法，
 * 业务层方法执行之后，执行提交事务的方法
 * 业务层方法出现异常之后，执行事务回滚的方法
 * 最后不管如何，也要执行释放资源的方法
 *      自然而然的也就象到了动态代理，在执行被代理对象的方法的时候，可以对方法进行增强
 *
 * 这里是JDK动态代理实现对方法的增强
 * jdk动态代理对是基于接口的动态代理技术，利用拦截器加上反射机制生成一个实现该接口的实例对象
 * 接口是：AccountService
 * 被代理对象：AccountServiceImpl，要增强被代理对象中的 transfer()方法
 *
 */
// 代理对象工厂：生成代理对象的
@Component
public class JDKProxyFactory {

    @Autowired
    private AccountService accountService;

    @Autowired
    private TransactionManager transactionManager;
    // 1.使用jdk提供的Proxy类生成代理接口的对象
    public AccountService createProxyAccountService() {
        /*
               参数1：ClassLoader loader 类加载器，通过被代理对象获取到类加载器
               Class<?>[] interfaces 被代理对象实现的所有接口
               InvocationHandler h 拦截器接口，当代理对象调用接口中的任意方法，都会执行InvocationHandler中的invoke()方法
         */
        // accountServiceProxy 就是代理对象
        AccountService accountServiceProxy = (AccountService) Proxy.newProxyInstance(accountService.getClass().getClassLoader(), accountService.getClass().getInterfaces(), new InvocationHandler() {
            // 代理对象调用接口中的任意方法，都会先执行这个方法
            /*
                    参数1 Object proxy：当前代理对象的引用
                    参数2 Method method：被代理对象中方法的引用，也就是指向我们要增强的方法
                    参数3 Object[] args：需要增强的方法中的参数
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                /*
                    参数1 Object obj：被代理对象，也就是我要增强被代理对象中的方法
                    参数2 Object... args：方法需要的参数
                 */
                // 1.开启手动提交事务
                try {
                    transactionManager.openTransaction();

                    method.invoke(accountService, args);

                    transactionManager.commit();
                } catch (Exception e) {
                    e.printStackTrace();
                    transactionManager.rollback();
                } finally {
                    transactionManager.close();
                }
                return null;
            }
        });

        return  accountServiceProxy;
    }
}

测试代码

	@Autowired
    private JDKProxyFactory jdkProxyFactory;
 	@Test
    public void testTransferJDKProxy() {
        String outUser = "tom";
        String inUser = "jerry";
        // 获取到了代理对象
        AccountService proxyAccountService = jdkProxyFactory.createProxyAccountService();
        // 代理对象调用接口中的任意方法，都会先执行拦截器中的invoke()方法
        // 而在invoke()方法中通过被代理对象方法的引用，执行了被代理对象中的方法
        proxyAccountService.transfer(outUser,inUser,200d);
    }

---

2.CGLIB动态代理方式

Cglib工厂类

package cn.xuguowen.proxy;

import cn.xuguowen.service.AccountService;
import cn.xuguowen.uitls.TransactionManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * @author 徐国文
 * @create 2021-10-13 16:06
 * Cglib动态代理技术：基于父类实现的代理技术
 * 注意：父类不可以被final修饰，父类中的方法也不能被final修饰，
 *      因为动态生成的一个代理子类要重写目标类中的方法
 *
 */
// 该类采用cglib动态代理技术来对目标类（AccountServiceImpl）进行方法（transfer）的动态增强（添加上事务的控制）
@Component
public class CglibProxyFactory {
    @Autowired
    private AccountService accountService;
    @Autowired
    private TransactionManager transactionManager;

    public AccountService createProxyInstance() {
        // 1.调用cglib API创建代理对象
        /**
         * Class type: 被代理类的字节码对象
         * Callback callback: 当前代理对象调用目标类中的方法时，会执行intercept方法
         */
        AccountService o = (AccountService) Enhancer.create(accountService.getClass(), new MethodInterceptor() {
            /**
             * 当代理对象调用被代理对象中方法时，都会先执行intercept方法
             * @param o 当前代理对象
             * @param method 被代理对象中方法的引用
             * @param objects 方法中的参数
             * @param methodProxy 代理方法 一般不用管
             * @return
             * @throws Throwable
             */
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                try {
                    // 1.开始手动提交事务
                    transactionManager.openTransaction();
                    // 执行被代理对象中的方法
                    method.invoke(accountService, objects);

                    // 2.提交事务
                    transactionManager.commit();
                } catch (Exception e) {
                    e.printStackTrace();
                    // 3.如果出现异常，则回滚事务
                    transactionManager.close();
                } finally {
                    // 4.最终不管如何：都要释放资源
                    transactionManager.close();
                }
                return null;
            }
        });

        return o;
    }
}

测试代码

 	@Autowired
    private CglibProxyFactory cglibProxyFactory;
	/**
     * 测试cglib动态代理优化转账案例
     */
    @Test
    public void testTransferCglibProxy() {
        // 代理对象的类型是Proxy类型的
        // Proxy proxyInstance1 = (Proxy) cglibProxyFactory.createProxyInstance();
        AccountService proxyInstance = cglibProxyFactory.createProxyInstance();

        String outUser = "tom";
        String inUser = "jerry";
        proxyInstance.transfer(outUser,inUser,200d);
    }

---

四、初识AOP

1.什么是AOP

AOP为Aspect Oriented Programming的缩写，意思为面向切面编程。
AOP是OOP（面向对象编程）的延续，也是Spring框架中的一个重要内容，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合段降低，提高程序的可重用性，同时提高了开发的效率。
这样做的好处：

• 在程序运行期间，不修改源码的情况下对方法进行功能的增强
• 逻辑清晰，开发核心业务层的时候，不必关注增强业务的代码
• 减少重复代码，提高开发效率，便于后期维护

---

2.AOP底层实现

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

---

3.AOP相关术语

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

	- Target（目标对象）：代理的目标对象
	- Proxy（代理）：一个类被AOP织入增强后，就产生一个结果代理类
	- Joinpoint（连接点）：所谓连接点是指那些可以被拦截到的点。在Spring中，这些点指的是方法，因为Spring只支持方法类型的连接点
	- Pointcut（切入点）：所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义
	- Advice（通知/增强）：所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知分类：前置通知、后置通知、异常通知、最终通知、环绕通知
	- Aspect（切面）：是切入点和通知（引介）的结合
	- weaving（织入）： 是指把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入

---

4.AOP开发明确事项

①：开发阶段（我们做的）

	- 1.编写核心业务代码（目标类的目标方法） 切入点
	- 2.把公用代码抽取出来，制作成通知（增强功能方法） 通知
	- 3.在配置文件中，声明切入点与通知间的关系，即切面

②：运行阶段（Spring框架完成的）

Spring框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类型，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。

③：底层代理实现

在Spring中，框架会根据目标类是否实现了接口来决定采用那种动态代理的方式。

• 当Bean实现接口时，会采用JDK动态代理技术
• 当Bean没有实现接口，用cglib实现（可以强制使用cglib动态代理技术(在Spring配置中加入（在spring配置中加入<aop:aspectj-autoproxy proxyt-target-class=”true”/>) ）

---

五、基于XML的AOP开发

1.快速入门

①：导入AOP相关坐标

 <!--导入spring的context坐标，context依赖aop-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <!-- aspectj的织入（切点表达式需要用到该jar包） -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.13</version>
        </dependency>
        <!--spring整合junit-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

②：创建目标接口和目标实现类

/**
 * @author 徐国文
 * @create 2021-10-13 23:08
 * 目标类
 */
public interface AccountService {
    /**
     * 目标方法：（切入点：要进行拦截增强的方法）
     */
    void transfer();
}

/**
 * @author 徐国文
 * @create 2021-10-13 23:09
 */
public class AccountServiceImpl implements AccountService {
    /**
     * 目标方法：（切入点：要进行拦截增强的方法）
     */transfer
    public void () {
        System.out.println("转账方法执行了！！！");
    }
}

③：创建通知类

/**
 * @author 徐国文
 * @create 2021-10-13 23:15
 * 通知类
 */
public class MyAdvice {
    /**
     *  前置通知
     */
    public void before() {
        System.out.println("前置增强！！！");
    }
}

④：将目标类和通知类的实例对象交给Spring IOC容器管理

	 <bean id="accountService" class="cn.xuguowen.service.impl.AccountServiceImpl"></bean>
    	<bean id="advice" class="cn.xuguowen.advice.MyAdvice"></bean>

⑤：在核心配置文件中配置织入关系,及切面

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!-- 导入aop的命名空间 -->
    <!-- 配置目标类实例对象和通知类实例对象-->
    <bean id="accountService" class="cn.xuguowen.service.impl.AccountServiceImpl"></bean>
    <bean id="advice" class="cn.xuguowen.advice.MyAdvice"></bean>

    <!-- aop配置 -->
    <aop:config>
        <!-- 引入通知类 -->
        <aop:aspect ref="advice">
            <!--配置目标类的transfer()方法执行时，使用通知类的before()方法进行前置增强-->
            <aop:before method="before" pointcut="execution(public void cn.xuguowen.service.impl.AccountServiceImpl.transfer())"/>
        </aop:aspect>
    </aop:config>
</beans>

⑥：编写测试代码

/**
 * @author 徐国文
 * @create 2021-10-13 23:25
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:applicationContext.xml"})
public class SpringAOPTest {
    @Autowired
    private AccountService accountService;
    @Test
    public void testSpringAOP() {
        accountService.transfer();
    }
}

---

2.XML配置AOP详解

①：切入点表达式语法

表达式语法：

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

栗子

execution(public void cn.xuguowen.service.impl.AccountServiceImpl.transfer())
execution(void cn.xuguowen.service.impl.AccountServiceImpl.*(..))
execution(* cn.xuguowen.service.impl.*.*(..))
execution(* cn.xuguowen.service..*.*(..))

②：切入点表达式抽取

当多个增强的切入点表达式相同时，可以将切入点表达式进行抽取，在增强中使用 pointcut-ref 属性代替pointcut 属性来引用抽取后的切点表达式。

<!-- aop配置 -->
    <aop:config>
        <!--抽取相同的切入点表达式-->
        <aop:pointcut id="service" expression="execution(void cn.xuguowen.service..*.*())"/>
        <!-- 引入通知类 -->
        <aop:aspect ref="advice">
            <!--配置目标类的transfer()方法执行时，使用通知类的before()方法进行前置增强-->
            <aop:before method="before" pointcut-ref="service"/>
            <aop:after-returning method="afterReturning" pointcut-ref="service" />
        </aop:aspect>
    </aop:config>

---

3.通知类型

通知类型的配置方法：
<aop:通知类型 method=“通知类中方法名” pointcut=“切点表达式"></aop:通知类型>

名称	标签	说明
前置通知	<aop:before>	用于配置前置通知。指定增强的方法在切入点方法之前执行
后置通知	<aop:after-returning>	用于配置后置通知。指定增强的方法在切入点方法之后执行
异常通知	<aop:after-throwing>	用于配置异常通知，指定增强的方法在切入点方法出现异常后执行
最终通知	<aop:after>	用于配置最终通知，无论切入点方法执行时是否有异常，都会执行
环绕通知	<aop:around>	用于配置环绕通知，开发者可以手动控制增强代码在什么时候执行

注意： 通常情况下，环绕通知都是独立使用的。

4.知识小结

* aop织入的配置
	<aop:config>
		<aop:aspect ref=“通知类”>
		<aop:before method=“通知方法名称” pointcut=“切点表达式"></aop:before>
		</aop:aspect>
	</aop:config>
* 通知的类型
	前置通知、后置通知、异常通知、最终通知
	环绕通知
* 切点表达式
	execution([修饰符] 返回值类型 包名.类名.方法名(参数))

---

六、基于注解的AOP开发

1.快速入门

①：导入AOP相关坐标

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

②：创建目标接口和目标实现类

/**
 * @author 徐国文
 * @create 2021-10-14 20:37
 */
public interface AccountService {
    /**
     * 目标方法：切入点
     */
    void transfer();
}

/**
 * @author 徐国文
 * @create 2021-10-14 20:38
 */
@Service("accountService")
public class AccountServiceImpl implements AccountService {
    /**
     * 目标方法：切入点
     */
    public void transfer() {
        System.out.println("转账方法执行了！");
    }
}

③：创建通知类

/**
 * @author 徐国文
 * @create 2021-10-14 20:38
 * 通知类
 */
@Component
@Aspect   // 将这个类升级为切面类。配置切入点和通知的关系
public class MyAdvice {
    /**
     * 前置增强
     */
    // 使用before对切点表达式中配置的方法进行前置增强
    @Before("execution(* cn.xuguowen.service.impl.AccountServiceImpl.*(..))")
    public void before() {
        System.out.println("前置增强执行了！");
    }
}

④：将目标类和通知类的实例对象交给Spring IOC容器管理

@Service
public class AccountServiceImpl implements AccountService {}
@Component
public class MyAdvice {}

⑤：在通知类中使用注解配置织入关系，升级为切面类

/**
 * @author 徐国文
 * @create 2021-10-14 20:38
 * 通知类
 */
@Component
@Aspect   // 将这个类升级为切面类。配置切入点和通知的关系
public class MyAdvice {
    /**
     * 前置增强
     */
    // 使用before对切点表达式中配置的方法进行前置增强
    @Before("execution(* cn.xuguowen.service.impl.AccountServiceImpl.*(..))")
    public void before() {
        System.out.println("前置增强执行了！");
    }
}

⑥：编写测试代码

/**
 * @author 徐国文
 * @create 2021-10-14 20:50
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringAOPAnnoTest {
    @Autowired
    private AccountService accountService;

    @Test
    public void test() {
        accountService.transfer();
    }
}

2.注解配置AOP详解

①：切入点表达式抽取

@Component
@Aspect
public class MyAdvice {
	@Pointcut("execution(* cn.xuguowen..*.*(..))")
	public void myPoint(){}
	@Before("myPoint()")
	public void before() {
	System.out.println("前置通知...");
}

3.通知类型

通知的配置语法：@通知注解(“切点表达式")

名称	标签	说明
前置通知	@Before	用于配置前置通知。指定增强的方法在切入点方法之前执行
后置通知	@AfterReturning	用于配置后置通知。指定增强的方法在切入点方法之后执行
异常通知	@AfterThrowing	用于配置异常通知，指定增强的方法在切入点方法出现异常后执行
最终通知	@After	用于配置最终通知，无论切入点方法执行时是否有异常，都会执行
环绕通知	@Around	用于配置环绕通知，开发者可以手动控制增强代码在什么时候执行

注意：

当前四个通知组合在一起时，执行顺序如下：
@Before -> @After -> @AfterReturning(如果有异常：@AfterThrowing)

---

4.纯注解配置

/**
 * @author 徐国文
 * @create 2021-10-14 23:06
 * Spring核心配置类
 */
@Configuration // 表示这个类是Spring的核心配置类
@ComponentScan("cn.xuguowen")   // 开启IOC注解自动扫描
@EnableAspectJAutoProxy // 注解开启AOP自动代理
public class SpringConfig {

}

5.知识小结

* 使用@Aspect注解，标注切面类
* 使用@Before等注解，标注通知方法
* 使用@Pointcut注解，抽取切点表达式
* 配置aop自动代理 <aop:aspectj-autoproxy/> 或 @EnableAspectJAutoProxy