Spring事务管理方式总结

最新推荐文章于 2021-04-08 18:07:35 发布

开启java之旅

最新推荐文章于 2021-04-08 18:07:35 发布

阅读量185

点赞数

分类专栏： Spring 文章标签： Spring事务配置汇总

本文链接：https://blog.csdn.net/qq_30301013/article/details/103399732

版权

Spring 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

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

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

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

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

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: 如果当前事务存在，则嵌套事务执行

事务超时：@Transactional(timeout = 60)

　　如果用这个注解描述一个方法的话，线程已经跑到方法里面，如果已经过去60秒了还没跑完这个方法并且线程在这个方法中的后面还有涉及到对数据库的增删改查操作时会报事务超时错误（会回滚）。

　　如果已经过去60秒了还没跑完但是后面已经没有涉及到对数据库的增删改查操作，那么这时不会报事务超时错误（不会回滚）。

Spring管理事务默认回滚的异常是什么？　

　　答案是 RuntimeException或者Error。　

Spring源码如下：
　　　　public boolean rollbackOn(Throwable ex) { 

     　　　　return (ex instanceof RuntimeException || ex instanceof Error);

　　　　} 

如果是RuntimeException或Error的话，就返回True，表示要回滚，否则返回False，表示不回滚。

注意：

如果事务在try{}catch(Exception e){e.printStackTrace();}中跑，并且catch中只是打印e的话，那么事务不会rollback。因为异常被catch掉了，框架不知道发生了异常。

　　如果想要rollback，可以加上rollbackFor=Exception.class，然后在方法上添加 throws Exception，将方法中出现的异常抛出给spring事务，接着去掉方法体中的try catch或者catch (Exception e) { throw e;}继续向上抛，目的是让spring事务捕获这个异常。
　　@Transactional(timeout = 60,rollbackFor=Exception.class)与rollbackFor=Exception.class的作用是

　　1 让checked例外也回滚：在整个方法前加上 @Transactional(rollbackFor=Exception.class)
　　2 让unchecked例外不回滚：在整个方法前加上 @Transactional(notRollbackFor=RunTimeException.class)

案例：

首先，以用户购买股票为例，新建用户对象、股票对象、以及dao、service层，新建对应的代码。

domain层（Pojo或者Entity）

/*** 账户对象*/
public class Account {
    private int accountid;
    private String name;
    private String balance;
    getter And setter方法......
}
/**股票对象*/
public class Stock {
    private int stockid;
    private String name;
    private Integer count;
    getter And setter方法.....
}

DAO层（接口与实现）
public interface AccountDao {
    void addAccount(String name,double money);
    void updateAccount(String name,double money,boolean isbuy);
}
public interface StockDao {    
    void addStock(String sname,int count);
    void updateStock(String sname,int count,boolean isbuy);
}
public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {
    @Override
    public void addAccount(String name, double money) {
        String sql = "insert account(name,balance) values(?,?);";
        this.getJdbcTemplate().update(sql,name,money); 
    }
    @Override
    public void updateAccount(String name, double money, boolean isbuy) {
        String sql = "update account set balance=balance+? where name=?";
        if(isbuy)
        sql = "update account set balance=balance-? where name=?";
        this.getJdbcTemplate().update(sql, money,name);
    } 
}
public class StockDaoImpl extends JdbcDaoSupport implements StockDao {
    @Override
    public void addStock(String sname, int count) {
        String sql = "insert into stock(name,count) values(?,?)";
        this.getJdbcTemplate().update(sql,sname,count);
    }
    @Override
    public void updateStock(String sname, int count, boolean isbuy) {
        String sql = "update stock set count = count-? where name = ?";
        if(isbuy)
        sql = "update stock set count = count+? where name = ?";
        this.getJdbcTemplate().update(sql, count,sname);
    }   
}
Service层（接口与实现）
public interface BuyStockService { 
    public void addAccount(String accountname, double money); 
    public void addStock(String stockname, int amount);
    public void buyStock(String accountname, double money, String stockname,int amount) throws BuyStockException;  
}
public class BuyStockServiceImpl implements BuyStockService{ 
    private AccountDao accountDao;
    private StockDao stockDao;
    @Override
    public void addAccount(String accountname, double money) {accountDao.addAccount(accountname,money);}
    @Override
    public void addStock(String stockname, int amount) {stockDao.addStock(stockname,amount);}
    @Override
    public void buyStock(String accountname, double money, String stockname, int amount) throws BuyStockException {
        boolean isBuy = true;
        accountDao.updateAccount(accountname, money, isBuy);
        if(isBuy==true){ throw new BuyStockException("购买股票发生异常");}
        stockDao.updateStock(stockname, amount, isBuy);
    }
    getter And setter方法......
}
测试代码：
public static void main(String[] args) {
        String resouce = "transaction/test2/applicationContext.xml";
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(resouce);
        BuyStockService buyStockService =  (BuyStockService) applicationContext.getBean("serviceProxy");
//      buyStockService.openAccount("小郑", 5000);   
//       buyStockService.openStock("知晓科技", 0);
        try {
            buyStockService.buyStock("小郑", 1000, "知晓科技", 100);
        } catch (BuyStockException e) {
            e.printStackTrace();
        }
    }

《一》基于XML配置的TransactionProxyFactoryBean的声明式事务管理

注意配置在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:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       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/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd">
<!--加载属性文件-->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!-- 注册数据源 C3P0 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"  >
    <property name="driverClass" value="${jdbc.driverClass}"></property>
    <property name="jdbcUrl"  value="${jdbc.url}"></property>
    <property name="user"  value="${jdbc.username}"></property>
    <property name="password" value="${jdbc.password}"></property>
