Spring事务传播属性

最新推荐文章于 2021-05-02 13:44:31 发布
最新推荐文章于 2021-05-02 13:44:31 发布
阅读量194 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cgm625637391/article/details/114490194
版权

参考文献

Spring事务传播属性和隔离级别 https://www.cnblogs.com/eunice-sun/p/11024584.html

spring事务传播机制总结 https://blog.csdn.net/m18330808841/article/details/109543815

spring boot @Transactional注解事务不回滚不起作用无效 https://blog.csdn.net/zdyueguanyun/article/details/80236401?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.control&dist_request_id=&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.control

正文

扫盲示例

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.12.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo-order</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo-order</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.26</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>
</project>

application.properties

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test
spring.datasource.username=root
spring.datasource.password=root

App.java

package com.example.demoorder;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class App {
    public static void main(String[] args) {
        SpringApplication.run(App.class, args);
    }
}

UserController.java

package com.example.demoorder;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {
    @Autowired
    private ServiceA serviceA;

    @GetMapping("/a")
    public void a() {
        serviceA.methodA();
    }
}

UserService.java

package com.example.demoorder;

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

@Service
public class UserService {
    @Autowired
    private UserMapper mapper;

    //什么都不写时，默认为Propagation.REQUIRED
    @Transactional(propagation = Propagation.REQUIRED)
    public void methodA() {
        System.out.println("methodA");
        mapper.saveA(11, "aa");
        int i = 1 / 0;
    }

    public void methodB() {
        System.out.println("methodB");
        mapper.saveB(22, "bb");
    }
}

UserMapper.java

package com.example.demoorder;

import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;

@Mapper
@Repository
public interface UserMapper {
    @Insert("insert into a (id,name) values (#{id},#{name})")
    public void saveA(@Param("id") Integer id, @Param("name") String name);

    @Insert("insert into b (id,name) values (#{id},#{name})")
    public void saveB(@Param("id") Integer id, @Param("name") String name);
}

ServiceA.java

package com.example.demoorder;

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

@Service
public class ServiceA {
    @Autowired
    private UserMapper mapper;
    //@Autowired
    //private ServiceB serviceB;

    @Transactional(propagation = Propagation.REQUIRED)
    public void methodA() {
        System.out.println("methodA");
        mapper.saveA(11, "aa");
        //serviceB.methodB();
        int i = 1 / 0;
    }
}

ServiceB.java

package com.example.demoorder;

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

@Service
public class ServiceB {
    @Autowired
    private UserMapper mapper;

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void methodB() {
        System.out.println("methodB");
        mapper.saveB(22, "bb");
    }
}

测试：浏览器输入 127.0.0.1:8080/a 

a表回滚成功

示例1：

Propagation.REQUIRED
1.如果前面的方法已经创建了事务，那么后面的方法加入这个已存在的事务

package com.example.demoorder;

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

@Service
public class ServiceA {
    @Autowired
    private UserMapper mapper;
    @Autowired
    private ServiceB serviceB;

    @Transactional(propagation = Propagation.REQUIRED)
    public void methodA() {
        System.out.println("methodA");
        mapper.saveA(11, "aa");
        serviceB.methodB();
    }
}

package com.example.demoorder;

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

@Service
public class ServiceB {
    @Autowired
    private UserMapper mapper;

    @Transactional(propagation = Propagation.REQUIRED)
    public void methodB() {
        System.out.println("methodB");
        mapper.saveB(22, "bb");
        int i = 1 / 0;
    }
}

测试：调用methodA()方法，发现a和b表都回滚成功。

2.如果前面的方法没有创建事务，那么后面的方法会新建一个事务.

package com.example.demoorder;

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

@Service
public class ServiceA {
    @Autowired
    private UserMapper mapper;
    @Autowired
    private ServiceB serviceB;
    
    public void methodA() {
        System.out.println("methodA");
        mapper.saveA(11, "aa");
        serviceB.methodB();
    }
}

package com.example.demoorder;

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

@Service
public class ServiceB {
    @Autowired
    private UserMapper mapper;

