Spring事务管理

最新推荐文章于 2024-05-24 08:30:00 发布
原创 最新推荐文章于 2024-05-24 08:30:00 发布 · 4.1k 阅读 · 3 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
博客探讨了在Spring中，使用@Transactional时同一个类内不兼容事务方法调用导致的UnexpectedRollbackException，并介绍了Spring的声明式事务管理，包括配置方式和一个实际应用示例。

@Transactional 同一个类中无事务方法a()内部调用有事务方法b()的问题

Methods should not call same-class methods with incompatible "@Transactional" values

When using Spring proxies, calling a method in the same class (e.g. this.aMethod()) with an incompatible @Transactional requirement will result in runtime exceptions because Spring only "sees" the caller and makes no provisions for properly invoking the callee.

Therefore, certain calls should never be made within the same class:

FromTo
non-@TransactionalMANDATORY, NESTED, REQUIRED, REQUIRES_NEW
MANDATORYNESTED, NEVER, NOT_SUPPORTED, REQUIRES_NEW
NESTEDNESTED, NEVER, NOT_SUPPORTED, REQUIRES_NEW
NEVERMANDATORY, NESTED, REQUIRED, REQUIRES_NEW
NOT_SUPPORTEDMANDATORY, NESTED, REQUIRED, REQUIRES_NEW
REQUIRED or @TransactionalNESTED, NEVER, NOT_SUPPORTED, REQUIRES_NEW
REQUIRES_NEWNESTED, NEVER, NOT_SUPPORTED, REQUIRES_NEW
SUPPORTSMANDATORY, NESTED, NEVER, NOT_SUPPORTED, REQUIRED, REQUIRES_NEW

Noncompliant Code Example

@Override
public void doTheThing() {
  // ...
  actuallyDoTheThing();  // Noncompliant
}

@Override
@Transactional
public void actuallyDoTheThing() {
  // ...
}

org.springframework.transaction.UnexpectedRollbackException: Transaction rolled back because it has been marked as rollback-only

org.springframework.transaction.UnexpectedRollbackException: Transaction rolled back because it has been marked as rollback-only↵ at org.springframework.transaction.support.AbstractPlatformTransactionManager.commit(AbstractPlatformTransactionManager.java:724)↵ at org.springframework.transaction.interceptor.TransactionAspectSupport.commitTransactionAfterReturning(TransactionAspectSupport.java:518)↵ at org.springframework.transaction.interceptor.TransactionAspectSupport.invokeWithinTransaction(TransactionAspectSupport.java:292)↵ at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:96)↵ at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)↵ at org.springframework.aop.aspectj.MethodInvocationProceedingJoinPoint.proceed(MethodInvocationProceedingJoinPoint.java:97)↵ at com.chanjet.paas.common.base.interceptor.ExceptionInterceptor.around(ExceptionInterceptor.java:63)↵ at sun.reflect.GeneratedMethodAccessor85.invoke(Unknown Source)↵ at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)↵ at java.lang.reflect.Method.invoke(Method.java:498)↵ at org.springframework.aop.aspectj.AbstractAspectJAdvice.invokeAdviceMethodWithGivenArgs(AbstractAspectJAdvice.java:629)↵ at org.springframework.aop.aspectj.AbstractAspectJAdvice.invokeAdviceMethod(AbstractAspectJAdvice.java:618)↵ at org.springframework.aop.aspectj.AspectJAroundAdvice.invoke(AspectJAroundAdvice.java:70)↵ at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:168)↵ at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:92)↵ at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)↵ at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:673)↵

Spring事务分类

Spring 提供了两种事务管理方式：声明式事务管理和编程式事务管理。

 

图解SPRING事务

声明式事务

配置方式

注：以下配置代码参考自Spring事务配置的五种方式

根据代理机制的不同，总结了五种Spring事务的配置方式，配置文件如下：

1、每个Bean有一个代理

2、所有Bean共享一个代理基类
3、使用拦截器
4、使用tx标签配置拦截器
<!-- 事务管理 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
   <property name="dataSource" ref="dataSource" />
</bean>
<!-- 使用annotation定义事务 -->
<tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true" />

<aop:config>
   <aop:advisor pointcut="execution(* com.*.*.event.local.service.*.*(..))" advice-ref="txAdviceLocalEvent"/>
</aop:config>

<tx:advice id="txAdviceLocalEvent">
   <tx:attributes>
      <tx:method name="update*"/>
      <tx:method name="add*"/>
      <tx:method name="del*"/>
      <tx:method name="*" read-only="true"/>
   </tx:attributes>
</tx:advice>
5、全注解方式

一个声明式事务的实例

