spring事务失效的几种场景以及原因-低调大师

spring事务失效的几种场景以及原因

2022-03-01 654

前言

spring事务失效场景可能大家在很多文章都看过了，所以今天就水一篇，看大家能不能收获一些不一样的东西。直接进入主题

spring事务失效场景以及原因

1、场景一：service没有托管给spring

public class TranInvalidCaseWithoutInjectSpring {

    private UserService userService;

    public TranInvalidCaseWithoutInjectSpring(UserService userService) {
        this.userService = userService;
    }

    @Transactional
    public boolean add(User user){
        boolean isSuccess = userService.save(user);
        int i = 1 % 0;
        return isSuccess;
    }
}

    @Test
    public void testServiceWithoutInjectSpring(){
        boolean randomBoolean = new Random().nextBoolean();
        TranInvalidCaseWithoutInjectSpring tranInvalidCaseWithoutInjectSpring;
        if(randomBoolean){
            tranInvalidCaseWithoutInjectSpring = applicationContext.getBean(TranInvalidCaseWithoutInjectSpring.class);
            System.out.println("service已经被spring托管");
        }else{
            tranInvalidCaseWithoutInjectSpring = new TranInvalidCaseWithoutInjectSpring(userService);
            System.out.println("service没被spring托管");
        }

        boolean isSuccess = tranInvalidCaseWithoutInjectSpring.add(user);
        Assert.assertTrue(isSuccess);

    }

失效原因： spring事务生效的前提是，service必须是一个bean对象 解决方案： 将service注入spring

2、场景二：抛出受检异常

@Service
public class TranInvalidCaseByThrowCheckException {

    @Autowired
    private UserService userService;


    @Transactional
    public boolean add(User user) throws FileNotFoundException {
        boolean isSuccess = userService.save(user);
        new FileInputStream("1.txt");
        return isSuccess;
    }
    }

 @Test
    public void testThrowCheckException() throws Exception{
        boolean randomBoolean = new Random().nextBoolean();
        boolean isSuccess = false;
        TranInvalidCaseByThrowCheckException tranInvalidCaseByThrowCheckException = applicationContext.getBean(TranInvalidCaseByThrowCheckException.class);
        if(randomBoolean){
            System.out.println("配置@Transactional(rollbackFor = Exception.class)");
            isSuccess = tranInvalidCaseByThrowCheckException.save(user);
        }else{
            System.out.println("配置@Transactional");
            tranInvalidCaseByThrowCheckException.add(user);
        }

        Assert.assertTrue(isSuccess);

    }

失效原因： spring默认只会回滚非检查异常和error异常 解决方案： 配置rollbackFor

3、场景三：业务自己捕获了异常

 @Transactional
    public boolean add(User user) {
        boolean isSuccess = userService.save(user);
        try {
            int i = 1 % 0;
        } catch (Exception e) {

        }
        return isSuccess;
    }

  @Test
    public void testCatchExecption() throws Exception{
        boolean randomBoolean = new Random().nextBoolean();
        boolean isSuccess = false;
        TranInvalidCaseWithCatchException tranInvalidCaseByThrowCheckException = applicationContext.getBean(TranInvalidCaseWithCatchException.class);
        if(randomBoolean){
            randomBoolean = new Random().nextBoolean();
            if(randomBoolean){
                System.out.println("将异常原样抛出");
                tranInvalidCaseByThrowCheckException.save(user);
            }else{
                System.out.println("设置TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();");
                tranInvalidCaseByThrowCheckException.addWithRollBack(user);
            }
        }else{
            System.out.println("业务自己捕获了异常");
            tranInvalidCaseByThrowCheckException.add(user);
        }

        Assert.assertTrue(isSuccess);

    }

失效原因： spring事务只有捕捉到了业务抛出去的异常，才能进行后续的处理，如果业务自己捕获了异常，则事务无法感知 解决方案： 1、将异常原样抛出； 2、设置TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();

4、场景四：切面顺序导致

@Service
public class TranInvalidCaseWithAopSort {

    @Autowired
    private UserService userService;

    @Transactional
    public boolean save(User user) {
        boolean isSuccess = userService.save(user);
        try {
            int i = 1 % 0;
        } catch (Exception e) {
            throw new RuntimeException();
        }
        return isSuccess;
    }



}

@Aspect
@Component
@Slf4j
public class AopAspect {


    @Around(value = " execution (* com.github.lybgeek.transcase.aopsort..*.*(..))")
    public Object around(ProceedingJoinPoint pjp){

        try {
            System.out.println("这是一个切面");
           return pjp.proceed();
        } catch (Throwable throwable) {
            log.error("{}",throwable);
        }

        return null;
    }
}

