Spring引入AOP

最新推荐文章于 2024-09-10 13:53:03 发布
最新推荐文章于 2024-09-10 13:53:03 发布
阅读量864 收藏
点赞数
分类专栏： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45402151/article/details/115405619
版权

AOP即面向切面编程是一种通过预编译和运行期动态代理的方式实现在不修改源代码的情况下给程序动态统一添加功能的技术；aop的基础是它的两种动态代理，JDK动态代理和CGLIb动态代理，区别在于JDK动态代理需要实现接口而CGLIb动态代理
则不需要，在实际开发中根据实际情况来选择使用那种动态代理

简单的转账功能

准备

创建一个Maven项目，做好基本配置
创建数据库，添加数据

# 删除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、导入数据库连接包等

	<dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.12</version>
    </dependency>
    
	<!--MySQL数据库驱动-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.22</version>
    </dependency>

    <dependency>
      <groupId>com.mchange</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.5.5</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/commons-beanutils/commons-beanutils -->
    <dependency>
      <groupId>commons-beanutils</groupId>
      <artifactId>commons-beanutils</artifactId>
      <version>1.9.4</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/commons-dbutils/commons-dbutils -->
    <dependency>
      <groupId>commons-dbutils</groupId>
      <artifactId>commons-dbutils</artifactId>
      <version>1.7</version>
    </dependency>

配置文件

<?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"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
	   xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
           http://www.springframework.org/schema/context 
           http://www.springframework.org/schema/context/spring-context-4.3.xsd
           http://www.springframework.org/schema/aop 
           http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
           http://www.springframework.org/schema/tx 
           http://www.springframework.org/schema/tx/spring-tx-4.3.xsd
           http://www.springframework.org/schema/mvc
           http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd
		   http://www.springframework.org/schema/util
           http://www.springframework.org/schema/mvc/spring-util-4.3.xsd">

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

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

	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
		<property name="driverClass" value="com.mysql.cj.jdbc.Driver"/>
		<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/spring_aop?characterEncoding=UTF-8&amp;useSSL=false&amp;serverTimezone=GMT%2B8"/>
		<property name="user" value="root"/>
		<property name="password" value="hs20010224"/>
	</bean>

</beans>

代码实现

数据库连接类

@Component
public class ConnectionUtils {
    private ThreadLocal<Connection> tl = new ThreadLocal<Connection>();
    @Autowired
    private ComboPooledDataSource dataSource;

    /**
     * 获得当前线程绑定的连接
     *
     * @return
     */
    public Connection getThreadConnection() {
        try {
            // 看线程是否绑了连接
            Connection conn = tl.get();
            if (conn == null) {
                // 从数据源获取一个连接
                conn = dataSource.getConnection();
                // 和线程局部变量  绑定
                tl.set(conn);
            }
            // 返回线程连接
            return tl.get();
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 把连接和当前线程进行解绑
     */
    public void removeConnection() {
        tl.remove();
    }
}

实体类

@Data
public class Account {
    private Integer id;
    private String accountNum;
    private Integer money;
}

dao层

public interface AccountDao {
    void updateAccount(Account account);

    Account findAccountByNum(String accountNum);
}

dao层实现类

@Repository("accountDao")
public class AccountDaoImpl implements AccountDao {
    // 数据库查询工具类
    @Autowired
    private QueryRunner queryRunner;
    // 数据库连接工具类
    @Autowired
    private ConnectionUtils connectionUtils;

    /**
     * 更新
     *
     * @param account
     */
    @Override
    public void updateAccount(Account account) {
        try {
            String sql="update account set accountNum=?,money=? where id=?";
            Object [] params={account.getAccountNum(),account.getMoney(),account.getId()};
            queryRunner.update(connectionUtils.getThreadConnection(),sql, params);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    /**
     * 根据编号查询账户
     *
     * @param accountNum
     * @return 如果没有结果就返回null，如果结果集超过一个就抛异常，如果有唯一的一个结果就返回
     */
    @Override
    public Account findAccountByNum(String accountNum) {
        List<Account> accounts = null;
        try {
            String sql="select * from account where accountNum = ?";
            accounts = queryRunner.query(connectionUtils.getThreadConnection(), sql, new BeanListHandler<Account>(Account.class), accountNum);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }

        if (accounts == null || accounts.size() == 0) {
            // 如果没有结果就返回null
            return null;
        } else if (accounts.size() > 1) {
            // 如果结果集超过一个就抛异常
            throw new RuntimeException("结果集不唯一，数据有问题");
        } else {
            // 如果有唯一的一个结果就返回
            return accounts.get(0);
        }
    }
}

service层

public interface AccountService {
    void transfer(String sourceAccount, String targetAccount, Integer money);
}

service层实现类

@Service("accountService")
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;

    @Override
    public void transfer(String sourceAccount, String targetAccount, Integer money) {
        // 查询原始账户
        Account source = accountDao.findAccountByNum(sourceAccount);
        // 查询目标账户
        Account target = accountDao.findAccountByNum(targetAccount);
        // 原始账号减钱
        source.setMoney(source.getMoney() - money);
        // 目标账号加钱
        target.setMoney(target.getMoney() + money);
        // 更新原始账号
        accountDao.updateAccount(source);
        // 更新目标账号
        accountDao.updateAccount(target);
        System.out.println("转账完毕");
    }
}

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class Test {

    @Autowired
    private AccountService accountService;

    @org.junit.Test
    public void testTransfer() {
        accountService.transfer("622200001", "622200002", 100);
    }
}

测试结果
在这里插入图片描述
数据库修改前后数据对比
在这里插入图片描述
在这里插入图片描述
缺陷
如果业务层代码出现异常，则转账会出现异常
在这里插入图片描述
在这里插入图片描述
数据库中money的值一个减少了100，但是另一个却没有增加100
在这里插入图片描述
可以发现数据库中的数据没有了原子性和一致性

通过代理模式解决事务

代码实现

事务管理类

@Component
public class TransactionManager {
    @Autowired
    private ConnectionUtils connectionUtils;

    @Pointcut("execution ( * com.service.*.*(..))")
    public void transactionPointcut(){

    }

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

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

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

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

动态代理类

@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
                     */
                    @Override
                    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();
                        }
                    }
                });

    }
}