注：该实例参考自Spring中的事务管理实例详解

首先是数据库表 
book(isbn, book_name, price) 
account(username, balance) 
book_stock(isbn, stock)

然后是XML配置

<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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

    <import resource="applicationContext-db.xml" />

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

    <tx:annotation-driven transaction-manager="txManager"/>

    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>

</beans>

使用的类 
BookShopDao

package com.springinaction.transaction;

public interface BookShopDao {
    // 根据书号获取书的单价
    public int findBookPriceByIsbn(String isbn);
    // 更新书的库存，使书号对应的库存-1
    public void updateBookStock(String isbn);
    // 更新用户的账户余额：account的balance-price
    public void updateUserAccount(String username, int price);
}

BookShopDaoImpl

package com.springinaction.transaction;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository("bookShopDao")
public class BookShopDaoImpl implements BookShopDao {

    @Autowired
    private JdbcTemplate JdbcTemplate;

    @Override
    public int findBookPriceByIsbn(String isbn) {
        String sql = "SELECT price FROM book WHERE isbn = ?";

        return JdbcTemplate.queryForObject(sql, Integer.class, isbn);
    }

    @Override
    public void updateBookStock(String isbn) {
        //检查书的库存是否足够，若不够，则抛出异常
        String sql2 = "SELECT stock FROM book_stock WHERE isbn = ?";
        int stock = JdbcTemplate.queryForObject(sql2, Integer.class, isbn);
        if (stock == 0) {
            throw new BookStockException("库存不足！");
        }
        String sql = "UPDATE book_stock SET stock = stock - 1 WHERE isbn = ?";
        JdbcTemplate.update(sql, isbn);
    }

    @Override
    public void updateUserAccount(String username, int price) {
        //检查余额是否不足，若不足，则抛出异常
        String sql2 = "SELECT balance FROM account WHERE username = ?";
        int balance = JdbcTemplate.queryForObject(sql2, Integer.class, username);
        if (balance < price) {
            throw new UserAccountException("余额不足！");
        }       
        String sql = "UPDATE account SET balance = balance - ? WHERE username = ?";
        JdbcTemplate.update(sql, price, username);
    }

}

BookShopService

package com.springinaction.transaction;
public interface BookShopService {
     public void purchase(String username, String isbn);
}

BookShopServiceImpl

package com.springinaction.transaction;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Service("bookShopService")
public class BookShopServiceImpl implements BookShopService {

    @Autowired
    private BookShopDao bookShopDao;

    /**
     * 1.添加事务注解
     * 使用propagation 指定事务的传播行为，即当前的事务方法被另外一个事务方法调用时如何使用事务。
     * 默认取值为REQUIRED，即使用调用方法的事务
     * REQUIRES_NEW：使用自己的事务，调用的事务方法的事务被挂起。
     *
     * 2.使用isolation 指定事务的隔离级别，最常用的取值为READ_COMMITTED
     * 3.默认情况下 Spring 的声明式事务对所有的运行时异常进行回滚，也可以通过对应的属性进行设置。通常情况下，默认值即可。
     * 4.使用readOnly 指定事务是否为只读。 表示这个事务只读取数据但不更新数据，这样可以帮助数据库引擎优化事务。若真的是一个只读取数据库值得方法，应设置readOnly=true
     * 5.使用timeOut 指定强制回滚之前事务可以占用的时间。
     */
    @Transactional(propagation=Propagation.REQUIRES_NEW,
            isolation=Isolation.READ_COMMITTED,
            noRollbackFor={UserAccountException.class},
            readOnly=true, timeout=3)
    @Override
    public void purchase(String username, String isbn) {
        //1.获取书的单价
        int price = bookShopDao.findBookPriceByIsbn(isbn);
        //2.更新书的库存
        bookShopDao.updateBookStock(isbn);
        //3.更新用户余额
        bookShopDao.updateUserAccount(username, price);
    }
}

Cashier

package com.springinaction.transaction;
import java.util.List;
public interface Cashier {
    public void checkout(String username, List<String>isbns);
}

CashierImpl：CashierImpl.checkout和bookShopService.purchase联合测试了事务的传播行为

package com.springinaction.transaction;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service("cashier")
public class CashierImpl implements Cashier {
    @Autowired
    private BookShopService bookShopService;

    @Transactional
    @Override
    public void checkout(String username, List<String> isbns) {
        for(String isbn : isbns) {
            bookShopService.purchase(username, isbn);
        }
    }
}

BookStockException


package com.springinaction.transaction;
public class BookStockException extends RuntimeException {

    private static final long serialVersionUID = 1L;

    public BookStockException() {
        super();
        // TODO Auto-generated constructor stub
    }

