Spring 从入门到精通系列 10 —— 使用 Spring 进行面向切面编程（AOP）

已于 2023-04-11 13:16:09 修改
阅读量520 收藏 1
点赞数 1
分类专栏： Spring # SpringFramework 文章标签： java spring aop
于 2021-06-02 15:43:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43819566/article/details/117463062
版权

本文针对 AOP 的概念作用进行了分析，并且对基于 XML 与注解两种方式配置 AOP 进行了解读。

在这里插入图片描述

文章目录

一、AOP 概述

1.1 什么是 AOP

在这里插入图片描述
  简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。

1.2 AOP 的作用及优势

  • 作用： 在程序运行期间，不修改源码对已有方法进行增强。
  • 优势： 减少重复代码；提高开发效率；维护方便

1.3 AOP 的实现方式

动态代理

1.4 Spring 中 AOP 的 相关术语

  1. 连接点： 所谓连接点就是指那些被拦截的点，即业务层中所有的方法。

  2. 切入点： 所谓切入点就是指我们要对哪些连接点进行拦截，即业务层中被增强的方法例如：

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
	if("test".equals(method.getName())){
		return method.invoke(accountService, args);
	}
	//...增强操作...
}

//业务层
void test();//是连接点，不是切入点。因为方法被拦截，没有被增强。

  3. 通知：前置通知、后置通知、异常通知、最终通知、环绕通知

    在这里插入图片描述

  4. Introduction（引介）： 引介是一种特殊的通知在不修改类代码的前提下，Introduction可以在运行期为类动态地添加一些方法或Fields。（了解）

  5. Target（目标对象）： 代理的目标对象。

  6. weaving（织入）： 是指把增强应用到目标对象来创建新的代理对象的 过程 。spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入。

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

  8. Aspect（切面）： 是切入点和通知（引介）的结合。

1.5 AOP 要明确做的事

  • 开发阶段（我们做的）
    编写核心业务代码(开发主线)：要求熟悉业务需求
    把公用代码抽取出来，制作成通知。
    在配置文件中，声明切入点与通知间的关系，即切面。
  • 运行阶段（Spring完成的）
    Spring 框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象。根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。

二、Spring 中基于 XML 的 AOP 配置步骤 ★

为了演示 AOP 配置步骤，建立一个工程。工程目录如下：
在这里插入图片描述

2.1 工程准备

导入依赖：

<dependencies>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-context</artifactId>
		<version>5.0.2.RELEASE</version>
	</dependency>
	<dependency>
		<groupId>org.aspectj</groupId>
		<artifactId>aspectjweaver</artifactId>
		<version>1.8.7</version>
	</dependency>
</dependencies>

账户业务层及其实现类代码：

public interface IAccountService {

    void saveAccount();

    void updateAccount(int i);

    int deleteAccount();
}

public class AccountServiceImpl implements IAccountService {
    public void saveAccount() {
        System.out.println("保存了账户");
    }

    public void updateAccount(int i) {
        System.out.println("更新了账户");
    }

    public int deleteAccount() {
        System.out.println("删除了账户");
        return 0;
    }
}

日志的工具类：

/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 */
public class Logger {

    /**
     * 用于打印日志：计划让其在切入点方法执行之前执行（切入点方法就是业务层方法）
     */
    public void printLog(){
        System.out.println("Logger类中的printLog方法开始执行了...");
    }
}

bean.xml:

<?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">

    <!--配置spring的ioc， service对象配置进来-->
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>
    
</beans>

2.2 配置 AOP 步骤

  1. 把通知 Bean 交给 spring 来管理

    <!--配置Logger类-->
<bean id="logger" class="com.itheima.utils.Logger"></bean>

  2. 使用 aop:config 标签标明开始 AOP 的配置

    <!--配置aop-->
<aop:config>   
</aop:config>

  3. 使用 aop:aspect 标签标明配置切面
    id 属性： 是给切面提供一个唯一标识，一般使用 logAdvice 作为 id 值
    ref 属性： 是指定通知类 bean 的 id

    <!--配置aop-->
<aop:config>
    <!--配置切面-->
    <aop:aspect id="logAdvice" ref="logger">
    </aop:aspect>
