44.Spring声明事务怎么用的？

已于 2023-12-11 19:03:31 修改
阅读量31 收藏
点赞数
分类专栏： spring 文章标签： spring
于 2023-12-11 18:07:09 首次发布
原文链接：http://www.itsoku.com/course/5/126
版权

spring事务有2种用法：编程式事务和声明式事务。

编程式事务上一篇文章中已经介绍了，不熟悉的建议先看一下编程式事务的用法。

这篇主要介绍声明式事务的用法，我们在工作中基本上用的都是声明式事务，所以这篇文章是比较重要的，建议各位打起精神，正式开始。

什么是声明式事务？

所谓声明式事务，就是通过配置的方式，比如通过配置文件（xml）或者注解的方式，告诉spring，哪些方法需要spring帮忙管理事务，然后开发者只用关注业务代码，而事务的事情spring自动帮我们控制。

比如注解的方式，只需在方法上面加一个@Transaction注解，那么方法执行之前spring会自动开启一个事务，方法执行完毕之后，会自动提交或者回滚事务，而方法内部没有任何事务相关代码，用起来特别的方法。

 

  1. @Transaction
  2. public void insert(String userName){
  3. this.jdbcTemplate.update("insert into t_user (name) values (?)", userName);
  4. }
 

声明式事务的2种实现方式
 

  1. 配置文件的方式，即在spring xml文件中进行统一配置，开发者基本上就不用关注事务的事情了，代码中无需关心任何和事务相关的代码，一切交给spring处理。
  2. 注解的方式，只需在需要spring来帮忙管理事务的方法上加上@Transaction注解就可以了，注解的方式相对来说更简洁一些，都需要开发者自己去进行配置，可能有些同学对spring不是太熟悉，所以配置这个有一定的风险，做好代码review就可以了。
 

配置文件的方式这里就不讲了，用的相对比较少，我们主要掌握注解的方式如何使用，就可以了。
 

声明式事务注解方式5个步骤
 

1、启用Spring的注释驱动事务管理功能
 

在spring配置类上加上@EnableTransactionManagement注解
 

 

  1. @EnableTransactionManagement
  2. public class MainConfig4 {
  3. }
 

简要介绍一下原理：当spring容器启动的时候，发现有@EnableTransactionManagement注解，此时会拦截所有bean的创建，扫描看一下bean上是否有@Transaction注解（类、或者父类、或者接口、或者方法中有这个注解都可以），如果有这个注解，spring会通过aop的方式给bean生成代理对象，代理对象中会增加一个拦截器，拦截器会拦截bean中public方法执行，会在方法执行之前启动事务，方法执行完毕之后提交或者回滚事务。稍后会专门有一篇文章带大家看这块的源码。
 

如果有兴趣的可以自己先去读一下源码，主要是下面这个这方法会
 

 

  1. org.springframework.transaction.interceptor.TransactionInterceptor#invoke
 

再来看看 EnableTransactionManagement 的源码
 

 

  1. @Target(ElementType.TYPE)
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Documented
  4. @Import(TransactionManagementConfigurationSelector.class)
  5. public @interface EnableTransactionManagement {
  7. /**
  8. * spring是通过aop的方式对bean创建代理对象来实现事务管理的
  9. * 创建代理对象有2种方式，jdk动态代理和cglib代理
  10. * proxyTargetClass：为true的时候，就是强制使用cglib来创建代理
  11. */
  12. boolean proxyTargetClass() default false;
  14. /**
  15. * 用来指定事务拦截器的顺序
  16. * 我们知道一个方法上可以添加很多拦截器，拦截器是可以指定顺序的
  17. * 比如你可以自定义一些拦截器，放在事务拦截器之前或者之后执行，就可以通过order来控制
  18. */
  19. int order() default Ordered.LOWEST_PRECEDENCE;
  20. }
 

2、定义事务管理器
 

事务交给spring管理，那么你肯定要创建一个或者多个事务管理者，有这些管理者来管理具体的事务，比如启动事务、提交事务、回滚事务，这些都是管理者来负责的。
 

spring中使用PlatformTransactionManager这个接口来表示事务管理者。
 

PlatformTransactionManager多个实现类，用来应对不同的环境
 

 

