springboot+mybatis+mysql事务回滚

最新推荐文章于 2024-05-31 16:18:33 发布
最新推荐文章于 2024-05-31 16:18:33 发布
阅读量3.3k 收藏 14
点赞数 1
分类专栏： java 记录 文章标签： mysql spring boot java mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/study_zy/article/details/123049157
版权
本文详细介绍了Spring Boot中基于@Transactional的事务管理，包括默认的异常回滚规则，如何处理Checked异常，以及如何设置回滚点和自定义回滚策略。示例代码展示了在Service和Controller中不同异常处理方式对事务的影响，强调了事务回滚必须在@Transactional作用域内。同时，文章探讨了事务的隔离级别和传播行为，并提供了多种解决异常回滚问题的方法。
摘要由CSDN通过智能技术生成

1.介绍

参考：

对于mysql本质上是利用数据库回滚，表的引擎要InnoDB

使用各个版本如下

<?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.6.3</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.example</groupId>
	<artifactId>demo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>demo</name>
	<description>Demo project for Spring Boot</description>
	<!-- 打包配置 -->
	<packaging>jar</packaging>
	<properties>
		<java.version>1.8</java.version>
		<mysql-driver.version>8.0.28</mysql-driver.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>

		<!-- 热部署 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
			<optional>true</optional>
		</dependency>

		<!-- thymeleaf,for html,jsp... -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-thymeleaf</artifactId>
		</dependency>

		<!-- json -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.2.79</version>
		</dependency>

		<!-- mybatis -->
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>2.2.2</version>
		</dependency>

		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>

		<!-- 数据库连接池druid -->
		<!-- https://mvnrepository.com/artifact/com.alibaba/druid-spring-boot-starter -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid-spring-boot-starter</artifactId>
			<version>1.1.10</version>
		</dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>

		<!--
			redis
			springboot 2.x:默认用lettuce实现的
			springboot 1.x:默认用Jedis实现的

			springboot 2.x改用jedis，如下代码
			<dependency>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-starter-data-redis</artifactId>
				<exclusions>
					排除lettuce包
					<exclusion>
						<groupId>io.lettuce</groupId>
						<artifactId>lettuce-core</artifactId>
					</exclusion>
				</exclusions>
			</dependency>
			添加jedis客户端
			<dependency>
				<groupId>redis.clients</groupId>
				<artifactId>jedis</artifactId>
			</dependency>
		-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
		</dependency>
		<!-- redis使用pool -->
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-pool2</artifactId>
<!--			<version>2.11.1</version>-->
		</dependency>
    </dependencies>

	<build>
		<plugins>
			<!--
				运用SpringBoot 插件
				使用spring-boot-devtools模块的应用,
				当classpath中的文件有改变时，会自动重启！
			-->
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
				<!-- 不加版本号，会报红 -->
				<version>2.6.3</version>
			</plugin>

			<!-- mybatis-generator.start -->
			<plugin>
				<groupId>org.mybatis.generator</groupId>
				<artifactId>mybatis-generator-maven-plugin</artifactId>
				<version>1.3.5</version>
				<dependencies>
					<dependency>
						<groupId> mysql</groupId>
						<artifactId>mysql-connector-java</artifactId>
						<version>${mysql-driver.version}</version>
						<scope>runtime</scope>
					</dependency>
					<!--
                    <dependency>
                        <groupId>org.mybatis.generator</groupId>
                        <artifactId>mybatis-generator-core</artifactId>
                        <version>1.3.5</version>
                    </dependency>
                    -->
				</dependencies>
				<!--
                <executions>
                    <execution>
                        <id>Generate MyBatis Artifacts</id>
                        <phase>package</phase>
                        <goals>
                            <goal>generate</goal>
                        </goals>
                    </execution>
                </executions>
                -->
				<configuration>
					<!--允许移动生成的文件 -->
					<verbose>true</verbose>
					<!-- 是否覆盖 -->
					<!-- 此处要特别注意,如果不加这个设置会导致每次运行都会在原目录再次创建-->
					<overwrite>true</overwrite>
					<!-- generator 工具配置文件的位置 -->
					<configurationFile>
						src/main/resources/mybatis-generator.xml
					</configurationFile>
				</configuration>
			</plugin>
			<!-- mybatis-generator.end -->
		</plugins>
	</build>

