从事务问题分析SpringAop

最新推荐文章于 2025-09-07 20:32:33 发布
最新推荐文章于 2025-09-07 20:32:33 发布
阅读量119 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： java postman
原文链接：https://juejin.im/post/5b82682d51882542d63b3440
博客围绕项目中数据初始化时的事务问题展开。用Postman调用接口，发现listUser方法中调用insertUser方法事务未开启，异常不回滚。经分析，Spring事务由AOP和动态代理实现，最终发现从Spring中获取代理对象调用insertUser方法，事务可生效并回滚。
前些月在项目中碰到个关于事务的问题，今天抽空来整理了一波，简单分享下。
  • 情况描述：大家在项目中应该都会碰到初始化某些数据的问题，有些会采用没有数据则插入的方式。
    • 这个时候大家可能会很自然的在select方法中直接this.insert方法，咋一看由于默认的事务传播级别是PROPAGATION_REQUIRED(如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务)，没有开启事务的listUser方法中调用开启了事务的insertUser方法是不会存在事务的问题。但是实际结果是insertUser方法中事务并没有开启。
  • 代码片段：

    @RestController
@RequestMapping("/user")
public class UserController {

    @Resource
    private UserService userService;

    @GetMapping("/listUser")
    public void listUser() throws Exception {
        userService.listUser();
    }

    @GetMapping("/insertDefault")
    public void insertDefault() throws Exception {
        User user = new User("XiaMu", "123456");
        System.out.println(userService.hashCode());
        userService.insertUser(user);
    }
}

@Service
public class UserServiceImpl implements UserService {

    @Resource
    private UserDao userDao;

    @Override
    public void listUser() throws Exception {
        List<User> users = userDao.listUser();
        if (users.isEmpty()) {
            User user = new User("XiaMu", "123456");
            this.insertUser(user);
        }
    }

    @Override
    @Transactional
    public void insertUser(User user) throws Exception {
        userDao.insertUser(user);
        throw new RuntimeException();
    }
}复制代码

这个时候用postman调用/user/listUser，出现了异常但是并没有回滚



  • 原因分析：
  1. spring中的事务是由aop实现的，spring中的aop又是由动态代理实现的，这个时候我们从这两方面去思考这个问题
  2. 将数据删除，在两个方法头部加上如下代码再次运行一次查看打印的信息

@Override
public void listUser() throws Exception {
    // 得到上一个栈帧的信息(方法调用处)
    StackTraceElement stack = (StackTraceElement)Thread.currentThread().getStackTrace()[2];
    System.out.println("调用类名:" + stack.getClassName() + " 调用方法名:" + stack.getMethodName());
    System.out.println("this:" + this.getClass());
    List<User> users = userDao.listUser();
    if (users.isEmpty()) {
        User user = new User("XiaMu", "123456");
        this.insertUser(user);
    }
}

@Override
@Transactional
public void insertUser(User user) throws Exception {
    // 得到上一个栈帧的信息(方法调用处)
    StackTraceElement stack = (StackTraceElement)Thread.currentThread().getStackTrace()[2];
    System.out.println("调用类:" + stack.getClassName() + " 调用方法名:" + stack.getMethodName());
    userDao.insertUser(user);
    throw new RuntimeException();
}复制代码

依旧没有事务，我们可以发现listUser的调用处是一个代理类的invoke方法。在listUser方法中打印的this是userServiceImpl对象，insertUser方法调用处正是userServiceImpl的方法。

调用类:com.xiamu.springboot.service.impl.UserServiceImpl$$FastClassBySpringCGLIB$$8ae4e401 调用方法名:invoke
this:class com.xiamu.springboot.service.impl.UserServiceImpl
调用类:com.xiamu.springboot.service.impl.UserServiceImpl 调用方法名:listUser复制代码

这个时候我们直接用postman调用/user/insertDefault，发现方法调用也是在代理类的invoke方法，并且事务生效了

调用类:com.xiamu.springboot.service.impl.UserServiceImpl$$FastClassBySpringCGLIB$$8ae4e401 调用方法名:invoke
复制代码

我们发现在这个代理类中调用insert方法时是有事务的，那么问题是不是在于list方法中的insert()并不是由代理类调用呢，再做次实验将list方法中的this.insertUser()改为下面这种方式