JpaTransactionManager：如果你用jpa来操作db，那么需要用这个管理器来帮你控制事务。
 

DataSourceTransactionManager：如果你用是指定数据源的方式，比如操作数据库用的是：JdbcTemplate、mybatis、ibatis，那么需要用这个管理器来帮你控制事务。
 

HibernateTransactionManager：如果你用hibernate来操作db，那么需要用这个管理器来帮你控制事务。
 

JtaTransactionManager：如果你用的是java中的jta来操作db，这种通常是分布式事务，此时需要用这种管理器来控制事务。
 

比如：我们用的是mybatis或者jdbctemplate，那么通过下面方式定义一个事务管理器。
 

 

  1. @Bean
  2. public PlatformTransactionManager transactionManager(DataSource dataSource) {
  3. return new DataSourceTransactionManager(dataSource);
  4. }
 

3、需使用事务的目标上加@Transaction注解
 

  • @Transaction放在接口上，那么接口的实现类中所有public都被spring自动加上事务
  • @Transaction放在类上，那么当前类以及其下无限级子类中所有pubilc方法将被spring自动加上事务
  • @Transaction放在public方法上，那么该方法将被spring自动加上事务
  • 注意：@Transaction只对public方法有效
 

下面我们看一下@Transactional源码：
 

 

  1. @Target({ElementType.TYPE, ElementType.METHOD})
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Inherited
  4. @Documented
  5. public @interface Transactional {
  7. /**
  8. * 指定事务管理器的bean名称，如果容器中有多事务管理器PlatformTransactionManager，
  9. * 那么你得告诉spring，当前配置需要使用哪个事务管理器
  10. */
  11. @AliasFor("transactionManager")
  12. String value() default "";
  14. /**
  15. * 同value，value和transactionManager选配一个就行，也可以为空，如果为空，默认会从容器中按照类型查找一个事务管理器bean
  16. */
  17. @AliasFor("value")
  18. String transactionManager() default "";
  20. /**
  21. * 事务的传播属性
  22. */
  23. Propagation propagation() default Propagation.REQUIRED;
  25. /**
  26. * 事务的隔离级别，就是制定数据库的隔离级别，数据库隔离级别大家知道么？不知道的可以去补一下
  27. */
  28. Isolation isolation() default Isolation.DEFAULT;
  30. /**
  31. * 事务执行的超时时间（秒），执行一个方法，比如有问题，那我不可能等你一天吧，可能最多我只能等你10秒
  32. * 10秒后，还没有执行完毕，就弹出一个超时异常吧
  33. */
  34. int timeout() default TransactionDefinition.TIMEOUT_DEFAULT;
  36. /**
  37. * 是否是只读事务，比如某个方法中只有查询操作，我们可以指定事务是只读的
  38. * 设置了这个参数，可能数据库会做一些性能优化，提升查询速度
  39. */
  40. boolean readOnly() default false;
  42. /**
  43. * 定义零(0)个或更多异常类，这些异常类必须是Throwable的子类，当方法抛出这些异常及其子类异常的时候，spring会让事务回滚
  44. * 如果不配做，那么默认会在 RuntimeException 或者 Error 情况下，事务才会回滚 
  45. */
  46. Class<? extends Throwable>[] rollbackFor() default {};
  48. /**
  49. * 和 rollbackFor 作用一样，只是这个地方使用的是类名
  50. */
  51. String[] rollbackForClassName() default {};
  53. /**
  54. * 定义零(0)个或更多异常类，这些异常类必须是Throwable的子类，当方法抛出这些异常的时候，事务不会回滚
  55. */
  56. Class<? extends Throwable>[] noRollbackFor() default {};
  58. /**
  59. * 和 noRollbackFor 作用一样，只是这个地方使用的是类名
  60. */
  61. String[] noRollbackForClassName() default {};
  63. }
 

参数介绍
 