配置文件
配置代理

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

测试类添加@Qualifier(“transactionProxyAccountService”)
在这里插入图片描述

测试

将数据库中的余额改为初始值1000
1、没有异常的情况
在这里插入图片描述
在这里插入图片描述
2、有异常的情况
在这里插入图片描述
在这里插入图片描述
可以发现有异常时，代码虽然报错，但是数据库的值没有被修改，代理模式的事务管理成功了

问题：代理模式虽然可以解决事务管理，但是自定义的代理模式代码比较臃肿，不够美观

引入AOP（XML）

代码实现

1、导入依赖

    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.9.6</version>
    </dependency>

2、修改配置文件，添加相关配置

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

	<!-- aop相关的节点配置 -->
	<aop:config>
		<!-- 切入点  表示哪些类的哪些方法在执行的时候会应用Spring配置的通知进行增强 -->
		<aop:pointcut expression="execution ( * com.service.*.*(..))" 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>

3、修改测试类
在这里插入图片描述

测试

1、没有异常
在这里插入图片描述
数据库执行前后数据
在这里插入图片描述
在这里插入图片描述
可以发现，程序执行成功

2、有异常
在这里插入图片描述
在这里插入图片描述
说明AOP的事务管理正常，可以保证数据的原子性和一致性

使用AOP注解的方式

注解介绍

  • @Aspect：声明某个类为切面类，用于设置切入点和通知
  • @Pointcut：声明一个方法为切入点，表示哪些类中的那些方法需要被增强
  • @Before：前置通知，在连接点执行前，本方法
  • @AfterReturning：后置通知，在连接点执行后，执行本方法
  • @AfterThrowing：异常通知，在连接点执行异常时，执行本方法
  • @After：最终通知，不管连接点是否执行成功都会执行本方法

代码实现

1、修改配置文件
在这里插入图片描述
2、修改事务类

@Aspect
@Component
public class TransactionManager {
    @Autowired
    private ConnectionUtils connectionUtils;

    @Pointcut("execution(* com.service.*.*(..))")
    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();
    }
}

测试

1、没有异常
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2、有异常
在这里插入图片描述
在这里插入图片描述
说明AOP注解模式也可以保证事务正常运行

总结

SpringAOP的作用就是在程序运行时，使用动态代理技术，在不修改源码的基础上，对方法进行织入增强

优势就是提高了开发效率，减少了重复代码，提高了代码的使用率；通常在日志记录的时候会使用AOP

