【Spring】5、事务操作

最新推荐文章于 2022-06-18 22:23:48 发布

Mithrandir_74

最新推荐文章于 2022-06-18 22:23:48 发布

阅读量79

点赞数

分类专栏： Spring 文章标签： spring java

本文链接：https://blog.csdn.net/weixin_44013961/article/details/108635419

版权

Spring 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

事务概念

什么是事务？
- 事务是数据库操作最基本单元，逻辑上的一组操作，要么都成功，如果有一个失败所有操作都失败
- 典型场景：银行转账
  
  Lucy 转账100元给 Marry
  
  Lucy 少100，Marry 多100
事务的四个特性（ACID）
- 原子性（Atomicity）：事务不可分割
- 一致性（Consistency）：操作前后整个数据的完整性保持稳定
- 隔离性（Isolation）：多事务操作要相互隔离，不会产生影响
- 持久性（Durability）：当事务正确完成后，它对于数据的改变是永久性的

搭建事务操作环境

Service 层：业务操作（创建转账的方法，在里面分别调用 Dao 层里的两个方法）

Dao 层：数据库操作，不写业务（创建少钱和多钱的方法）

创建数据库和表，添加记录

创建 service，搭建 dao，完成对象创建和注入关系

service 注入 dao，在 dao 注入 JdbcTemplate，在 JdbcTemplate 注入 DataSource

@Service
public class UserService {

    //注入dao
    @Autowired
    private UserDao userDao;
}

@Repository
public class UserDaoImpl implements UserDao{

    @Autowired
    private JdbcTemplate jdbcTemplate;
}

在 dao 里创建两个方法：多钱和少钱的方法，在 service 里创建转账的方法

@Repository
public class UserDaoImpl implements UserDao{

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public void addMoney() {
        String sql = "update t_account set money=money+? where username=?";
        jdbcTemplate.update(sql,100,"Marry");
    }

    @Override
    public void reduceMoney() {
        String sql = "update t_account set money=money-? where username=?";
        jdbcTemplate.update(sql,100,"Lucy");
    }
}

@Service
public class UserService {

    //注入dao
    @Autowired
    private UserDao userDao;

    public void transferMoney(){
        //Lucy少100
        userDao.reduceMoney();
        //Marry多100
        userDao.addMoney();
    }
}

事务场景引入

上面代码，如果正常执行没有问题的，但是如果代码执行过程中出现异常，会产生问题：

public void transferMoney(){
    //Lucy少100
    userDao.reduceMoney();
    //模拟异常
    int i = 10/0;
    //Marry多100
    userDao.addMoney();
}

Lucy 钱少了，Marry 钱却并没有增加

问题如何解决？

使用事务进行解决

事务操作过程：（没实现，只是实例过程）

@Service
public class UserService {

    //注入dao
    @Autowired
    private UserDao userDao;

    public void transferMoney(){
        try {
            //第一步 开启事务

            //第二步 进行业务操作
            //Lucy少100
            userDao.reduceMoney();
            //模拟异常
            int i = 10/0;
            //Marry多100
            userDao.addMoney();

            //第三步 没有发生异常，提交事务
        }catch (Exception e){
            //第四步 出现异常，回滚事务
            
        }
    }
}

Spring 事务管理介绍

事务应该添加到哪一层？

事务添加到 JavaEE 三层结构里面 Service 层（业务逻辑层）
在 Spring 进行事务操作有两种方式：
- 编程式事务管理
- 声明式事务管理（更常用）
编程式事务管理：

上面事务场景引入中的事务操作过程就是编程式事务管理
声明式事务管理的两种实现方式：
- 基于注解方式
- 基于 xml 配置文件方式
在 Spring 进行声明式事务管理，底层使用 AOP 原理
Spring 事务管理 API：

提供一个接口PlatformTransactionManager，代表事务管理器，这个接口针对不同的框架提供不同的实现类

注解声明式事务管理

在 Spring 配置文件中配置事务管理器

<!--创建事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!--注入数据源-->
    <property name="dataSource" ref="dataSource"/>
</bean>

在 Spring 配置文件中开启事务注解

在 Spring 配置文件引入名称空间 tx

<?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: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">

开启事务注解

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

在 service 类上面（或者 service 类里面方法上面添加事务注解）
- @Transactional，这个注解添加到类上面，也可以添加方法上面
- 如果把这个注解添加类上面，这个类里面所有的方法都添加事务
- 如果把这个注解添加方法上面，为这个方法添加事务
```
@Service
@Transactional
public class UserService {
```

注解声明式事务管理参数配置

在 service 类上面添加注解@Transactional，在这个注解里面可以配置事务相关参数

propagation：事务传播行为

多事务方法直接进行调用，这个过程中事务是如何进行管理的称为事务传播行为

（事务方法：对数据库表数据进行变化的操作）

事务的传播行为可以由传播属性指定。Spring 定义了7种类传播行为