参数描述
value指定事务管理器的bean名称，如果容器中有多事务管理器PlatformTransactionManager，那么你得告诉spring，当前配置需要使用哪个事务管理器
transactionManager同value，value和transactionManager选配一个就行，也可以为空，如果为空，默认会从容器中按照类型查找一个事务管理器bean
propagation事务的传播属性，下篇文章详细介绍
isolation事务的隔离级别，就是制定数据库的隔离级别，数据库隔离级别大家知道么？不知道的可以去补一下
timeout事务执行的超时时间（秒），执行一个方法，比如有问题，那我不可能等你一天吧，可能最多我只能等你10秒 10秒后，还没有执行完毕，就弹出一个超时异常吧
readOnly是否是只读事务，比如某个方法中只有查询操作，我们可以指定事务是只读的 设置了这个参数，可能数据库会做一些性能优化，提升查询速度
rollbackFor定义零(0)个或更多异常类，这些异常类必须是Throwable的子类，当方法抛出这些异常及其子类异常的时候，spring会让事务回滚 如果不配做，那么默认会在 RuntimeException 或者 Error 情况下，事务才会回滚
rollbackForClassName同 rollbackFor，只是这个地方使用的是类名
noRollbackFor定义零(0)个或更多异常类，这些异常类必须是Throwable的子类，当方法抛出这些异常的时候，事务不会回滚
noRollbackForClassName同 noRollbackFor，只是这个地方使用的是类名
 

4、执行db业务操作
 

在@Transaction标注类或者目标方法上执行业务操作，此时这些方法会自动被spring进行事务管理。
 

如，下面的insertBatch操作，先删除数据，然后批量插入数据，方法上加上了@Transactional注解，此时这个方法会自动受spring事务控制，要么都成功，要么都失败。
 

 

  1. @Component
  2. public class UserService {
  3. @Autowired
  4. private JdbcTemplate jdbcTemplate;
  6. //先清空表中数据，然后批量插入数据，要么都成功要么都失败
  7. @Transactional
  8. public void insertBatch(String... names) {
  9. jdbcTemplate.update("truncate table t_user");
  10. for (String name : names) {
  11. jdbcTemplate.update("INSERT INTO t_user(name) VALUES (?)", name);
  12. }
  13. }
  14. }
 

5、启动spring容器，使用bean执行业务操作
 

 

  1. @Test
  2. public void test1() {
  3. AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
  4. context.register(MainConfig4.class);
  5. context.refresh();
  7. UserService userService = context.getBean(UserService.class);
  8. userService.insertBatch("java高并发系列", "mysql系列", "maven系列", "mybatis系列");
  9. }
 

案例1
 

准备数据库
 

 

  1. DROP DATABASE IF EXISTS javacode2018;
  2. CREATE DATABASE if NOT EXISTS javacode2018;
  4. USE javacode2018;
  5. DROP TABLE IF EXISTS t_user;
  6. CREATE TABLE t_user(
  7. id int PRIMARY KEY AUTO_INCREMENT,
  8. name varchar(256) NOT NULL DEFAULT '' COMMENT '姓名'
  9. );
 

spring配置类
 

 

  1. package com.javacode2018.tx.demo4;
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.context.annotation.ComponentScan;
  5. import org.springframework.context.annotation.Configuration;
  6. import org.springframework.jdbc.core.JdbcTemplate;
  7. import org.springframework.jdbc.datasource.DataSourceTransactionManager;
  8. import org.springframework.transaction.PlatformTransactionManager;
  9. import org.springframework.transaction.annotation.EnableTransactionManagement;
  10. import org.springframework.transaction.support.TransactionTemplate;
  12. import javax.sql.DataSource;
  14. @EnableTransactionManagement //@1
  15. @Configuration
  16. @ComponentScan
  17. public class MainConfig4 {
  18. //定义一个数据源
  19. @Bean
  20. public DataSource dataSource() {
  21. org.apache.tomcat.jdbc.pool.DataSource dataSource = new org.apache.tomcat.jdbc.pool.DataSource();
  22. dataSource.setDriverClassName("com.mysql.jdbc.Driver");
  23. dataSource.setUrl("jdbc:mysql://localhost:3306/javacode2018?characterEncoding=UTF-8");
  24. dataSource.setUsername("root");
  25. dataSource.setPassword("root123");
  26. dataSource.setInitialSize(5);
  27. return dataSource;
  28. }
  30. //定义一个JdbcTemplate,用来执行db操作
  31. @Bean
  32. public JdbcTemplate jdbcTemplate(DataSource dataSource) {
  33. return new JdbcTemplate(dataSource);
  34. }
  36. //定义我一个事物管理器
  37. @Bean
  38. public PlatformTransactionManager transactionManager(DataSource dataSource) { //@2
  39. return new DataSourceTransactionManager(dataSource);
  40. }
  41. }
 

