[TOC]

前言#

学习目标#

理解Spring事务核心思想
熟悉Spring事务的注解@Transactional

前置知识准备#

事务
AOP思想

事务的回顾#

事务的特性#

原子性 Atomicity
一致性 Consistency
隔离性 Isolation
持久性 Durability

事务并发引起的问题#

脏读
- 一个事务读取到另外一个事务还未提交的数据
不可重复读
- 一个事务读取到另外一个事务已经提交的数据（修改）
虚读/幻读
- 一个事务读取到另外一个事务已经提交的数据（增删）

数据库的隔离级别#

读未提交（Read uncommitted）
读已提交（Read committed）
可重复读（Repeatable read）
串行化（Serializable）

	脏读	不可重复读	虚读/幻读
读未提交	×	×	×
读已提交	√	×	×
可重复读	√	√	×
串行化	√	√	√

MySql的默认隔离级别是可重复读，但没有虚读问题的。

MyBatis整合#

要使用Spring框架整合MyBatis

引入依赖#

1
<!--Spring整合MyBatis依赖-->
2
<dependency>
3
  <groupId>org.mybatis</groupId>
4
  <artifactId>mybatis-spring</artifactId>
5
  <version>2.0.7</version>
6
</dependency>
7
<dependency>
8
  <groupId>org.springframework</groupId>
9
  <artifactId>spring-jdbc</artifactId>
10
  <version>5.2.15.RELEASE</version>
11
</dependency>
12
<!--druid-->
13
<dependency>
14
  <groupId>com.alibaba</groupId>
15
  <artifactId>druid</artifactId>
16
  <version>1.2.11</version>
17
</dependency>

组件注册#

1
@Configuration
2
@ComponentScan("com.cskaoyan.demo2")
3
public class AppConfiguration {
4

5
    /*@Bean
6
    public SqlSessionFactory sqlSessionFactory() {
7
        try {
8
            SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis.xml"));
9
            return sessionFactory;
10
        } catch (IOException e) {
11
            e.printStackTrace();
12
        }
13
        return null;
14
    }*/
15

16
    /**
17
    * MyBatis最早没有考虑整合Spring，后面发现有个大腿
18
    * mybatis-spring这个依赖提供了一个类，能够注册SqlSessionFactory组件
19
    * SqlSessionFactoryBean implements FactoryBean<SqlSessionFactory>
20
    * */
21
    @Bean
22
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
23
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
24
        sqlSessionFactoryBean.setDataSource(dataSource);
25
        return sqlSessionFactoryBean;
26
    }
27
    @Bean
28
    public DataSource dataSource() {
29
        DruidDataSource dataSource = new DruidDataSource();
30
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
31
        dataSource.setUrl("jdbc:mysql://localhost:3306/cskaoyan_db?useUnicode=true&characterEncoding=utf-8");
32
        dataSource.setUsername("root");
33
        dataSource.setPassword("123456");
34
        return dataSource;
35
    }
36

37
    @Bean
38
    public MapperScannerConfigurer mapperScannerConfigurer() {
39
        MapperScannerConfigurer configurer = new MapperScannerConfigurer();
40
        // 使用set方法提供一些信息 → 它就会根据这些信息向容器中注册mapper组件
41
        configurer.setSqlSessionFactoryBeanName("sqlSessionFactory");// sqlSessionFactory=applicationContext.getBean(beanName)
42
        configurer.setBasePackage("com.cskaoyan.demo2.mapper");
43
        return configurer;
44
    }
45
}

Service中可以直接注入Mapper#

1
@Service
2
public class AccountServiceImpl implements AccountService{
3

4
    /*@Autowired
5
    SqlSessionFactory sqlSessionFactory;*/
6

7
    @Autowired
8
    AccountMapper accountMapper;
9

10
    @Override
11
    public int transfer(Integer fromId, Integer destId, Integer money) {
12
        /*SqlSession sqlSession = sqlSessionFactory.openSession();
13
        AccountMapper accountMapper = sqlSession.getMapper(AccountMapper.class);*/
14
        Integer fromMoney = accountMapper.selectByPrimaryKey(fromId) - money;
15
        Integer destMoney = accountMapper.selectByPrimaryKey(destId) + money;
16

17
        accountMapper.update(fromId, fromMoney);
18
        int i = 1 / 0;
19
        accountMapper.update(destId, destMoney);
20
        /*sqlSession.commit();*/
21
        return 0;
22
    }
23
}