    @Transactional(propagation = Propagation.REQUIRED)
    public void methodB() {
        System.out.println("methodB");
        mapper.saveB(22, "bb");
        int i = 1 / 0;
    }
}

测试：调用methodA()方法，发现b表回滚成功，但是a表没有回滚。

示例2：Propagation.SUPPORTS
1如果当前存在事务，则加入当前事务

package com.example.demoorder;

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

@Service
public class ServiceA {
    @Autowired
    private UserMapper mapper;
    @Autowired
    private ServiceB serviceB;

    @Transactional(propagation = Propagation.REQUIRED)
    public void methodA() {
        System.out.println("methodA");
        mapper.saveA(11, "aa");
        serviceB.methodB();
    }
}

package com.example.demoorder;

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

@Service
public class ServiceB {
    @Autowired
    private UserMapper mapper;

    @Transactional(propagation = Propagation.SUPPORTS)
    public void methodB() {
        System.out.println("methodB");
        mapper.saveB(22, "bb");
        int i = 1 / 0;
    }
}

测试：调用methodA()方法，发现a和b表都回滚成功。
2如果当前没有事务，就以非事务方法执行

package com.example.demoorder;

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

@Service
public class ServiceA {
    @Autowired
    private UserMapper mapper;
    @Autowired
    private ServiceB serviceB;
    
    public void methodA() {
        System.out.println("methodA");
        mapper.saveA(11, "aa");
        serviceB.methodB();
    }
}

package com.example.demoorder;

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

@Service
public class ServiceB {
    @Autowired
    private UserMapper mapper;

    @Transactional(propagation = Propagation.SUPPORTS)
    public void methodB() {
        System.out.println("methodB");
        mapper.saveB(22, "bb");
        int i = 1 / 0;
    }
}

测试：调用methodA()方法，发现a和b表都不回滚。

示例3：Propagation.MANDATORY
1当前存在事务，则加入当前事务，

package com.example.demoorder;

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

@Service
public class UserService {
    @Autowired
    private UserMapper mapper;

    @Transactional(propagation = Propagation.REQUIRED)
    public void methodA() {
        System.out.println("methodA");
        mapper.saveA(11, "aa");
        methodB();
    }

    @Transactional(propagation = Propagation.MANDATORY)
    public void methodB() {
        System.out.println("methodB");
        mapper.saveB(22, "bb");
        int i = 1 / 0;
    }
}

测试：调用methodA()方法，发现a和b表都回滚成功。
2如果当前事务不存在，则抛出异常。

package com.example.demoorder;

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

@Service
public class ServiceA {
    @Autowired
    private UserMapper mapper;
    @Autowired
    private ServiceB serviceB;
    
    public void methodA() {
        System.out.println("methodA");
        mapper.saveA(11, "aa");
        serviceB.methodB();
    }
}

package com.example.demoorder;

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

@Service
public class ServiceB {
    @Autowired
    private UserMapper mapper;

    @Transactional(propagation = Propagation.MANDATORY)
    public void methodB() {
        System.out.println("methodB");
        mapper.saveB(22, "bb");
        int i = 1 / 0;
    }
}

测试：调用methodA()方法，发现a表不回滚，methodB()方法进不来，也不打印methodB字符串。

示例4 ： Propagation.REQUIRES_NEW

在执行时，不论当前是否存在事务，总是会新建一个事务。

package com.example.demoorder;

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

@Service
public class ServiceA {
    @Autowired
    private UserMapper mapper;
    @Autowired
    private ServiceB serviceB;
    @Transactional(propagation = Propagation.REQUIRED)
    public void methodA() {
        System.out.println("methodA");
        mapper.saveA(11, "aa");
        serviceB.methodB();
        int i = 1 / 0;
    }
}

package com.example.demoorder;

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

@Service
public class ServiceB {
    @Autowired
    private UserMapper mapper;

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void methodB() {
        System.out.println("methodB");
        mapper.saveB(22, "bb");

    }
}

测试：调用methodA()方法，发现a表回滚，b表插入数据库成功，b表不回滚

示例5 ：Propagation.NOT_SUPPORTED

在执行时，不论当前是否存在事务，都会以非事务的方式运行。

