Spring核心之事务管理

快来打我* 2023-09-27 10:23 26阅读 0赞

## Spring事务 ##

**事务的特性**

*  `原子性(atomicity)`  
    一个事务必须被视为一个不可分割的最小工作单元, 整个事务中的所有操作要么全部执行成功, 要么全部失败回滚, 对于一个事务来说, 不可能只执行其中的一部分操作.
 *  `一致性(consistency)`  
    事务必须使数据库从一个一致性的状态变换到另一个一致性的状态, 也就是说一个事务执行之前和执行之后都必须处于一致性的状态. 拿转账来说, 假设用户A和用户B两者的钱加起来一共是5000, 那么不管A和B之间如何转账, 转几次账, 事务结束后两个用户的钱相加起来应该还得是5000, 这就是事务的一致性.
 *  `隔离性(isolation)`  
    并发的事务之间是相互隔离的, 一个事务所做的修改在最终提交之前, 对其他事务是不可见的. 例如, 账户A有5000元存款, 执行完转账语句(-500), 只要该事务没有提交, 对其他事务来说账户余额还是5000元.
 *  `持久性(durability)`  
    事务一旦提交, 其对数据库的修改就是永久性的, 即使系统崩溃, 修改的数据也不会丢失.

**并发事务带来的问题**

*  `更新丢失(Lost Update)`  
    多个事务修改同一行记录(都未提交), 后面的修改覆盖了前面的修改.
 *  `脏读(Dirty Reads)`  
    一个事务可以读取另一个事务未提交的数据.  
    不可重复读(Non-Repeatable Reads)  
    同一个事务中执行两次相同的查询, 可能得到不一样的结果. 这是因为在查询间隔内，另一个事务修改了该记录并提交了事务.
 *  `幻读(Phantom Reads)`  
    当某个事务在读取某个范围内的记录时, 另一个事务又在该范围内插入了新的记录, 当之前的事务再次读取该范围的记录时, 会产生幻行.

**隔离级别**

在MySQL常用的存储引擎中, 只有InnoDB支持事务, 所以这里说的隔离级别指的是InnoDB下的事务隔离级别.

*  `READ UNCOMMITTED(读未提交)`  
    在该隔离级别, 事务中的修改即使没有提交, 对其他事务也都是可见的. 避免了更新丢失的发生.
 *  `READ COMMITTED(读已提交)`  
    在该隔离级别, 一个事务只能看见已经提交的事务所做的修改. 避免了更新丢失和脏读.
 *  `REPEATABLE READ(可重复读)`  
    MySQL默认的隔离级别, 该级别保证了在同一个事务中多次读取同样的记录的结果是一致的. 避免了更新丢失、脏读、不可重复读和幻读. (注意看MySQL官网, RR隔离级别下解决了幻读问题)
 *  `SERIALIZABLE(可串行化)`  
    SERIALIZABLE是最高的隔离级别, 它通过强制事务串行化执行, 避免了并发事务带来的问题.

<table> 
 <thead> 
  <tr> 
   <th>隔离级别</th> 
   <th>读数据一致性</th> 
   <th>更新丢失</th> 
   <th>脏读</th> 
   <th>不可重复读</th> 
   <th>幻读</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>读未提交</td> 
   <td>最低级别, 只能保证不读取物理上损坏的数据</td> 
   <td>×</td> 
   <td>√</td> 
   <td>√</td> 
   <td>√</td> 
  </tr> 
  <tr> 
   <td>读已提交</td> 
   <td>语句级</td> 
   <td>×</td> 
   <td>×</td> 
   <td>√</td> 
   <td>√</td> 
  </tr> 
  <tr> 
   <td>可重复读</td> 
   <td>事务级</td> 
   <td>×</td> 
   <td>×</td> 
   <td>×</td> 
   <td>×</td> 
  </tr> 
  <tr> 
   <td>可串行化</td> 
   <td>最高级别, 事务级</td> 
   <td>×</td> 
   <td>×</td> 
   <td>×</td> 
   <td>×</td> 
  </tr> 
 </tbody> 