    public BookStockException(String arg0, Throwable arg1, boolean arg2,
            boolean arg3) {
        super(arg0, arg1, arg2, arg3);
        // TODO Auto-generated constructor stub
    }

    public BookStockException(String arg0, Throwable arg1) {
        super(arg0, arg1);
        // TODO Auto-generated constructor stub
    }

    public BookStockException(String arg0) {
        super(arg0);
        // TODO Auto-generated constructor stub
    }

    public BookStockException(Throwable arg0) {
        super(arg0);
        // TODO Auto-generated constructor stub
    }
}

UserAccountException

package com.springinaction.transaction;
public class UserAccountException extends RuntimeException {

    private static final long serialVersionUID = 1L;

    public UserAccountException() {
        super();
        // TODO Auto-generated constructor stub
    }

    public UserAccountException(String arg0, Throwable arg1, boolean arg2,
            boolean arg3) {
        super(arg0, arg1, arg2, arg3);
        // TODO Auto-generated constructor stub
    }

    public UserAccountException(String arg0, Throwable arg1) {
        super(arg0, arg1);
        // TODO Auto-generated constructor stub
    }

    public UserAccountException(String arg0) {
        super(arg0);
        // TODO Auto-generated constructor stub
    }

    public UserAccountException(Throwable arg0) {
        super(arg0);
        // TODO Auto-generated constructor stub
    }
}

测试类

package com.springinaction.transaction;