</bean>
<!--配置DAOBean,可以使用注解@Repository(value ="accountDao")代替-->
<bean id="accountDao" class="transaction.test2.dao.AccountDaoImpl">
     <property name="dataSource" ref="dataSource"/>
 </bean>
 <!--配置DAOBean,可以使用注解@Repository(value ="stockDao")代替-->
 <bean id="stockDao" class="transaction.test2.dao.StockDaoImpl">
      <property name="dataSource" ref="dataSource"/>
 </bean>
 <!--配置ServiceBean,可以使用注解@Service(value="buyStockService")代替-->
 <bean id="buyStockService" class="transaction.test2.service.BuyStockServiceImpl">
      <property name="accountDao" ref="accountDao"></property>
      <property name="stockDao" ref="stockDao"></property>
 </bean>
 <!--事务管理器,可以使用注解@Bean(value="myTracnsactionManager")代替-->
 <bean id="myTracnsactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
     <property name="dataSource" ref="dataSource"></property>
 </bean>
 <!-- 事务代理工厂 -->
 <!-- 生成事务代理对象,该部分可以用第二种方式替换-->
 <bean id="serviceProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
      <property name="transactionManager" ref="myTracnsactionManager"></property>
      <property name="target" ref="buyStockService"></property>
      <property name="transactionAttributes">
            <props>
                <!-- 主要 key 是方法   
                    ISOLATION_DEFAULT  事务的隔离级别
                    PROPAGATION_REQUIRED  传播行为
                -->
                <prop key="add*">ISOLATION_DEFAULT,PROPAGATION_REQUIRED</prop>
                <!-- -Exception 表示发生指定异常回滚，+Exception 表示发生指定异常提交 -->
                <prop key="buyStock">ISOLATION_DEFAULT,PROPAGATION_REQUIRED,-BuyStockException</prop>
            </props>
       </property>  
    </bean>
</beans>

注意：如果为WEB项目，则控制层应该注入事务代理类，而不是业务层类。事务不生效。

《二》基于 @Transactional 的声明式事务管理

XML替换配置如下: ~~~~~同上~~~~~  <tx:annotation-driven transaction-manager="myTracnsactionManager"/> ~~~~~同上~~~~~

Service代码层改造如下：

  public class BuyStockServiceImpl implements BuyStockService{
    private AccountDao accountDao;
    private StockDao stockDao;
    
    public BuyStockServiceImpl() {}

    @Transactional(isolation=Isolation.DEFAULT,propagation=Propagation.REQUIRED)
    @Override
    public void addAccount(String accountname, double money) throws BuyStockException{
        accountDao.addAccount(accountname,money);
    }

   @Transactional(isolation=Isolation.DEFAULT,propagation=Propagation.REQUIRED)
   @Override
   public void addStock(String stockname, int amount) throws BuyStockException{
        stockDao.addStock(stockname,amount);
   }
 
   @Transactional(isolation=Isolation.DEFAULT,propagation=Propagation.REQUIRED,rollbackFor=BuyStockException.class)
   @Override
   public void buyStock(String accountname, double money, String stockname, int amount) throws BuyStockException {
        boolean isBuy = true;
        accountDao.updateAccount(accountname, money, isBuy);
        if(isBuy==true){
            throw new BuyStockException("购买股票发生异常");
        }
        stockDao.updateStock(stockname, amount, isBuy);
    }
    getter And setter方法....
}

《三》基于Aspectj AOP配置事务

public class BuyStockServiceImpl implements BuyStockService{
    private AccountDao accountDao;
    private StockDao stockDao;
    
    @Override
    public void addAccount(String accountname, double money) {
        accountDao.addAccount(accountname,money);
    }
 
    @Override
    public void addStock(String stockname, int amount) {
        stockDao.addStock(stockname,amount); 
    }
 
    public BuyStockServiceImpl() {}
    
    @Override
    public void buyStock(String accountname, double money, String stockname, int amount) throws BuyStockException {
        boolean isBuy = true;
        accountDao.updateAccount(accountname, money, isBuy);
        if(isBuy==true){
            throw new BuyStockException("购买股票发生异常");
        }
            stockDao.updateStock(stockname, amount, isBuy);
        
    }
    getter And setter方法....

}

XML配置如下：

~~~~~~同上~~~~~~~
<tx:advice id="txAdvice" transaction-manager="myTracnsactionManager">
    <tx:attributes>
       <!-- 为连接点指定事务属性 -->
       <tx:method name="add*" isolation="DEFAULT" propagation="REQUIRED"/>
       <tx:method name="buyStock" isolation="DEFAULT" propagation="REQUIRED" rollback-for="BuyStockException"/>
    </tx:attributes>
 </tx:advice>
 <aop:config>
     <!-- 切入点配置 -->
     <aop:pointcut expression="execution(* *..service.*.*(..))" id="point"/>
     <aop:advisor advice-ref="txAdvice" pointcut-ref="point"/>
 </aop:config>
~~~~~~同上~~~~~~~

开启java之旅

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring事务管理方式总结

spring事务：什么是事务:事务逻辑上的一组操作,组成这组操作的各个逻辑单元,要么一起成功,要么一起失败.事务特性（4种）:原子性（atomicity）:强调事务的不可分割.一致性（consistency）:事务的执行的前后数据的完整性保持一致.隔离性（isolation）:一个事务执行的过程中,不应该受到其他事务的干扰持久性（durability）:事务一旦结束,数...
复制链接

扫一扫

专栏目录