package com.example.demoorder;

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

@Service
public class ServiceA {
    @Autowired
    private UserMapper mapper;
    @Autowired
    private ServiceB serviceB;
    @Transactional(propagation = Propagation.REQUIRED)
    public void methodA() {
        System.out.println("methodA");
        mapper.saveA(11, "aa");
        serviceB.methodB();
    }
}

package com.example.demoorder;

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

@Service
public class ServiceB {
    @Autowired
    private UserMapper mapper;

    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public void methodB() {
        System.out.println("methodB");
        mapper.saveB(22, "bb");
        int i = 1 / 0;
    }
}

测试：调用methodA()方法，发现a表回滚，b表不回滚

示例6 ：Propagation.NEVER

就是我这个方法不使用事务，并且调用我的方法也不允许有事务，如果调用我的方法有事务则我直接抛出异常。

package com.example.demoorder;

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

@Service
public class ServiceA {
    @Autowired
    private UserMapper mapper;
    @Autowired
    private ServiceB serviceB;
    @Transactional(propagation = Propagation.REQUIRED)
    public void methodA() {
        System.out.println("methodA");
        mapper.saveA(11, "aa");
        serviceB.methodB();
    }
}

package com.example.demoorder;

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

@Service
public class ServiceB {
    @Autowired
    private UserMapper mapper;

    @Transactional(propagation = Propagation.NEVER)
    public void methodB() {
        System.out.println("methodB");
        mapper.saveB(22, "bb");
        int i = 1 / 0;
    }
}

测试：调用methodA()方法，发现a表回滚，ServiceB的methodB不执行，不打印methodB字符串

示例7 ：Propagation.NESTED

如果当前事务不存在，则像 Propagation.REQUIRED开启一个新事物
如果当前事务存在，则在嵌套事务中执行。嵌套事务一个非常重要的概念就是内层事务依赖于外层事务。外层事务失败时，会回滚内层事务所做的动作。而内层事务操作失败并不会引起外层事务的回滚。

package com.example.demoorder;

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

@Service
public class ServiceA {
    @Autowired
    private UserMapper mapper;
    @Autowired
    private ServiceB serviceB;

    public void methodA() {
        System.out.println("methodA");
        mapper.saveA(11, "aa");
        serviceB.methodB();
    }
}

package com.example.demoorder;

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

@Service
public class ServiceB {
    @Autowired
    private UserMapper mapper;

    @Transactional(propagation = Propagation.NESTED)
    public void methodB() {
        System.out.println("methodB");
        mapper.saveB(22, "bb");
        int i = 1 / 0;
    }
}

测试：调用methodA()方法，发现a表不回滚，b表回滚

package com.example.demoorder;

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

@Service
public class ServiceA {
    @Autowired
    private UserMapper mapper;
    @Autowired
    private ServiceB serviceB;