UserServiceImpl serviceImpl = SpringUtil.getBean("userServiceImpl");
serviceImpl.insertUser(user);复制代码

结果发现我们从spring中拿出来的userServiceImpl就是一个代理对象，并且此时有了事务并回滚了。

调用类名:com.xiamu.springboot.service.impl.UserServiceImpl$$FastClassBySpringCGLIB$$8ae4e401 调用方法名:invoke
this:class com.xiamu.springboot.service.impl.UserServiceImpl
调用类名:com.xiamu.springboot.service.impl.UserServiceImpl$$FastClassBySpringCGLIB$$8ae4e401 调用方法名:invoke
复制代码

 至此已经可以确定是由于SpringAop导致的问题，在list方法中使用this.insertUser()调用是直接使用了userServiceImpl对象，并不是增强后的代理对象。
  • SpringAop的分析：
SpringAop使用了动态代理实现，有JDK动态代理（需要实现接口）和Cglib代理（在运行期间生成的代理对象是针对目标类扩展的子类）两种方式。Spring中使用动态代理的规则如下，config.isOptimize()与config.isProxyTargetClass()都是配置项(网上都说默认是false false,我这个demo使用的是springboot2.0，Debug时发现生成userServiceImpl代理对象时，第二个配置为true)，hasNoUserSuppliedProxyInterfaces()判断代理的对象是否实现了接口。没有实现接口默认使用Cglib

public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
    // 判断是使用JDK动态代理还是Cglib
    if (!config.isOptimize() && !config.isProxyTargetClass() && !this.hasNoUserSuppliedProxyInterfaces(config)) {
        return new JdkDynamicAopProxy(config);
    } else {
        Class<?> targetClass = config.getTargetClass();
        if (targetClass == null) {
            throw new AopConfigException("TargetSource cannot determine target class: Either an interface or a target is required for proxy creation.");
        } else {
            return (AopProxy)(!targetClass.isInterface() && !Proxy.isProxyClass(targetClass) ? new ObjenesisCglibAopProxy(config) : new JdkDynamicAopProxy(config));
        }
    }
}

private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {
    Class<?>[] ifcs = config.getProxiedInterfaces();
    return ifcs.length == 0 || ifcs.length == 1 && SpringProxy.class.isAssignableFrom(ifcs[0]);
}复制代码

调用通过Cglib代理生成的对象中的方法会被CglibAopProxy中的intercept方法拦截。在这个方法中this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);是用来获取拦截链的，如果拦截链是空的则直接调用原对象的方法(所以在这个Demo中service中方法调用对象是代理对象，打印this发现是原对象)。像是我们在service中加上的@Transactional就会在这个拦截链中，后续在invokeWithinTransaction()方法中会为我们初始化平台事务管理器等相关配置、开启事务、提交或回滚事务等操作(代码就不分析了看不太懂@-@)

// 拦截所有目标类方法的调用
@Nullable
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
    Object oldProxy = null;
    boolean setProxyContext = false;
    Object target = null;
    TargetSource targetSource = this.advised.getTargetSource();

    Object var16;
    try {
        if (this.advised.exposeProxy) {
            oldProxy = AopContext.setCurrentProxy(proxy);
            setProxyContext = true;
        }

        target = targetSource.getTarget();
        Class<?> targetClass = target != null ? target.getClass() : null;
        // 获取的拦截器,返回一个拦截链
        List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
        Object retVal;
        if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
            Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
            retVal = methodProxy.invoke(target, argsToUse);
        } else {
            retVal = (new CglibAopProxy.CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy)).proceed();
        }

        retVal = CglibAopProxy.processReturnType(proxy, target, method, retVal);
        var16 = retVal;
    } finally {
        if (target != null && !targetSource.isStatic()) {
            targetSource.releaseTarget(target);
        }

        if (setProxyContext) {
            AopContext.setCurrentProxy(oldProxy);
        }

    }

    return var16;
}复制代码
摸着石头过河，如果有讲的有问题的地方欢迎大家指出。