</project>

2.默认情况，事务会在unchecked异常时回滚

2.1注意抛出异常要在@Transactional注解的类/方法中及其子方法

2.1.1Service

package com.demo.services;

import com.demo.models.mapper.AppadminMapper;
import com.demo.models.mapper.UserMapper;
import com.demo.models.po.User;
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;

import java.util.List;

@Service
public class UserService {

    //自动注入
    @Autowired
    private UserMapper userMapper;

    public User getUser(Integer id) {
        return userMapper.selectByPrimaryKey(id);
    }

    public int insertUser(User user) throws Exception {
        int count = userMapper.insert(user);
        if( count > 0){
            //这里抛出unchecked异常，会导致回滚
            throw new RuntimeException("测试uncheck异常导致回滚");
        }
        return count;
    }

    @Transactional
    public int insertUsers(List<User> userList) throws Exception {
        int count = 0;
        for(User user : userList){
            //调用子方法insertUser,将使用注解@Transactional定义的传播行为
            //insertUser方法没有定义传播行为，它会采用REQUIRED(默认)
            //也就是沿用当前的事务，所以它将与insertUsers方法使用同一个事务
            count += insertUser(user);
        }
        return count;
    }
}

2.1.2控制器

package com.demo.controllers;

import com.demo.models.po.User;
import com.demo.services.UserService;
import com.demo.utils.AjaxResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import java.util.Arrays;
import java.util.HashMap;

@RestController
@RequestMapping("/user")
public class UserController {
    //自动注入
    @Autowired
    private UserService service;
    
    /**
     * http://localhost:9000/demo/user/addlist
     * @param user
     * @return
     */
    @RequestMapping(value = "/addlist", method = RequestMethod.POST)
    public AjaxResult insertUsers(User user){
        try{
            int count = service.insertUsers(Arrays.asList(user));
            return AjaxResult.success("插入成功", new HashMap<String, Object>(){
                {
                    put("count", count);
                    put("user", user);
                }
            });
        }catch(Exception e){
            return AjaxResult.error(e.getMessage());
        }
    }
}

2.1.3测试类

package com.demo.controllers;

import com.alibaba.fastjson.JSON;
import com.demo.models.po.User;
import com.example.demo.DemoApplication;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.mock.web.MockHttpSession;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultHandlers;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.context.WebApplicationContext;

import javax.servlet.http.Cookie;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;

import static org.junit.Assert.*;

/**
 * 想要执行的时候，鼠标放在对应的方法，右键选择run该方法即可。
 */
@RunWith(SpringRunner.class)
//不写classes会报错：you need to use @ContextConfiguration or @SpringBootTest(classes=...) with your test
//classes指向启动类
@SpringBootTest(classes= DemoApplication.class)
public class UserControllerTest {
    @Autowired
    private WebApplicationContext wac;

    private MockMvc mvc;
    private MockHttpSession session;

    /**
     * 开始前，模拟登录
     */
    @Before
    public void setupMockMvc(){
        //初始化MockMvc对象
        mvc = MockMvcBuilders.webAppContextSetup(wac).build();
        session = new MockHttpSession();
        //拦截器那边会判断用户是否登录，所以这里注入一个用户
        session.setAttribute("user", "root");
    }

    /**
     * 注意url:这里url不必加上/demo(配置文件的二级目录server.servlet.context-path=/demo)
     * @throws Exception
     */
    @Test
    public void insertUser() throws Exception {
        MultiValueMap<String, String> params = new LinkedMultiValueMap<String, String>();
        params.add("id", "4");
        params.add("name", "test4");
        params.add("birthday", "2020-1-4");
        params.add("address", "测试城市4");

        String uri = "/user/addlist";
        String result = mvc.perform(MockMvcRequestBuilders.post(uri)
                //模拟cookie
                .cookie( new Cookie("token", "123456") )
                //模拟session
                .session(session)
                //主流浏览器如谷歌符合正常规范，不需要设置字符编码了,但考虑非主流浏览器，仍然保留
                .contentType(MediaType.APPLICATION_JSON_UTF8)
                .accept(MediaType.APPLICATION_JSON_UTF8)
                .params(params)

//                .contentType(MediaType.APPLICATION_JSON)
//                .content(paramsJSON)  //传过去为Null？？？？
          )
          .andExpect(MockMvcResultMatchers.status().is2xxSuccessful())
          .andDo(MockMvcResultHandlers.print())
          //返回请求的字符串信息
          .andReturn().getResponse().getContentAsString();


        Assert.assertEquals("调用成功","demo8-1",result);
    }

}