</aop:config>

  4. 在 aop:aspect 标签的内部使用对应标签来配置通知的类型

    我们现在示例是让 printLog 方法在切入点执行之前执行：所以是前置通知。 aop:before: 表示配置前置通知
    method 属性： 用于指定 logger 类中那个方法是前置通知
    pointcut 属性： 用于指定切入点表达式，该表达式的含义指的是对业务层中哪些方法增强（建立前置通知和业务层之间的关系）

    <!--配置aop-->
<aop:config>
    <!--配置切面-->
    <aop:aspect id="logAdvice" ref="logger">
        <!--配置通知的类型，并且建立通知方法和切入点方法的关联-->
        <aop:before method="printLog" pointcut="execution( * com.itheima.service.impl.*.*(..))"></aop:before>
    </aop:aspect>
</aop:config>

2.3 切入点表达式的写法

关键字： execution(表达式)

表达式： 访问修饰符 返回值 包名.包名.包名…类名.方法名(参数列表)

  1. 标准的表达式写法

    public void com.ithiema.service.impl.AccountServiceImpl.saveAccount()

  2. 访问修饰符可以省略

    void com.ithiema.service.impl.AccountServiceImpl.saveAccount()

  3. 返回值可以使用通配符，表示任意返回值

    * com.ithiema.service.impl.AccountServiceImpl.saveAccount()

  4. 包名可以使用通配符，表示任意包。但是有几级包，就需要写几个 *.

    * *.*.*.*.AccountServiceImpl.saveAccount()

  5. 包名可以使用…表示当前包及其子包

    * *..AccountServiceImpl.saveAccount()

  6. 类名和方法名都可以使用 * 来实现通配

    * *..*.*()

  7. 参数列表：

    1. 可以直接写数据类型：
      基本类型直接写名称，int。如：* *…AccountServiceImpl.saveAccount(int)
      引用类型写包名.类名的方式，如：java.lang.String
    2. 可以使用 通配符 表示任意类型，但是必须有参数：
      可以使用…表示有无参数均可，有参数可以是任意类型。如：* *…AccountServiceImpl.saveAccount(…)
    3. 全通配写法：* ….*(…)

2.3.1 切入点表达式的通常写法

实际开发中切入点表达式的通常写法：切到业务层实现类下的所有方法: 

* com.itheima.service.impl.*.*(..)

配置完成后的 bean.xml 文件如下：

<?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">

    <!--配置spring的ioc， service对象配置进来-->
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>

    <!--配置Logger类-->
    <bean id="logger" class="com.itheima.utils.Logger"></bean>

    <!--配置aop-->
    <aop:config>
        <!--配置切面-->
        <aop:aspect id="logAdvice" ref="logger">
            <!--配置通知的类型，并且建立通知方法和切入点方法的关联-->
            <aop:before method="printLog" pointcut="execution( * com.itheima.service.impl.*.*(..))"></aop:before>
        </aop:aspect>
    </aop:config>
</beans>

测试方法：

public class AOPTest {
    public static void main(String[] args) {
        //1.获取容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");

        //2. 获取对象
        IAccountService as = (IAccountService) ac.getBean("accountService");

        //3. 执行方法
        as.saveAccount();
        as.deleteAccount();
        as.updateAccount(1);
    }
}

执行结果：
在这里插入图片描述

2.3.2 通用化切入点表达式

当我们对切入点表达式重复的引用时，配置会显得很冗长，因此可利用配置切入点表达式解决该问题。

<aop:pointcut id="pt1" expression="execution( * com.itheima.service.impl.*.*(..))"></aop:pointcut>
  • 配置切入点表达式 id 的属性用于指定表达式的唯一标识。expression 属性用于指定表达式内容
  • 此标签既可以写在 aop:aspect 内部，也可以写在外部。
  • 标签写在内部只能当前切面使用，写在外面代表所有切面可用，但是一定要放在aop:config标签的最顶部

标签写在 aop:aspect 内部：

<!--配置aop-->
<aop:config>
    <!--配置切面-->
    <aop:aspect id="logAdvice" ref="logger">
        <!--配置前置通知：在切入点方法执行之前执行-->
        <aop:before method="beforePrintLog" pointcut-ref="pt1"></aop:before>
        <aop:pointcut id="pt1" expression="execution( * com.itheima.service.impl.*.*(..))"></aop:pointcut>
    </aop:aspect>
