Spring5学习06:事务

港控/mmm° 2022-10-21 11:54 144阅读 0赞

## 1.概念 ##

> 事务是数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败所有操
> 
> 作都失败

典型场景:银行转账,A转账100给B,成功了B多100块,A少100块.失败了AB不增不减

## 2.四个特性 ##

1.  原子性:整个事务中的所有操作,要么全部成功,要么全部失败,不会停滞在中间某环节.
2.  一致性:事务开始前和结束后,数据库的完整性约束没有被破坏.比如银行转账中,AB的总账不会因转账而改变
3.  隔离性:并发执行的事务彼此无法看到对方的中间状态
4.  持久性:在事务完成后,数据库中的变更操作便持久保存在数据库中,不会回滚.

## 3.事务操作 ##

### 1.环境搭建(银行转账) ###

#### 1.创建表和添加数据 t\_account ####

![image.png][]

#### 2.创建 service ，搭建 dao,完成注入 ####

@Repository
    public class UserDaoImpl implements UserDao {
    
        // 注入 JdbcTemplate
        @Autowired
        private JdbcTemplate jdbcTemplate;
    
        @Override
        public void reduceMoney() {
            String sql =  "update t_account set money=money- - ? where username=?";
            jdbcTemplate.update(sql,100,"lucy");
        }
    
        @Override
        public void addMoney() {
            String sql =  "update t_account set money=money+? where username=?";
            jdbcTemplate.update(sql,100,"mary");
        }
    
        
    }
    
    @Service
    public class UserService {
    
        // 注入 dao
        @Autowired
        private UserDao userDao;
    
        
        public void accountMoney() {
            userDao.reduceMoney();
            userDao.addMoney();
        }
        
    }

#### 3.测试 ####

@Test
        public void test1() {
            ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
            UserService userService = context.getBean("userService", UserService.class);
            userService.accountMoney();
        }

结果:

![image.png][image.png 1]

测试过程中没有出错,数据一致,如果在减钱后出错,导致加钱没运行,该如何解决这种情况

开启事务

public void accountMoney() {
            userDao.reduceMoney();
            int i=1/0;
            userDao.addMoney();
        }

### 2.事务管理介绍 ###

#### 1.事务添加到 JavaEE 三层结构里面 Service 层（业务逻辑层） ####

#### 2 、在 Spring 进行事务管理操作 ####

有两种方式：编程式事务管理和声明式事务管理（使用）

#### 3.声明式事务管理 ####

1.  基于注解方式（使用）
2.  基于 xml 配置文件方式

#### 4. 在 Spring 进行声明式事务管理，底层使用 AOP ####

#### 5.Spring 事务管理 API ####

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

![image.png][image.png 2]

### 3.演示 ###

#### 1.注解式 ####

##### 1.spring.xml配置:名称空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">
        
        <context:component-scan base-package="cn.zj"></context:component-scan>
        
        <context:property-placeholder
            location="classpath:jdbc.properties" />
    
        
        <bean id="dataSource"
            class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
            <property name="url" value="${prop.url}" />
            <property name="username" value="${prop.userName}" />
            <property name="password" value="${prop.password}" />
            <property name="driverClassName" value="${prop.driverClass}" />
        </bean>
    
    
        
        <bean id="jdbcTemplate"
            class="org.springframework.jdbc.core.JdbcTemplate">
            
            <property name="dataSource" ref="dataSource"></property>
        </bean>
    
    
        
        <bean id="transactionManager"
            class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            
            <property name="dataSource" ref="dataSource"></property>
        </bean>
    
        
        <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
    </beans>

##### 2.service层加事务注解 #####

> 1.  @Transactional，这个注解添加到类上面，也可以添加方法上面
> 2.  如果把这个注解添加类上面，这个类里面所有的方法都添加事务
> 3.  如果把这个注解添加方法上面，为这个方法添加事务

@Transactional
    @Service
    public class UserService {
    
        // 注入 dao
        @Autowired
        private UserDao userDao;
    
        public void accountMoney() {
            userDao.reduceMoney();
            int i = 1 / 0;
            userDao.addMoney();
    
        }
    
    }

运行测试:

![image.png][image.png 3]

数据库表数据

![image.png][image.png 4]

#### 2.xml配置式 ####

##### 1.创建事务管理器和通知配置 #####

<bean id="transactionManager"
            class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            
            <property name="dataSource" ref="dataSource"></property>
        </bean>
    
    
        
        <tx:advice id="txadvice">
            
            <tx:attributes>
                
                <tx:method name="accountMoney" propagation="REQUIRED" />
                
            </tx:attributes>
        </tx:advice>
        
        <aop:config>
            
            <aop:pointcut id="pt"
                expression="execution(* cn.zj.service.UserService.*(..))" />
            
            <aop:advisor advice-ref="txadvice" pointcut-ref="pt" />
        </aop:config>