结果：回滚

2.2抛出异常不在@Transactional注解的类/方法中及其子方法

如果@Transactional在Service类，而在控制器抛出异常(不管是不是unchecked)都不会回滚

2.2.1控制器类

package com.demo.controllers;

import com.demo.models.po.User;
import com.demo.services.UserService;
import com.demo.utils.AjaxResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import java.util.Arrays;
import java.util.HashMap;

@RestController
@RequestMapping("/user")
public class UserController {
    //自动注入
    @Autowired
    private UserService service;
    
    /**
     * http://localhost:9000/demo/user/addlist
     * @param user
     * @return
     */
    @RequestMapping(value = "/addlist", method = RequestMethod.POST)
    public AjaxResult insertUsers(User user){
        try{
            int count = service.insertUsers(Arrays.asList(user));
            if( count>0 ){
                //不在注解方法及其子方法抛出异常,不会导致回滚
                throw new RuntimeException("测试uncheck异常不会导致回滚");
            }
            return AjaxResult.success("插入成功", new HashMap<String, Object>(){
                {
                    put("count", count);
                    put("user", user);
                }
            });
        }catch(Exception e){
            return AjaxResult.error(e.getMessage());
        }
    }
}

2.2.2Service

package com.demo.services;

import com.demo.models.mapper.AppadminMapper;
import com.demo.models.mapper.UserMapper;
import com.demo.models.po.User;
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;

import java.util.List;

@Service
public class UserService {

    //自动注入
    @Autowired
    private UserMapper userMapper;

    public User getUser(Integer id) {
        return userMapper.selectByPrimaryKey(id);
    }

    public int insertUser(User user) throws Exception {
        int count = userMapper.insert(user);
        return count;
    }

    @Transactional
    public int insertUsers(List<User> userList) throws Exception {
        int count = 0;
        for(User user : userList){
            //调用子方法insertUser,将使用注解@Transactional定义的传播行为
            //1.insertUser方法没有定义传播行为，它会采用REQUIRED(默认)
            //也就是沿用当前的事务，所以它将与insertUsers方法使用同一个事务
            count += insertUser(user);
        }
        return count;
    }
}

结果：不会回滚

3.默认情况下，遇到checked异常，则不会回滚

3.1Service

package com.demo.services;

import com.demo.models.mapper.AppadminMapper;
import com.demo.models.mapper.UserMapper;
import com.demo.models.po.User;
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;

import java.util.List;

@Service
public class UserService {

    //自动注入
    @Autowired
    private UserMapper userMapper;

    public User getUser(Integer id) {
        return userMapper.selectByPrimaryKey(id);
    }

    public int insertUser(User user) throws Exception {
        int count = userMapper.insert(user);
        if( count > 0){
            //check异常，不会导致回滚
            throw new Exception("测试check异常不会导致回滚");
        }
        return count;
    }

    @Transactional
    public int insertUsers(List<User> userList) throws Exception {
        int count = 0;
        for(User user : userList){
            //调用子方法insertUser,将使用注解@Transactional定义的传播行为
            //insertUser方法没有定义传播行为，它会采用REQUIRED(默认)
            //也就是沿用当前的事务，所以它将与insertUsers方法使用同一个事务
            count += insertUser(user);
        }
        return count;
    }
}

3.2控制器

package com.demo.controllers;

import com.demo.models.po.User;
import com.demo.services.UserService;
import com.demo.utils.AjaxResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import java.util.Arrays;
import java.util.HashMap;