</aop:config>

标签写在 aop:aspect 外部：

<!--配置aop-->
<aop:config>
	<!--配置切入点表达式-->
	<aop:pointcut id="pt1" expression="execution( * com.itheima.service.impl.*.*(..))"></aop:pointcut>
    <!--配置切面-->
    <aop:aspect id="logAdvice" ref="logger">
        <!--配置前置通知：在切入点方法执行之前执行-->
        <aop:before method="beforePrintLog" pointcut-ref="pt1"></aop:before>
    </aop:aspect>
</aop:config>

2.4 四种常用类型通知

日志的工具类：

/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 */
public class Logger {

    /**
     * 前置通知
     */
    public void beforePrintLog(){
        System.out.println("前置通知Logger类中的printLog方法开始执行了...");
    }

    /**
     * 后置通知
     */
    public void afterReturningPrintLog(){
        System.out.println("后置通知Logger类中的printLog方法开始执行了...");
    }

    /**
     * 异常通知
     */
    public void afterThrowingPrintLog(){
        System.out.println("异常通知Logger类中的printLog方法开始执行了...");
    }

    /**
     * 最终通知
     */
    public void afterPrintLog(){
        System.out.println("最终通知Logger类中的printLog方法开始执行了...");
    }
}

bean.xml：

<?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">

    <!--配置spring的ioc， service对象配置进来-->
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>

    <!--配置Logger类-->
    <bean id="logger" class="com.itheima.utils.Logger"></bean>

    <!--配置aop-->
    <aop:config>
        <!--配置切面-->
        <aop:aspect id="logAdvice" ref="logger">
            <!--配置前置通知：在切入点方法执行之前执行-->
            <aop:before method="beforePrintLog" pointcut-ref="pt1"></aop:before>
            <!--配置后置通知：在切入点之后正常方法之后执行，他和异常通知永远只能执行一个-->
            <aop:after-returning method="afterReturningPrintLog"  pointcut-ref="pt1"></aop:after-returning>
            <!--配置异常通知：在切入点之后异常方法之后执行，他和异常通知永远只能执行一个-->
            <aop:after-throwing method="afterThrowingPrintLog"  pointcut-ref="pt1"></aop:after-throwing>
            <!--配置最终通知：无论切入点方法是否正常执行，他都会在其后面执行-->
            <aop:after method="afterPrintLog" pointcut-ref="pt1"></aop:after>
            
            <!--在切面内部配置切入点表达式-->
            <aop:pointcut id="pt1" expression="execution( * com.itheima.service.impl.*.*(..))"></aop:pointcut>
        </aop:aspect>
    </aop:config>
</beans>

测试结果：
在这里插入图片描述

2.5 环绕通知

Spring 为我们提供了一个接口，ProceedingJoinPoint。该接口有一个方法 proceed()，此方法就相当于明确调用切入点方法。
该接口可以作为环绕通知的方法参数，在程序执行时，spring框架会为我们提供该接口的实现类供我们使用。

Spring 中的环绕通知： 它是 Spring 框架为我们提供的一种可以在代码中手动增强方法和执行的方式。

在 Logger 中编写以下代码：

/**
 * 环绕通知
 */
public Object aroundPrintLog(ProceedingJoinPoint pjp){
    Object rtValue = null;
    try {
        Object[] args = pjp.getArgs(); // 固定写法
        System.out.println("Logger类中aroundPrintLog方法开始记录日志了。。前置");
        rtValue = pjp.proceed(args); // 固定写法
        System.out.println("Logger类中aroundPrintLog方法开始记录日志了。。后置");
        return rtValue;
    } catch (Throwable throwable) {
        System.out.println("Logger类中aroundPrintLog方法开始记录日志了。。异常");
        throw new RuntimeException(throwable);
    } finally {
        System.out.println("Logger类中aroundPrintLog方法开始记录日志了。。最终");
    }
}

注意：catch 的异常只能是 Throwable，其他异常获取不到。

bean.xml：

<!--配置aop-->
<aop:config>
    <!--配置切面-->
    <aop:aspect id="logAdvice" ref="logger">
        <!-- 配置环绕通知 -->
        <aop:around method="aroundPrintLog" pointcut-ref="pt1"></aop:around>
        <!--配置切入点表达式-->
        <aop:pointcut id="pt1" expression="execution( * com.itheima.service.impl.*.*(..))"></aop:pointcut>
    </aop:aspect>
