SpringBoot——基于@Transactional注解的事务回滚

1.创建数据库实体类以及mapper

1.1数据库字段

数据库表字段如下所示：

1.2创建对应实体类

package com.aries.jc.dciTest.modules.entity.local;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data
@TableName("tb_test")
public class TbTest {

    @TableField("region_name")
    private String regionName;

    @TableField("region_code")
    private String regionCode;

    @TableField("region_config")
    private Integer regionConfig;
}

1.3 创建对应mapper

package com.aries.jc.dciTest.modules.mapper.local;

import com.aries.jc.dciTest.modules.entity.local.TbTest;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;


@Mapper
public interface TbTestMapper extends BaseMapper {

}

1.4 创建service层接口：

package com.aries.jc.dciTest.modules.service;

import com.aries.jc.dciTest.modules.entity.local.TbTest;
import com.hikvision.ga.common.BaseResult;

public interface TbTestService {
    
    BaseResult insertTbTest1(TbTest tbTest);
    BaseResult insertTbTest2(TbTest tbTest);
    BaseResult insertTbTest3(TbTest tbTest);
}

1.5 创建service层接口实现类

方法insertTbTest1执行正常的数据库添加操作
方法insertTbTest2执行数据库添加操作后，会通过
int l = 2/0;
触发一个异常
方法insertTbTest3执行数据库添加操作后，会通过
int l = 2/0;
触发一个异常，但在该方法上添加了注解

@Transactional(rollbackFor = Exception.class)

来执行事务回滚

package com.aries.jc.dciTest.modules.service.impl;

import com.aries.jc.dciTest.modules.entity.local.TbTest;
import com.aries.jc.dciTest.modules.mapper.local.TbTestMapper;
import com.aries.jc.dciTest.modules.service.TbTestService;
import com.hikvision.ga.common.BaseResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class TbTestServiceImpl implements TbTestService {
    private static final Logger LOGGER = LoggerFactory.getLogger(TbTestServiceImpl.class);

    @Autowired
    private TbTestMapper tbTestMapper;

    /**
     * 向数据库添加操作，不触发异常
     * @param tbTest
     * @return
     */
    @Override
    public BaseResult insertTbTest1(TbTest tbTest) {
        BaseResult baseResult = new BaseResult();

        //向数据库添加操作
        int i = tbTestMapper.insert(tbTest);
        if (i != 0 ){
            LOGGER.info("添加成功");
        }

        baseResult.setMsg("添加成功");
        baseResult.setCode("0");
        return baseResult;
    }

    /**
     * 向数据库添加操作，添加后触发异常，但不执行事务回滚
     * @param tbTest
     * @return
     */
    @Override
    public BaseResult insertTbTest2(TbTest tbTest) {
        BaseResult baseResult = new BaseResult();

        //向数据库添加操作
        int i = tbTestMapper.insert(tbTest);
        if (i != 0 ){
            LOGGER.info("添加成功");
        }
        //触发异常
        int l = 2/0;

        baseResult.setMsg("添加成功");
        baseResult.setCode("0");
        return baseResult;
    }

    /**
     * 向数据库添加操作，添加后触发异常，执行事务回滚
     * @param tbTest
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public BaseResult insertTbTest3(TbTest tbTest) {
        BaseResult baseResult = new BaseResult();

        //向数据库添加操作
        int i = tbTestMapper.insert(tbTest);
        if (i != 0 ){
            LOGGER.info("添加成功");
        }
        //触发异常
        int l = 2/0;

        baseResult.setMsg("添加成功");
        baseResult.setCode("0");
        return baseResult;
    }
}

1.6 创建controller层

package com.aries.jc.dciTest.modules.controller;

import com.aries.jc.dciTest.modules.entity.local.PointConfig;
import com.aries.jc.dciTest.modules.entity.local.TbTest;
import com.aries.jc.dciTest.modules.service.TbTestService;
import com.hikvision.ga.common.BaseResult;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
@Api(tags = "测试")
@RequestMapping("/test")
public class TbTestController {

    @Autowired
    private TbTestService tbTestService;

    @RequestMapping(value = "/insert1", method = RequestMethod.POST)
    @ApiOperation("测试事务回滚：正常添加，不触发异常")
    public BaseResult insertTbTest1(@RequestBody TbTest tbTest){
        return tbTestService.insertTbTest1(tbTest);
    }

    @RequestMapping(value = "/insert2", method = RequestMethod.POST)
    @ApiOperation("测试事务回滚：正常添加，添加后触发异常，不执行事务回滚")
    public BaseResult insertTbTest2(@RequestBody TbTest tbTest){
        return tbTestService.insertTbTest2(tbTest);
    }

    @RequestMapping(value = "/insert3", method = RequestMethod.POST)
    @ApiOperation("测试事务回滚：正常添加，添加后触发异常，执行事务回滚")
    public BaseResult insertTbTest3(@RequestBody TbTest tbTest){
        return tbTestService.insertTbTest3(tbTest);
    }
}

2.swagger测试：

正常添加，不触发异常：方法insertTbTest1
正常向数据库添加



正常添加，添加后触发异常，不执行事务回滚：方法insertTbTest2
向数据库成功添加后，触发了异常，但因为没有事务回滚，数据库中就保留了添加的对象




正常添加，添加后触发异常，执行事务回滚：方法insertTbTest3
向数据库成功添加后，触发了异常，但因为设置了事务回滚，数据库就回滚了该方法调用之前的状态，即在数据库中没有新添加的对象