@1：使用@EnableTransactionManagement注解开启spring事务管理
 

@2：定义事务管理器
 

来个业务类
 

 

  1. package com.javacode2018.tx.demo4;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.jdbc.core.JdbcTemplate;
  5. import org.springframework.stereotype.Component;
  6. import org.springframework.transaction.annotation.Transactional;
  8. import java.util.List;
  9. import java.util.Map;
  11. @Component
  12. public class UserService {
  13. @Autowired
  14. private JdbcTemplate jdbcTemplate;
  16. //先清空表中数据，然后批量插入数据，要么都成功要么都失败
  17. @Transactional //@1
  18. public int insertBatch(String... names) {
  19. int result = 0;
  20. jdbcTemplate.update("truncate table t_user");
  21. for (String name : names) {
  22. result += jdbcTemplate.update("INSERT INTO t_user(name) VALUES (?)", name);
  23. }
  24. return result;
  25. }
  27. //获取所有用户信息
  28. public List<Map<String, Object>> userList() {
  29. return jdbcTemplate.queryForList("SELECT * FROM t_user");
  30. }
  31. }
 

@1：insertBatch方法上加上了@Transactional注解，让spring来自动为这个方法加上事务
 

测试类
 

 

  1. package com.javacode2018.tx.demo4;
  3. import org.junit.Test;
  4. import org.springframework.context.annotation.AnnotationConfigApplicationContext;
  6. public class Demo4Test {
  7. @Test
  8. public void test1() {
  9. AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
  10. context.register(MainConfig4.class);
  11. context.refresh();
  13. UserService userService = context.getBean(UserService.class);
  14. //先执行插入操作
  15. int count = userService.insertBatch(
  16. "java高并发系列",
  17. "mysql系列",
  18. "maven系列",
  19. "mybatis系列");
  20. System.out.println("插入成功（条）：" + count);
  21. //然后查询一下
  22. System.out.println(userService.userList());
  23. }
  24. }
 

运行输出
 

 

  1. 插入成功（条）：4
  2. [{id=1, name=java高并发系列}, {id=2, name=mysql系列}, {id=3, name=maven系列}, {id=4, name=mybatis系列}]
 

有些朋友可能会问，如何知道这个被调用的方法有没有使用事务？ 下面我们就来看一下。
 

如何确定方法有没有用到spring事务
 

方式1：断点调试
 

spring事务是由TransactionInterceptor拦截器处理的，最后会调用下面这个方法，设置个断点就可以看到详细过程了。
 

 

  1. org.springframework.transaction.interceptor.TransactionAspectSupport#invokeWithinTransaction
 

 

方式2：看日志
 

spring处理事务的过程，有详细的日志输出，开启日志，控制台就可以看到事务的详细过程了。
 

添加maven配置
 

 

  1. <dependency>
  2. <groupId>ch.qos.logback</groupId>
  3. <artifactId>logback-classic</artifactId>
  4. <version>1.2.3</version>
  5. </dependency>
 

src\main\resources新建logback.xml
 

 

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <configuration>
  3. <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
  4. <encoder>
  5. <pattern>[%d{MM-dd HH:mm:ss.SSS}][%thread{20}:${PID:- }][%X{trace_id}][%level][%logger{56}:%line:%method\(\)]:%msg%n##########**********##########%n</pattern>
  6. </encoder>
  7. </appender>
  9. <logger name="org.springframework" level="debug">
  10. <appender-ref ref="STDOUT" />
  11. </logger>
  13. </configuration>
 