</aop:config>

测试方法结果：
在这里插入图片描述

三、Spring 中基于注解的 AOP 配置步骤（了解）

为了演示基于注解的AOP配置步骤，我们创建一个新的工程，工程目录如下：
在这里插入图片描述

3.1 工程准备

bean.xml：

<?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:context="http://www.springframework.org/schema/context"
       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/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--配置spring创建容器是要扫描的包-->
    <context:component-scan base-package="com.itheima"></context:component-scan>

    <!--开启spring开启Aop的支持-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

账户业务层及其实现类：

public interface IAccountService {
    void saveAccount();
}

@Service("accountService")
public class AccountServiceImpl implements IAccountService {
    public void saveAccount() {
        System.out.println("保存了账户");
    }
}

3.1 四种常用类型通知与环绕通知

@Component("logger")
@Aspect // 表示当前类是一个切面类
public class Logger {

    @Pointcut("execution( * com.itheima.service.impl.*.*(..))")
    private void pt1(){}
    
    /**
     * 前置通知
     */
    @Before("pt1()")
    public void beforePrintLog(){
        System.out.println("前置通知Logger类中的printLog方法开始执行了...");
    }

    /**
     * 后置通知
     */
    @AfterReturning("pt1()")
    public void afterReturningPrintLog(){
        System.out.println("后置通知Logger类中的printLog方法开始执行了...");
    }

    /**
     * 异常通知
     */
    @AfterThrowing("pt1()")
    public void afterThrowingPrintLog(){
        System.out.println("异常通知Logger类中的printLog方法开始执行了...");
    }

    /**
     * 最终通知
     */
    @After("pt1()")
    public void afterPrintLog(){
        System.out.println("最终通知Logger类中的printLog方法开始执行了...");
    }
    
}

测试方法：

public static void main(String[] args) {
	//1.获取容器
	ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");	
	//2. 获取对象
	IAccountService as = (IAccountService) ac.getBean("accountService");	
	//3. 执行方法
	as.saveAccount();
}

在这里插入图片描述
从结果中看出，后置通知与最终通知顺序有所不同，这个是 Spring 内部的问题。解决该问题的方法是使用环绕通知，我们手动增强方法和执行的方式。

3.2 环绕通知类型

@Component("logger")
@Aspect//表示当前类是一个切面类
public class Logger {

    @Pointcut("execution( * com.itheima.service.impl.*.*(..))")
    private void pt1(){}

    /**
     * 环绕通知
     */
    @Around(("pt1()"))
    public Object aroundPrintLog(ProceedingJoinPoint pjp){
        Object rtValue = null;
        try {
            Object[] args = pjp.getArgs();
            System.out.println("Logger类中aroundPrintLog方法开始记录日志了。。前置");
            rtValue = pjp.proceed(args);
            System.out.println("Logger类中aroundPrintLog方法开始记录日志了。。后置");
            return rtValue;
        } catch (Throwable throwable) {
            System.out.println("Logger类中aroundPrintLog方法开始记录日志了。。异常");
            throw new RuntimeException(throwable);
        } finally {
            System.out.println("Logger类中aroundPrintLog方法开始记录日志了。。最终");
        }
    }

}

方法执行结果如下：
在这里插入图片描述

四、应用 AOP 对转账方法事务的优化（了解)

上一讲对于转账事务提出了一种解决方案，具体实现方式可查看右侧链接： Spring 从入门到精通系列 09 —— 转账方法的事务问题与动态代理
但是事务控制的比较冗余，现可通过 AOP 对于动态代理的方式进行优化。

4.1 方案一：xml 配置环绕通知

工程目录：
在这里插入图片描述

bean.xml

