Spring 事务详解

最新推荐文章于 2024-09-06 00:29:50 发布
最新推荐文章于 2024-09-06 00:29:50 发布
阅读量863 收藏 27
点赞数 37
分类专栏： java EE 文章标签： spring java 后端 spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/N_0050/article/details/141758912
版权

  前言👀~

上一章我们介绍了Spring AOP，今天来讲解Spring事务

什么是事务？

为什么需要事务？

Spring 中事务的实现

1.编程式事务

2.声明式事务

@Transactional详解

1. rollbackFor

2. Isolation

3. propagation

1. REQUIRED（默认值）

2. REQUIRES_NEW

3.NEVER

4.Nested

如果各位对文章的内容感兴趣的话，请点点小赞，关注一手不迷路，讲解的内容我会搭配我的理解用我自己的话去解释如果有什么问题的话，欢迎各位评论纠正 🤞🤞🤞

47497722484f4d519a7e014f8100ec05.png

个人主页：N_0050-CSDN博客

相关专栏：java SE_N_0050的博客-CSDN博客  java数据结构_N_0050的博客-CSDN博客   软件测试_N_0050的博客-CSDN博客   MySQL_N_0050的博客-CSDN博客  java EE_N_0050的博客-CSDN博客

什么是事务？

回顾之前数据库中的事务，事务是一组操作的集合，在数据库中可以把事务看作是一组SQL语句，例如转账这个操作就会涉及到多条SQL语句也就是一组集合，这个操作要么都成功要么都失败，所以事务具有原子性

为什么需要事务？

上面的例子中就说明为什么需要事务了，如果转账过程中转账方扣款成功，但是接收方未收到收款就会出现问题，所以我们使用事务可以解决这个问题，让一组操作要么都成功要么都失败

事务的操作：

1. 开启事务：start transaction/ begin (⼀组操作前开启事务)

2. 提交事务：commit (这组操作全部成功，提交事务)

3. 回滚事务：rollback (这组操作中间任何⼀个操作出现异常，回滚事务)

Spring 中事务的实现

1.编程式事务

类似MySQL事务，手动开启事务，手动提及事务，手动回滚事务。SpringBoot 内置了两个对象：DataSourceTransactionManager 事务管理器，用来获取事务(开启事务)，提交或回滚事务。TransactionDefinition 是事务的属性，在获取事务的时候需要将TransactionDefinition 传递进去从⽽获得⼀个事务 TransactionStatus

    •    代码演示，先把对应的数据准备好

@Data
public class UserInfo {
    private Integer id;
    private String userName;
    private String password;
    private Date createTime;
    private Date updateTime;
}
@Mapper
public interface UserInfoMapper {

    @Insert("insert into user_info(`user_name`,`password`)values(#{userName},#{password})")
    Integer insert(@Param("userName") String userName, @Param("password") String password);

}
@Service
public class UserService {
    @Autowired
    private UserInfoMapper userInfoMapper;

    public Integer insert(String userName, String password) {
        return userInfoMapper.insert(userName, password);
    }
}

观察输出结果，返回注册成功，观察一下日志也是插入成功返回结果也是1

但是数据库中没有数据！！！说明事务回滚了

我们修改一下代码试试

@Slf4j
@RequestMapping("/user")
@RestController
public class UserInfoController {

    //事务管理器
    @Autowired
    private DataSourceTransactionManager dataSourceTransactionManager;

    //事务的属性
    @Autowired
    private TransactionDefinition transactionDefinition;

    @Autowired
    private UserService userService;

    @RequestMapping("/registry")
    public String registry(String userName, String password) {
        TransactionStatus transaction = dataSourceTransactionManager.getTransaction(transactionDefinition);
        Integer result = userService.insert(userName, password);
        log.info("用户插入成功,result:" + result);

        dataSourceTransactionManager.commit(transaction);

        return "注册成功";
    }
}

观察输出结果，接口返回的还是注册成功，再看看日志这次多了一条语句，提交了sqlSession

观察数据库，id为2，说明上条数据确实有插入但是事务回滚了

2.声明式事务