Spring在MyBatis执行mapper的方法之后会立即提交事务，而我们有时候需要将多个方法放到一个事务里

事务的核心接口#

PlatformTransactionManager 平台事务管理器
TransactionStatus 事务状态
TransactionDefinition 事务定义

PlatformTransactionManager平台事务管理器#

平台事务管理器，Spring要管理事务，必须使用事务管理器有多种实现，通过实现此接口，Spring可以管理任何实现了这些接口的事务。开发人员可以使用统一的编程模型来控制管理事务。

常见的事务管理器的实现 DataSourceTransactionManager，jdbc开发时事务管理器，使用JdbcTemplate、MyBatis（SSM） HibernateTransactionManager，Hibernate开发时事务管理器，整合Hibernate（SSH）

1
public interface PlatformTransactionManager extends TransactionManager {
2
  // 开启事务
3
    TransactionStatus getTransaction(@Nullable TransactionDefinition var1) throws TransactionException;
4
  // 提交事务
5
    void commit(TransactionStatus var1) throws TransactionException;
6
  // 回滚事务
7
    void rollback(TransactionStatus var1) throws TransactionException;
8
}

TransactionStatus事务状态#

获取事务的状态（回滚点、是否完成、是否新事务、是否回滚）属性，是一个过程值

1
public interface TransactionStatus extends TransactionExecution, SavepointManager, Flushable {
2
  boolean hasSavepoint();
3

4
  void flush();
5
}

提供了关于事务状态的方法

图片缺失：image/Snipaste_2021-07-22_16-14-53.png

TransactionDefinition事务定义#

定义事务的名称、隔离级别、传播行为、超时时间长短、只读属性等

1
public interface TransactionDefinition {
2
  int PROPAGATION_REQUIRED = 0;
3
  int PROPAGATION_SUPPORTS = 1;
4
  int PROPAGATION_MANDATORY = 2;
5
  int PROPAGATION_REQUIRES_NEW = 3;
6
  int PROPAGATION_NOT_SUPPORTED = 4;
7
  int PROPAGATION_NEVER = 5;
8
  int PROPAGATION_NESTED = 6;
9
  int ISOLATION_DEFAULT = -1;
10
  int ISOLATION_READ_UNCOMMITTED = 1;
11
  int ISOLATION_READ_COMMITTED = 2;
12
  int ISOLATION_REPEATABLE_READ = 4;
13
  int ISOLATION_SERIALIZABLE = 8;
14
  int TIMEOUT_DEFAULT = -1;
15

16
  default int getPropagationBehavior() {
17
    return 0;
18
  }
19

20
  default int getIsolationLevel() {
21
    return -1;
22
  }
23

24
  default int getTimeout() {
25
    return -1;
26
  }
27

28
  default boolean isReadOnly() {
29
    return false;
30
  }
31

32
  @Nullable
33
  default String getName() {
34
    return null;
35
  }
36

37
  static TransactionDefinition withDefaults() {
38
    return StaticTransactionDefinition.INSTANCE;
39
  }
40
}

事务的传播行为#

事务的传播行为属于TransactionDefinition，这个概念是之前没有讲过的一个概念

指多个方法之间如何来共享事务：发生异常的情况，谁提交谁回滚

REQUIRED 默认的事务传播行为
- 一荣俱荣，同生共死
REQUIRES_NEW
- 自私型
NESTED
- 无私型

REQUIRED#

如果当前没有事务，就新建一个事务；如果当前存在，则以当前事务方式运行。

一荣俱荣，一损俱损。要么一起提交，要么一起回滚。

1
现在有两个method，methodB（外围）调用了methodA（内部）
2
Q1：如果methodB发生异常，谁回滚？
3
Q2：如果methodA发生异常，谁回滚？

Q1/Q2：AB都回滚

REQUIRES_NEW#