@RestController
@RequestMapping("/user")
public class UserController {
    //自动注入
    @Autowired
    private UserService service;

    /**
     * http://localhost:9000/demo/user/addlist
     * @param user
     * @return
     */
    @RequestMapping(value = "/addlist", method = RequestMethod.POST)
    public AjaxResult insertUsers(User user){
        try{
            int count = service.insertUsers(Arrays.asList(user));
            return AjaxResult.success("插入成功", new HashMap<String, Object>(){
                {
                    put("count", count);
                    put("user", user);
                }
            });
        }catch(Exception e){
            return AjaxResult.error(e.getMessage());
        }
    }
}

结果：不会回滚

3.3解决方法1：设置回滚点

在@Transactional的类/方法及其子方法中设置回滚点，捕获checked异常后就回滚到回滚点

Service：

package com.demo.services;

import com.demo.models.mapper.AppadminMapper;
import com.demo.models.mapper.UserMapper;
import com.demo.models.po.User;
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;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.util.List;

@Service
public class UserService {

    //自动注入
    @Autowired
    private UserMapper userMapper;

    public User getUser(Integer id) {
        return userMapper.selectByPrimaryKey(id);
    }

    public int insertUser(User user) throws Exception {
        //插入不会回滚的id=5
        User noRollUser = new User();
        noRollUser.setId(5);
        noRollUser.setName("测试5");
        userMapper.insert(noRollUser);
        //设置回滚点
        Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
        try{
            int count = userMapper.insert(user);
            if( count > 0){
//            throw new RuntimeException("测试uncheck异常导致回滚");
                throw new Exception("测试check异常不会导致回滚");
            }
            return count;
        }catch(Exception e){
            //捕获异常后，回滚到savePoint
            TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
            throw e;
        }
    }

    @Transactional
    public int insertUsers(List<User> userList) throws Exception {
        int count = 0;
        for(User user : userList){
            //调用子方法insertUser,将使用注解@Transactional定义的传播行为
            //insertUser方法没有定义传播行为，它会采用REQUIRED(默认)
            //也就是沿用当前的事务，所以它将与insertUsers方法使用同一个事务
            count += insertUser(user);
        }
        return count;
    }
}

 结果：只回滚了4，没回滚5

3.4如果是unchecked异常，也会到回滚点，而不是全部

package com.demo.services;

import com.demo.models.mapper.AppadminMapper;
import com.demo.models.mapper.UserMapper;
import com.demo.models.po.User;
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;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.util.List;

@Service
public class UserService {

    //自动注入
    @Autowired
    private UserMapper userMapper;

    public User getUser(Integer id) {
        return userMapper.selectByPrimaryKey(id);
    }

    public int insertUser(User user) throws Exception {
        //插入不会滚的id=5
        User noRollUser = new User();
        noRollUser.setId(5);
        noRollUser.setName("测试5");
        userMapper.insert(noRollUser);
        //设置回滚点
        Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
        try{
            int count = userMapper.insert(user);
            if( count > 0){
                throw new RuntimeException("测试uncheck异常导致回滚");
//                throw new Exception("测试check异常不会导致回滚");
            }
            return count;
        }catch(Exception e){
            //捕获异常后，回滚到savePoint
            TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
            throw e;
        }
    }

    @Transactional
    public int insertUsers(List<User> userList) throws Exception {
        int count = 0;
        for(User user : userList){
            //调用子方法insertUser,将使用注解@Transactional定义的传播行为
            //insertUser方法没有定义传播行为，它会采用REQUIRED(默认)
            //也就是沿用当前的事务，所以它将与insertUsers方法使用同一个事务
            count += insertUser(user);
        }
        return count;
    }
}

结果：只回滚了4，没回滚5

 

3.5解决方法2：@Transactional的rollbackFor

直接抛出异常，这里不能捕获异常，否则会让rollbackFor失效

Service

package com.demo.services;

import com.demo.models.mapper.AppadminMapper;
import com.demo.models.mapper.UserMapper;
import com.demo.models.po.User;
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;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.util.List;

@Service
public class UserService {

