首页 > 代码库 > spring3-spring的事务管理机制

spring3-spring的事务管理机制

1. Spring的事务管理机制

 

Spring事务管理高层抽象主要包括3个接口,Spring的事务主要是由他们共同完成的:
PlatformTransactionManager:事务管理器—主要用于平台相关事务的管理
TransactionDefinition:    事务定义信息(隔离、传播、超时、只读)—通过配置如何进行事务管理。
TransactionStatus:事务具体运行状态—事务管理过程中,每个时间点事务的状态信息。

 

 

1.1. PlatformTransactionManager事务管理器

该接口提供三个方法:

commit:提交事务

rollback:回滚事务

getTransaction:获取事务状态

 

Spring为不同的持久化框架提供了不同PlatformTransactionManager接口实现

事务

说明

org.springframework.jdbc.datasource.DataSourceTransactionManager

使用Spring JDBCiBatis 进行持久化数据时使用

org.springframework.orm.hibernate3.HibernateTransactionManager

使用Hibernate3.0版本进行持久化数据时使用

org.springframework.orm.jpa.JpaTransactionManager

使用JPA进行持久化时使用

org.springframework.jdo.JdoTransactionManager

当持久化机制是Jdo时使用

org.springframework.transaction.jta.JtaTransactionManager

使用一个JTA实现来管理事务,在一个事务跨越多个资源时必须使用

 

DataSourceTransactionManager针对JdbcTemplateMyBatis 事务控制 ,使用Connection(连接)进行事务控制 

开启事务 connection.setAutoCommit(false);

提交事务 connection.commit();

回滚事务 connection.rollback();

 

HibernateTransactionManager针对Hibernate框架进行事务管理, 使用SessionTransaction相关操作进行事务控制 

开启事务 session.beginTransaction();

提交事务 session.getTransaction().commit();

回滚事务 session.getTransaction().rollback();

事务管理器的选择?

用户根据选择和使用的持久层技术,来选择对应的事务管理器。

 

1.2. TransactionDefinition事务定义信息

用来定义事务相关的属性的,给事务管理器用。

该接口主要提供的方法:

getIsolationLevel:获取 隔离级别

getPropagationBehavior:获取 传播行为

getTimeout:获取 超时时间(事务的有效期)

isReadOnly 是否只读(保存、更新、删除对数据进行操作-变成可读写的,查询-设置这个属性为true,只能读不能写),事务管理器能够根据这个返回值进行优化。

这些事务的定义信息,都可以在配置文件中配置和定制。

 

1.2.1. 事务的隔离级别IsolationLevel

隔离级别

含义

DEFAULT

使用后端数据库默认的隔离级别(spring中的默认选择项)

READ_UNCOMMITED

允许你读取还未提交的改变了的数据。可能导致脏、幻、不可重复读

READ_COMMITTED

允许在并发事务已经提交后读取。可防止脏读,但幻读和 不可重复读仍可发生

REPEATABLE_READ

对相同字段的多次读取是一致的,除非数据被事务本身改变。可防止脏、不可重复读,但幻读仍可能发生。

SERIALIZABLE

完全服从ACID的隔离级别,确保不发生脏、幻、不可重复读。这在所有的隔离级别中是最慢的,它是典型的通过完全锁定在事务中涉及的数据表来完成的。

隔离级别

含义

DEFAULT

使用后端数据库默认的隔离级别(spring中的默认选择项)

READ_UNCOMMITED

允许你读取还未提交的改变了的数据。可能导致脏、幻、不可重复读

READ_COMMITTED

允许在并发事务已经提交后读取。可防止脏读,但幻读和 不可重复读仍可发生

REPEATABLE_READ

对相同字段的多次读取是一致的,除非数据被事务本身改变。可防止脏、不可重复读,但幻读仍可能发生。

SERIALIZABLE

完全服从ACID的隔离级别,确保不发生脏、幻、不可重复读。这在所有的隔离级别中是最慢的,它是典型的通过完全锁定在事务中涉及的数据表来完成的。

 