</table>

**spring 事务失效**

![在这里插入图片描述][b968fd47841344fb8736063f78c7c5f3.png]

## **Spring事务管理** ##

> 下面是Spring事务注解的源代码, 从中可以看到Spring事务管理的四个属性: `Propagation, Isolation, timeout, readOnly`.

@Target({ElementType.METHOD, ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Inherited
    @Documented
    public @interface Transactional {
        @AliasFor("transactionManager")
        String value() default "";
    
        @AliasFor("value")
        String transactionManager() default "";
    
        Propagation propagation() default Propagation.REQUIRED;
    
        Isolation isolation() default Isolation.DEFAULT;
    
        int timeout() default -1;
    
        boolean readOnly() default false;
    
        Class<? extends Throwable>[] rollbackFor() default {};
    
        String[] rollbackForClassName() default {};
    
        Class<? extends Throwable>[] noRollbackFor() default {};
    
        String[] noRollbackForClassName() default {};
    }

**事务传播行为**

public enum Propagation {
        REQUIRED(0),
        SUPPORTS(1),
        MANDATORY(2),
        REQUIRES_NEW(3),
        NOT_SUPPORTED(4),
        NEVER(5),
        NESTED(6);
    
        private final int value;
    
        private Propagation(int value) {
            this.value = value;
        }
    
        public int value() {
            return this.value;
        }
    }

事务传播行为是指方法之间事务的传播. 比如, 在方法A中调用了方法B:

*  `REQUIRED`  
    如果A有事务就使用当前事务, 如果A没有事务, 就创建一个新事务.
 *  `SUPPORTS`  
    如果A有事务就使用当前事务, 如果A没有事务, 就以非事务执行.
 *  `MANDATORY`  
    如果A有事务就使用当前事务, 如果A没有事务, 就抛异常.
 *  `REQUIRES_NEW`  
    不管A有没有事务都创建一个新事务.
 *  `NOT_SUPPORTED`  
    不管A有没有事务都以非事务执行.
 *  `NEVER`  
    如果A有事务就抛异常, 如果A没有事务, 就以非事务执行.
 *  `NESTED`  
    如果A没有事务就创建一个事务, 如果A有事务, 就在当前事务中嵌套其他事务.

**事务隔离级别**

public enum Isolation {
        DEFAULT(-1),
        READ_UNCOMMITTED(1),
        READ_COMMITTED(2),
        REPEATABLE_READ(4),
        SERIALIZABLE(8);
    
        private final int value;
    
        private Isolation(int value) {
            this.value = value;
        }
    
        public int value() {
            return this.value;
        }
    }

其中 DEFAULT 表示使用数据库的隔离级别.

**事务超时**

为了解决事务执行时间太长, 消耗太多资源的问题, 我们可以给事务设置一个超时时间, 如果事务执行时间超过了超时时间, 就回滚事务.

**只读事务**

一些不需要事务的方法, 比如读取数据, 就可以设置为只读事务, 这样可以有效地提高一些性能.

## **手动管理事务** ##

Spring使用 TransactionTemplate 事务模板来管理事务.

（1）dao层

public interface AccountDao {
    	 //汇款
    	public void out(String outer , Integer money);
    	
    	//收款
    	public void in(String inner , Integer money);
    }
    
    public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {
    
    	public void out(String outer, Integer money) {
    		this.getJdbcTemplate().update("update account set money = money - ? where username = ?", money,outer);
    	}
    
    	public void in(String inner, Integer money) {
    		this.getJdbcTemplate().update("update account set money = money + ? where username = ?", money,inner);
    	}
    }

（2）Service层

public interface AccountService {
    	//转账
    	public void transfer(String outer ,String inner ,Integer money);
    }
    
    public class AccountServiceImpl implements AccountService {
    
        private AccountDao accountDao;
    
    	private TransactionTemplate transactionTemplate;
    
        public void setAccountDao(AccountDao accountDao) {
            this.accountDao = accountDao;
        }	
        
        public void setTransactionTemplate(TransactionTemplate transactionTemplate) {
            this.transactionTemplate = transactionTemplate;
        }
    
        public void transfer(final String outer, final String inner, final Integer money) {
            transactionTemplate.execute(new TransactionCallbackWithoutResult() {
    
                @Override
                protected void doInTransactionWithoutResult(TransactionStatus arg0) {
                    accountDao.out(outer, money);
                    //模拟故障
                    int i = 1/0;
                    accountDao.in(inner, money);
                }
            });
        }
    }

（3）Spring配置

（4）测试代码

@Test
    public void demo(){
    	String xmlPath = "applicationContext.xml";
    	ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
    	AccountService accountService =  (AccountService) applicationContext.getBean("accountService");
    	accountService.transfer("jack", "rose", 1000);
    }

## Spring事务代理 ##

（1）Service层

public interface AccountService {
    	//转账
    	public void transfer(String outer ,String inner ,Integer money);
    }
    
    public class AccountServiceImpl implements AccountService {
    
    	private AccountDao accountDao;
    
    	public void setAccountDao(AccountDao accountDao) {
    		this.accountDao = accountDao;
    	}
    	
    	public void transfer(String outer, String inner, Integer money) {
    		accountDao.out(outer, money);
    		//模拟故障
    		int i = 1/0;
    		accountDao.in(inner, money);
    	}
    }

（2）Spring配置文件

<beans>
    	
    	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    		<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
    		<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"></property>
    		<property name="user" value="root"></property>
    		<property name="password" value="123"></property>
    	</bean>
    	
    	
    	<bean id="accountDao" class="org.tx.dao.impl.AccountDaoImpl">
    		<property name="dataSource" ref="dataSource"></property>
    	</bean>
    	
    	
    	<bean id="accountService" class="org.tx.service.impl.AccountServiceImpl">
    		<property name="accountDao" ref="accountDao"></property>
    	</bean>
    	
    	
    	<bean id="proxyAccountService" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
    		<property name="proxyInterfaces" value="org.tx.service.AccountService"></property>
    		<property name="target" ref="accountService"></property>
    		<property name="transactionManager" ref="txManager"></property>
    		<property name="transactionAttributes">
    			<props>
    				<prop key="transfer">PROPAGATION_REQUIRED,ISOLATION_DEFAULT</prop>
    			</props>
    		</property>
    	</bean>
    	
    	
    	<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    		<property name="dataSource" ref="dataSource"></property>
    	</bean>
    </beans>

（3）测试代码

@Test
    public void demo(){
    	String xmlPath = "applicationContext.xml";
    	ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
    	AccountService accountService =  (AccountService) applicationContext.getBean("proxyAccountService");
    	accountService.transfer("jack", "rose", 1000);
    }

## Spring + AspectJ ##

基于xml配置

（1）Service层

public interface AccountService {
    	//转账
    	public void transfer(String outer ,String inner ,Integer money);
    }
    
    public class AccountServiceImpl implements AccountService {
    
    	private AccountDao accountDao;
    	public void setAccountDao(AccountDao accountDao) {
    		this.accountDao = accountDao;
    	}
    	
    	public void transfer(String outer, String inner, Integer money) {
    		accountDao.out(outer, money);
    		//模拟故障
    		int i = 1/0;
    		accountDao.in(inner, money);
    	}
    }

（2）Spring配置文件

（3）测试代码

基于注解

（1）Service层

@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT)
    public class AccountServiceImpl implements AccountService {
    
    	private AccountDao accountDao;
    	public void setAccountDao(AccountDao accountDao) {
    		this.accountDao = accountDao;
    	}
    	
    	//或者 @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT)
    	public void transfer(String outer, String inner, Integer money) {
    		accountDao.out(outer, money);
    		//模拟故障
    		int i = 1/0;
    		accountDao.in(inner, money);
    	}
    }

（2）Spring配置文件

（3）测试代码

[b968fd47841344fb8736063f78c7c5f3.png]: https://img-blog.csdnimg.cn/b968fd47841344fb8736063f78c7c5f3.png