    @Transactional(propagation = Propagation.REQUIRED)
    public void methodA() {
        System.out.println("methodA");
        mapper.saveA(11, "aa");
        try {
            serviceB.methodB();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package com.example.demoorder;

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

@Service
public class ServiceB {
    @Autowired
    private UserMapper mapper;

    @Transactional(propagation = Propagation.NESTED)
    public void methodB() {
        System.out.println("methodB");
        mapper.saveB(22, "bb");
        int i = 1 / 0;
    }
}

测试：调用methodA()方法，发现a表不回滚，b表回。因为调用方catch了被调方的异常，所以只有子事务回滚了。

package com.example.demoorder;

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

@Service
public class ServiceA {
    @Autowired
    private UserMapper mapper;
    @Autowired
    private ServiceB serviceB;
    @Transactional(propagation = Propagation.REQUIRED)
    public void methodA() {
        System.out.println("methodA");
        mapper.saveA(11, "aa");
        serviceB.methodB();
        int i = 1 / 0;
    }
}

package com.example.demoorder;

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

@Service
public class ServiceB {
    @Autowired
    private UserMapper mapper;

    @Transactional(propagation = Propagation.NESTED)
    public void methodB() {
        System.out.println("methodB");
        mapper.saveB(22, "bb");
    }
}

测试：调用methodA()方法，发现a表回滚，b表回滚
 

spring事务传播属性
weixin_40187126的博客
02-04 1198
/** 1在不同类中(方法事务 第一个方法(有) 第二个方法(无) 第三个方法(有)) Propagation propagation() default Propagation.REQUIRED; 传播属性 serviceA(有事务) serviceB(无) serviceC(有事务) updateBeansA调用updateBeansB调用updateBeansC updateBeansA() updateBeansB() updateBeansC() *事务名称 com.ex
Spring 事务管理高级应用难点剖析
sam
05-29 538
http://www.ibm.com/developerworks/cn/java/j-lo-spring-ts1/index.html   http://www.ibm.com/developerworks/cn/education/opensource/os-cn-spring-trans/index.html    事务方法嵌套调用的迷茫 Spring 事务一个被讹传很广说法是：一
Spring 事务传播属性
Pluto的专栏
07-08 698
Propagation behaviorWhat it meansPROPAGATION_MANDATORYIndicates that the method must run within a transaction. If no existing transaction is in progress, an exception wil
Spring事务的传播特性和隔离级别
梅鹏同學的专栏
01-31 875
事务的几种传播特性 1. PROPAGATION_REQUIRED: 如果存在一个事务，则支持当前事务。如果没有事务则开启 2. PROPAGATION_SUPPORTS: 如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行 3. PROPAGATION_MANDATORY: 如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常。 4. PROPAGATION_
Spring的事务传播属性
jieshaowang1229的专栏
12-24 724
Spring的事务传播属性，可以选择以下几个取值，具体的取值含义如下： Never：指定业务方法绝对不能在事务范围内执行。如果业务方法在某个事务中执行，容器会抛出例外只有业务方法没有关联到任何事务，才能正常执行。 MANDATORY：该属性指定业务方法只能在一个已经存在的事务中执行，业务方法不能发起自己的事务。如果业务方法在没有事务的环境下调用，容器就会抛出例外。
Spring事务传播属性和隔离级别详细介绍
08-29
Spring事务传播属性和隔離级别详细介绍 Spring事务传播属性（Propagation）是指在事务中如何处理事务边界的规则。它定义了事务如何与其他事务进行交互，例如是否支持当前事务、创建新的事务、抛出异常等。 1. ...
Spring中事务的传播属性详解
03-11
本文将详细介绍Spring中的事务传播属性，并通过具体的例子来解释每种传播行为的特点。 #### 二、事务传播属性概述 事务传播行为（Propagation）定义了当一个事务方法被另一个事务方法调用时的行为。在Spring中，...
Spring事务传播属性详解：七种模式实战应用
`ServiceA`中有一个方法`methodA()`，当调用`ServiceB`的`methodB()`时，我们可以通过设置`methodB`的事务传播属性来调整其行为。 - 如果`methodB`设置为`PROPAGATION_REQUIRED`，当`methodA`在事务中执行时，`...
Spring的事务的传播属性
uk8692的专栏
05-18 502
Spring事务有7种传播属性： 1.PROPAGATION_REQUIRED：如果存在一个事务，则支持当前事务。如果没有事务则开启一个新的事务。 2.PROPAGATION_SUPPORTS：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。 3.PROPAGATION_MANDATORY：支持当前事务，如果当前没有事务，就抛出异常。 4.PROPAGATION_REQUIRES_NEW...
spring事务的传播性
weixin_45295678的博客
05-02 921
spring事务的传播性 1、事务的传播性 研究的是多个事务存在时的处理策略 1）REQUIRED：如果存在一个事务，则支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。 2）SUPPORTS：如果存在一个事务，支持当前事务，如果当前没有事务，就以非事务方式执行。 3）MANDATORY：如果存在一个事务，支持当前事务，如果当前没有事务，就抛出异常。 4）REQUIRES_NEW：新建事务，如果当前存在事务，把当前事务挂起。 5）NOT_SUPPORTED：以非事务方式执行操作，如果当前存在
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

cgm625637391

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

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

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

打赏作者

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

抵扣说明：

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

余额充值