脏读:一个事务读取了另一个事务改写但还未提交的数据,如果这些数据被回滚,则读到的数据是无效的。

不可重复读:在同一事务中,多次读取同一数据返回的结果有所不同。换句话说就是,后续读取可以读到另一事务已提交的更新数据。

相反,“可重复读”在同一事务中多次读取数据时,能够保证所读数据一样,也就是,后续读取不能读到另一事务已提交的更新数据。

幻读:一个事务读取了几行记录后,另一个事务插入一些记录,幻读就发生了。再后来的查询中,第一个事务就会发现有些原来没有的记录。

 

事务四大特性 ACID ---隔离性引发问题 ---- 解决事务的隔离问题 隔离级别

Mysql 默认隔离级别 REPEATABLE_READ

Oracle 默认隔离级别 READ_COMMITTED

技术分享

 

1.2.2. 事务的传播行为PropagationBehavior

什么是事务的传播行为? 有什么作用?

事务传播行为用于解决两个被事务管理的方法互相调用问题

技术分享

业务层两个方法面临的事务问题:

* 有些时候需要处于同一个事务(删除用户删除完成之后,需要同时删除用户对应的订单,需要事务回滚,例如商场工作人员删除订单业务),

* 有些时候不能在同一个事务(取款是一个事务操作,打印凭条是一个事务操作,例如ATM取款业务) !

 

 

事务的传播行为的7种类型:

 

事务传播行为类型

说明

PROPAGATION_REQUIRED

支持当前事务,如果不存在 就新建一个

PROPAGATION_SUPPORTS

支持当前事务,如果不存在,就不使用事务

PROPAGATION_MANDATORY

支持当前事务,如果不存在,抛出异常

PROPAGATION_REQUIRES_NEW

如果有事务存在,挂起当前事务,创建一个新的事务

PROPAGATION_NOT_SUPPORTED

以非事务方式运行,如果有事务存在,挂起当前事务

PROPAGATION_NEVER 

以非事务方式运行,如果有事务存在,抛出异常

PROPAGATION_NESTED

如果当前事务存在,则嵌套事务执行

只对DataSourceTransactionManager 起效

 

主要分为三大类:

l PROPAGATION_REQUIRED(默认值)PROPAGATION_SUPPORTSPROPAGATION_MANDATORY

支持当前事务, A调用B,如果A事务存在,BA处于同一个事务 。

事务默认传播行为 REQUIRED。最常用的。

 

l PROPAGATION_REQUIRES_NEW、PROPAGATION_NOT_SUPPORTEDPROPAGATION_NEVER

不会支持原来的事务 ,A调用B, 如果A事务存在, B肯定不会和A处于同一个事务。

常用的事务传播行为:PROPAGATION_REQUIRES_NEW

 

l PROPAGATION_NESTED

嵌套事务 ,只对DataSourceTransactionManager有效 ,底层使用JDBCSavePoint机制,允许在同一个事务设置保存点,回滚保存点

 

【面试题】REQUIREDREQUIRES_NEWNESTED 区分

REQUIRED:只有一个事务(默认,推荐)

REQUIRES_NEW:存在两个事务,如果事务存在,挂起事务,重新又开启了一个新的事务

NESTED:嵌套事务,事务可以设置保存点,回滚到保存点 ,选择提交或者回滚

 

 

1.3. TransactionStatus 事务状态

事务运行过程中,每个时间点 事务状态信息

flush(),给hibernate使用,底层发出sql

hasSavepoint():判断是否有保留点

isCompleted():判断事务是否结束

isNewTransaction():判断当前事务是否是新开的一个事务。

isRollbackOnly():判断事务是否只能回滚

setRollbackOnly():设置事务是否回滚

事务的结束:必须通过commit 确认事务提交,rollback作用标记为回滚。

数据库操作中,如果只是回滚,后面不操作,数据库在关闭连接的时候,自动发出了commit

    try {
        操作
    } catch (){
        rollback
    } finally {
        commit 
}

 

