spring事务传播机制和隔离级别

原文链接： https://blog.csdn.net/qq_17085835/article/details/84837253

    Spring的事务，也就是数据库的事务操作，符合ACID标准，也具有标准的事务隔离级别。

    但是Spring事务有自己的特点，也就是事务传播机制。

    所谓事务传播机制，也就是在事务在多个方法的调用中是如何传递的，是重新创建事务还是使用父方法的事务？父方法的回滚对子方法的事务是否有影响？这些都是可以通过事务传播机制来决定的。

    本文就测试一下这些事务传播机制的使用及异同

 

1.准备测试方法

 

    主要是创建两个service接口（接口主要是对数据库表的操作），并创建其实现类

 

    1）创建beans.xml，开启事务

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
	
	<tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

   2）创建实体类和表（表创建读者可自定义创建）

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Blog {
	private int id;
	private String name;
	private String ur;
}

    3）创建service接口（BlogService和BlogService2，主要是对Blog的不同操作）

// BlogService
package jdbc;
// 主要负责Blog的添加和修改
public interface BlogService {
	void save(Blog blog);
	void update(Blog blog);
}
 
// BlogService2
package jdbc;
// 主要负责Blog的删除
public interface BlogService2 {
	void delete(int id);
}

    4）创建其实现类（BlogServiceImpl，BlogService2）

    BlogServiceImpl.java

@Transactional(propagation=Propagation.REQUIRED)
@Component
public class BlogServiceImpl implements BlogService {
 
	@Autowired
	private JdbcTemplate jdbcTemplate;
	
	@Autowired
	private BlogService2 blogService2;
	
	@Override
	public void save(Blog blog) {
 
		String sql = "insert into blog values(?,?,?)";
		jdbcTemplate.update(sql,
			new Object[]{blog.getId(),blog.getName(),blog.getUr()},
			new int[]{java.sql.Types.INTEGER,java.sql.Types.VARCHAR,java.sql.Types.VARCHAR});
		
		blogService2.delete(16);
//		update(blog);
//		throw new RuntimeException("error");
		
	}
	
	@Override
	public void update(Blog blog){
		
		String sql = "update blog set name = ? where id=?";
		jdbcTemplate.update(sql, new Object[]{blog.getName(),blog.getId()},
				new int[]{java.sql.Types.VARCHAR,java.sql.Types.INTEGER});
	}
}

    BlogService2.java

@Transactional(propagation=Propagation.REQUIRED)
@Component
public class BlogServiceImpl2 implements BlogService2 {
 
	@Autowired
	private JdbcTemplate jdbcTemplate;
	
	@Override
	public void delete(int id){
		
		String sql = "delete from blog where id=?";
		jdbcTemplate.update(sql, id);
	}
}

    注意：既然要实现多事务的传播，就需要在一个方法里调用另一个类的方法，下面的测试就是基于这种方法，在BlogService的save()方法中调用BlogService2的delete()方法

 

    5）创建Configuration类，用于创建DataSource实现

@Configuration
@ComponentScan(basePackages={"jdbc"})// 扫描BlogService实现类所在的包路径
@ImportResource(locations={"classpath:beans.xml"})// 添加事务管理
public class JdbcConfig {
 
	@Bean
	public JdbcTemplate jdbcTemplate(DataSource dataSource){
		return new JdbcTemplate(dataSource);
	}
	
	@Bean
	public DataSourceTransactionManager transactionManager(DataSource dataSource){
		return new DataSourceTransactionManager(dataSource);
	}
	
	@Bean
	public DataSource dataSource(){
		try {
			return new SimpleDriverDataSource(new com.mysql.jdbc.Driver(), "jdbc:mysql://localhost:3306/test", "root", "root");
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}
}

    6）测试

public class Test {
 
	public static void main(String[] args) {
		AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(JdbcConfig.class);
		BlogService service = ac.getBean(BlogService.class);
		
		Blog b = new Blog(18,"lili","url");
		service.save(b);
	}
}

总结：大体的测试框架就如上所示，下面的测试修改主要是修改BlogServiceImpl和BlogServiceImpl2的事务传播机制@Transactional(propagation=Propagation.REQUIRED)

 

 

3.事务传播机制的测试

 

    1）REQUIRED

    定义：如果有事务则加入事务，如果没有事务，则创建一个新的（默认值）

    操作1：将BlogServiceImpl和BlogServiceImpl2的事务传播机制都修改为

@Transactional(propagation=Propagation.REQUIRED)

    结果1：

    操作2：将BlogServiceImpl事务传播机制修改为@Transactional(propagation=Propagation.NOT_SUPPORTED)，BlogServiceImpl2的仍为@Transactional(propagation=Propagation.REQUIRED)

    结果2：

    总结：

        当BlogServiceImpl提供事务的时候，BlogServiceImpl2的方法执行使用当前已有事务，不再新建事务；

        当BlogServiceImpl不创建事务的时候，BlogServiceImpl2的方法执行发现没有事务可用，自己新建事务；

    

 

    2）NOT_SUPPORTED

    定义：Spring不为当前方法开启事务，相当于没有事务

    操作：将BlogServiceImpl和BlogServiceImpl2的事务传播机制都

修改为@Transactional(propagation=Propagation.NOT_SUPPORTED)

    结果：

    总结：

        NOT_SUPPORTED相当于没有Spring事务，每条执行语句单独执行，单独提交

 

 

    3）REQUIRES_NEW

    定义：不管是否存在事务，都创建一个新的事务，原来的方法挂起，新的方法执行完毕后，继续执行老的事务

    操作：将BlogServiceImpl事务传播机制修改为@Transactional(propagation=Propagation.REQUIRED)，BlogServiceImpl2的仍为@Transactional(propagation=Propagation.REQUIRES_NEW)