再来运行一下案例1
 

 

  1. [09-10 11:20:38.830][main: ][][DEBUG][o.s.jdbc.datasource.DataSourceTransactionManager:370:getTransaction()]:Creating new transaction with name [com.javacode2018.tx.demo4.UserService.insertBatch]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
  2. ##########**********##########
  3. [09-10 11:20:39.120][main: ][][DEBUG][o.s.jdbc.datasource.DataSourceTransactionManager:265:doBegin()]:Acquired Connection [ProxyConnection[PooledConnection[com.mysql.jdbc.JDBC4Connection@65fe9e33]]] for JDBC transaction
  4. ##########**********##########
  5. [09-10 11:20:39.125][main: ][][DEBUG][o.s.jdbc.datasource.DataSourceTransactionManager:283:doBegin()]:Switching JDBC Connection [ProxyConnection[PooledConnection[com.mysql.jdbc.JDBC4Connection@65fe9e33]]] to manual commit
  6. ##########**********##########
  7. [09-10 11:20:39.139][main: ][][DEBUG][org.springframework.jdbc.core.JdbcTemplate:502:update()]:Executing SQL update [truncate table t_user]
  8. ##########**********##########
  9. [09-10 11:20:39.169][main: ][][DEBUG][org.springframework.jdbc.core.JdbcTemplate:860:update()]:Executing prepared SQL update
  10. ##########**********##########
  11. [09-10 11:20:39.169][main: ][][DEBUG][org.springframework.jdbc.core.JdbcTemplate:609:execute()]:Executing prepared SQL statement [INSERT INTO t_user(name) VALUES (?)]
  12. ##########**********##########
  13. [09-10 11:20:39.234][main: ][][DEBUG][org.springframework.jdbc.core.JdbcTemplate:860:update()]:Executing prepared SQL update
  14. ##########**********##########
  15. [09-10 11:20:39.235][main: ][][DEBUG][org.springframework.jdbc.core.JdbcTemplate:609:execute()]:Executing prepared SQL statement [INSERT INTO t_user(name) VALUES (?)]
  16. ##########**********##########
  17. [09-10 11:20:39.236][main: ][][DEBUG][org.springframework.jdbc.core.JdbcTemplate:860:update()]:Executing prepared SQL update
  18. ##########**********##########
  19. [09-10 11:20:39.237][main: ][][DEBUG][org.springframework.jdbc.core.JdbcTemplate:609:execute()]:Executing prepared SQL statement [INSERT INTO t_user(name) VALUES (?)]
  20. ##########**********##########
  21. [09-10 11:20:39.238][main: ][][DEBUG][org.springframework.jdbc.core.JdbcTemplate:860:update()]:Executing prepared SQL update
  22. ##########**********##########
  23. [09-10 11:20:39.239][main: ][][DEBUG][org.springframework.jdbc.core.JdbcTemplate:609:execute()]:Executing prepared SQL statement [INSERT INTO t_user(name) VALUES (?)]
  24. ##########**********##########
  25. [09-10 11:20:39.241][main: ][][DEBUG][o.s.jdbc.datasource.DataSourceTransactionManager:741:processCommit()]:Initiating transaction commit
  26. ##########**********##########
  27. [09-10 11:20:39.241][main: ][][DEBUG][o.s.jdbc.datasource.DataSourceTransactionManager:328:doCommit()]:Committing JDBC transaction on Connection [ProxyConnection[PooledConnection[com.mysql.jdbc.JDBC4Connection@65fe9e33]]]
  28. ##########**********##########
  29. [09-10 11:20:39.244][main: ][][DEBUG][o.s.jdbc.datasource.DataSourceTransactionManager:387:doCleanupAfterCompletion()]:Releasing JDBC Connection [ProxyConnection[PooledConnection[com.mysql.jdbc.JDBC4Connection@65fe9e33]]] after transaction
  30. ##########**********##########
  31. 插入成功（条）：4
  32. [09-10 11:20:39.246][main: ][][DEBUG][org.springframework.jdbc.core.JdbcTemplate:427:query()]:Executing SQL query [SELECT * FROM t_user]
  33. ##########**********##########
  34. [09-10 11:20:39.247][main: ][][DEBUG][org.springframework.jdbc.datasource.DataSourceUtils:115:doGetConnection()]:Fetching JDBC Connection from DataSource
  35. ##########**********##########
  36. [{id=1, name=java高并发系列}, {id=2, name=mysql系列}, {id=3, name=maven系列}, {id=4, name=mybatis系列}]
 