<?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 https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- (7) 配置代理的service
    <bean id="proxyAccountService" factory-bean="beanFactory" factory-method="getAccountService" />-->

    <!-- (6) 配置beanFactory -->
    <bean id="beanFactory" class="com.axy.factory.BeanFactory">
        <!-- 注入service 
        <property name="accountService" ref="accountService" />-->
        <!-- 注入事务管理器 -->
        <property name="txManager" ref="txManager" />
    </bean>

    <!-- 配置Service -->
    <bean id="accountService" class="com.axy.service.impl.AccountServiceImpl">
        <!-- 注入dao -->
        <property name="accountDao" ref="accountDao" />
    </bean>

    <!--配置Dao对象-->
    <bean id="accountDao" class="com.axy.dao.impl.AccountDaoImpl">
        <!-- 注入QueryRunner -->
        <property name="runner" ref="runner" />
        <!-- (3) 注入ConnectionUtils -->
        <property name="connectionUtils" ref="connectionUtils" />
    </bean>

    <!--配置QueryRunner-->
    <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype" />

    <!-- 配置数据源 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!--连接数据库的必备信息-->
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver" />
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/mybatisdb?useSSL=false&amp;useUnicode=true&amp;characterEncoding=utf8&amp;serverTimezone=CST" />
        <property name="user" value="root" />
        <property name="password" value="123456" />
    </bean>

    <!-- (2) 配置 connectionUtils 工具类 -->
    <bean id="connectionUtils" class="com.axy.utils.ConnectionUtils">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource" />
    </bean>

    <!-- (4) 配置事务管理器 -->
    <bean id="txManager" class="com.axy.utils.TransactionManager">
        <!-- (5) 注入ConnectionUtils -->
        <property name="connectionUtils" ref="connectionUtils" />
    </bean>

    <!-- new: 配置AOP-->
    <aop:config>
        <!--配置切面-->
        <aop:aspect id="workAdvice" ref="beanFactory">
            <aop:around method="getAccountService" pointcut="execution(* com.axy.service.impl.*.*(..))" />
        </aop:aspect>
    </aop:config>
</beans>

BeanFactory.java：

/**
 * 用于创建 Service 的代理对象的工厂
 */
public class BeanFactory {
    private TransactionManager txManager;
    public void setTxManager(TransactionManager txManager) {
        this.txManager = txManager;
    }

    public Object getAccountService(ProceedingJoinPoint pjp){
        Object rtValue = null;
        try {
            Object[] args = pjp.getArgs();
            // 1. 开启事务
            txManager.beginTransaction();
            // 2. 执行操作
            rtValue = pjp.proceed(args);
            //3.提交事务
            txManager.commit();
            //4.返回结果
            return rtValue;
        }catch (Throwable t){
            //5.回滚操作
            txManager.rollback();
            throw new RuntimeException(t);
        }finally {
            //6.释放连接
            txManager.release();
        }
    }
}

测试类：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")
public class AccountServiceTest {
    @Autowired
    private IAccountService as;

    @Test
    public  void testTransfer(){
        as.transfer("aaa","bbb",100f);
    }
}

测试结果：

在这里插入图片描述

4.2 方案二：xml 配置四种常用通知

这种方案不会将 BeanFactory 加入 IOC 容器，而是直接指定事务管理器。

bean.xml：

<?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 https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 配置Service -->
    <bean id="accountService" class="com.axy.service.impl.AccountServiceImpl">
        <!-- 注入dao -->
        <property name="accountDao" ref="accountDao" />
    </bean>

    <!--配置Dao对象-->
    <bean id="accountDao" class="com.axy.dao.impl.AccountDaoImpl">
        <!-- 注入QueryRunner -->
        <property name="runner" ref="runner" />
        <!-- (3) 注入ConnectionUtils -->
        <property name="connectionUtils" ref="connectionUtils" />
    </bean>

    <!--配置QueryRunner-->
    <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype" />

    <!-- 配置数据源 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!--连接数据库的必备信息-->
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver" />
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/mybatisdb?useSSL=false&amp;useUnicode=true&amp;characterEncoding=utf8&amp;serverTimezone=CST" />
        <property name="user" value="root" />
        <property name="password" value="123456" />
    </bean>

    <!-- (2) 配置 connectionUtils 工具类 -->
    <bean id="connectionUtils" class="com.axy.utils.ConnectionUtils">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource" />
    </bean>

    <!-- (4) 配置事务管理器 -->
    <bean id="txManager" class="com.axy.utils.TransactionManager">
        <!-- (5) 注入ConnectionUtils -->
        <property name="connectionUtils" ref="connectionUtils" />
    </bean>

    <!-- new: 配置AOP-->
    <aop:config>
        <aop:pointcut id="pt1" expression="execution(* com.axy.service.impl.*.*(..))" />
        <!--配置切面-->
        <aop:aspect id="workAdvice" ref="txManager">
            <aop:before method="beginTransaction" pointcut-ref="pt1" />
            <aop:after-returning method="commit"  pointcut-ref="pt1" />
            <aop:after-throwing method="rollback"  pointcut-ref="pt1" />
            <aop:after method="release" pointcut-ref="pt1" />
        </aop:aspect>
    </aop:config>