如果当前没有事务，新建事务；如果当前存在事务，则新建一个事务。

自私型。外部不会影响内部，内部会影响外围。

1
现在有两个method，methodB（外围）调用了methodA（内部）
2
Q1：如果methodB发生异常，谁回滚？
3
Q2：如果methodA发生异常，谁回滚？

Q1：A不回滚，B回滚

Q2：AB都回滚

内部的方法更重要

NESTED#

如果当前没有事务，就新建一个事务；如果当前存在事务，则以嵌套事务的方式运行。

无私型。外围会影响内部，内部不会影响外围。

1
现在有两个method，methodB（外围）调用了methodA（内部）
2
Q1：如果methodB发生异常，谁回滚？
3
Q2：如果methodA发生异常，谁回滚？

Q1：AB都回滚

Q2：A回滚，B不回滚

外部的方法更重要

UserService → register

CouponService → send

register调用send

其他传播行为#

传播行为	描述
PROPAGATION_SUPPORTS	支持当前事务，假设当前没有事务，就以非事务方式运行
PROPAGATION_MANDATORY	支持当前事务，假设当前没有事务，就抛出异常
PROPAGATION_NOT_SUPPORTED	以非事务方式运行操作。假设当前存在事务，就把当前事务挂起
PROPAGATION_NEVER	以非事务方式运行，假设当前存在事务，则抛出异常

事务的案例#

不管使用的是哪一个案例，只要使用Spring事务，必然要使用Spring事务管理器。

1
@Bean
2
public PlatformTransactionManager transactionManager(DataSource dataSource) {
3
  DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
4
  transactionManager.setDataSource(dataSource);
5
  return transactionManager;
6
}

TransactionTemplate（了解）#

事务的模板，采用事务模板提供的方法来使用事务

在容器中注册TransactionTemplate组件

1
@Configuration
2
@ComponentScan("com.cskaoyan")
3
public class MyBatisConfiguration {
4

5
    // javaConfig讲过这个组件注册
6
    // MyBatis注册的组件略
7

8
    @Bean
9
    public PlatformTransactionManager transactionManager(DataSource dataSource) {
10
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
11
        transactionManager.setDataSource(dataSource);
12
        return transactionManager;
13
    }
14
    @Bean
15
    public TransactionTemplate transactionTemplate(PlatformTransactionManager transactionManager) {
16
        TransactionTemplate transactionTemplate = new TransactionTemplate();
17
        transactionTemplate.setTransactionManager(transactionManager);
18
        return transactionTemplate;
19
    }
20
}

使用TransactionTemplate提供的方法

1
@Service
2
public class AccountServiceImpl implements AccountService{
3
    @Autowired
4
    AccountDao accountDao;
5
    @Autowired
6
    TransactionTemplate transactionTemplate;
7
    @Override
8
    public void transfer(String from, String dest, Integer money) {
9
        Integer fromMoney = accountDao.selectMoneyByName(from) - money;
10
        Integer destMoney = accountDao.selectMoneyByName(dest) + money;
11

12
        //execute方法的返回值 是doInTransaction方法的返回值
13
        Integer execute = transactionTemplate.execute(new TransactionCallback<Integer>() {
14
            //需要增加事务的代码放入到doInTransaction中
15
            //如果需要增加事务的方法需要返回值 → 直接返回对应的值即可
16
            @Override
17
            public Integer doInTransaction(TransactionStatus transactionStatus) {
18

19
                accountDao.updateMoneyByName(from, fromMoney);//操作了数据库中的数据，需要增加事务
20
                int i = 1/0;
21
                accountDao.updateMoneyByName(dest, destMoney);//操作了数据库中的数据，需要增加事务
22
                return null;
23
            }
24
        });
25
        /*transactionTemplate.execute(new TransactionCallbackWithoutResult() {
26
            @Override
27
            protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
28
                accountDao.updateMoneyByName(from, fromMoney);//操作了数据库中的数据，需要增加事务
29
                accountDao.updateMoneyByName(dest, destMoney);//操作了数据库中的数据，需要增加事务
30
            }
31
        });*/
32
    }
33
}

Transactional注解#