    //自动注入
    @Autowired
    private UserMapper userMapper;

    public User getUser(Integer id) {
        return userMapper.selectByPrimaryKey(id);
    }

    public int insertUser(User user) throws Exception {
         int count = userMapper.insert(user);
         if( count > 0){
            throw new Exception("测试check异常不会导致回滚");
         }
         return count;
    }

    @Transactional(
            //隔离级别：
            //一个事务只能读取另一个事务已经提交的数据。该级别可以防止脏读
            isolation = Isolation.READ_COMMITTED,
            //传播行为：
            // REQUIRED：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。
            propagation = Propagation.REQUIRED,
            //指定异常类
            rollbackFor = Exception.class  //{RuntimeException.class, Exception.class}
    )
    public int insertUsers(List<User> userList) throws Exception {
        int count = 0;
        for(User user : userList){
            //调用子方法insertUser,将使用注解@Transactional定义的传播行为
            //1.insertUser方法没有定义传播行为，它会采用REQUIRED，
            //也就是沿用当前的事务，所以它将与insertUsers方法使用同一个事务
            count += insertUser(user);
        }
        return count;
    }
}

结果：会回滚

3.6 解决方法3：捕获异常，手动回滚

3.6.1 注意这里要在@Transactional的类/方法及其子方法中捕获并处理，在之外无效

3.6.2 捕获异常不再抛出时，rollbackFor指定了也不会回滚

注意这里无论是checked还是unchecked异常，只要捕获了不再抛出，都不会回滚

Service

package com.demo.services;

import com.demo.models.mapper.AppadminMapper;
import com.demo.models.mapper.UserMapper;
import com.demo.models.po.User;
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;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.util.List;

@Service
public class UserService {

    //自动注入
    @Autowired
    private UserMapper userMapper;

    public User getUser(Integer id) {
        return userMapper.selectByPrimaryKey(id);
    }

    public int insertUser(User user) throws Exception {
        try{
            int count = userMapper.insert(user);
            if( count > 0){
                //throw new RuntimeException("测试uncheck异常导致回滚");
                throw new Exception("测试check异常不会导致回滚");
            }
            return count;
        }catch(Exception e){
            //要处理回滚，不然即使是unchecked也无效
            return 0;
        }
    }

    @Transactional(
            //隔离级别：
            //一个事务只能读取另一个事务已经提交的数据。该级别可以防止脏读
            isolation = Isolation.READ_COMMITTED,
            //传播行为：
            // REQUIRED：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。
            propagation = Propagation.REQUIRED,
            //指定异常类
            rollbackFor = Exception.class
    )
    public int insertUsers(List<User> userList) throws Exception {
        int count = 0;
        for(User user : userList){
            //调用子方法insertUser,将使用注解@Transactional定义的传播行为
            //1.insertUser方法没有定义传播行为，它会采用REQUIRED，
            //也就是沿用当前的事务，所以它将与insertUsers方法使用同一个事务
            count += insertUser(user);
        }
        return count;
    }
}

结果：不会回滚

 

3.6.3 正确用法：在捕获异常后手动回滚

package com.demo.services;

import com.demo.models.mapper.AppadminMapper;
import com.demo.models.mapper.UserMapper;
import com.demo.models.po.User;
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;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.util.List;

@Service
public class UserService {

    //自动注入
    @Autowired
    private UserMapper userMapper;

    public User getUser(Integer id) {
        return userMapper.selectByPrimaryKey(id);
    }

    public int insertUser(User user) throws Exception {
        try{
            int count = userMapper.insert(user);
            if( count > 0){
                //throw new RuntimeException("测试uncheck异常导致回滚");
                throw new Exception("测试check异常不会导致回滚");
            }
            return count;
        }catch(Exception e){
            //结合@Transactional(rollbackFor = Exception.class)使用，才会回滚
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return 0;
        }
    }