通过@Transactional注解来实现自动开启和提交事务（推荐），这个注解注意应当加到我们Service里对应的是业务逻辑层。无需手动开启事务和提交事务，进⼊方法时⾃动开启事务，⽅法执行完会自动提交事务，如果中途发生了没有处理的异常会自动回滚事务。如果所在方法没有抛出异常时，事务就提交

@Transactional注解可以用来修饰⽅法或类：

1.修饰⽅法时：只有修饰public ⽅法时才⽣效(修饰其他⽅法时不会报错，也不生效)

2.修饰类时：对 @Transactional 修饰的类中所有的 public ⽅法都生效
 


    •    下面进行演示，正常情况

@Slf4j
@RequestMapping("/user")
@RestController
public class UserInfoController {

    @Autowired
    private UserService userService;

    @Transactional
    @RequestMapping("/registry")
    public String registry(String userName, String password) {
        Integer result = userService.insert(userName, password);
        log.info("用户插入成功,result:" + result);
        return "注册成功";
    }
}

观察输出结果，可以发现事务有提交那就上面没有问题了

    •    如果在方法执行过程中，出现异常，且异常未被捕获，我们看看结果会是什么样的

@Slf4j
@RequestMapping("/user")
@RestController
public class UserInfoController {

    @Autowired
    private UserService userService;

    @Transactional
    @RequestMapping("/registry")
    public String registry(String userName, String password) {
        Integer result = userService.insert(userName, password);
        log.info("用户插入成功,result:" + result);
        int a = 10 / 0;
        return "注册成功";
    }
}

观察输出结果，报异常了，事务也未进行提交。说明方法执行过程中，出现异常，且异常未被捕获就进行事务回滚操作


    •    如果异常被程序捕获的话，结果会不会不一样呢？

@Slf4j
@RequestMapping("/user")
@RestController
public class UserInfoController {

    @Autowired
    private UserService userService;

    @Transactional
    @RequestMapping("/registry")
    public String registry(String userName, String password) {
        Integer result = userService.insert(userName, password);
        log.info("用户插入成功,result:" + result);
        try {
            int a = 10 / 0;
        } catch (Exception e) {
            log.error("程序出错");
        }
        return "注册成功";
    }
}

观察输出结果，接口没问题，日志上面我设置了对应输出的内容，我们可以得出异常被程序捕获的话，方法就被认为是成功执行，依然会提交事务

从数据库中也可以得出，上一段代码提交异常回滚了，因为id的变化

补充：@Transactional注解也是AOP一种实现的体现，对于事务这一类事情进行集中处理，在整个方法执行前先开启事务，如果发生异常就进行回滚，如果没有就正常提交

如果需要事务进行回滚, 有以下两种方式：

1. 重新抛出异常：

@Slf4j
@RequestMapping("/user")
@RestController
public class UserInfoController {

    @Autowired
    private UserService userService;

    @Transactional
    @RequestMapping("/registry")
    public String registry(String userName, String password) {
        Integer result = userService.insert(userName, password);
        log.info("用户插入成功,result:" + result);
        try {
            int a = 10 / 0;
        } catch (Exception e) {
            log.error("程序出错");
            throw e;//补获后再抛出
        }
        return "注册成功";
    }
}

观察输出结果，没有提交事务的日志，说明事务进行回滚了


2. 手动回滚事务：

我们可以选择重新抛异常的方式

使用 TransactionAspectSupport.currentTransactionStatus() 得到当前的事务， 并使用 setRollbackOnly 设置 setRollbackOnly

@Slf4j
@RequestMapping("/user")
@RestController
public class UserInfoController {

    @Autowired
    private UserService userService;

    @Transactional
    @RequestMapping("/registry")
    public String registry(String userName, String password) {
        Integer result = userService.insert(userName, password);
        log.info("用户插入成功,result:" + result);
        try {
            int a = 10 / 0;
        } catch (Exception e) {
            log.error("程序出错");
            //捕获异常后设置事务回滚
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
        return "注册成功";
    }
}

观察输出结果，没有事务提交的日志，那就说明事务进行了回滚

小结：@Transactional注解它不并关注方法内部是怎么处理的，它就看你这个异常到底有没有处理掉。例如公司的一个小部门发生了一些小事情，只要没有发酵到哈高层那边，就当没有这件事情，哪怕部门里的人知道，就当没有这件事情

@Transactional详解


@Transactional 注解当中的三个常见属性：

1. rollbackFor

异常回滚属性，指定能够触发事务回滚的异常类型，可以指定多个异常类型