思路

1
//@Component
2
//@Aspect
3
public class TransactionAspect {
4

5
    @Autowired
6
    PlatformTransactionManager transactionManager;
7
    @Pointcut("")
8
    public void transactionPointcut(){}
9

10
    @Around("transactionPointcut()")
11
    public Object transactionAround(ProceedingJoinPoint joinPoint) {
12
        Object proceed = null;
13
        TransactionStatus status = null;
14
        try {
15
            status = transactionManager.getTransaction(TransactionDefinition.withDefaults());
16
            proceed = joinPoint.proceed();
17
            transactionManager.commit(status);
18
        } catch (Throwable throwable) {
19
            transactionManager.rollback(status);
20
            throwable.printStackTrace();
21
        }
22
        return proceed;
23
    }
24
}

@Transactional注解的ElementType为TYPE和METHOD，意味着可以写在类上或方法上

1
@Target({ElementType.TYPE, ElementType.METHOD})
2
@Retention(RetentionPolicy.RUNTIME)
3
@Inherited
4
@Documented
5
public @interface Transactional {
6
    @AliasFor("transactionManager")
7
    String value() default "";
8

9
    @AliasFor("value")
10
    String transactionManager() default "";
11

12
    Propagation propagation() default Propagation.REQUIRED;
13

14
    Isolation isolation() default Isolation.DEFAULT;
15

16
    int timeout() default -1;
17

18
    boolean readOnly() default false;
19

20
    Class<? extends Throwable>[] rollbackFor() default {};
21

22
    String[] rollbackForClassName() default {};
23

24
    Class<? extends Throwable>[] noRollbackFor() default {};
25

26
    String[] noRollbackForClassName() default {};
27
}

使用注解前，需要先打开事务的注解驱动

1
@Configuration
2
@ComponentScan("com.cskaoyan")
3
@EnableTransactionManagement
4
public class MyBatisConfiguration {}

直接使用@Transactional注解，可以使用注解提供的属性配置事务的TransactionDefinition

1
/**
2
 * 在类上增加@Transactional 意味着该类下的所有方法都增加事务
3
 * @Transactional要增加在容器中的组件或组件中的方法里
4
 */
5
@Transactional
6
@Service
7
public class AccountServiceImpl implements AccountService{
8
    @Autowired
9
    AccountDao accountDao;
10

11
    //对应的方法增加上事务
12
    @Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.DEFAULT,timeout = 5)
13
    @Override
14
    public void transfer(String from, String dest, Integer money) {
15
        Integer fromMoney = accountDao.selectMoneyByName(from) - money;
16
        Integer destMoney = accountDao.selectMoneyByName(dest) + money;
17

18
        accountDao.updateMoneyByName(from, fromMoney);//操作了数据库中的数据，需要增加事务
19
        int i = 1/0;
20
        accountDao.updateMoneyByName(dest, destMoney);//操作了数据库中的数据，需要增加事务
21

22
    }
23
}

前言#

学习目标#

前置知识准备#

事务的回顾#

事务的特性#

事务并发引起的问题#

数据库的隔离级别#

MyBatis整合#

引入依赖#

组件注册#

Service中可以直接注入Mapper#

事务的核心接口#

PlatformTransactionManager平台事务管理器#

TransactionStatus事务状态#

TransactionDefinition事务定义#

事务的传播行为#

REQUIRED#

REQUIRES_NEW#

NESTED#

其他传播行为#

事务的案例#

TransactionTemplate（了解）#

Transactional注解#

文章分享

文章目录

Java Web 开发：Spring 事务

前言#

学习目标#

前置知识准备#

事务的回顾#

事务的特性#

事务并发引起的问题#

数据库的隔离级别#

MyBatis整合#

引入依赖#

组件注册#

Service中可以直接注入Mapper#

事务的核心接口#

PlatformTransactionManager平台事务管理器#

TransactionStatus事务状态#

TransactionDefinition事务定义#

事务的传播行为#

REQUIRED#

REQUIRES_NEW#

NESTED#

其他传播行为#

事务的案例#

TransactionTemplate（了解）#

Transactional注解#

文章分享

文章目录