    @Transactional(
            //隔离级别：
            //一个事务只能读取另一个事务已经提交的数据。该级别可以防止脏读
            isolation = Isolation.READ_COMMITTED,
            //传播行为：
            // REQUIRED：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。
            propagation = Propagation.REQUIRED,
            //指定异常类
            rollbackFor = Exception.class //{RuntimeException.class, Exception.class}
    )
    public int insertUsers(List<User> userList) throws Exception {
        int count = 0;
        for(User user : userList){
            //调用子方法insertUser,将使用注解@Transactional定义的传播行为
            //1.insertUser方法没有定义传播行为，它会采用REQUIRED，
            //也就是沿用当前的事务，所以它将与insertUsers方法使用同一个事务
            count += insertUser(user);
        }
        return count;
    }
}

 结果：会回滚

4.事务属性设置

@Transactional(
            //隔离级别：
            //一个事务只能读取另一个事务已经提交的数据。该级别可以防止脏读
            isolation = Isolation.READ_COMMITTED,
            //传播行为：
            // REQUIRED：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。
            propagation = Propagation.REQUIRED
            // SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
//            propagation = Propagation.SUPPORTS
    )
    public int insertUsers(List<User> userList) throws Exception {
        int count = 0;
        for(User user : userList){
            //调用子方法insertUser,将使用注解@Transactional定义的传播行为
            //1.insertUser方法没有定义传播行为，它会采用REQUIRED，
            //也就是沿用当前的事务，所以它将与insertUsers方法使用同一个事务
            //2.SUPPORTS：insertUser方法没有定义传播行为，跟着采用SUPPORTS
            count += insertUser(user);
        }
        return count;
    }

 

 

5.总结

事务的回滚，一定在@Transactional的类/方法及其子方法中，在外面是无效的，所以一般异常捕获可以放在外面

为了同时回滚unchecked和checked异常，在@Transactional范围内，可以采用：

1.捕获异常+设置回滚点

2.捕获异常+rollbackFor+手动回滚setRollbackOnly

 

