Fork me on GitHub

JavaWeb 之 Spring 事务管理

Spring 事务管理


事务


概念

事务:指的是逻辑上的一组操作,组成这个事务的各个执行单元,要么一起成功,要么一起失败!

事务的特性

  • 原子性
  • 一致性
  • 隔离性
  • 持久性

安全性问题

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

  • 读问题:

    脏读
    不可重复读
    虚读

  • 写问题:

    丢失更新

如何解决安全性问题

读问题解决,设置数据库隔离级别

写问题解决可以使用 悲观锁乐观锁 的方式解决


Spring 框架的事务管理


Spring 框架的事务管理相关的类和 API

接口

  1. PlatformTransactionManager接口————平台事务管理器。(真正管理事务的类)。该接口有具体的实现类,根据不同的持久层框架,需要选择不同的实现类!
  2. TransactionDefinition接口————事务定义信息。(事务的隔离级别,传播行为,超时,只读)
  3. TransactionStatus接口————事务的状态

总结:上述对象之间的关系:平台事务管理器真正管理事务对象。根据事务定义的信息 TransactionDefinition 进行事务管理,在管理事务中产生一些状态,将状态记录到 TransactionStatus 中。

PlatformTransactionManager 接口中实现类和常用的方法

  1. 接口的实现类

    如果使用的 Spring 的 JDBC 模板或者 MyBatis 框架,需要选择 DataSourceTransactionManager 实现类
    如果使用的是 Hibernate 的框架,需要选择 HibernateTransactionManager 实现类

  2. 该接口的常用方法

    void commit(TransactionStatus status)
    TransactionStatus getTransaction(TransactionDefinition definition)
    void rollback(TransactionStatus status)

TransactionDefinition 接口中实现类和常用的方法

  1. 事务隔离级别的常量

    static int ISOLATION_DEFAULT————采用数据库的默认隔离级别
    static int ISOLATION_READ_UNCOMMITTED
    static int ISOLATION_READ_COMMITTED
    static int ISOLATION_REPEATABLE_READ
    static int ISOLATION_SERIALIZABLE

  2. 事务的传播行为常量(不用设置,使用默认值

  • 事务的传播行为:解决的是业务层之间的方法调用!

    PROPAGATION_REQUIRED(默认值)————A 中有事务,使用 A 中的事务。如果没有,B 就会开启一个新的事务,将 A 包含进来。(保证 A,B 在同一个事务中),默认值!
    PROPAGATION_SUPPORTS————A 中有事务,使用 A 中的事务。如果 A 中没有事务,那么 B 也不使用事务。
    PROPAGATION_MANDATORY————A 中有事务,使用 A 中的事务。如果 A 没有事务,抛出异常。

    PROPAGATION_REQUIRES_NEW(记)————A 中有事务,将 A 中的事务挂起。B 创建一个新的事务。(保证 A,B 没有在一个事务中)
    PROPAGATION_NOT_SUPPORTED————A 中有事务,将 A 中的事务挂起。
    PROPAGATION_NEVER————A 中有事务,抛出异常。

    PROPAGATION_NESTED(记)————嵌套事务。当 A 执行之后,就会在这个位置设置一个保存点。如果 B 没有问题,执行通过。如果 B 出现异常了,运行客户根据需求回滚(选择回滚到保存点或者是最初始状态)

搭建事务管理转账案例的环境

(强调:简化开发,以后 DAO 可以继承 JdbcDaoSupport 类)

步骤一:创建 WEB 工程,引入需要的 jar 包

IoC 的 6 个包
AOP 的 4 个包
C3P0 的 1 个包
MySQL 的驱动包
JDBC 模板 2 个包
整合 JUnit 测试包

步骤二:引入配置文件

  • 引入配置文件

    引入 log4j.properties

  • 引入 applicationContext.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<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: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/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">
</beans>

步骤三:创建对应的包结构和类

  • com.itheima.demo2

    AccountService
    AccountServlceImpl
    AccountDao
    AccountDaoImpl

步骤四:引入 Spring 的配置文件,将类配置到 Spring 中

1
2
3
4
5
<bean id="accountService" class="com.renkaigis.demo2.AccountServiceImpl">
</bean>

<bean id="accountDao" class="com.renkaigis.demo2.AccountDaoImpl">
</bean>

步骤五:在业务层注入 DAO ,在 DAO 中注入 JDBC 模板

(强调:简化开发,DAO 可以继承 JdbcDaoSupport 类)

1
2
3
4
5
6
7
<bean id="accountService" class="com.renkaigis.demo2.AccountServiceImpl">
<property name="accountDao" ref="accountDao"/>
</bean>

<bean id="accountDao" class="com.renkaigis.demo2.AccountDaoImpl">
<property name="dataSource" ref="dataSource"/>
</bean>

步骤六:编写 DAO 和 Service 中的方法

Service

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class AccountServiceImpl implements AccountService {
@Resource(name = "accountDao")
private AccountDao accountDao;

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

@Override
public void pay(String out, String in, double money) {
// 先扣钱
accountDao.outMoney(out, money);
// 后加钱
accountDao.inMoney(in, money);
}
}

DAO

1
2
3
4
5
6
7
8
9
10
11
12
public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {
// 扣钱
@Override
public void outMoney(String out, double money) {
this.getJdbcTemplate().update("update t_account set money = money - ? where name = ?", money, out);
}
// 加钱
@Override
public void inMoney(String in, double money) {
this.getJdbcTemplate().update("update t_account set money = money + ? where name = ?", money, in);
}
}

步骤七:编写测试程序

1
2
3
4
5
6
7
8
9
10
11
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Demo1 {
@Resource(name = "accountService")
private AccountService accountService;

@Test
public void run1() {
accountService.pay("小关", "小西", 1000);
}
}

Spring 框架事务管理的分类

  1. Spring 的编程式事务管理(不推荐使用)

    通过手动编写代码的方式完成事务的管理(不推荐)

  2. Spring 的声明式事务管理(底层采用 AOP 的技术)

    通过一段配置的方式完成事务的管理(重点掌握注解的方式)

Spring 框架事务管理之编程式事务管理(了解)

说明:Spring 为了简化事务管理的代码:提供了模板类 TransactionTemplate,所以手动编程的方式来管理事务,只需要使用该模板类即可!

步骤一:配置一个事务管理器

Spring 使用 PlatformTransactionManager 接口来管理事务,所以需要使用到他的实现类!

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

步骤二:配置事务管理的模板

1
2
3
4
<!--手动编码,提供了模板类,使用该类管理事务比较简单-->
<bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
<property name="transactionManager" ref="transactionManager"/>
</bean>

步骤三:在需要进行事务管理的类中,注入事务管理的模板

1
2
3
4
<bean id="accountService" class="com.renkaigis.demo2.AccountServiceImpl">
<property name="accountDao" ref="accountDao"/>
<property name="transactionTemplate" ref="transactionTemplate"/>
</bean>

步骤四:在业务层使用模板管理事务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class AccountServiceImpl implements AccountService {
private AccountDao accountDao;

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

// 注入事务的模板类
private TransactionTemplate transactionTemplate;

public void setTransactionTemplate(TransactionTemplate transactionTemplate) {
this.transactionTemplate = transactionTemplate;
}

@Override
public void pay(String out, String in, double money) {
transactionTemplate.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
accountDao.outMoney(out, money);
// 模拟异常
// int a = 10 / 0;
accountDao.inMoney(in, money);
}
});
}
}