weixin_45402151
关注
专栏目录
Spring AOP
m0_65729948的博客
06-10 437
断更一个多月的橙子带着她的 AOP回来啦
spring AOP 引入jar包，spring IOC 引入Jar包
09-07
Spring AOP 和 Spring IOC 是 Spring 框架的两个核心组件，它们对于任何基于 Java 的企业级应用开发都至关重要。Spring AOP（面向切面编程）允许开发者在不修改源代码的情况下，通过“切面”来插入新的行为或增强已...
Spring Aop的引入
weixin_42067668的博客
03-28 878
介绍为什么要用到Aop， 在我们以前的开发中，加入一个转帐的功能，一共需要开启五个事务，这5个事务就会有与数据库使用jdbc技术（步骤1新建链接，2，链接数据库3.准备数据库执行语句，4，开始执行，5，返回结果6，结果处理，7，释放链接） 但是如果中间有出现异常的话，就会造成异常之前的事务处理成功，异常之后的事务执行失败，其根本原因是这个转账业务应该同一写到统一的线程中，由线程进行创建链接，全局...
AOP 自定义注解
最新发布
tianzhiya_ts的专栏
09-10 432
自定义注释实现记录请求耗时和转换返回值格式
AOP概念的引入，相关的概念，AOP技术
m0_61983575的博客
02-20 294
首先我们来看一下登录的原理 如上图所示这是一个基本的登录原理图，但是如果我们想要在这个登录之上添加一些新的功能，比如权限校验 那么我们能想到的就有两种方法： ①：通过对源代码的修改实现 ②：不通过修改源代码方式添加新的功能 （AOP） ​​​​​​ 1. AOP的概述 什么是AOP的技术？ 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程 AOP是一种编程范式，隶属于软工范畴，指导开发者如何组织程序结构 AOP最早由A...
spring aop引入功能
weixin_43931625的博客
04-23 323
spring aop引入功能
Spring| AOP之 引入(Introductions)
YvesHe的专栏
06-28 1440
在看此文章之前，你可能已经知道了，Spring是通过Before、After、AfterRunning、AfterThrowing以及Around 共5中通知方式为目标方法增加切面功能，比如一个需要在目标类执行一个目标方法之前和之后分别打印一份日志，就可以建立一个切面在这个方法前后打印日志。 但是如果我想在此目标类中再增加一个目标方法是，该怎么办呢？ 最简单的办法就是在建立此目标类的时候，增加此方...
spring-aop-5.2.6.RELEASE.jar
02-27
java运行依赖jar包
spring_aop.rar_spring_aop
09-19
Spring AOP，全称为Aspect-Oriented Programming（面向切面编程），是Spring框架的重要组成部分，它为Java应用程序提供了强大的横切关注点管理能力。在Java Web开发中，Spring AOP通常用于实现如日志记录、权限控制...
spring-boot aop
01-23
1. **引入依赖**：在`pom.xml`或`build.gradle`文件中添加Spring AOP和AspectJ的依赖。对于Maven，添加以下依赖： ```xml <groupId>org.springframework.boot <artifactId>spring-boot-starter-aop ``` 2. ...
spring之AOP（动态代理）
09-06
首先，我们需要引入Spring AOP和AspectJ的依赖，这通常在pom.xml或build.gradle文件中完成。然后，我们可以定义一个切面（Aspect），它包含通知（Advice）——即在特定连接点执行的代码。通知可以是前置通知（Before...
Spring 引入式AOP
qq_44562459的博客
04-14 125
package cn.com.spring.springAop; /** 目标切点类 / public interface Performance { /* 目标切点方法 */ public void perform(); } package cn.com.spring.springAop; import org.springframework.stereotype.Component; /** 目标切点的实现类 */ @Component public class PerformanceImp
Spring AOP 的引入(一)
qq_26837711的博客
11-19 242
假设有这么一个需求 在执行计算的时候，给控制台答应的格式为 begain  method  with [ args1,args2 ]  end method with result 看看原来的代码： 接口：ArithmethicCalculator  package com.dxf.ArithmethicCalculator; public int
spring-AOP引入
怕秃头的潘s的博客
11-06 316
定义接口 package com.abc.service; public interface ISomeService {    public void first();    public void second();     } 实现类 package com.abc.service; public class SomeServiceImpl implemen
Spring AOP（五）AOP的引入
DDLoveWorld的博客
02-18 1039
转载自 https://blog.csdn.net/Sadlay/article/details/83478481 AOP的引入 引入就是在一个接口的基础上引入新的接口增强功能。 在上一篇博客中测试AOO的时候，我们打印了用户信息，如果用户信息为空，则抛出异常。 事实上，我们还可以检测用户信息是否为空，如果为空则不再打印，这样就没有异常产生了。 但现有的UserService接口并没有提供这样的功...
Spring 引入式AOP 实例
我是xxxx
07-24 322
Spring 引入式AOP 实例 package cn.com.chujie.spring.springAop; /** * 目标切点类 */ public interface Performance { /** * 目标切点方法 */ public void perform(); } package cn.com.chujie.spring.spri...
【spring】AOP引入的使用与源码分析
morris
04-09 5596
通知是对目标对象方法的增强，而引入可以动态为目标对象实现新的接口，实现对类的增强。 引入的使用 目标类 public class DogService { public void hi() { System.out.println("wangwang"); } } 增强接口 public interface CatService { void eat(); } 增强接口实现类 public class CatServiceImpl implements CatService { @Overr
Spring--AOP-引入
赵亚兰的博客
05-27 416
Spring3.0 AOP 教程：简单DEMO
为了运行这个DEMO，你需要配置Spring的AOP支持，并确保引入了Spring、Commons Logging、AspectJ以及aopalliance相关的依赖库。在Eclipse中，你可以创建一个Java项目或者Web项目，然后将这些类和配置文件添加进去，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值