hyszy
关注
专栏目录
SpringBoot-Mybatis处理事务
08-15
SpringBoot+Mybatis简单的处理事务回滚
Spring+Mybatis整合事务回滚
11-23
花了一晚上时间终于搞出来了Spring整合Mybatis事务回滚(Mysql数据库)，控制Service层中的多次插入操作，多次操作整体是一个事务。 里面有缘嘛和jar包，资源为war包，导入即可。运行Test类中的测试代码即可。 建表语句见txt文件。
Spring 事务
weixin_43612949的博客
04-14 817
1.数据库是否为InnoDB引擎，具体原因请查看 Mysql引擎类型刨析 2.配置文件中是否开启 transaction: rollback-on-commit-failure: true 3.是否在启动类中加入注解（此项可忽略，spring boot 默认开启了事务） @EnableTransactionManagement 4.@Transactional注解位置： @Transactiona...
spring boot  mybatis 事务回滚
改天的博客
11-05 1489
spring boot mybatis 事务回滚 运行失败时mapper的数据 已插入的数据会回滚 @Override @Transactional(propagation = Propagation.REQUIRED)//事务 回滚 public void insertWareHousing(HttpServletRequest request) { appWareHousingMapper.insertDeviceInfo(deviceInfo.
Mybatis 事物回滚最简单的操作方式
赵先森
12-04 9263
如果同一个方法需要同时进行两条sql的update 那么此时为了原子性，需要运用到事物。 @Transactional @ApiOperation("上移") @RequestMapping(value = "/upExamLib", method = RequestMethod.PUT) public Result upExamLib(@Valid @Reques...
mybatis数据库回滚Java_SprinBoot +MyBatis + MySQL8 启用数据库事务回滚
weixin_39618173的博客
02-28 542
本文参考借鉴：https://zhuanlan.zhihu.com/p/64489012学习目录：第一：认识数据库事务第二：SpringBoot + MyBatis+MySQL8 如何启动数据库事务1、什么是数据库事务1.1 为什么需要数据库事务银行转账是常见的生活操作，比如张三向李四的账户转账100元这个操作，从用户的角度看是单一操作，但是从系统研发人员的角度上来看时是二个操作：1、张三的账户金...
spring +springboot+mybatis+maven 读写分离及事务管理
09-07
spring +springboot+mybatis+maven 读写分离，数据库采用mysql, 采用springboot 采用项目框架搭建，继承spring 中的AbstractRoutingDataSource，实现 determineCurrentLookupKey 进行数据源的动态切换，采用Spring ...
springboot + mybatis + atomikos 多数据源分布式事物管理
05-18
Spring Boot、MyBatis 和 Atomikos 的结合提供了一种解决方案，用于处理多数据源的分布式事务管理。以下是对这个主题的详细阐述。 首先，Spring Boot 是一个基于 Spring 框架的轻量级开发工具，它简化了配置过程并...
springboot+mybatis+jta+atomikos解决多数据源事务问题.pdf
05-21
这样，即使一个数据源的事务失败，整个业务操作也可以回滚到事务开始之前的状态，保持数据的一致性和完整性。 ### 结论 本文档所述的多数据源事务问题解决方案，借助了Spring Boot、MyBatis、JTA和Atomikos，展示...
Springboot+MyBatis+MySQL实现多功能个人博客系统.zip
08-05
【标题】Springboot+MyBatis+MySQL实现多功能个人博客系统 这个项目是一个基于SpringBoot、MyBatis和MySQL数据库的毕业设计，旨在构建一个功能完善的个人博客平台。SpringBoot以其简洁的配置和快速开发特性，是现代...
Spring/SpringMVC/MyBatis整合+事务回滚
02-24
Spring/SpringMVC/MyBatis整合,可事务回滚
SpringBoot事务使用及回滚实现代码详解
08-18
主要介绍了SpringBoot事务使用及回滚实现代码详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Mybatis源码解析之六剑客
码猿技术专栏
09-07 269
持续原创输出，点击上方蓝字关注我吧前言Mybatis的专题文章写到这里已经是第四篇了，前三篇讲了Mybatis的基本使用，相信只要认真看了的朋友，在实际开发中正常使用应该不是问题。没有看...
Spring Boot + Mybatis Plus手动触发事务回滚
yancie_的博客
03-30 1万+
使用第一种方法（省略了操作数据库的代码）操作MybatisPlus的事务，若出现异常进入catch之后，不会执行数据库操作的回滚，反而会报Notransactionaspect-managedTransactionStatusinscope的错误，修改为第二种可以正常进行事务管理和回滚 第一种方法： ​ @PostMapping("/save1") publicboole...
springboot 事务回滚
weixin_30800807的博客
11-30 57
在springboot中，使用事务回滚时，添加@Transactional注解，然后在try-catch块中，发生异常时，在catch中 添加 TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); 构造异常场景 测试后查库发现，库中没有数据被删除 转载于:https://www.cnblo...
MyBatis事务回滚
最新发布
ding43930053的专栏
05-31 254
2、在函数体内，需要回滚的位置加上。1、在函数上增加注解。
@Transactional事务几点注意
热门推荐
每每看到代码，就会有亲切之感！
02-08 4万+
这里面有几点需要大家留意： A. 一个功能是否要事务，必须纳入设计、编码考虑。不能仅仅完成了基本功能就ok。 B. 如果加了事务，必须做好开发环境测试（测试环境也尽量触发异常、测试回滚），确保事务生效。 C. 以下列了事务使用过程的注意事项，请大家留意。 1. 不要在接口上声明@Transactional ，而要在具体类的方法上使用 @Transactional 注解，否则注解可能无效。
SpringBoot进行事务管理并且手动事务回滚
胖墩的IT博客
08-02 2万+
spring boot都是在SSM整合的基础上进行的 首先添加依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jdbc</artifactId> ...
mybatis 回滚记录
anmoudian8588的博客
08-14 137
@Transactional public int addThumbsUp(Map map) throws Exception{ int result = 0; //如果调用其他方法执行sql，不进行回滚 // int addGroupPoint = this.addGradeGroupPoint(map); // int addOrdere...
SpringBoot+MyBatis：多数据源读写分离（注解实现）
为了支持这种场景，项目引入了Lombok、Spring Boot测试、MyBatis Spring Boot Starter、MySQL驱动和Druid数据源等相关依赖。 1. **配置文件**：在Spring Boot项目的配置文件中，你需要定义多个数据源，每个数据源...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值