失效原因： spring事务切面的优先级顺序最低，但如果自定义的切面优先级和他一样，且自定义的切面没有正确处理异常，则会同业务自己捕获异常的那种场景一样 解决方案： 1、在切面中将异常原样抛出； 2、在切面中设置TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();

5、场景五：非public方法

@Service
public class TranInvalidCaseWithAccessPerm {

        @Autowired
        private UserService userService;

        @Transactional
        protected boolean save(User user){
            boolean isSuccess = userService.save(user);
            try {
                int i = 1 % 0;
            } catch (Exception e) {
                throw new RuntimeException();
            }
            return isSuccess;
        }

}

public class TranInvalidCaseWithAccessPermTest {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(Application.class);
        TranInvalidCaseWithAccessPerm tranInvalidCaseWithAccessPerm = context.getBean(TranInvalidCaseWithAccessPerm.class);
        boolean isSuccess = tranInvalidCaseWithAccessPerm.save(UserUtils.getUser());

        System.out.println(isSuccess);

    }
}

失效原因： spring事务默认生效的方法权限都必须为public

解决方案： 1、将方法改为public； 2、修改TansactionAttributeSource,将publicMethodsOnly改为false【这个从源码跟踪得出结论】 3、开启 AspectJ 代理模式【从spring文档得出结论】

文档如下

Method visibility and @Transactional When using proxies, you should apply the @Transactional annotation only to methods with public visibility. If you do annotate protected, private or package-visible methods with the @Transactional annotation, no error is raised, but the annotated method does not exhibit the configured transactional settings. Consider the use of AspectJ (see below) if you need to annotate non-public methods.

具体步骤：

1、在pom引入aspectjrt坐标以及相应插件

<dependency>
	<groupId>org.aspectj</groupId>
	<artifactId>aspectjrt</artifactId>
	<version>1.8.9</version>
</dependency>

<plugin>
	<groupId>org.codehaus.mojo</groupId>
	<artifactId>aspectj-maven-plugin</artifactId>
	<version>1.9</version>
	<configuration>
		<showWeaveInfo>true</showWeaveInfo>
		<aspectLibraries>
			<aspectLibrary>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aspects</artifactId>
			</aspectLibrary>
		</aspectLibraries>
	</configuration>
	<executions>
		<execution>
			 <goals>
              <goal>compile</goal>       <!-- use this goal to weave all your main classes -->
              <goal>test-compile</goal>  <!-- use this goal to weave all your test classes -->
            </goals>
		</execution>
	</executions>
</plugin>

2、在启动类上加上如下配置

@EnableTransactionManagement(mode = AdviceMode.ASPECTJ)

注：如果是在idea上运行，则需做如下配置

4、直接用TransactionTemplate

示例：

    @Autowired
    private TransactionTemplate transactionTemplate;

    private void process(){
        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus status) {
                processInTransaction();
            }
        });

    }

6、场景六：父子容器

失效原因： 子容器扫描范围过大，将未加事务配置的serivce扫描进来

解决方案： 1、父子容器个扫个的范围； 2、不用父子容器，所有bean都交给同一容器管理

注：因为示例是使用springboot，而springboot启动默认没有父子容器,只有一个容器，因此就该场景就演示示例了

7、场景七：方法用final修饰

    @Transactional
    public final boolean add(User user, UserService userService) {
        boolean isSuccess = userService.save(user);
        try {
            int i = 1 % 0;
        } catch (Exception e) {
            throw new RuntimeException();
        }
        return isSuccess;
    }

失效原因： 因为spring事务是用动态代理实现，因此如果方法使用了final修饰，则代理类无法对目标方法进行重写，植入事务功能

解决方案： 1、方法不要用final修饰

8、场景八：方法用static修饰

  @Transactional
    public static boolean save(User user, UserService userService) {
        boolean isSuccess = userService.save(user);
        try {
            int i = 1 % 0;
        } catch (Exception e) {
            throw new RuntimeException();
        }
        return isSuccess;
    }

失效原因： 原因和final一样

解决方案： 1、方法不要用static修饰

9、场景九：调用本类方法

   public boolean save(User user) {
        return this.saveUser(user);
    }

    @Transactional
    public boolean saveUser(User user) {
        boolean isSuccess = userService.save(user);
        try {
            int i = 1 % 0;
        } catch (Exception e) {
            throw new RuntimeException();
        }
        return isSuccess;
    }

失效原因： 本类方法不经过代理，无法进行增强

