Spring中的事务管理-蒲公英云

事务的回顾

1、什么是事务？

事务：逻辑上的一组操作，组成这组操作的各个语句，要么全都成功，要么全都失败。

2、事务的特性

原子性：事务不可分割
一致性：事务执行前后数据完整性保持一致
隔离性：一个事务的执行不应该受到其他事务的干扰
持久性：一旦事务结束，数据就持久化到数据库

3、如果不考虑隔离性引发安全性问题

（1）读的问题：
脏读：一个事务读到另一个事务未提交的数据。
不可重复读：一个事务读到另一个事务已经提交的update的数据，导致一个事务中多次查询结果不一致。
虚读、幻读：一个事务读到另一个事务已经提交的insert的数据，导致一个事务中多次查询结果不一致。

（2）写的问题
丢失更新

4、解决读问题

设置事务的隔离级别
Read uncommitted ：读未提交，任何读问题解决不了。
Read committed ：读已提交，解决脏读，但是不可重复读和虚读有可能发生。
Repeatable read ：可重复读，解决脏读和不可重复读，但是虚读有可能发生。
Serializable ：串行化执行，解决所有读问题，但同时效率变低了。

Oracle默认使用读已提交，MySQL默认使用可重复读。

Spring中事务管理的API类

1、PlatformTransactionManager：平台事务管理器

平台事务管理器：是一个接口，是Spring用于管理事务的真正的对象。

实现类有：
DataSourceTransactionManager ：底层使用JDBC管理事务
HibernateTransactionManager ：底层使用Hibernate管理事务

2、TransactionDefinition ：事务定义信息

事务定义：用于定义事务的相关的信息，隔离级别、超时信息、传播行为、是否只读。

3、TransactionStatus：事务的状态

事务状态：用于记录在事务管理过程中，事务的状态的对象。

4、事务管理的API之间的关系

Spring进行事务管理的时候，首先平台事务管理器（PlatformTransactionManager）根据事务定义信息（TransactionDefinition）进行事务的管理，在事务管理过程中，产生各种状态，将这些状态的信息记录到事务状态（TransactionStatus）的对象中。

Spring中事务的传播行为

Spring中提供了七种事务的传播行为：分为三类。
只需记住每类的第一个。

1、保证多个操作在同一个事务中

（1）PROPAGATION_REQUIRED ：默认值，如果A中有事务，使用A中的事务，如果A没有，创建一个新的事务，将操作AB都包含进来。

（2）PROPAGATION_SUPPORTS ：支持事务，如果A中有事务，使用A中的事务。如果A没有事务，不使用事务。

（3）PROPAGATION_MANDATORY ：如果A中有事务，使用A中的事务。如果A没有事务，抛出异常。

2、保证多个操作不在同一个事务中

（1）PROPAGATION_REQUIRES_NEW ：如果A中有事务，将A的事务挂起（暂停），创建新事务，只包含自身操作。如果A中没有事务，创建一个新事务，只包含自身操作。

（2）PROPAGATION_NOT_SUPPORTED ：如果A中有事务，将A的事务挂起。不使用事务管理。

（3）PROPAGATION_NEVER ：如果A中有事务，报异常。

3、嵌套式事务

PROPAGATION_NESTED ：嵌套事务，如果A中有事务，按照A的事务执行，执行完成后，设置一个保存点，执行B中的操作，如果没有异常，执行通过，如果有异常，可以选择回滚到最初始位置，也可以回滚到保存点。

Spring的事务管理

1、搭建Spring的事务管理的环境

（1）创建Service的接口和实现类

public interface AccountService { 
    public void transfer(Integer fromId, Integer toId, Double money);
}
public class AccountServiceImpl implements AccountService { 
    @Resource(name = "accountDao")
    private AccountDao accountDao;
    @Override
    public void transfer(Integer fromId, Integer toId, Double money) { 
        accountDao.outMoney(fromId, money);
        //int i = 1 / 0; // 模拟中间出现异常
        accountDao.inMoney(toId, money);
    }
}

（2）创建DAO的接口和实现类

public interface AccountDao { 
    void outMoney(Integer fromId, Double money);
    void inMoney(Integer toId, Double money);
}
// 继承JdbcDaoSupport可以获取Jdbc模板，不需要属性注入
public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao { 
    @Override
    public void outMoney(Integer fromId, Double money) { 
        String sql = "update t_act set balance = balance - ? where id = ?";
        this.getJdbcTemplate().update(sql, money, fromId);
    }
    @Override
    public void inMoney(Integer toId, Double money) { 
        String sql = "update t_act set balance = balance + ? where id = ?";
        this.getJdbcTemplate().update(sql, money, toId);
    }
}

2、配置Service和DAO：交给Spring管理

<bean id="accountService" class="com.pipi.spring.tx.demo1.AccountServiceImpl"></bean>
<bean id="accountDao" class="com.pipi.spring.tx.demo1.AccountDaoImpl"></bean>

3、配置连接池和JDBC的模板

<!-- 引入jdbc属性配置文件 -->
<context:property-placeholder location="classpath:jdbc.properties" />
<!-- 配置C3P0数据连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="${jdbc.driverClass}" />
    <property name="jdbcUrl" value="${jdbc.url}" />
    <property name="user" value="${jdbc.username}" />
    <property name="password" value="${jdbc.password}" />