来理解一下日志
 

insertBatch方法上有@Transaction注解，所以会被拦截器拦截，下面是在insertBatch方法调用之前，创建了一个事务。
 

 

insertBatch方法上@Transaction注解参数都是默认值，@Transaction注解中可以通过value或者transactionManager来指定事务管理器，但是没有指定，此时spring会在容器中按照事务管理器类型找一个默认的，刚好我们在spring容器中定义了一个，所以直接拿来用了。事务管理器我们用的是new DataSourceTransactionManager(dataSource)，从事务管理器的datasource中获取一个数据库连接，然后通过连接设置事务为手动提交，然后将（datasource->这个连接)丢到ThreadLocal中了，具体为什么，可以看上一篇文章。
 

 

下面就正是进入insertBatch方法内部了，通过jdbctemplate执行一些db操作，jdbctemplate内部会通过datasource到上面的threadlocal中拿到spring事务那个连接，然后执行db操作。
 

 

最后insertBatch方法执行完毕之后，没有任何异常，那么spring就开始通过数据库连接提交事务了。
 

 

总结
 

本文讲解了一下spring中编程式事务的使用步骤。
 

主要涉及到了2个注解：
 

@EnableTransactionManagement：开启spring事务管理功能
 

@Transaction：将其加在需要spring管理事务的类、方法、接口上，只会对public方法有效。
 

大家再消化一下，有问题，欢迎留言交流。
 

下篇文章将详细介绍事务的传播属性，敬请期待。
 

案例源码
 

 

  1. git地址：
  2. https://gitee.com/javacode2018/spring-series
  4. 本文案例对应源码：spring-series\lesson-002-tx\src\main\java\com\javacode2018\tx\demo4

                

        

        

    




    

      

        

            

              
                
                  老徐徐老
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                  1
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
什么是事务？spring如何处理事务？

				
			

			

				

					shisannnn的博客
				

				

					08-26
					
					1734
					
				

			

		

		

			
				
spring的事务处理
1.什么是事务？
 mysql开始，提出了事务的概念。事务是指一组sql语句的集合，集合中有多条sql语句，可能是insert，update，select，delete，我们希望这些多个sql语句都能成功，或者失败，这些sql语句的执行是一致的，作为一个整体执行。
2.在什么时候想到使用事务？
 当我们的操作涉及到多个表，或者是多个sql语句的insert、update、delete。需要保证这些语句都是成功才能完成我们的功能，或者都失败，保证操作是符合要求的。
 列如a转账给b，那

			
		

	



                

              
                



	

		

			

				
					
Spring 声明式事务

				
			

			

				

					qq_43668183的博客
				

				

					05-05
					
					409
					
				

			

		

		

			
				
声明式事务声明式事务控制1. 编程式事务控制相关对象1.1 PlatformTransactionManager1.2 TransactionDefinition1. 事务隔离级别2. 事务传播行为1.3 TransactionStatus1.4 知识要点2 基于 XML 的声明式事务控制2.1 什么是声明式事务控制2.2 声明式事务控制的实现2.3 切点方法的事务参数的配置2.4 知识要点3 基于注解的声明式事务控制3.1 使用注解配置声明式事务控制3.2 注解配置声明式事务控制解析3.3 知识要点
声明

			
		

	



                


  
              

                


	

		

			

				
					
Spring——什么是事务？传播行为？事务隔离级别有哪些？

				
			

			

				

					一起加油吧~
				

				

					03-04
					
					2658
					
				

			

		

		

			
				
Spring——什么是事务？传播行为？事务隔离级别有哪些？

			
		

	





	

		

			

				
					
Spring声明式事务管理

				
			

			

				

					nuist_NJUPT的博客
				

				

					06-20
					
					1498
					
				

			

		

		

			
				
Spring声明式事务管理
Spring的声明式事务管理是通过AOP技术实现的事务管理，其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行目标方法之后根据执行情况提交或者回滚事务。
声明式事务管理的最大优点是不需要通过编程的方式管理事务，因而不需要在业务逻辑代码中掺杂事务处理代码，只需要相关的事务规则声明便可以将事务规则应用到业务逻辑中，在通常情况下，在开发中使用声明式事务管理不仅因为简单，更主要因为纯业务代码不会被污染，极大地方便代码的后期维护。
Spring声明式事务管理可以

			
		

	



		

			
		



	

		

			

				
					