import java.util.Arrays;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTransitionTest {

    private ApplicationContext ctx = null;
    private BookShopDao bookShopDao = null;
    private BookShopService bookShopService = null;
    private Cashier cashier = null;
    {
        ctx = new ClassPathXmlApplicationContext("config/transaction.xml");
        bookShopDao = ctx.getBean(BookShopDao.class);
        bookShopService = ctx.getBean(BookShopService.class);
        cashier = ctx.getBean(Cashier.class);
    }

    @Test
    public void testBookShopDaoFindPriceByIsbn() {
        System.out.println(bookShopDao.findBookPriceByIsbn("1001"));
    }

    @Test
    public void testBookShopDaoUpdateBookStock(){
        bookShopDao.updateBookStock("1001");
    }

    @Test
    public void testBookShopDaoUpdateUserAccount(){
        bookShopDao.updateUserAccount("AA", 100);
    }
    @Test
    public void testBookShopService(){
        bookShopService.purchase("AA", "1001");
    }

    @Test
    public void testTransactionPropagation(){
        cashier.checkout("AA", Arrays.asList("1001", "1002"));
    }
}
@Transactional 注解使用场景详细说明包括（不生效的场景，事务回滚）
daralisdan的博客
08-30 1350
@Transactional 注解使用场景详细说明包括（不生效的场景，事务回滚）
SpringSource Blog是一个资源丰富的平台，它包含了Springsource Tool Suite 2.0入门教程
[Blog][Domain] programb.blog.csdn.net
05-17 1329
它是专门为Spring框架设计的，提供了丰富的Spring框架功能，如自动依赖注入（DI）、配置管理和Spring Boot项目的快速构建。：它预装有Spring项目的模板，简化了新项目创建的过程，减少了配置工作，直接从Eclipse的上下文中运行Spring应用。：随着Spring Boot的兴起，STS也提供了对Spring Boot项目的良好支持，便于开发者构建现代微服务架构的应用。：作为Spring官方的一部分，STS得到了Spring社区的强大支持，更新及时，文档详细。
事物处理@Transactional
weixin_33989780的博客
01-10 422
@Transactional 加于private方法, 无效 @Transactional 加于未加入接口的public方法, 再通过普通接口方法调用, 无效 @Transactional 加于接口方法, 无论下面调用的是private或public方法, 都有效 @Transactional 加于接口方法后, 被本类普通接口方法直接调用, 无效 @Transactional 加于接口...
Java事务踩坑
tmax52HZ的博客
09-28 1704
Java事务采坑记录
spring事务失效的原因与场景
qq_41884972的博客
01-26 347
spring事务失效的原因与场景 Spring的事务在什么样的情况下会失效？ 1底层数据库不支持事务 如MySQL的MyISAM 引擎是不支持事务操作的，如果底层使用MySQL数据库和MyISAM 引擎。那么spring事务事务管理会失效。 2没有被spring管理 如下面例子所示： // @Service public class OrderServiceImpl implements OrderService { @Transactional public void updateOrde
【Spring】Spring的事务管理
m0_62645012的博客
01-08 2030
该接口是Spring提供平台事务管理器，主要用于管理事务状态事务TransactionStatus getTransaction(TransactionDefinition definition)：获取事务的状态信息void commit(TransactionStatus status)：用于提交事务void rollback(TransactionStatus status)：用于回滚事务该接口并不了解具体实现类，常用如下。
【Spring】— Spring的事务管理
衍生星球的博客
05-06 3198
Spring的事务管理简化了传统的事务管理流程，并且在一定程度上减少了开发者的工作量。
Spring事务管理总结
qq_42961888的博客
10-27 679
Spring事务管理机制概述 Spring事务管理模块主要包括3个接口 PlatformTransactionManager：事务管理器，主要用于平台相关的事务管理。 TransactionDefinition：事务定义信息(隔离级别、传播、超时、只读)通过配置如何进行事务管理。 TransactionStatus：事务具体运行状态——事务管理过程中，每个时间点事务的状态信息。 1、Platf...
Spring 事务管理机制概述
热门推荐
Rico's Blogs
06-26 3万+
用户的每次请求都对应一个业务逻辑方法，而一个业务逻辑方法往往包括一系列数据库原子访问操作，并且这些操作应绑定成一个事务来执行。使用传统事务编程策略时，程序代码必然和具体的事务操作代码耦合，而Spring事务管理策略可以避免这种尴尬。Spring提供了两种事务管理方式：编程式事务管理和声明式事务管理，本文在对Spring事务管理API分析的基础上，详细地阐述了Spring编程式事务管理和声明式事务管理的原理、本质和使用
【Spring】Spring事务管理
wosixiaokeai的博客
05-24 1125
1.1简介Spring框架内部使用事务管理器的接口，来完成commit和rollback针对不同的框架，提供不同的实现类1.2ACID属性。
SonarLint 默认扫描规则
全盛
09-08 2万+
请看原文：原文链接：https://blog.csdn.net/jiaomubai/article/details/116596868 在平时写代码的时候，为了代码规范和减少 bug 的数量，使用 SonarLint 插件进行代码检查无疑是一个很好的方法。Sonar 是一个用于代码质量管理的开源平台，用来管理源代码的质量，通过插件的形式支持包括 Java、C++、C语言等多种编程语言的代码质量管理与检测。 Sonar 从以下七个维度来进行代码质量的检测： 不遵循代码标准：Sonar 可以通过 PMD、
透过现象看原理：详解 Spring 中 Bean 的 this 调用导致 AOP 失效的原因
qq_39951411的博客
05-18 1759
前言在我们使用Spring时，可能有前辈教导过我们，在bean中不要使用this来调用被@Async、@Transactional、@Cacheable等注解标注的方法，this下注解是不生效的。那么大家可曾想过以下问题为何致this调用的方法，注解会不生效这些注解生效的原理又是什么如果确实需要调用本类方法，且还需要注解生效，该怎么做？代理是否可以做到this调用注解就直接生效？通过本文，上面...
【Spring】Spring Framework Reference Documentation中文版35
kingdz618的博客
08-07 1569
40. Classic Spring AOP Usage 经典的spring的AOP使用   In this appendix we discuss the lower-level Spring AOP APIs and the AOP support used in Spring 1.2 applications. For new applications, we recommend th
Sonar Java默认的扫描规则
兴趣是最好的老师
09-09 6730
Sonar Java默认的扫描规则
spring 事物 关于在同一个类中一个方法调用另一个方法，事物的传播行为会失效
u011186019的专栏
05-06 1万+
spring 提供了强大的事物管理机制，直接到在方法或者类上加@Transactional，也可以使用XML配置事物。在一次的测试中发现当一个方法在同一个类被其它方法调用的时候，导致事物的传播行为不生效。具体说明：类结构:public class Demo { public void methodA() { this.methodB(); } public void metho...
Spring - 基本用法参考
Happy博客
01-28 1684
位于包 com.alibaba.spring:spring-context-support 下用于处理自定义注解。如果使用「自定义注解」注解了属性或者方法，并且需要创建对象将其设置到属性或者方法入参，可以继承AbstractAnnotationBeanPostProcessor，并实现doGetInjectedBean 以创建需要注入的对象。
Sonar安全扫描代码规则
weixin_44188105的博客
03-21 3836
Sonar安全扫描代码规则
Sonar Java默认扫描规则
yiyijianxian的博客
08-07 9177
规则如下： ".equals()" should not be used to test the values of "Atomic" classes：equals()方法不应该用在原子类型的数据上（如：AtomicInteger, AtomicLong, AtomicBoolean）. "=+" should not be used instead of "+="："=+"不可以替代 “+=”. "==" and "!=" should not be used when "equals" is ov
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

江晓曼*凡云基地

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

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

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

打赏作者

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

抵扣说明：

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

余额充值