Spring 框架事务管理之声明式事务管理

即通过配置文件来完成事务管理(AOP 思想)

  • 声明式事务管理又分成两种方式

    基于 AspectJ 的 XML 方式(重点掌握)
    基于 AspectJ 的注解方式(重点掌握)

Spring 框架事务管理之基于 AspectJ 的 XML 方式(重点掌握)

步骤一:恢复转账开发环境
步骤二:引入 AOP 的开发包
步骤三:配置事务管理器
1
2
3
4
<!--配置平台事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
步骤四:配置事务增强
1
2
3
4
5
6
7
<!--先配置通知-->
<tx:advice id="myAdvice" transaction-manager="transactionManager">
<tx:attributes>
<!--aop:advisor,是 Spring 框架提供的通知-->
<tx:method name="pay" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>

name:绑定事务的方法名,可以使用通配符,可以配置多个。
propagation:传播行为
isolation:隔离级别
read-only:是否只读
timeout:超时信息
rollback-for:发生哪些异常回滚
no-rollback-for:发生哪些异常不回滚

步骤五:配置 AOP 的切面
1
2
3
4
<!--配置 AOP:如果是自己编写的 AOP,使用 aop:aspect 配置,使用的是 Spring 提供的通知用 aop:advisor-->
<aop:config>
<aop:advisor advice-ref="myAdvice" pointcut="execution(public * com.renkaigis.demo3.AccountServiceImpl.pay(..))"/>
</aop:config>

注意:如果是自己编写的切面,使用 <aop:aspect> 标签,如果是系统提供的,使用 <aop:advisor> 标签。

步骤六:编写测试类
1
2
3
4
5
6
7
8
9
10
11
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Demo2 {
@Resource(name = "accountService")
private AccountService accountService;

@Test
public void run1() {
accountService.pay("小关", "小西", 1000);
}
}

Spring 框架事务管理之基于 AspectJ 的注解方式

(重点掌握,最简单的方式)

步骤一:恢复转账的开发环境
步骤二:配置事务管理器

同上。

步骤三:开启注解事务
1
2
<!--开启事务的注解-->
<tx:annotation-driven transaction-manager="transactionManager"/>
步骤四:在业务层上添加一个注解:@Transactional
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/**
* Transactional 类上添加注解,类中的方法全部就都有了事务
*/
@Transactional
public class AccountServiceImpl implements AccountService {
private AccountDao accountDao;
public void setAccountDao(AccountDao accountDao) {
this.accountDao = accountDao;
}

@Override
public void pay(String out, String in, double money) {
accountDao.outMoney(out, money);
// 模拟异常
// int a = 10 / 0;
accountDao.inMoney(in, money);
}
}
步骤五:编写测试类
1
2
3
4
5
6
7
8
9
10
11
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext3.xml")
public class Demo2 {
@Resource(name = "accountService")
private AccountService accountService;

@Test
public void run1() {
accountService.pay("小关", "小西", 1000);
}
}
--- The End    Thanks For Your Reading ---

本文标题:JavaWeb 之 Spring 事务管理

文章作者:RenKai

发布时间:2018年08月11日 - 22:08

最后更新:2018年08月13日 - 10:08

原始链接:http://yoursite.com/JavaWeb-Spring05.html

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。

宠辱不惊,看庭前花开花落;去留无意,望天上云卷云舒。