解决方案： 1、注入自己来调用； 2、使用@EnableAspectJAutoProxy(exposeProxy = true) + AopContext.currentProxy()

10、场景十：多线程调用

 @Transactional(rollbackFor = Exception.class)
    public boolean save(User user) throws ExecutionException, InterruptedException {

        Future<Boolean> future = executorService.submit(() -> {
            boolean isSuccess = userService.save(user);
            try {
                int i = 1 % 0;
            } catch (Exception e) {
                throw new Exception();
            }
            return isSuccess;
        });
        return future.get();


    }

失效原因： 因为spring的事务是通过数据库连接来实现，而数据库连接spring是放在threadLocal里面。同一个事务，只能用同一个数据库连接。而多线程场景下，拿到的数据库连接是不一样的，即是属于不同事务

11、场景十一：错误的传播行为

 @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public boolean save(User user) {
        boolean isSuccess = userService.save(user);
        try {
            int i = 1 % 0;
        } catch (Exception e) {
            throw new RuntimeException();
        }
        return isSuccess;
    }

失效原因： 使用的传播特性不支持事务

12、场景十二：使用了不支持事务的存储引擎

失效原因： 使用了不支持事务的存储引擎。比如mysql中的MyISAM

13、场景十三：数据源没有配置事务管理器

注：因为springboot，他默认已经开启事务管理器。org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration。因此示例略过

14、场景十四：被代理的类过早实例化

@Service
public class TranInvalidCaseInstantiatedTooEarly implements BeanPostProcessor , Ordered {

    @Autowired
    private UserService userService;


    @Transactional
    public boolean save(User user) {
        boolean isSuccess = userService.save(user);
        try {
            int i = 1 % 0;
        } catch (Exception e) {
            throw new RuntimeException();
        }
        return isSuccess;
    }

    @Override
    public int getOrder() {
        return 1;
    }
}

失效原因： 当代理类的实例化早于AbstractAutoProxyCreator后置处理器，就无法被AbstractAutoProxyCreator后置处理器增强

总结

本文列举了14种spring事务失效的场景，其实这14种里面有很多都是归根结底都是属于同一类问题引起，比如因为动态代理原因、方法限定符原因、异常类型原因等

demo链接

https://github.com/lyb-geek/springboot-learning/tree/master/springboot-transaction-invalid-case

微信关注我们

原文链接：https://my.oschina.net/u/4494662/blog/5468690

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

OAuthApp v1.3.1 更新

2022-3-1 更新如下 1，增加了服务器文件管理 2，应用用户统计UI 更新 —————————————————————————————————— OAuthApp H5云开发、托管工具 https://www.oauthapp.com/tenant 1， H5云空间 - 支持一键发布本地H5项目到云空间（无需下载，网页直接发布） - 可设定独立二级目录 - 支持版本回滚 - 灵活的自定义开发（参考开发文档） 2，CDN/文件存储 - 应用文件管理 - 国内CDN 3，数据库 - 独立数据库 - Json存储操作方式 4，用户池 - 独立用户池，多渠道接入（微信，小程序，网页等可自定义） 5，排行榜 - 可快速搭建H5小游戏排行榜，问卷调查系统具体可查看开发文档https://web.oauthapp.com/4/docs/ 6，支持开通二级站点（独立数据库）地址：www.oauthapp.com

2022-03-01

555

1、vuex简介 1、定义在vue项⽬中，每个组件的数据都有其独⽴的作⽤域。当组件间需要跨层级或者同层之间频繁传递的时候，数据交互就会⾮常繁琐。vuex的主要作⽤就是集中管理所有组件的数据和状态以及规范数据修改的⽅式。官方解释：Vuex 是⼀个专为 Vue.js 应⽤程序开发的状态管理模式。它采⽤集中式存储管理应⽤的所有组件的状态，并以相应的规则保证状态以⼀种可预测的⽅式发⽣变化。 2、使用场景⼀般来讲，是以项⽬中的数据交互复杂程度来决定的。具体包括以下场景：项⽬组件间数据交互不频繁，组件数量较少：不使⽤状态管理项⽬组件间数据交互频繁，但组件数量较少：使⽤eventBus或者vue store解决项⽬组件间数据交互频繁，组件数量较多：vuex解决 3、核心原理分析 // a.vue <h1>{{ username }}</h1> // b.vue <h2> {{ username }} </h2> /** * 如果 username 需要在每个组件都获取一次，是不是很麻烦，虽然可以通过共同的父级传入，但是...

2022-03-01

596

资源下载

更多资源

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。