    结果：

    总结：

        REQUIRES_NEW为当前方法创建一个新的事务，并且当前事务先提交，然后再提交老的事务

 

 

    4）MANDATORY

    定义：必须在一个已有的事务中执行，否则报错

  操作：将BlogServiceImpl事务传播机制修改为@Transactional(propagation=Propagation.NOT_SUPPORTED)，BlogServiceImpl2的仍为@Transactional(propagation=Propagation.MANDATORY)，查看是否报错

    结果：

    总结：    

        MANDATORY必须在已有事务下被调用，否则报错

        NOT_SUPPORTED执行数据库层面的事务操作，故当前测试中，insert方法成功执行，delete方法的抛错并不影响insert方法的执行

 

 

    5）NEVER

    定义：必须在一个没有的事务中执行，否则报错

    操作：将BlogServiceImpl事务传播机制修改为@Transactional(propagation=Propagation.REQUIRED)，BlogServiceImpl2的仍为@Transactional(propagation=Propagation.MANDATORY)，查看是否报错

    结果： 

    总结：

        NEVER必须在没有事务的方法中执行，否则报错；

        save方法开启一个事务，还没来及提交发现delete方法报错，只能回滚事务

 

 

    6）SUPPORTS

    定义：如果其他bean调用这个方法时，其他bean声明了事务，则就用这个事务，如果没有声明事务，那就不用事务

    操作1：将BlogServiceImpl事务传播机制修改为@Transactional(propagation=Propagation.REQUIRED)，BlogServiceImpl2的仍为@Transactional(propagation=Propagation.SUPPORTS)

    结果1：

    操作1：将BlogServiceImpl事务传播机制修改为@Transactional(propagation=Propagation.NOT_SUPPORTED)，BlogServiceImpl2的仍为@Transactional(propagation=Propagation.SUPPORTS)

    结果1：

    总结：

        SUPPORTS类型的事务传播机制，是否使用事务取决于调用方法是否有事务，如果有则直接用，如果没有则不使用事务

 

 

    7）NESTED

    定义：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与REQUIRED类似的操作

    操作1：将BlogServiceImpl事务传播机制修改为@Transactional(propagation=Propagation.REQUIRED)，BlogServiceImpl2的仍为@Transactional(propagation=Propagation.NESTED)

    结果1：

    操作2：将BlogServiceImpl事务传播机制修改为@Transactional(propagation=Propagation.NOT_SUPPORTED)，BlogServiceImpl2的仍为@Transactional(propagation=Propagation.NESTED)

    结果2：

    总结：

        save方法创建一个事务，则再调用delete方法时，直接在该事务的基础上创建一个嵌套事务，本质上还是同一个事务，做一次提交；

        save方法不创建事务，则调用delete方法时，直接创建一个新的事务，单独提交

 

 

4.注意事项

 

    1）REQUIRED

        当两个方法的传播机制都是REQUIRED时，如果一旦发生回滚，两个方法都会回滚

 

    2）REQUIRES_NEW

        当delete方法传播机制为REQUIRES_NEW，会开启一个新的事务，并单独提交方法，所以save方法的回滚并不影响delete方法事务提交

 

    3）NESTED

        当save方法为REQUIRED，delete方法为NESTED时，delete方法开启一个嵌套事务；

        当save方法回滚时，delete方法也会回滚；反之，如果delete方法回滚，则并不影响save方法的提交

 

 

 

spring事务的四种隔离级别

1、事务的四大特性（ACID）

• 原子性
  操作要么全部成功，要么全部失败回滚。
• 一致性
  事务执行前和执行后处于一致性状态。例如，转账前A、B共5000元，A、B之间转账后，两者之和仍应该是5000元。
• 隔离性
  事务之间互不干扰。
• 持久性
  事务一旦提交，数据的改变是永久性的，即使这时候数据库发生故障，数据也不会丢失。

2、与事务隔离级别的相关问题

• 脏读
  A事务对一条记录进行修改，尚未提交，B事务已经看到了A的修改结果。若A发生回滚，B读到的数据就是错误的，这就是脏读。
• 不可重复读
  A事务对一条记录进行修改，尚未提交，B事务第一次查询该记录，看到的是修改之后的结果，此时A发生回滚，B事务又一次查询该记录，看到的是回滚后的结果。同一个事务内，B两次查询结果不一致，这就是不可重复读。
• 幻读
  A事务对所有记录进行修改，尚未提交，此时B事务创建了一条新记录，A、B都提交。A查看所有数据，发现有一条数据没有被修改，因为这是B事务新增的，就想看到了幻象一样，这就是幻读。

3、事务的隔离级别

• 读未提交（read uncommitted）
  事务尚未提交，其他事务即可以看到该事务的修改结果。隔离级别最差，脏读、不可重复读、幻读都不能避免。
• 读提交（read committed）
  事务只能看到其他事务提交之后的数据。可避免脏读，不可重复读、幻读无法避免。
  不可重复读原因：A事务修改，B事务查询，A提交前和提交后，B事务看到的数据是不一致的。
  幻读原因：A事务修改，B事务新增，B事务提交前，A事务已经提交。B事务提交后，A发现仍有数据未修改。
• 可重复读（repeatable read）-------innodb默认隔离级别
  一个事务多次查询，无论其他事务对数据如何修改，看到的数据都是一致的。因为A事务查询数据时，若B同时在修改数据，A事务看到的永远是B事务执行前的数据。只有当A提交或者回滚之后，看到的才是最新的被B修改知乎的数据。可避免脏读、不可重复读，幻读无法避免。
• 序列化（serializable）
  事务顺序执行，可避免脏读、不可重复读、幻读，但效率最差。因为A事务执行时，其他事务必须等待。