【三个事务超级接口对象之间的关系】

1) 首先用户管理事务,需要先配置TransactionManager(事务管理器)进行事务管理;

2)然后根据TransactionDefinition(事务定义信息、事务的管理方案),通过TransactionManager(事务管理器)进行事务管理;

3)最后事务运行过程中,每个时刻都可以通过获取TransactionStatus(事务状态)来了解事务的运行状态。

技术分享

 

 

1.4. Spring事务管理两种方式

Spring 支持两种方式事务管理

一:编程式的事务管理

通过TransactionTemplate手动管理事务

在实际应用中很少使用,原因是要修改原来的代码,加入事务管理代码 (侵入性

 

二:声明式事务管理(XML配置文件方式或注解方式)

Spring的声明式事务是通过AOP实现的(环绕通知)

开发中经常使用(代码侵入性最小)--推荐使用!

注:后面会演示声明式事务管理的两种方式:xml配置文件方式和注解方式,不演示编程式方式

 

2.  声明式事务管理案例-转账(xml、注解)

2.1. 编写转账案例,引出事务管理问题

需求:账号转账,Tom账号取出1000元,存放到Jack账号上

 第一步:创建工程(略)

 第二步:配置文件

spring的配置文件:applicationContext.xml

<!-- 引入外部文件 -->
    <context:property-placeholder location="classpath:db.properties" />

    <!-- 配置数据源 -->
    <!-- c3p0连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!-- 设置连接字符串 -->
        <property name="driverClass" value="http://www.mamicode.com/${jdbcClass}" />
        <property name="jdbcUrl" value="http://www.mamicode.com/${jdbcUrl}" />
        <property name="user" value="http://www.mamicode.com/${user}" />
        <property name="password" value="http://www.mamicode.com/${password}" />
    </bean>

     <!-- 配置dao,注入jdbctemplate 对象-->
    <bean id="AccounDaoImpl" class="cn.itcast.spring.dao.AccounDaoImpl">
        <!-- 方案二:BookDao类继承JdbcDaoSupport,直接注入数据源,就拥有了jdbctempate对象 -->
        <property name="dataSource" ref="dataSource"/>
    </bean>

 

第三步:创建IAccountDao接口

 

public interface IAccountDao {
    //转入
    public void in(String name,Double money);
    //转出
    public void out(String name,Double money);
}

创建AccounDaoImpl实现类,实现了IAccountDao接口

 

//账户操作持久层
//技术方案:jdbctempate
public class AccountDaoImpl extends JdbcDaoSupport implements IAccountDao {
    
    //转入
    public void in(String name,Double money){
        String sql="update t_account set money = money+ ? where name = ?";
        super.getJdbcTemplate().update(sql, money,name);
    }
    
    //转出
    public void out(String name,Double money){
        String sql="update t_account set money = money- ? where name = ?";
        super.getJdbcTemplate().update(sql, money,name);
    }
}

 

 

第四步:建立service层,创建IAccountService接口,编写转账的业务代码:

public interface IAccountService {
    //转账业务
    void transfer(String outName,String inName,Double money);
}

创建AccountServiceImpl实现类,实现了IAccountService接口,编写转账的业务操作

 

//掌握操作的业务层
public class AccountServiceImpl implements IAccountService{
    
    //注入dao(xml方式)
    private IAccountDao accountDao;

    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }

    //转账操作的业务逻辑
    public void transfer(String outName,String inName,Double money){
        //调用dao层
        //先取出
        accountDao.out(outName, money);
        //再转入
        accountDao.in(inName, money);
    }
}

 

 

继续配置applicationContext.xml文件:

  <!-- 配置dao-->
    <bean id="accountDao" class="cn.dao.AccountDaoImpl">
        <!--注入数据源  -->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 配置service -->
    <bean id="accountService" class="cn.itcast.service.AccountServiceImpl">
        <!-- 注入dao  -->
        <property name="accountDao" ref="accountDao"></property>
    </bean>

 