</beans>

4.3 方案三：xml 和注解配置四种通知

不用 beanFactory 的形式，并且将 service 和 dao 放入 IOC 容器。

bean.xml：

<?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"
       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/aop https://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <!--注解包扫描-->
    <context:component-scan base-package="com.axy" />

    <!--配置QueryRunner-->
    <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype" />

    <!-- 配置数据源 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!--连接数据库的必备信息-->
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver" />
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/mybatisdb?useSSL=false&amp;useUnicode=true&amp;characterEncoding=utf8&amp;serverTimezone=CST" />
        <property name="user" value="root" />
        <property name="password" value="123456" />
    </bean>

    <!-- new: 配置AOP-->
    <aop:config>
        <aop:pointcut id="pt1" expression="execution(* com.axy.service.impl.*.*(..))" />
        <!--配置切面-->
        <aop:aspect id="workAdvice" ref="txManager">
            <aop:before method="beginTransaction" pointcut-ref="pt1" />
            <aop:after-returning method="commit"  pointcut-ref="pt1" />
            <aop:after-throwing method="rollback"  pointcut-ref="pt1" />
            <aop:after method="release" pointcut-ref="pt1" />
        </aop:aspect>
    </aop:config>
</beans>

其他类：

@Service("accountService")
public class AccountServiceImpl implements IAccountService{
	@Autowired
    private IAccountDao accountDao;
	...
}

@Repository("accountDao")
public class AccountDaoImpl implements IAccountDao {
    @Autowired
    private QueryRunner runner;
    @Autowired
    private ConnectionUtils connectionUtils;
    ...
}

@Component("txManager")
public class TransactionManager {
    @Autowired
    private ConnectionUtils connectionUtils;
	...
}

4.4 方案四：xml 和注解配置环绕通知

bean.xml：

<?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"
       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/aop https://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <!--注解包扫描-->
    <context:component-scan base-package="com.axy" />

    <!--配置QueryRunner-->
    <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype" />

    <!-- 配置数据源 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!--连接数据库的必备信息-->
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver" />
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/mybatisdb?useSSL=false&amp;useUnicode=true&amp;characterEncoding=utf8&amp;serverTimezone=CST" />
        <property name="user" value="root" />
        <property name="password" value="123456" />
    </bean>

    <!-- new: 配置AOP-->
    <aop:config>
	    <!--配置切面-->
        <aop:aspect id="workAdvice" ref="txManager">
            <aop:around method="getAccountService" pointcut="execution(* com.axy.service.impl.*.*(..))" />
        </aop:aspect>
    </aop:config>
</beans>

@Component("txManager")
public class TransactionManager {
    @Autowired
    private ConnectionUtils connectionUtils;

    public Object aroundAdvice(ProceedingJoinPoint pjp){
        Object rtValue = null;
        try {
            Object[] args = pjp.getArgs();
            // 1. 开启事务
            this.beginTransaction();
            // 2. 执行操作
            rtValue = pjp.proceed(args);
            //3.提交事务
            this.commit();
            //4.返回结果
            return rtValue;
        }catch (Throwable t){
            //5.回滚操作
            this.rollback();
            throw new RuntimeException(t);
        }finally {
            //6.释放连接
            this.release();
        }
    }
}

另外，使用注解配置切面只可配置环绕通知，配置四种通知，由于提交事务和释放连接事务顺序不对，会出现异常。