</bean>

4、在DAO注入Jdbc的模板：

<bean id="accountDao" class="com.pipi.spring.tx.demo1.AccountDaoImpl">
    <!-- 注入dataSource连接池 -->
    <property name="dataSource" ref="dataSource" />
</bean>

5、测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(value = "classpath:com/pipi/spring/tx/demo1/tx1.xml")
public class Spring_tx_Test { 
    @Resource(name = "accountService")
    private AccountService accountService;
    @Test
    public void test01() { 
        accountService.transfer(1001, 1002, 500d);
    }
}

Spring的事务管理：

第一类：编程式事务（了解，需要手动编写代码）

1、第一步：配置平台事务管理器

<!-- 配置平台事务管理器 -->
<bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
</bean>

2、第二步：Spring提供了事务管理的模板类

<!-- 配置事务的管理的模板 -->
<bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
    <property name="transactionManager" ref="dataSourceTransactionManager" />
</bean>

3、第三步：在业务层注入事务管理的模板

<bean id="accountService" class="com.pipi.spring.tx.demo1.AccountServiceImpl">
    <property name="accountDao" ref="accountDao" />
    <!-- 注入事务管理的模板 -->
    <property name="transactionTemplate" ref="transactionTemplate" />
</bean>

4、编写事务管理的代码

@Override
public void transfer(Integer fromId, Integer toId, Double money) { 
    transactionTemplate.execute(new TransactionCallbackWithoutResult() { 
        @Override
        protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) { 
            accountDao.outMoney(fromId, money);
            int i = 1 / 0;  // 模拟中间出现异常
            accountDao.inMoney(toId, money);
        }
    });
}

5、测试：

@Test
public void test01() { 
    accountService.transfer(1001, 1002, 500d);
}

Spring的事务管理：二类：声明式事务管理（通过AOP配置实现）

1、XML方式的声明式事务管理

（1）第一步：引入aop的开发包
（2）第二步：恢复转账环境，即中间出现异常，钱会转丢。
（3）第三步：配置事务管理器

<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
</bean>

（4）第四步：配置增强

<!-- 配置事务的通知增强 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <!-- 事务管理的规则 -->
        <!--<tx:method name="save*" propagation="REQUIRED" isolation="DEFAULT" /> <tx:method name="delete*" propagation="REQUIRED" /> <tx:method name="update*" propagation="REQUIRED" /> <tx:method name="find*" read-only="true" />-->
        <tx:method name="*" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>

（5）第五步：AOP的配置

<!-- 配置AOP，切入点与切面，切面用advisor，一个通知与一个切入点的组合 -->
<aop:config>
    <aop:pointcut id="pointcut1" expression="execution(* com.pipi.spring.tx.demo2.AccountServiceImpl.*(..))" />
    <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut1" />
</aop:config>

（6）测试程序

@Test
public void test01() { 
    accountService.transfer(1001, 1002, 500d);
}

2、注解方式的声明式事务管理

（1）第一步：引入aop的开发包
（2）第二步：恢复转账环境
（3）第三步：配置事务管理器

<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
</bean>

（4）第四步：开启注解事务

<!-- 开启注解事务 -->
<tx:annotation-driven transaction-manager="transactionManager" />

（5）第五步：在业务层类上添加注解

@Transactional
public class AccountServiceImpl implements AccountService {  
    // ......
}

(6测试程序的执行：

@Test
public void test01() { 
    accountService.transfer(1001, 1002, 500d);
}

声明式事务管理的XML方式，与注解方式都有优点：

XML方式的事务管理，能让匹配上的所有类中的方法都使用配置好的事务管理。

而注解方式极其方便，但需要在所有的所需类上添加注解。

Spring中的事务管理

事务的回顾

Spring中事务管理的API类

Spring中事务的传播行为

Spring的事务管理

Spring的事务管理：

第一类：编程式事务（了解，需要手动编写代码）

Spring的事务管理：二类：声明式事务管理（通过AOP配置实现）

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Spring中的事务管理

相关 Spring中的事务管理

相关 spring中的事务管理

相关 Spring中的事务管理

相关 Spring中的事务管理

相关事务以及Spring中的事务管理二

相关事务以及Spring中的事务管理一

相关 spring中的事务管理(三)

相关 Spring中的事务管理详解

相关 Spring中的事务管理

随便看看

【AI PC端算法优化】四，一步步将Sobel边缘检测加速22倍

Django admin后台页面管理搜索输中文报错解决办法

SpringBoot的Web开发入门案例1

“Library not loaded: @rpath/libmysqlclient.21.dylib”问题解决办法

FreeRTOS常用资源

Django搭建博客_3：视图和 URL 配置

教程文章

热评文章

1江湖小白之一起学Python （二）爬取数据的保存

2Java Shiro：简化身份验证和授权的安全框架

3Java中try()catch{}的使用方法

4Swagger注解-@ApiModel 和 @ApiModelProperty

5windows下强制杀死tomcat进程

6uni-app 条形码(一维码)/二维码生成实现

标签列表