第五步:使用SpringTest进行测试

 

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:applicationContext.xml"})
public class SpringTest {
    //注入测试的service
    @Autowired
    private IAccountService accountService;
    
    //需求:账号转账,Tom账号取出1000元,存放到Jack账号上
    @Test
    public void testTransfer(){
        accountService.transfer("Tom", "Jack", 1000d);
        System.out.println("转账成功!");
    }
}

 

但是发现问题:

事务管理问题:在Service层没有事务的情况下,如果出现异常,则会转账不成功,数据异常。

扩展:如果不配置事务,那么每一个数据库的操作都是单独的一个事务。

 

2.2. 方式一:XML配置方式

【操作思路】:

1 确定目标:需要对AccountService transfer方法,配置切入点

2 需要Advice (环绕通知),方法前开启事务,方法后提交关闭事务

3 配置切面和切入点

配置Advice通知:

Spring为简化事务的配置,提供了<tx:advice>来配置事务管理,也可以理解为该标签是spring为你实现好了的事务的通知增强方案。

 

第一步:导入jar包:

技术分享

其中:

com.springsource.org.aopalliance-1.0.0.jar:aop切面编程
com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar:注解开发切面
spring-aop-3.2.0.RELEASE.jar:aop切面编程
spring-aspects-3.2.0.RELEASE.jar:注解开发切面
spring-tx-3.2.0.RELEASE.jar:事务处理

 

第二步:配置spring文件applicationContext.xml

  <!-- 引入外部属性配置文件-->
    <context:property-placeholder location="classpath:db.properties"/> 
    
     <!-- 配置数据源 -->
    <!-- c3p0连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="http://www.mamicode.com/${jdbc.className}" />
        <property name="jdbcUrl" value="http://www.mamicode.com/${jdbc.url}" />
        <property name="user" value="http://www.mamicode.com/${jdbc.user}" />
        <property name="password" value="http://www.mamicode.com/${jdbc.password}" />
    </bean>
    
    <!-- 配置dao -->
    <bean id="accountDao" class="cn.itcast.spring.dao.AccountDaoImpl">
        <!-- 注入数据源,才拥有jdbctemplate -->
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!-- 配置service -->
    <bean id="accountService" class="cn.itcast.spring.service.AccountServiceImpl">
        <!-- 注入dao -->
        <property name="accountDao" ref="accountDao"/>
    </bean>

    <!-- 第一步:定义具体的平台事务管理器(DataSource事务管理器) -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 注入数据源 -->
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!-- 第二步:定义通知,通知中要处理的就是事务 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager"> 
     //注意:如果第一步的事务管理器id设为transactionManager,transaction-manager属性可以省略,默认
        <!-- 配置事务的属性定义 -->
        <tx:attributes>
            <!-- 配置具体的方法的事务属性
                name:事务添加在哪个方法上,需要自己定义
                Isolation:事务的隔离级别,默认是按数据库的隔离级别来
                Propagation:事务的传播行为,默认是同一个事务
                timeout="-1": 事务的超时时间,默认值使用数据库的超时时间。
                read-only="false": 事务是否只读,默认可读写。
                rollback-for: 遇到哪些异常就回滚,其他的都不回滚
                no-rollback-for:遇到哪些异常不回滚,其他的都回滚。和上面互斥的
             -->
            //method定义的方法都会添加事务管理
            <tx:method name="transfer" isolation="DEFAULT"    propagation="REQUIRED" timeout="-1" read-only="false"/>
            
            <!-- 支持通配符:切面中 方法名字符合下面规则的方法都会添加事务管理  -->
            <tx:method name="save*"/>
            <tx:method name="update*"/>
            <tx:method name="delete*"/>
            <tx:method name="find*" read-only="true"/> 
        </tx:attributes>
    </tx:advice>

    <!-- 第三步:配置切入点,让通知关联切入点,即事务控制业务层的方法 -->
    <aop:config>
        <!-- 切入点 -->
        <aop:pointcut expression="bean(*Service)" id="txPointcut"/>
        <!-- 切面 -->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>
    </aop:config>

 