传播属性	描述
REQUIRED	如果有事务在运行，当前的方法就在这个事务内运行，否则，就启动一个新的事务，并在自己的事务内运行
REQUIRED_NEW	当前的方法必须启动新事务，并在它自己的事务内运行，如果有事务正在运行，应该将它挂起
SUPPORTS	如果有事务在运行，当前的方法就在这个事务内运行，否则它可以不运行在事务中
NOT_SUPPORTED	当前的方法不应该运行在事务中，如果有运行的事务，将它挂起
MANDATORY	当前的方法必须运行在事务内部，如果没有运行的事务，就抛出异常
NEVER	当前的方法不应该运行在事务中，如果有运行的事务，就抛出异常
NESTED	如果有事务在运行，当前的方法就应该在这个事务的嵌套事务内运行，否则，就启动一个新的事务，并在它自己的事务内运行

@Transactional(propagation = Propagation.REQUIRED)（不写默认情况）

ioslation：事务隔离级别
- 事务有一个特性称为为隔离性，多事务操作之间不会产生影响。不考虑隔离性产生很多问题：
- 有三个读问题：脏读、不可重复读、虚（幻）读
  - 脏读：一个未提交事务读取到另一个未提交事务的数据
  - 不可重复读：一个未提交事务读取到另一提交事务修改数据
  - 虚（幻）读：一个未提交事务读取到另一提交事务添加数据
- 解决：通过设置事务隔离级别，解决读问题
  
  脏读不可重复读幻读
  READ_UNCOMMITED（读未提交）有有有
  READ_COMMITED（读已提交）无有有
  REPETABLE_READ（可重复读）无无有
  SERIALIZABLE （串行化）无无无
  @Transactional(isolation = Isolation.REPEATABLE_READ)（不写默认情况）
timeout：超时时间
- 事务需要在一定时间内进行提交，如果不提交进行回滚
- 默认值是 -1，设置时间以秒单位进行计算
readOnly：是否只读
- 读：查询操作，写：添加修改删除操作
- readOnly 默认值 false，表示可以查询，可以添加修改删除操作
- 设置 readOnly 值是 true，设置成 true 之后，只能查询
rollbackFor：回滚
- 设置出现哪些异常进行事务回滚
- 参数写 异常类型.class
noRollbackFor：不回滚
- 设置出现哪些异常不进行事务回滚
- 参数写 异常类型.class
transactionManager：指定事务管理器
- 指定用哪个事务管理器
- 参数写事务管理器名字，例如
  
  @Transactional(transactionManager = "transactionManager")

	脏读	不可重复读	幻读
READ_UNCOMMITED（读未提交）	有	有	有
READ_COMMITED（读已提交）	无	有	有
REPETABLE_READ（可重复读）	无	无	有
SERIALIZABLE （串行化）	无	无	无

XML 声明式事务管理

在 spring 配置文件中进行配置

第一步：配置事务管理器
第二步：配置通知
第三步：配置切入点和切面

<!--1 创建事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!--注入数据源-->
    <property name="dataSource" ref="dataSource"/>
</bean>

<!--2 配置通知-->
<tx:advice id="txadvice">
    <!--配置事务参数-->
    <tx:attributes>
        <!--指定哪种规则的方法上面添加事务-->
        <tx:method name="transferMoney" propagation="REQUIRED"/>
        <!--或者<tx:method name="transfer*"/>-->
    </tx:attributes>
</tx:advice>

<!--3 配置切入点和切面-->
<aop:config>
    <!--配置切入点-->
    <aop:pointcut id="pt" expression="execution(* com.demo1.Spring5.service.UserService.*(..))"/>
    <!--配置切面-->
    <aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
</aop:config>

完全注解声明式事务管理

创建配置类，使用配置类替代 xml 配置文件

@Configuration //配置类
@ComponentScan(basePackages = "com.demo1.Spring5")
@EnableTransactionManagement //开启事务
public class TxCongfig {

    //创建数据库连接池
    @Bean
    public DruidDataSource getDruidDataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/user_db?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai");
        dataSource.setUsername("root");
        dataSource.setPassword("mysql700");
        return dataSource;
    }

    //创建JdbcTemplate对象
    @Bean
    public JdbcTemplate getJdbcTemplate(DruidDataSource dataSource){//到IOC容器中根据类型找到dataSource对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        //注入dataSource
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }

    //创建事务管理器
    @Bean
    public DataSourceTransactionManager getDataSourceTransactionManager(DruidDataSource dataSource){
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }
}

Mithrandir_74

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【Spring】5、事务操作

事务概念什么是事务？事务是数据库操作最基本单元，逻辑上的一组操作，要么都成功，如果有一个失败所有操作都失败典型场景：银行转账Lucy 转账100元给 MarryLucy 少100，Marry 多100事务的四个特性（ACID）原子性（Atomicity）：事务不可分割一致性（Consistency）：操作前后整个数据的完整性保持稳定隔离性（Isolation）：多事务操作要相互隔离，不会产生影响持久性（Durability）：当事务正确完成后，它对于数据的改变是永久
复制链接

扫一扫