40 spring 的4种事务特性，5种隔离级别，7种传播行

2020-08-11 本文已影响0人滔滔逐浪

spring 事务：
什么是事务：
事务逻辑上的一组操作，组成这组操作的各个逻辑单元，要么一起成功，要么一起失败。

事务特性（4种：）
原子性(actomicity): 强调事务的不可分割。
一致性(consistency)：事务的执行的前后数据的完整性保持一致。
隔离性(isolation)：一个事务执行的过程种，不应该受到其他事务的干扰。
持久性（durability）：事务一旦结束，数据就持久到数据库。

如果不考虑隔离性引发安全性问题：
脏读：一个事务读到了另一个事务的未提交的数据
不可重复读：一个事务读到了另一个事务已经提交的update 的数据导致多次查询结果不一致。

解决读问题：设置事务隔离级别（5种）
DEFAULT 这是一个PlatfromTransactionManage 默认的隔离级别，使用数据库默认的隔离级别。
未提交读(read uncommited): 脏读。不可重复读。虚读都有可能发生。
已提交读(read commited): 避免脏读。但是不可重复读和虚读有可能发生。
可重复读(repeatable read)：避免脏读和不可重复读，但是虚读有可能发生。
串行化的 (serializable)：避免以上所有读问题：

事务的传播行为

propagion_XXX :事务的传播行为

保证同一个事务中
propagion_required: 支持当前事务，如果不存在就新建一个(默认)
propagion_supports: 支持当前事务，如果不存在，就不使用事务
propagion_mandatory: 支持当前事务，如果不存在，抛出异常

保证没有在同一个事务中
propagion_requires_new: 如果有事务存在，挂起当前事务，创建一个新的事务
propagion_not_supported: 以非事务方式运行，如果有事务存在，挂起当前事务
propagion_never: 以非事务方式运行，如果有事务存在，抛出异常
propagion_nested: 如果当前事务存在，则嵌套事务执行

一：事务传播行为：
事务传播行为(Propagation behavior) 指的是当一个事务方法被另一个事务方法调用时，这个事务方法如何运行。
例如： methodA方法调用methodB 方法时，methodB 是继续在调用者methodA的事务中运行呢还是为自己开启一个新事务运行，这就是由methodB的事务传播行为决定。

二事务的7种传播行为
Spring在TransactionDefinition 接口中规定了7种类型的事务传播性行为。事务传播行为是Spring框架独有的事务增强特性。这是Spring 为我们提供的强大的工具箱，使用事务传播行为可以为我们的开发工作提供许多便利。

7种事务传播行为如下：

PROPAGATION_REQUIRED

如果当前没有事务，就创建一个新事务。如果当前存在事务，就加入该事务。如果当前不存在事务，就以非事务执行。

1 PROPAGATION_MANDATORY
支持当前事务，如果存在当前事务，就加入该事务，如果当前不存在事务，就抛出异常。

PROPAGATION_REQUIRES_NEW
创建新事务，无论当前存不存在事务，都创建新事务。

以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

以非事务方式执行，如果当前存在事务，则抛出异常。

7种传播行为实战：

演示前先建立2个表，用户表和用户角色表，一开始2个表里没有数据。

需要注意下，为了数据更直观，每次执行代码时先清空下user和user_role表的数据。


user表：

CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) DEFAULT NULL,
  `password` varchar(255) DEFAULT NULL,
  `sex` int(11) DEFAULT NULL,
  `des` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
user_role表：

CREATE TABLE `user_role` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `user_id` int(11) DEFAULT NULL,
  `role_id` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

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.3.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.taotao</groupId>
    <artifactId>springshiwu</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springshiwu</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.3.2</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.62</version>
        </dependency>
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity-engine-core</artifactId>
            <version>2.2</version>
        </dependency>
        <dependency>
            <groupId>com.ibeetl</groupId>
            <artifactId>beetl</artifactId>
            <version>3.1.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.3.2</version>
        </dependency>
        <dependency>
            <groupId>org.freemarker</groupId>
            <artifactId>freemarker</artifactId>
            <version>2.3.30</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

application.yml



server:
  port: 8080
spring:
  datasource:
    # type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/test1?useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true&serverTimezone=UTC
    username: root
    password: root

mybatis:
  mapper-locations: classpath:/mapper/*.xml
  typeAliasesPackage: com.taotao.entity
logging:
  level:
    com.taotao.dao: debug

entity


package com.taotao.springshiwu.entity;

import java.io.Serializable;

import lombok.Data;
import lombok.EqualsAndHashCode;

/**
 * <p>
 *
 * </p>
 *
 * @author jobob
 * @since 2020-08-11
 */
@Data
@EqualsAndHashCode(callSuper = false)
public class User implements Serializable {

    private static final long serialVersionUID = 1L;
    private int id;
    private String name;

    private String password;

    private Integer sex;

    private String des;


}


package com.taotao.springshiwu.entity;

import java.io.Serializable;
import lombok.Data;
import lombok.EqualsAndHashCode;