使用SpringTest.java测试:

 

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:applicationContext.xml"})
public class SpringTest {
    //注入测试的service
    @Autowired
    private IAccountService accountService;
    
    //需求:账号转账,Tom账号取出1000元,存放到Jack账号上
    @Test
    public void testTransfer(){
        accountService.transfer("Tom", "Jack", 1000d);
        System.out.println("转账成功!");
    }

}

数据正常!

 

 

【声明式事务处理的原理图】

技术分享

技术分享

【注意】

如果不配置,则走默认的事务(默认事务是每个数据库操作都是一个事务,相当于没事务),所以我们开发时需要配置事务。

 

【补充了解】:

rollback-for属性:

技术分享

注意事项:声明式事务处理对运行时异常有效,任何 RuntimeException 将触发事务回滚,但是任何 checked Exception 将不触发事务回滚

 

测试:applicationContext.xml:

技术分享

遇到该异常事务不会回滚:

 

2.3. 方式二:注解方式

步骤:

1.在需要管理事务的方法或者类上面 添加@Transactional 注解  

2.配置注解驱动事务管理(事务管理注解生效的作用)(需要配置对特定持久层框架使用的事务管理器)

 

第一步:确定目标(bean的方法)创建IAccountDaoAccountDaoImpl

(1)IAccountDao接口

public interface IAccountDao {
    //(存入)转入
    public void in(String name,Double money);
    //(取出)转出
    public void out(String name,Double money);
}

 

2AccountDaoImpl

 

//账户操作持久层
//技术方案:jdbctempate
/**
 * @Repository("accountDao")
 * 相当于容易中定义<bean id="accountDao" class="cn.itcast.spring.anntx.dao.AccountDaoImpl"/>
 */
@Repository("accountDao")
public class AccountDaoImpl extends JdbcDaoSupport implements IAccountDao {
    
 /*
    演示:注入数据源的错误方式:
    //注入数据源
    /*@Autowired
    private DataSource dataSource;  
    //注入失败,@Autowired的原理是为属性生成setter方法通过setter方法注入,但是JdbcDaoSupport 类有setter方法方法且为最终方法,不可重写
    注意:xml配置与注解注入数据源的区别:xml配置是在配置文件中注入数据源到dao,不生成setter方法,注解注入的@Autowired会底层生成setter方法,
 */
    
    //注入数据源的正确方式:自定义方法,在方法内调用父类方法注入数据源
    @Autowired   //当初始化dao的时候,会调用该方法,通过set方法的形参注入数据源
    public void setSuperDataSource(DataSource dataSource){      //方法名自定义
        //调用父类的setDataSource方法,注入数据源
        super.setDataSource(dataSource);        
    }
    
    //(存入)转入
    public void in(String name,Double money){
        String sql="update t_account set money = money+ ? where name = ?";
        super.getJdbcTemplate().update(sql, money,name);
    }
    
    //(取出)转出
    public void out(String name,Double money){
        String sql="update t_account set money = money- ? where name = ?";
        super.getJdbcTemplate().update(sql, money,name);
    }
}

 

创建IAccountServiceAccountServiceImpl

(1)IAccountService接口

 

public interface IAccountService {
    void transfer(String outName,String inName,Double money);
}

(2)AccountServiceImpl

 

//掌握操作的业务层
/**
 * @Service("accountService")
 * 相当于spring容器中定义:<bean id="accountService" class="cn.itcast.spring.anntx.service.AccountServiceImpl">
 */
@Service("accountService")
@Transactional  //在类上添加事务管理,自动对类中所有的公有的方法添加事务
public class AccountServiceImpl implements IAccountService{
    
    //注入dao
    @Autowired
    private IAccountDao accountDao;