   •    下面进演示非运行时异常情况

@Slf4j
@RequestMapping("/user")
@RestController
public class UserInfoController {

    @Autowired
    private UserService userService;

    @Transactional
    @RequestMapping("/registry")
    public String registry(String userName, String password) throws IOException {
        Integer result = userService.insert(userName, password);
        log.info("用户插入成功,result:" + result);
        try {
            int a = 10 / 0;
        } catch (Exception e) {
            log.error("程序出错");
            throw new IOException();
        }
        return "注册成功";
    }
}

观察输出结果，虽然异常捕获后重新抛出了，但是事务还是成功提交了


    •    运行时异常情况

@Slf4j
@RequestMapping("/user")
@RestController
public class UserInfoController {

    @Autowired
    private UserService userService;

    @Transactional
    @RequestMapping("/registry")
    public String registry(String userName, String password) {
        Integer result = userService.insert(userName, password);
        log.info("用户插入成功,result:" + result);
        try {
            int a = 10 / 0;
        } catch (Exception e) {
            log.error("程序出错");
            throw new RuntimeException();
        }
        return "注册成功";
    }
}

观察输出结果，没有事务提交的日志，说明事务进行回滚了

小结：@Transactional 默认只在遇到运行时异常和Error时才会回滚，⾮运行时异常不回滚，即Exception的⼦类中，除了RuntimeException及其⼦类

    •    使用rollbackFor指定触发遇到啥样的类型就回滚

@Slf4j
@RequestMapping("/user")
@RestController
public class UserInfoController {

    @Autowired
    private UserService userService;

    @Transactional(rollbackFor = {Exception.class, Error.class})
    @RequestMapping("/registry")
    public String registry(String userName, String password) throws IOException {
        Integer result = userService.insert(userName, password);
        log.info("用户插入成功,result:" + result);
        try {
            int a = 10 / 0;
        } catch (Exception e) {
            log.error("程序出错");
            throw new IOException();
        }
        return "注册成功";
    }
}

这次抛IOException观察输出结果，没有事务提交的日志，说明事务进行回滚了。说明我们设置的rollback生效了


小结：在Spring的事务管理中，默认只在遇到运行时异常RuntimeException和Error时才会回滚。如果需要回滚指定类型的异常，可以通过rollbackFor属性来指定

2. Isolation

事务的隔离级别，默认值为 Isolation.DEFAULT。和MySQL的隔离级别差不多，下面简单回顾一下MySQL的隔离级别再解释Spring 事务隔离级别

MySQL 事务隔离级别：

    •    SQL 标准定义了四种隔离级别，MySQL 全都⽀持这四种隔离级别

    •    1.读未提交(READ UNCOMMITTED)：该隔离级别的事务可以读取到其他事务未进行提交的数据。因为其他事务未提交的数据可能会发⽣回滚, 但是该隔离级别却可以读到，我们把该级别读到的数据称之为脏数据， 这个问题称之为脏读

  