/**
 * <p>
 * 
 * </p>
 *
 * @author jobob
 * @since 2020-08-11
 */
@Data
@EqualsAndHashCode(callSuper = false)
public class UserRole implements Serializable {

    private static final long serialVersionUID = 1L;

    private Integer userId;

    private Integer roleId;


}

启动类

package com.taotao.springshiwu;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@MapperScan("com.taotao.springshiwu.mapper")
@SpringBootApplication
public class SpringshiwuApplication {

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

}

controller:

package com.taotao.springshiwu.controller;


import com.taotao.springshiwu.entity.User;
import com.taotao.springshiwu.service.IUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

/**
 * <p>
 *  前端控制器
 * </p>
 *
 * @author jobob
 * @since 2020-08-11
 */
@RestController
@RequestMapping("/sprngshiwu/user")
public class UserController {
    @Autowired
    private IUserService iUserService;
    @RequestMapping("/add")
    public int add(User user) {
        return iUserService.add(user);
    }
}


package com.taotao.springshiwu.controller;


import com.taotao.springshiwu.entity.UserRole;
import com.taotao.springshiwu.service.IUserRoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

/**
 * <p>
 *  前端控制器
 * </p>
 *
 * @author jobob
 * @since 2020-08-11
 */
@RestController
@RequestMapping("/sprngshiwu/user-role")
public class UserRoleController {
    @Autowired
    private IUserRoleService iUserRoleService;
    @RequestMapping("/add")
    public int add(UserRole userRole) {
        return iUserRoleService.add(userRole);
    }
}

service

package com.taotao.springshiwu.service;

import com.taotao.springshiwu.entity.User;
import com.baomidou.mybatisplus.extension.service.IService;

/**
 * <p>
 *  服务类
 * </p>
 *
 * @author jobob
 * @since 2020-08-11
 */
public interface IUserService extends IService<User> {

    int add(User user);
}

package com.taotao.springshiwu.service;

import com.taotao.springshiwu.entity.UserRole;
import com.baomidou.mybatisplus.extension.service.IService;

/**
 * <p>
 *  服务类
 * </p>
 *
 * @author jobob
 * @since 2020-08-11
 */
public interface IUserRoleService extends IService<UserRole> {

    int add(UserRole userRole);
}

impl


package com.taotao.springshiwu.service.impl;

import com.taotao.springshiwu.entity.UserRole;
import com.taotao.springshiwu.mapper.UserRoleMapper;
import com.taotao.springshiwu.service.IUserRoleService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author jobob
 * @since 2020-08-11
 */
@Service
public class UserRoleServiceImpl extends ServiceImpl<UserRoleMapper, UserRole> implements IUserRoleService {
@Autowired
private UserRoleMapper userRoleMapper;
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public int add(UserRole userRole) {
        return userRoleMapper.insert(userRole);
    }
}

package com.taotao.springshiwu.service.impl;

import com.taotao.springshiwu.entity.User;
import com.taotao.springshiwu.mapper.UserMapper;
import com.taotao.springshiwu.service.IUserService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author jobob
 * @since 2020-08-11
 */
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {
@Autowired
private  UserMapper userMapper;
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public int add(User user) {
        return userMapper.insert(user);
    }
}

mapper


package com.taotao.springshiwu.mapper;

import com.taotao.springshiwu.entity.User;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

/**
 * <p>
 *  Mapper 接口
 * </p>
 *
 * @author jobob
 * @since 2020-08-11
 */
public interface UserMapper extends BaseMapper<User> {

}

package com.taotao.springshiwu.mapper;

import com.taotao.springshiwu.entity.UserRole;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

/**
 * <p>
 *  Mapper 接口
 * </p>
 *
 * @author jobob
 * @since 2020-08-11
 */
public interface UserRoleMapper extends BaseMapper<UserRole> {

}

测试：

package com.taotao.springshiwu;

import com.taotao.springshiwu.entity.User;
import com.taotao.springshiwu.entity.UserRole;
import com.taotao.springshiwu.service.IUserRoleService;
import com.taotao.springshiwu.service.IUserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class SpringshiwuApplicationTests {

    @Autowired
    private IUserService userService;
    @Autowired
    private IUserRoleService iUserRoleService;
    @Test
    void contextLoads() {
    }

    /**
     * 两个实现类UserServiceImpl和UserRoleServiceImpl制定事物传播行为
     * propagation=Propagation.REQUIRED 然后在测试方法中同时调用2个方法
     * 并在调用2个方法后抛出异常
     *结果分析

外围方法未开启事务，插入用户表和用户角色表的方法在自己的事务中独立运行，外围方法异常不影响内部插入，所以两条记录都新增成功。
     */

    @Test
    void text_PROPAGATION_REQUIRED(){
        // 增加用户表
        User user = new User();
        user.setName("Java碎碎念");
        user.setPassword("123456");
        userService.add(user);
        // 增加用户角色表
        UserRole userRole = new UserRole();
        userRole.setUserId(user.getId());
        userRole.setRoleId(200);
        iUserRoleService.add(userRole);
        //抛异常
        throw new RuntimeException();
    }
}