    //转账操作的业务逻辑
    @Transactional   //在方法上添加事务管理,事务管理只在此方法上
    public void transfer(String outName,String inName,Double money){
        
        //调用dao层
        //先取出
        accountDao.out(outName, money);
        //异常
        int d = 1/0;
        //再转入
        accountDao.in(inName, money);
    }
    
    @Transactional(readOnly=true)    //在方法和类上同时定义了事务的属性,且属性值不同,局部会覆盖全局
    public void findAccount(){
        System.out.println("查询帐号的信息了");
    }
}

 

 

第二步:创建applicationContext-tx.xmlapplicationContext-tx.xml中配置:

 

    <!-- 引入外部属性文件 -->
    <context:property-placeholder location="classpath:db.properties" />

    <!-- 配置数据源 -->
    <!-- c3p0连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="http://www.mamicode.com/${jdbc.className}" />
        <property name="jdbcUrl" value="http://www.mamicode.com/${jdbc.url}" />
        <property name="user" value="http://www.mamicode.com/${jdbc.user}" />
        <property name="password" value="http://www.mamicode.com/${jdbc.password}" />
    </bean>    

    <!-- 配置bean注解扫描 -->
    <context:component-scan base-package="cn.itcast.spring.anntx"/>
    
    <!-- 事务管理 -->
    <!-- 配置事务管理器(DataSource事务管理器) -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 注入数据源 -->
        <property name="dataSource" ref="dataSource"/>
    </bean>
    
    <!-- 配置事务注解驱动 :识别事务的注解@tr
          transaction-manager:具体的平台事务管理器
    -->
    <!-- 默认的平台事务管理器的名字叫:transactionManager,如果与自定义的事务管理器id相同,transaction-manager="transactionManager"可以省略 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

 

 

【注意】:方法与类添加事务管理:

 1)在需要管理事务的方法或者类上面 添加@Transactional 注解

 技术分享

2)配置事务的定义属性信息,在注解中直接配置:

技术分享

扩展1

如果 @Transactional 标注在 Class 上面, 那么将会对这个 Class 里面所有的 public 方法都包装事务方法。等同于该类的每个公有方法都放上了@Transactional

如果某方法需要单独的事务定义,则需要在方法上加@Transactional来覆盖类上的标注声明。 记住:方法级别的事务覆盖类级别的事务

//掌握操作的业务层
/**
 * @Service("accountService")
 * 相当于spring容器中定义:<bean id="accountService" class="cn.itcast.spring.anntx.service.AccountServiceImpl">
 */
@Service("accountService")
@Transactional()  //会对该类中,所有的共有的方法,自动加上事务--全局的设置,默认是可写
public class AccountServiceImpl implements IAccountService{
    
    //注入dao
    @Autowired
    private IAccountDao accountDao;

    //转账操作的业务逻辑
    @Transactional(readOnly=false)//在方法上添加事务
    public void transfer(String outName,String inName,Double money){
        //调用dao层
        //先取出
        accountDao.out(outName, money);
        int d = 1/0;
        //再转入
        accountDao.in(inName, money);

    }
    
    @Transactional(readOnly=true)  //使用局部覆盖全局的
    public void findAccount(){
        System.out.println("查询帐号的信息了");
    }
}

 

2.4. 小结-xml和注解的选择

XML配置方式和注解配置方式 进行事务管理 哪种用的多?

XML方式,集中式维护,统一放置到applicationContext.xml文件中,缺点在于配置文件中的内容太多。

使用@Transactional注解进行事务管理,配置太分散,使用XML进行事务管理,属性集中配置,便于管理和维护  

技术分享

注意:以后的service的方法名字的命名,必须是上面规则,否则,不能被spring事务管理。!!!!

即以save开头的方法,update开头的方法,delete开头的方法,表示增删改的操作,故事务为可写

find开头的方法,表示查询,故事务为只读

1xml方式小结

技术分享

2)注解方式小结

技术分享

 

spring3-spring的事务管理机制