 •    2. 读提交(READ COMMITTED）：该隔离级别不会有脏读的问题，但由于在事务的执行中可以读取到其他事务提交的结果，所以 在不同时间的相同 SQL 查询可能会得到不同的结果，这种现象叫做不可重复读

   •    3. 可重复读(REPEATABLE READ)：事务不会读到其他事务对已有数据的修改，即使其他事务已提交，也就可以确保同⼀事务多次查询的结果⼀致。但是其他事务新插⼊的数据，是可以感知到的，这也就引发了幻读问题。可重复读，是 MySQL 的默认事务隔离级别


    •    ⽐如此级别的事务正在执行时，另⼀个事务成功的插⼊了某条数据，但因为它每次查询的结果都是⼀样的，所以会导致查询不到这条数据，自己重复插⼊时⼜失败(因为唯⼀约束的原因)。明明在事务中查询不到这条信息，但⾃⼰就是插⼊不进去, 这个现象叫幻读

    •    4. 串行化(SERIALIZABLE)：序列化，事务最⾼隔离级别。它会强制事务排序，使之不会发⽣冲突。从而解决了上述发生的问题，但执行效率低

Spring 中事务隔离级别有5 种：

    •    1. Isolation.DEFAULT：以连接的数据库的事务隔离级别为主

    •    2. Isolation.READ_UNCOMMITTED：读未提交，对应SQL标准中 READ UNCOMMITTED

    •    3. Isolation.READ_COMMITTED：读已提交，对应SQL标准中 READ COMMITTED

    •    4. Isolation.REPEATABLE_READ：可重复读，对应SQL标准中 REPEATABLE READ

    •    5. Isolation.SERIALIZABLE：串行化，对应SQL标准中 SERIALIZABLE

    •    可以通过Isolation属性设置事务的隔离级别

3. propagation

事务的传播机制，默认值为 Propagation.REQUIRED，我们可以通过 propagation 属性来指定传播⾏为

什么是事务传播机制？

事务传播机制就是多个事务方法存在调用关系时， 事务是如何在这些方法间进行传播的

例子：比如有两个⽅法A, B都被 @Transactional 修饰，A⽅法调⽤B⽅法，A⽅法运行时, 会开启⼀个事务. 当A调⽤B时, B⽅法本⾝也有事务, 此时B⽅法运行时，是加⼊A的事务，还是创建⼀个新的事务呢？这个就涉及到了事务的传播机制

    •    事务隔离级别解决的是多个事务同时调用⼀个数据库的问题


    •    事务传播机制解决的是⼀个事务在多个节点(方法)中传递的问题


Spring 事务传播机制有以下 7 种：


    •    1. Propagation.REQUIRED ：默认的事务传播级别，如果当前存在事务， 则加⼊该事务，如果当前没有事务，则创建⼀个新的事务。如图中方法1有事务了方法2直接用方法1的事务

    •    2. Propagation.SUPPORTS： 如果当前存在事务，则加⼊该事务。如果方法1有事务，方法2和方法1共用一个事务。如图中如果方法1当前没有事务（虽然方法2加了@Transactional ）方法2还是以⾮事务的⽅式继续运行。所以从这可以得出并不是加了@Transactional注解事务就会生效的

    •    3. Propagation.MANDATORY： 强制性，如果当前存在事务，则加⼊该事务，如果当前没有事务，抛出异常。如图中这个简单方法1有事务方法2直接用，如果没有直接抛异常

    •    4. Propagation.REQUIRES_NEW： 创建⼀个新的事务，如果当前存在事务，则把当前事务挂起，也就是说不管外部⽅法是否开启事务, Propagation.REQUIRES_NEW 修饰的内部⽅法都会新开启自己的事务，且开启的事务相互独立，互不干扰

    •    5. Propagation.NOT_SUPPORTED： 以⾮事务⽅式运行，如果当前存在事务，则把当前事务挂起(即使方法1有事务，我也不用)

    •    6. Propagation.NEVER： 以⾮事务⽅式运行， 如果当前存在事务，则抛出异常。如果方法1存在事务，方法2就抛出异常

    •    7. Propagation.NESTED： 如果当前存在事务，则创建⼀个事务作为当前事务的嵌套事务（可以看作是子事务）来运行。如果当前没有事务，则该取值等价于 PROPAGATION_REQUIRED。可以看作一个大公司可以有很多子公司，如果子公司发生问题肯定会影响到大公司

Spring 事务传播行为有什么用？

 答案就几个字：控制事务的边界

Spring 事务传播机制使用和各种场景演示：

对于以上事务传播机制，我们重点关注以下就可以了：

1. REQUIRED（默认值）


    •    下面进行演示，再准备一些数据

@Mapper
public interface LogInfoMapper {
    @Insert("insert into log_info(`user_name`,`op`)values(#{userName},#{op})")
    Integer insertLog(@Param("userName") String userName, @Param("op") String op);
}
@Service
public class LogInfoService {
    @Autowired
    private LogInfoMapper logInfoMapper;

    @Transactional(propagation = Propagation.REQUIRED)
    public Integer insert(String userName, String op) {
        return logInfoMapper.insertLog(userName, "用户注册");
    }
}
@Service
public class UserService {
    @Autowired
    private UserInfoMapper userInfoMapper;

    @Transactional(propagation = Propagation.REQUIRED)
    public Integer insert(String userName, String password) {
        return userInfoMapper.insert(userName, password);
    }
}
@Slf4j
@RequestMapping("/user")
@RestController
public class UserInfoController {

    @Autowired
    private UserService userService;

    @Autowired
    private LogInfoService logInfoService;

    @Transactional(propagation = Propagation.REQUIRED)
    @RequestMapping("/registry")
    public String registry(String userName, String password) throws IOException {
        Integer result = userService.insert(userName, password);
        log.info("用户插入成功,result:" + result);

        Integer result2 = logInfoService.insert(userName, "用户注册");
        log.info("日志插入成功,result:" + result2);
        return "注册成功";
    }
}

观察输出结果，事务提交成功，两条SQL语句都成功执行了


    •    我们试试异常情况，会是什么样的

@Service
public class LogInfoService {
    @Autowired
    private LogInfoMapper logInfoMapper;

    @Transactional(propagation = Propagation.REQUIRED)
    public Integer insert(String userName, String op) {
        int a = 10 / 0;
        return logInfoMapper.insertLog(userName, "用户注册");
    }
}

观察输出结果，事务进行回滚了，由于这两者都属于同一事务，一个事务出现异常进行回滚另外一个事务也会进行回滚。这就是默认事务传播级别

2. REQUIRES_NEW

创建⼀个新的事务，如果当前存在事务，则把当前事务挂起，也就是说不管外部⽅法是否开启事务, Propagation.REQUIRES_NEW 修饰的内部⽅法都会新开启自己的事务，且开启的事务相互独立，互不干扰

我们修改一下上面的代码接着演示，看看输出结果还是不是和上面一样

@Service
public class UserService {
    @Autowired
    private UserInfoMapper userInfoMapper;

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public Integer insert(String userName, String password) {
        return userInfoMapper.insert(userName, password);
    }
}
@Service
public class LogInfoService {
    @Autowired
    private LogInfoMapper logInfoMapper;

    @Transactional(propagation = Propagation.REQUIRED)
    public Integer insert(String userName, String op) {
        int a = 10 / 0;
        return logInfoMapper.insertLog(userName, "用户注册");
    }
}

观察输出结果，第一个事务成功提交，即使第二个事务抛异常了也不受其影响

补充：上面的代码修改一下传播机制，也可以选择在另外一个LogInfoService改成REQUIRES_NEW，效果也是一样的，注意是都要UserService也要修改成REQUIRES_NEW，如果只在LogInfoService加效果就不是这样的了

3.NEVER

以非事务方式运行， 如果当前存在事务，则抛出异常。如果方法1存在事务，方法2就抛出异常

修改一下代码下面进行演示，一个是NEVER，一个是REQUIRES_NEW

@Service
public class LogInfoService {
    @Autowired
    private LogInfoMapper logInfoMapper;

    @Transactional(propagation = Propagation.NEVER)
    public Integer insert(String userName, String op) {
        return logInfoMapper.insertLog(userName, "用户注册");
    }
}
@Service
public class UserService {
    @Autowired
    private UserInfoMapper userInfoMapper;

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public Integer insert(String userName, String password) {
        return userInfoMapper.insert(userName, password);
    }
}

输出结果，抛异常了但是不影响另外一个REQUIRES_NEW传播机制级别的事务

4.Nested

如果当前存在事务，则创建⼀个事务作为当前事务的嵌套事务（可以看作是子事务）来运行。如果当前没有事务，则该取值等价于 PROPAGATION_REQUIRED。可以看作一个大公司可以有很多子公司，如果子公司发生问题肯定会影响到大公司

    •    下面先演示都正常的情况下，将两个事务传播机制级别都设置成NESTED

@Service
public class LogInfoService {
    @Autowired
    private LogInfoMapper logInfoMapper;

    @Transactional(propagation = Propagation.NESTED)
    public Integer insert(String userName, String op) {
        return logInfoMapper.insertLog(userName, "用户注册");
    }
}
@Service
public class UserService {
    @Autowired
    private UserInfoMapper userInfoMapper;

    @Transactional(propagation = Propagation.NESTED)
    public Integer insert(String userName, String password) {
        return userInfoMapper.insert(userName, password);
    }
}

观察输出结果，两个事务都提交成功

    •    看看异常情况是怎么样的

@Service
public class LogInfoService {
    @Autowired
    private LogInfoMapper logInfoMapper;

    @Transactional(propagation = Propagation.NESTED)
    public Integer insert(String userName, String op) {
        int a = 10 / 0;
        return logInfoMapper.insertLog(userName, "用户注册");
    }
}

观察输出结果，事务回滚了，和上面举的例子一个意思子公司发生问题肯定会影响到大公司

    •    设置回滚事务，看看和required的区别

@Service
public class LogInfoService {
    @Autowired
    private LogInfoMapper logInfoMapper;

    @Transactional(propagation = Propagation.NESTED)
    public Integer insert(String userName, String op) {
        try {
            int a = 10 / 0;
        } catch (Exception e) {
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
        return logInfoMapper.insertLog(userName, "用户注册");
    }
}

观察输出结果，虽然事务提交成功了，但是只有一个事务成功提交了

    •    设置required的看看区别

@Service
public class LogInfoService {
    @Autowired
    private LogInfoMapper logInfoMapper;

    @Transactional(propagation = Propagation.REQUIRED)
    public Integer insert(String userName, String op) {
        try {
            int a = 10 / 0;
        } catch (Exception e) {
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
        return logInfoMapper.insertLog(userName, "用户注册");
    }
}
@Service
public class UserService {
    @Autowired
    private UserInfoMapper userInfoMapper;

    @Transactional(propagation = Propagation.REQUIRED)
    public Integer insert(String userName, String password) {
        return userInfoMapper.insert(userName, password);
    }
}

观察输出结果，又回到第一种情况了，如果一个事务出现问题进行回滚，另外一个事务也会一起回滚，所以没有一个事务会提交成功

NESTED和REQUIRED 有什么区别？

嵌套事务（NESTED）不会回滚嵌套之前的事务，也就是说嵌套事务可以实现部分事务回滚。REQUIRED 如果回滚就是回滚所有事务，不能实现部分事务的回滚（因为属于同⼀个事务）。可以简单理解为NESTED法人不同，REQUIRED 法人相同


    •    1.整个事务如果全部执行成功，⼆者的结果是⼀样的

    •    2.如果事务⼀部分执行成功，REQUIRED加⼊事务会导致整个事务全部回滚。NESTED嵌套事务可以实现局部回滚，不会影响上⼀个⽅法中执⾏的结果


补充：嵌套事务之所以能够实现部分事务的回滚，是因为事务中有⼀个保存点(savepoint)的概念，嵌套事务进⼊之后相当于新建了⼀个保存点，⽽滚回时只回滚到当前保存点。REQUIRED 是加⼊到当前事务中，并没有创建事务的保存点，因此出现了回滚就是整个事务回滚，这就是嵌套事务和加⼊事务的区别

以上便是本章Spring事务的知识点，这章概念偏多，好了我们下一章再见💕

N_0050
关注
  • 37
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 13
    评论
专栏目录
Spring事务详解
Reggie97的博客
04-14 731
本文详细介绍了事务的特点，使用的方式，隔离级别，超时行为，传播行为等多种知识，并附带了Spring和SpringBoot两种框架的事务示例。
spring事务详解
xiasiyu123456的博客
07-23 721
本文将按照声明式事务的五个特性进行介绍： 事务传播机制 事务隔离机制 只读 事务超时 回滚规则 Spring事务传播机制 事务的特性 原子性（Atomicity）：事务是一个原子操作，由一系列动作组成。事务的原子性确保动作要么全部完成，要么完全不起作用。 一致性（Consistency）：一旦事务完成（不管成功还是失败），系统必须确保它所建模的业务处于一致的状态，而不会是部分完成部分失败。在现实中的数据不应该被破坏。 隔离性（Isolation）：可能有许多事务会同时处理相同的数据，因此每个事务都应该
spring 事务详解
weixin_46591962的博客
04-28 1016
spring 事务有两种 注解型事务和编程式事务。
Spring的事务详解
热门推荐
h295928126的博客
06-29 4万+
Spring的事务详解
Spring 事务（详解）
qq_45559559的博客
03-24 8989
将⼀组操作封装成⼀个执⾏单元，要么全部成功要么全部失败。
Spring中的事务详解
努力分享一些干货内容，纯干货，没有一点水
07-19 1222
但是随着事务越来越大，执行时间也会变长，就需要将这个大事务拆分成多个事务，如果确保这个事务能够拆分成多个事务，就需要指定Spring的事务传播行为。比如，在用户注册时候，需要记录注册日志，这时候可以将记录日志的操作单独划分为一个事务，而注册是另一个单独的事务，可以将保存日志的方法指定。事务隔离级别，即数据库中事务隔离级别，指的是一个事务对数据的修改与另一个并行的事务的隔离程度。事务传播行为指，当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行，是应该加入现有事务，还是应该启动一个新事务。
Spring事务详解与使用
itzhuzhu的博客
01-10 1553
J2EE开发使用分层设计的思想进行，对于简单的业务层转调数据层的单一操作，事务开启在业务层或者数据层并无太大差别，当业务中包含多个数据层的调用时，需要在业务层开启事务，对数据层中多个操作进行组合并归属于同一个事务进行处理
【Spring事务详解】--- 7.事务提交、回滚的流程分析
自律使我自由
01-24 1907
Spring事务详解连载
Spring之事务详解
上善若泪
02-25 1万+
1.Spring事物的定义： 事务，就是一组操作数据库的动作集合。事务是现代数据库理论中的核心概念之一。 如果一组处理步骤或者全部发生或者一步也不执行，我们称该组处理步骤为一个事务。 当所有的步骤像一个操作一样被完整地执行，我们称该事务被提交。 由于其中的一部分或多步执行失败，导致没有步骤被提交，则事务必须回滚到最初的系统状态。 2. spring七个事务传播属性： PROP......
Hibernate缓存与spring事务详解
03-29
**标题：“Hibernate缓存与Spring事务详解”** 在IT领域，尤其是Java开发中，Hibernate作为一款流行的ORM（对象关系映射）框架，极大地简化了数据库操作。而Spring框架则以其全面的功能，包括依赖注入、AOP（面向切...
java重点学习-spring
qq_40453972的博客
09-03 875
AOP称为面向切面编程，用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取并封装为一个可重用的模块，这个模块被命名为“切面”(Aspect)，减少系统中的重复代码，降低了模块间的耦合度，同时提高了系统的可维护性。常见的AOP使用场景记录操作日志、●缓存处理Spring中内置的事务处理什么是AOP面向切面编程，用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取公共模块复用，降低耦合你们项目中有没有使用到AOP。
SpringBoot 项目集成 xxl-job
qq_58159506的博客
09-03 742
SpringBoot 项目集成 xxl-job
springboot服务器文件读取工具类
最新发布
dashalen的博客
09-06 696
springboot服务器本地文件读取和网络文件读取
Spring理论知识（Ⅳ）——Spring Instrumentation模块
敢问路在何方，路在脚下
09-02 762
总的来说，Spring Instrumentation提供了类植入（Instrumentation）支持和类加载器的实现，可以在特定的应用服务器中使用。本质上是一种JVM级别（操作系统级别）的AOP，用到了代理java.lang.instrument（容器类）做动态Instrumentation是Java SE 5的新特性使用 Instrumentation，开发者可以构建一个独立于应用程序的代理程序（Agent），用来监测和协助运行在 JVM 上的程序，甚至能够替换和修改某些类的定义。
Spring MVC 八股文
szchen2的博客
09-02 1492
Spring MVC 是 Spring 提供的一个基于 MVC 设计模式的轻量级 Web 开发框架，本质上相当于 Servlet。它将model、view、controller分离，对web层进行解耦，把复杂的web应用分成逻辑清晰的几部分，简化开发，减少出错，方便组内开发人员之间的配合。
评论 13
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值