本文针对 AOP 的概念作用进行了分析，并且对基于 XML 与注解两种方式配置 AOP 进行了解读，并对之前案例进行优化，如果大家对文章内容还存在一些疑问，欢迎大家在评论区留言哦~
Xiu Yan
关注
专栏目录
Spring——面向切面编程(AOP)
行者无疆的博客
06-05 3749
本文介绍了切向切面编程(AOP)中的各个概念，并用两个案例分别讲解了如何通过注解和XML配置的方式使用AOP。
Spring 面向切面编程AOP实现详解
08-25
Spring 面向切面编程AOP实现详解 面向切面编程（AOP）是一种编程技术，旨在将横切关注点从业务逻辑中分离出来，提高系统的可扩展性和可维护性。Spring 作为一个流行的 Java 框架，提供了完备的 AOP 实现机制。 1. ...
Java之Spring AOP入门到精通【IDEA版】（一篇文章精通系列）
程序员猫爪
10-17 759
一、设计模式-代理模式 代理模式：给某一个对象提供一个代理对象，并由代理对象控制对源对象的引用。代理 就是一个人或一个机构代表另一个人或者一个机构采取行动。某些情况下，客户不想或者不 能够直接引用一个对象，代理对象可以在客户和目标对象直接起到中介的作用。 客户端分辨不出代理主题对象与真实主题对象。代理模式可以并不知道真正的被代理对象，而仅仅持有一个被代理对象的接口，这时候代理对象不能够创建被代理对象，被代理对象必须有系统的 其他角色代为创建并传入。 为什么要使用代理模式呢？ 第一，它有间接的特点，可以起到中
猿创征文|Spring系列框架之面向切面编程AOP
未见花闻的博客
09-06 2674
本篇文章将介绍一种特别重要的思想，AOP（Aspect Oriented Programming），即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。 AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。
深入浅出Spring AOP：面向切面编程的实战与解析
热门推荐
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
03-30 3万+
Spring AOP（面向切面编程）作为Spring框架的核心特性之一，提供了强大的横切关注点处理能力，使得开发者能够更好地解耦系统架构，将非功能性需求（如日志记录、事务管理、权限控制等）从主业务逻辑中抽离出来，实现模块化的交叉关注点处理。本文将带你逐步探索Spring AOP的关键技术要点及其实战应用。
【Spring进阶系列丨第九篇】基于XML的面向切面编程(AOP)详解
陈橘又青的博客
04-14 1万+
/ 保存用户// 根据id查询用户// 查询全部用户// 保存用户// 根据id查询用户// 查询全部用户// 定义记录日志的类,这个类就封装了我们所有的公共的代码// 该方法的作用是在切入点方法执行之前执行System.out.println("开始打印日志啦");
AOP——面向切面编程
m0_62912377的博客
05-05 8351
AOP(Aspect Oriented Programming)面向切面编程，一种编程范式，指导开发者如何组织程序结构。 OOP(Object Oriented Programming)面向对象编程，是一种编程思想，所以，AOP也是一种编程思想，只是他们两个是不同的编程范式。
SpringAop面向切面编程使用详解
qq_44749491的博客
11-22 5495
一文学会SpringAop的使用
【Spring进阶系列丨第八篇】Spring整合junit & 面向切面编程(AOP)详解
陈橘又青的博客
04-10 1万+
是Endava的专职开发主管和培训师，他负责欧洲、美国和亚洲客户的金融市场项目开发。他有超过10年的开发经验。Laurenţiu相信，重要的不仅是交付高质量的软件，还要分享知识和帮助他人提升技能。这些信念驱使他去设计和讲授与Java技术相关的课程，并进行演示和参与研讨会。
Spring核心功能——AOP（面向切面编程）
hang_sa_mu的博客
09-03 1542
Spring中另外一个核心功能,AOPAOP(Aspect Oriented Programming),即面向切面编程OOP(Object Oriented Programming ),即面向对象编程.AOP面向切面编程,利用 一种称为"横切"的技术，剖开封装的对象内部，并将那些影响了多个类的公共行为抽取出封装到一个可重用模块），并将其命名 为"Aspect"，即切面。
【SSM直击大厂】第十章：Spring AOP面向切面编程
专注Spring、SSM、数据结构与算法、蓝桥杯领域创作者
04-11 3278
🙊🙊作者主页：🔗求不脱发的博客 📔📔 精选专栏：🔗SSM直击大厂 📋📋 精彩摘要：SpringAOP面向切面编程是Java OOP面向对象编程的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍 生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序 的可重用性，同时提高了开发的效率。 💞💞觉得文章还不错的话欢迎大家点赞👍➕收藏⭐️➕评论💬支持博主🤞 📚 📖 📝1️⃣ 2️⃣ 3️⃣ 4️⃣ 5️⃣ 6️⃣ ..
Spring AOP面向切面编程实现原理方法详解
08-18
Spring AOP面向切面编程实现原理方法详解 面向切面编程（AOP）是Spring框架中的一个重要内容，通过预编译方式和运行期动态代理实现，在不修改源代码的情况下，给程序动态统一添加功能的一种技术。AOP可以对业务逻辑...
AOP_使用spring框架进行面向切面编程
03-26
面向切面编程（AOP）是一种编程范式，它旨在减少代码中的重复部分，特别是那些与核心业务逻辑无关但又必须处理的交叉关注点，如日志、事务管理、安全控制等。Spring框架是Java领域中实现AOP的常用工具，它通过提供...
Java Spring AOP 面向切面编程的4种实现
07-16
Spring AOP (面向切面编程框架): Spring框架内建了支持动态代理的功能，使用@AspectJ注解可以轻松地创建AOP代理。Spring AOP既支持JDK动态代理也支持CGLIB，会根据目标类是否实现了接口选择合适的底层技术。 Guice ...
Mybatis、Spring、SpringMVC 最详细学习路线
秀岩的博客
07-20 1892
  参考黑马教程总结了 Mybatis、Spring 及 SpringMVC 三大框架的学习笔记，供读者参考，也用于日后框架的复习。需要掌握程度是通过个人总结的，读者还需根据个人需求来学习。 Mybatis 从入门到精通系列目录结构 序号 账目名称 需要掌握程度 1 快速入门 了解 2 执行查询的底层原理分析 了解 3 基于注解配置的查询所有 会用 4 基于XML配置实现增删改查 掌握 5 Mybatis 传入参数总结 会用 6 properties 和 typeAlia