##### 2.测试 #####

@Test
        public void test2() {
            ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
            UserService userService = context.getBean("userService", UserService.class);
            userService.accountMoney();
        }

#### 3.完全注解 ####

1.创建代替xml的配置类

package cn.zj.config;
    
    import javax.sql.DataSource;
    
    import org.junit.jupiter.params.shadow.com.univocity.parsers.annotations.Validate;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.PropertySource;
    import org.springframework.jdbc.core.JdbcTemplate;
    import org.springframework.jdbc.datasource.DataSourceTransactionManager;
    import org.springframework.transaction.annotation.EnableTransactionManagement;
    
    import com.alibaba.druid.pool.DruidDataSource;
    
    @Configuration // 配置类
    @ComponentScan(basePackages = "cn.zj") // 组件扫描
    @EnableTransactionManagement // 开启事务
    @PropertySource("classpath:jdbc.properties")
    public class TxConfig {
    //创建数据库连接池
        @Value("${prop.driverClass}")
        private String driverClassName;
        @Value("${prop.url}")
        private String url;
        @Value("${prop.userName}")
        private String username;
        @Value("${prop.password}")
        private String password;
    
        @Bean
        public DruidDataSource getDruidDataSource() {
            DruidDataSource dataSource = new DruidDataSource();
            dataSource.setDriverClassName(driverClassName);
            dataSource.setUrl(url);
            dataSource.setUsername(username);
            dataSource.setPassword(password);
            return dataSource;
        }
    
    //创建 JdbcTemplate 对象
        @Bean
        public JdbcTemplate getJdbcTemplate(DataSource dataSource) {
    //到 ioc 容器中根据类型找到 dataSource
            JdbcTemplate jdbcTemplate = new JdbcTemplate();
    //注入 dataSource
            jdbcTemplate.setDataSource(dataSource);
            return jdbcTemplate;
        }
    
    //创建事务管理器
        @Bean
        public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource) {
            DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
            transactionManager.setDataSource(dataSource);
            return transactionManager;
        }
    }

2.测试

@Test
        public void test3() {
            ApplicationContext context = new AnnotationConfigApplicationContext(TxConfig.class);
            UserService userService = context.getBean("userService", UserService.class);
            userService.accountMoney();
        }

#### 4.事务参数配置 ####

##### 1.propagation #####

![image.png][image.png 5]

![image.png][image.png 6]

@Transactional(propagation = Propagation.REQUIRED)
    @Service
    public class UserService{

##### 2.ioslation ：事务隔离级别 #####

（1）事务有特性成为隔离性，多事务操作之间不会产生影响。不考虑隔离性产生很多问题

（2）有三个读问题：脏读、不可重复读、虚（幻）读

*  脏读：一个未提交事务读取到另一个未提交事务的数据
 *  不可重复读：一个未提交事务读取到另一提交事务修改数据,update数据
 *  虚读：一个未提交事务读取到另一提交事务添加数据,insert into数据

（3）解决：通过设置事务隔离级别，解决读问题

![image.png][image.png 7]

mysql默认可重复度,oracle默认读已提交

@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ)

##### 3.timeout ：超时时间 #####

*  事务需要在一定时间内进行提交，如果不提交进行回滚
 *  默认值是 -1 ，设置时间以秒单位进行计算

@Transactional(timeout =10, propagation= Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ)

##### 4.readOnly #####

*  读：查询操作，写：添加修改删除操作
 *  readOnly 默认值 false，表示可以查询，可以添加修改删除操作
 *  设置 readOnly 值是 true，设置成 true 之后，只能查询

@Transactional(readOnly=false,timeout =10, propagation= Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ)

##### 5.rollbackFor ：回滚 #####

设置出现哪些异常进行事务回滚

##### 6.noRollbackFor ：不回滚 #####

设置出现哪些异常不进行事务回滚

[image.png]: /images/20221021/552e70e8484f4405a288dd43d54f614c.png
[image.png 1]: /images/20221021/983c3ff1eda2453da40b21ec4847e9c0.png
[image.png 2]: /images/20221021/5c7f696073e3408c962c1d1c265cebcb.png
[image.png 3]: /images/20221021/81ee52d021f9450e805cb413771c0093.png
[image.png 4]: /images/20221021/63738fd29fd34ab29657376035c1268d.png
[image.png 5]: /images/20221021/db415bbbc03a468298265034ed8d95c8.png
[image.png 6]: /images/20221021/6b3ce1548c2644eb95bae51fe81553ec.png
[image.png 7]: /images/20221021/a0be6d86cd354b8eb291bfbf0339aa3c.png