Spring声明式事务管理实现及原理详解

				
			

			

				

					
				

				

					11-07
					
					2099
					
				

			

		

		

			
				
目录

1、实现步骤

1.1、配置事务管理器

1.2、启动事务注解

1.3、业务添加注解

2、代码演示

2.1、bean文件

2.2、目标类

2.3、测试类

3、Spring事务属性

3.1、传播行为

3.2、隔离级别

3.3、回滚属性

3.4、超时和只读

4、Spring事务回滚原则

5、Spring事务失效原因

5.1、数据库引擎

5.2、方法属性

5.3、抛...

			
		

	





	

		

			

				
					
spring声明式事务

				
			

			

				

					时光
				

				

					06-29
					
					2666
					
				

			

		

		

			
				
spring声明式事务

			
		

	





	

		

			

				
					
Spring系列之详解spring声明式事务(@Transactional)

				
			

			

				

					azhou的代码园
				

				

					05-16
					
					1725
					
				

			

		

		

			
				
什么是声明式事务？

所谓声明式事务，就是通过配置的方式，比如通过配置文件（xml）或者注解的方式，告诉spring，哪些方法需要spring帮忙管理事务，然后开发者只用关注业务代码，而事务的事情spring自动帮我们控制。

比如注解的方式，只需在方法上面加一个@Transaction注解，那么方法执行之前spring会自动开启一个事务，方法执行完毕之后，会自动提交或者回滚事务，而方法内部没有任何事务相关代码，用起来特别的方法。