分布式调度方案：Elastic-Job
最新发布
秀岩的博客
09-09 1347
一、什么是分布式调度 二、Elastic-Job 介绍 三、Elastic-Job 实战 3.1 环境搭建 3.1.1 本地部署 3.1.2 服务器部署 3.1.3 Zookeeper 管控台界面 3.2 入门案例 3.3 SpringBoot 集成 Elastic-Job 3.4 任务分片（★） 3.5 Dataflow 类型调度任务
负载均衡 Ribbon 与 Fegin 远程调用原理
秀岩的博客
09-05 1198
文章目录 一、什么是负载均衡 二、Ribbon 负载均衡 2.1 Ribbon 使用 2.2 Ribbon 实现原理 (★) 2.3 Ribbon 负载均衡算法 三、Feign 远程调用 3.1 Feign 简述 3.2 Feign 的集成 3.3 Feign 实现原理 (★)
服务网关工作原理，如何获取用户真实IP？
秀岩的博客
09-07 1115
一、什么是网关 二、网关工作原理 三、SpringCloud Gateway 3.1 Gateway 简介 3.2 Gateway 环境搭建 3.3 自定义路由规则 3.4 局部过滤器 3.5 全局过滤器（案例：网关获取用户真实IP地址） 补充1：不同类型的客户端如何设置网关 补充2：多个全局多滤器的执行优先级 补充3：局部过滤器和全局过滤器的执行优先级
Spring 从入门到精通系列 04 —— Spring 中创建 bean 的三种方式
秀岩的博客
06-01 1082
  Spring 对 bean 的管理细节包括：创建 bean的三种方式、bean 标签的作用范围以及 bean 对象的生命周期，本文针对此部分进行分析与解读。 文章目录一、创建bean的三种方式1.1 使用默认构造函数创建。1.2 使用普通工厂中的方法创建对象1.3 使用工厂中的静态方法创建对象二、bean 标签的作用范围调整三、bean 对象的生命周期 一、创建bean的三种方式 1.1 使用默认构造函数创建。 在spring的配置文件中使用bean标签，配以id和class属性之后，且没有其他属
Spring AOP：面向切面编程详解与实战
本章节深入探讨了面向切面编程(AOP)这一强大的软件设计模式，它是软件开发中的一种热点技术，特别在Spring框架中占有重要地位。AOP旨在通过预先编译或运行时动态代理，实现对程序功能的集中管理和维护，从而提高代码...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Xiu Yan

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值