image.png

2, PROPAGATION_SUPPORTS测试
支持当前事务，如果当前存在事务，就加入该事务，如果当前不存在事务，就以非事务执行
场景一：
此场场景外围方法没有开启事务
1，验证方法
2个实现类UserRoleServiceImpl和UserServiceImpl制定事务传播行为porpagation=Propagation.SUPPORTS，然后在测试方法中同时调用2个方法并在调用结果结束后抛出异常。

1，主要代码：
外层调用方法代码：

 @Test
    void test_PROPAGATION_SUPPORTS(){
        // 增加用户表
        User user = new User();
        user.setName("Java碎碎念");
        user.setPassword("123456");
        userService.add1(user);
        // 增加用户角色表
        UserRole userRole = new UserRole();
        userRole.setUserId(user.getId());
        userRole.setRoleId(200);
        userRoleService.add1(userRole);
        //抛异常
        throw new RuntimeException();
    }

UserServiceImpl代码

    @Override
    @Transactional(propagation = Propagation.SUPPORTS)
    public int add1(User user) {
        return userMapper.insert(user);
    }

UserRoleServiceImpl代码

    @Override
    @Transactional(propagation = Propagation.SUPPORTS)
    public int add1(UserRole userRole) {
        return userRoleMapper.insert(userRole);
    }

结果分析

外围方法未开启事务，插入用户表和用户角色表的方法以非事务的方式独立运行，外围方法异常不影响内部插入，所有2条记录都新增成功。

场景2
此场景外围方法开启事务
1，主要代码
test_PROPAGATION_SUPPORTS方法添加注解@Transactional即可。
1,代码执行后数据库截图：2张表数据都为空，截图如下：

image.png

3 结果分析
外围方法开启事务，内部方法加入外围方法事务，外围方法回滚，内部方法页要回滚。所以2个记录都插入失败。

结论：以上结果证明在外围方法开启事务的情况下Propagation.SUPPORTS 修饰的内部方法会加入到外围方法的事务中，所以Propagation.SUPPORTS修饰的内部方法和外围方法均属于同一事务。只要一个方法回滚，整个事务均回滚。

3，PROPAGATION_MANDATORY测试
支持当前事务，如果当前存在事务，就加入该事务，如果当前不存在事务，就抛出异常。

通过上面的测试，“支持当前事务，如果当前存在事务，就加入该事务”，这句话已经验证了，外层添加@Transaction注解后2条记录都新增失败，所以这个传播行为只测试下外层没有开始事务的场景。
场景一：
此场景外围方法没有开启事务：
2个实现类制定事务传播行为propagation=Propagation.MANDATORY.主要代码如下：

外层调用方法：



 @Test
   @Transactional
    void test_PROPAGATION_MANDATORY(){
        // 增加用户表
        User user = new User();
        user.setName("Java碎碎念");
        user.setPassword("123456");
        userService.add2(user);
        // 增加用户角色表
        UserRole userRole = new UserRole();
        userRole.setUserId(user.getId());
        userRole.setRoleId(200);
        userRoleService.add2(userRole);
        //抛异常
       throw new RuntimeException();
    }

    @Override
    @Transactional(propagation = Propagation.MANDATORY)
    public int add2(UserRole userRole) {
        return userRoleMapper.insert(userRole);
    }

    @Override
    @Transactional(propagation = Propagation.MANDATORY)
    public int add2(User user) {
        return userMapper.insert(user);
    }

1,代码执行后数据库截图

2张表数据都为空，截图如下：

image.png

数据为空截图
1，结果分析
运行日志如下，可以发现在调用 userService.add2(user);时候已经报错了，所以2个表都没有新增数据，验证了 “如果不存在事务，就抛出异常”

4，PROPAGATION_REQUIRES_NEWS 测试
创建新事务，无论当前存不存在事务，都创建新事务。
这种情况每次都创建事务，所以我们验证一种情况即可。
场景一：
此场景外围方法开启事务
1 验证方法：
2个实现类制定事务传播行为为propagation =Propagation.REQUIRES_NEW，主要代码如下：
1，主要代码

外层调用方法代码：


  @Test
    @Transactional
    void test_REQUIRES_NEW(){
        // 增加用户表
        User user = new User();
        user.setName("Java碎碎念");
        user.setPassword("123456");
        userService.add3(user);
        // 增加用户角色表
        UserRole userRole = new UserRole();
        userRole.setUserId(user.getId());
        userRole.setRoleId(200);
        userRoleService.add3(userRole);
        //抛异常
        throw new RuntimeException();
    }

40 spring 的4种事务特性，5种隔离级别，7种传播行

猜你喜欢

热点阅读

40 spring 的4种事务特性 ，5种隔离级别，7种传播行

猜你喜欢

热点阅读

40 spring 的4种事务特性，5种隔离级别，7种传播行