@Transaction
publicvoidinsert(Stri..

			
		

	





	

		

			

				
					
如何正确打开 Spring 事务？

				
			

			

				

					大鹏的博客
				

				

					07-07
					
					4076
					
				

			

		

		

			
				
Spring 事务传播行为是 Spring 中一个常见的面试题，它贯穿于 Spring 的事务管理中，因此想要理解 Spring 事务传播行为，首先要对 Spring 的事务管理有一个整体的认识。本篇先对 Spring 事务的使用加以介绍，后续逐步分析 Spring 事务实现，直至深入理解 Spring 事务传播行为为止。...

			
		

	





	

		

			

				
					
详解 Spring 声明式事务

				
			

			

				

					Jitwxs
				

				

					06-13
					
					4000
					
				

			

		

		

			
				
一、引言
Spring的事务机制包括声明式事务和编程式事务。


编程式事务管理：Spring推荐使用 TransactionTemplate，实际开发中使用声明式事务较多。


声明式事务管理：将我们从复杂的事务处理中解脱出来，获取连接，关闭连接、事务提交、回滚、异常处理等这些操作都不用我们处理了，Spring都会帮我们处理。
声明式事务管理使用了 AOP 实现的，本质就是在目标方法执行前后进行...

			
		

	





	

		

			

				
					
Spring的事务（Transaction）

					
热门推荐

				
			

			

				

					陌守
				

				

					02-23
					
					1万+
					
				

			

		

		

			
				
Spring的事务（Transaction）


问题：
1、什么是事务？
事务是指一组SQL语句的集合，集合中有多条SQL语句，可以是insert、update、select、delete，希望这些SQL语句执行是一致的，作为一个整体执行。要么都成功，要么都失败。
2、什么时候想到使用事务？
（1）当操作设计多个表，或者是多个SQL语句的insert、update、delete。需要保证这些语句都是成功才能完成功能，或者都失败是符合要求的。（要么都成功，要么都失败）
（2）事务在java开发中如何运用？


			
		

	





	

		

			

				
					
Spring声明式事务配置管理方法

				
			

			

				

					03-02
				

			

		

		

			
				
发布于2013-5-6项目使用SSH架构，现在要添加Spring事务管理功能，针对当前环境，只需要添加Spring2.0AOP类库即可。添加方法：点击项目右键->BuildPath->Addlibrarys:打开AddLibraries对话框，然后选定...

			
		

	





	

		

			

				
					
spring声明式事务.zip

				
			

			

				

					08-19
				

			

		

		

			
				
本文将深入探讨Spring声明式事务的实现机制、优缺点以及如何在实际项目中进行配置和使用。  1. **声明式事务管理概述**  声明式事务管理与编程式事务管理相对，后者需要开发者在代码中显式调用开始、提交、回滚等...

			
		

	





	

		

			

				
					
实验 spring 声明事务

				
			

			

				

					11-09
				

			

		

		

			
				
实验 "Spring 声明事务" 是 Java 高级编程中的一个重要环节，旨在让学生掌握 Spring 框架中声明式事务管理的配置和使用。在实际应用中，事务管理是确保数据一致性、完整性和可靠性的关键组件。Spring 提供了声明式...

			
		

	





	

		

			

				
					
spring 自定义事务管理器，编程式事务，声明式事务@Transactional使用

				
			

			

				

					07-13
				

			

		

		

			
				
本教程将深入探讨如何在Spring中实现自定义事务管理器、编程式事务处理以及声明式事务`@Transactional`的使用。  首先，让我们了解事务管理的基本概念。事务是一组数据库操作，这些操作要么全部执行，要么全部回滚，...

			
		

	





	

		

			

				
					
Spring实战之使用注解实现声明式事务操作示例

				
			

			

				

					08-25
				

			

		

		

			
				
Spring实战之使用注解实现声明式事务操作示例  在本文中，我们将详细介绍如何使用 Spring 框架来实现声明式事务操作，通过对配置文件和接口实现的分析，来描述如何使用注解来实现事务操作。  事务管理  在 Spring ...

			
		

	





	

		

			

				
					
Spring Security的Filter

				
			

			

				

					weixin_44263023的博客
				

				

					07-08
					
					702
					
				

			

		

		

			
				
如果你需要实现一些 Spring Security 没有提供的特定安全功能，你可以通过实现 javax.servlet.Filter 接口来创建自定义的过滤器，并使用 Spring Security 的 FilterRegistrationBean 或通过 Spring Security 的配置类将其添加到过滤器链中。

			
		

	





	

		

			

				
					
Spring常见的自定义和扩展的方法

					
最新发布

				
			

			

				

					Casual_Lei的博客
				

				

					07-12
					
					166
					
				

			

		

		

			
				
通过类和@Bean方法，自定义Bean的创建过程。@Bean使用Spring AOP（Aspect-Oriented Programming）自定义注解和拦截方法调用。通过实现接口，在Bean的初始化前后添加自定义逻辑。@Component@Override@Override通过实现接口，可以在Bean定义加载后但在Bean实例化前修改Bean定义。@Component@Override通过实现接口，监听Spring应用上下文事件。

			
		

	





	

		

			

				
					
5.SpringBoot核心源码-启动类源码分析

				
			

			

				

					流月up的博客
				

				

					07-12
					
					261
					
				

			

		

		

			
				
SpringBoot核心源码-启动类源码分析

			
		

	





	

		

			

				
					
Springboot 配置 log4j2 时的注意事项

				
			

			

				

					rainyspring4540的专栏
				

				

					07-08
					
					339
					
				

			

		

		

			
				
因此，在使用 log4j2 日志时，必须要在依赖中把 logback 给 exclude 掉。并且，使用 log4j2 日志还需要适配器 log4j-slf4j-impl，它跟 SpringBoot 的 starter 自带的 log4j-to-slf4j 是相互冲突的，因此还需要将 log4j-to-slf4j 也 exclude 掉。logback 日志和 log4j2 日志都是对 slf4j 门面的实现，只能存在一个，且必须存在一个，不存在或者存在多个都会出错。

			
		

	





	

		

			

				
					
spring声明式事务配置方法.docx

				
			

			

				

					04-16
				

			

		

		

			
				
Spring 声明式事务配置方法  Spring 声明式事务配置是指在 Spring 框架中通过配置文件或注解的方式来管理事务的提交和回滚。这种配置方法可以使得事务管理变得更加灵活和可靠。  TransactionProxyFactoryBean 方式是...

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		
评论 1

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值