Spring引入AOP

最新推荐文章于 2024-06-16 17:48:49 发布
最新推荐文章于 2024-06-16 17:48:49 发布
阅读量821 收藏
点赞数
分类专栏： 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
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring AOP 引入jar包，spring IOC 引入Jar包
09-07
Spring AOP 和 Spring IOC 是 Spring 框架的两个核心组件，它们对于任何基于 Java 的企业级应用开发都至关重要。Spring AOP（面向切面编程）允许开发者在不修改源代码的情况下，通过“切面”来插入新的行为或增强已...
Spring 入门AOP材料
02-13
1. **导入依赖**：确保你的项目中已经引入了Spring AOP相关的依赖，例如`spring-aop`和`aspectjrt`。 2. **定义切面**：创建一个类，并使用`@Aspect`注解标记为切面。在这个类中，你可以定义切入点表达式和通知。 ...
Spring Aop的引入
weixin_42067668的博客
03-28 838
介绍为什么要用到Aop， 在我们以前的开发中，加入一个转帐的功能，一共需要开启五个事务，这5个事务就会有与数据库使用jdbc技术（步骤1新建链接，2，链接数据库3.准备数据库执行语句，4，开始执行，5，返回结果6，结果处理，7，释放链接） 但是如果中间有出现异常的话，就会造成异常之前的事务处理成功，异常之后的事务执行失败，其根本原因是这个转账业务应该同一写到统一的线程中，由线程进行创建链接，全局...
AOP概念的引入，相关的概念，AOP技术
m0_61983575的博客
02-20 253
首先我们来看一下登录的原理 如上图所示这是一个基本的登录原理图，但是如果我们想要在这个登录之上添加一些新的功能，比如权限校验 那么我们能想到的就有两种方法： ①：通过对源代码的修改实现 ②：不通过修改源代码方式添加新的功能 （AOP） ​​​​​​ 1. AOP的概述 什么是AOP的技术？ 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程 AOP是一种编程范式，隶属于软工范畴，指导开发者如何组织程序结构 AOP最早由A...
Spring高手之路20——深入理解@EnableAspectJAutoProxy的力量
最新发布
卓越无关环境，保持空杯心态——靡不有初，鲜克有终
06-16 1万+
本文详细探讨了Spring框架中的面向切面编程（AOP），特别是通过@EnableAspectJAutoProxy注解来启用和配置AOP的详细过程。从基本的AOP概念介绍到高级配置技巧，文章全面解析了如何在Spring应用中有效地使用AOP来增强代码的模块化和重用性。通过深入的代码示例和解释，本文不仅帮助初学者理解Spring AOP的基础，也使得经验丰富的开发者能够精通其高级特性和性能优化方法。
Spring的依赖注入和AOP使用详解
qq_49195366的博客
10-18 1192
Spring的依赖注入和AOP使用详解
JavaSpring-AOP详解（Maven导入 深入浅出）
Garson的博客
10-07 2846
在CSDN上看了很多关于配置AOP的文章，不是很复杂就是省略了很多步骤。本文用最简单并且最清晰的方法从导入依赖到AOP底层原理。逐步讲解SpringAOP的相关操作帮你快速了解AOP。
spring的AOP
UserGuan的博客
08-19 265
使用注解的方式 spring-aop-annotation-beans.xml配置文件 User实体类 UserDao层 UserDaoImpl UserDaoStaticProxyImpl UserService层 UserServiceImpl UserController层 LogInfo类 LogInfoNote类 AspectLog类 GetAspectLog类 ...
spring_aop.rar_spring_aop
09-19
Spring AOP，全称为Aspect-Oriented Programming（面向切面编程），是Spring框架的重要组成部分，它为Java应用程序提供了强大的横切关注点管理能力。在Java Web开发中，Spring AOP通常用于实现如日志记录、权限控制...
Spring aop.docx
12-14
**Spring AOP 入门** 在深入探讨Spring AOP之前，我们先理解AOP（面向切面编程）的概念。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. ...
在 SpringBoot 中引入 aop 切面编程
new_baibai的博客
05-20 512
SpringBoot 引入 AOP 切面
Spring 引入式AOP 实例
我是xxxx
07-24 308
Spring 引入式AOP 实例 package cn.com.chujie.spring.springAop; /** * 目标切点类 */ public interface Performance { /** * 目标切点方法 */ public void perform(); } package cn.com.chujie.spring.spri...
Spring导入AOP的依赖/引入命名空间
Denial_learn的博客
11-07 5770
导入AOP依赖 <!-- https://mvnrepository.com/artifact/org.springframework/spring-aop --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aop</...
SpringBoot项目中使用AOP
weixin_34273046的博客
02-18 326
为什么80%的码农都做不了架构师？>>> ...
Spring AOP详细介绍
热门推荐
JinXYan的博客
04-14 7万+
什么是AOP AOP（Aspect-OrientedProgramming，面向切面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的关系，...
Spring–添加AOP支持
最佳 Java 编程
05-12 570
我听到了一个有关一位高级（且酬劳颇丰）软件工程师的故事。 他的任务是记录他正在研究的项目中每个控制器中的每个方法。 工程师重写了所有控制器方法，因此使用如下代码： @RequestMapping(method = RequestMethod.GET) public String showEmployees(Model model) { List<Empl...
spring aop 示例（引入）
weixin_43931625的博客
09-24 248
springaop 引入 作用：为现有的类添加新的方法 ******************************************************* 使用示例 为HelloService的实现类添加新的方法 ************************************ service层 public interface...
Spring注解原理的详细剖析与实现
hongweigg的专栏
05-25 5448
Spring注解原理的详细剖析与实现 本文主要分为三部分： 一、 注解的基本概念和原理及其简单实用 二、 spring中如何使用注解 三、 编码剖析spring@Resource的实现原理 一、注解的基本概念和原理及其简单实用 注解（Annotation）提供了一种安全的类似注释的机制，为我们在代码中添加信息提供了一种形式化得方法，使我们可以在稍后某个时刻方便的使用这些数据
spring aop aopalliance
08-07
在Spring框架中，将AOP联盟的接口以内嵌的形式放到了spring-aop包中，同时也引入了springframework包来实现AOP切面编程思想。Spring AOP的最小拦截粒度是方法级别，它通过拦截连接点（即方法）来实现对方法的增强。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值