Spring事务传播级别
zengjyxxz的博客
06-01 421
主流数据库隔离级别： 未提交读（隔离事务的最低级别，只能保证不读取物理上损坏的数据） 已提交读（数据库引擎的默认级别） 可重复读 可序列化（隔离事务的最高级别，事务之间完全隔离） 主流数据库默认隔离级别： mysql默认的事务处理级别是’REPEATABLE-READ’,也就是可重复读。 oracle数据库支持READ COMMITTED 和 SERIALIZABLE这两种事务隔离级别。 sql server 默认系统事务隔离级别是read committed,也就是读已提交。 传播行为（pragation
Spring AOP 源码剖析
LHY537200的博客
08-08 1375
Spring AOP通过动态代理技术提供了一种灵活的方式来增强现有方法的功能，而无需修改源代码。其源码实现涉及Bean生命周期管理、动态代理技术、责任链模式等多个方面，深入理解这些机制有助于更好地使用和维护Spring AOP。
Spring——事务与AOP
hwp_ing的博客
11-13 577
我们调用了UserService中的test方法，首先Spring会检查其存在@transactional注解，存在就生成代理对象关闭自动提交等操作。在调用原来对象的test方法，但是原来对象中test方法调用了a（）方法，由于员对象不是代理对象，所以a（）方法上的@transactional注解是无效的。此时的UserServiceBase.a()中存在@transactional注解，也会产生代理对象来执行方法。AOP的原理是在bean的生命周期是实现了beanPostProcessor接口。
java增删改查service_面试—机试：用springboot写出简单的增删改查（controller层，service层，dao层，配置，依赖）...
weixin_39853131的博客
02-28 740
@TOC 框架：springboot 数据源：druid 数据库：mysqlcontroller层@Controller@RequestMapping("/user")public class UserController {@Autowiredprivate UserService userService;//增@RequestMapping("/insertUser")public void ...
用springboot写出简单的增删改查（controller层，service层，dao层，配置，依赖）
m0_57050876的博客
10-18 5893
用springboot写出简单的增删改查（controller层，service层，dao层，配置，依赖） 框架：springboot 数据源：druid 数据库：mysql controller层 @Controller @RequestMapping("/user") public class UserController { @Autowired private UserService userService; //增 @RequestMapping("/insertUser") public voi
Mybatis实践教程（四）-数据添加
路人甲的专栏
06-11 420
需求：添加一条用户信息至t_user表中 需求：添加一条用户信息至t_user表中 我们在上一章节的代码中继续增加代码 UserService接口增加添加数据的方法 int insertUser(User user); UserServiceImpl增加实现方法 @Override public int insertUser(User user) { return...
《从理论到实战：Spring AOP深度剖析》
09-04
内容概要：本文深入剖析了Spring AOP（面向切面编程）的核心概念、实现方式与实际应用。首先介绍了AOP的基本概念、核心术语（如切面、通知、切入点、连接点和目标对象）及其在日志记录、权限控制、事务管理、性能...
Spring AOP剖析
12-15
在Spring框架中，AOP主要用于实现非业务逻辑，将这些关注点从核心业务代码中解耦出来，使得代码更加模块化，易于维护。 1. **切面（Aspect）**：切面是关注点的模块化，比如日志、事务管理等。在Spring AOP中，切面...
springAop.rar_AOP java_cglib_spring aop
09-21
在提供的压缩包文件中，"www.pudn.com.txt"可能是下载来源的说明或者包含一些额外的信息，而"springAop"可能是一个包含Spring AOP示例代码的文件。对于学习和理解Spring AOP以及CGLIB的用法，分析这个文件的内容将...
深度剖析Spring AOP源码，图文详解，小白也能看明白。
Java技术攻略的博客
03-13 2489
AOP 的全称是 “Aspect Oriented Programming”，即⾯向切⾯编程。在 AOP 的思想⾥⾯，周边功能（⽐如性能统计，⽇志，事务管理等）被定义为切⾯，核⼼功能和切⾯功能分别独 ⽴进⾏开发，然后把核⼼功能和切⾯功能“编织”在⼀起，这就叫 AOP。AOP 能够将那些与业务⽆关，却为业务模块所共同调⽤的逻辑封装起来，便于减少系统的重复代码，降低模块间的 耦合度，并有利于未来的可拓展性和可维护性。我们再⼩节⼀下，⽂章先介绍了什么是 AOP，以及 AOP 的原理和示例。
SpringBoot+Mybatis实现用户账号CRUD系统+前后端交互(含源码)
一个爱运动的程序员的博客
08-25 8103
文章目录一、实现基于mybatis实现CRUD功能二、验证码与前端的基础实现三、前后端的交互1、前后交互之创建账号2、前后交互之数据库数据传入前端显示3、前后交互之修改密码4、前后交互之删除5、前后交互之权限区别登录四、小总结与源码获取 Mybatis-Spring地址 SpringBoot整合持久层框架有很多：例如SpringJDBC、Hibernate、Mybatis（这里SpringBoot整合Mybatis时，sql语句写在XML中，这种方式对于后期的维护、优化等方面可读性好，所以这里就不采用注解.
公开课：AOP
qq_28764557的博客
09-01 228
aop： 在运行的时候织入并且在初始化的时候织入 1.aop的应用 打开spring的官网： https://spring.io/projects/spring-framework#overview 术语的中英文介绍 中文： ...
aop学习笔记之代理模式（三）
zyb2017的博客
03-13 392
1 代理概念 织入的时机分三种： 1.编译期织入（Aspect） 2.类加载时织入（AspectJ 5+） 3.运行时织入（Spring AOP） 那如何实现运行时织入呢？通过代理。 上面这张图描述了调用方、代理对象、目标对象之间的关系，目标对象将自己托管给代理对象。比如当调用方发起请求执行目标对象中的方法，代理对象会响应并决定自己在其之前或之后执行相关动作，而原本目标对象该执行...
代理模式
qq_37834488的博客
02-09 345
静态代理 目标类：UserServiceImpl ，即：被代理的类 public class UserServiceImpl implements UserService{ //private UserDAO ud; @Override public void updateUser(User user){ System.out.println("update核心功能"); //核心功能 //System.out.println(...
Spring事务失效场景
weixiaohuai的博客
10-16 1766
目录 一、事务方法访问修饰符非public，导致事务失效 二、@Transactional注解的方法抛出的异常不是Spring的事务支持的异常，导致事务失效 三、数据表本身是不支持事务，导致事务失效 四、@Transactional注解所在的类没有被Spring管理，导致事务失效 五、catch掉异常之后，没有再次抛出异常，导致事务失效 六、方法自身（this）调用问题，导致事务失效 七、数据源没有配置事务管理器，导致事务失效 八、传播类型不支持事务，导致事务失效 九、多线程调用，导致
Redis客户端之Jedis，SpringBoot中使用StringRedisTemplate，通过注解的方式简单操作以及连接池的配置
javazht的博客
07-09 7788
简介： 其实就是一个基于java语言的redis-cli客户端。 Redis是一种运行在内存当中键值数据库，而且是以字符串类型为中心的，当前它能够支持多重数据类型，包括字符串， 散列，列表，集合，有序集合，基数和地理位置等。 在Spring项目当中使用Redis: 我们需要通过连接池创建一个RedisConnectionFactory对象，通过它我们就能够创建RedisConnec...
Spring源码学习（7）——AOP
weixin_34212189的博客
02-08 100
我们知道，使用面对对象编程的时候有一些弊端，当需要为多个不具有继承关系的对象引入同一个公共行为时，例如日志、安全检测等，所以就有了一个对面对对象编程的补充，即面对切面编程（AOP）,AOP所关注的方向是横向的，不同于OOP的纵向。 Spring2.0采用@AspectJ注解来定义一个包含切点信息和增强横切逻辑的切面，这样的方案比采用配置的方案要来得更方便。 那要支持注解方式的AOP，首先需要在...
二叉树的前中后序遍历(迭代法)
最新发布
mrjieke6的博客
09-07 1313
本文系统介绍了二叉树前序、中序和后序遍历的迭代实现方法。前序遍历采用栈结构，按;根→右→左 ;顺序入栈；中序遍历先全部左子树入栈再访问节点；后序遍历则通过修改前序遍历顺序为"根→右→左 ;后反转结果。三种遍历时间复杂度均为O(n)，空间复杂度最坏O(n)。与递归实现相比，迭代方法避免了栈溢出风险，处理大型树更稳定。每种遍历方式都配有详细代码解析、执行示例和复杂度分析，并讨论了实际应用场景，为掌握树结构操作提供了系统指导。
SpringAOP与Hibernate整合事务管理实践
【标题】:SpringAOP整合Hibernate并使用事务 【知识点详细解析】 1. Spring框架概述 Spring是一个开源的Java/Java EE全功能栈轻量级框架，提供了一个全面的企业级编程和配置模型。它以高度解耦、POJO（普通Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值